docs/hdk/vulkan__handles_8hpp_source.html

 // Copyright 2015-2022 The Khronos Group Inc.

 //

 // SPDX-License-Identifier: Apache-2.0 OR MIT

 //


 // This header is generated from the Khronos Vulkan XML API Registry.


 #ifndef VULKAN_HANDLES_HPP

 #define VULKAN_HANDLES_HPP


 namespace VULKAN_HPP_NAMESPACE

 {

   //===================================

   //=== STRUCT forward declarations ===

   //===================================


   //=== VK_VERSION_1_0 ===

   struct Extent2D;

   struct Extent3D;

   struct Offset2D;

   struct Offset3D;

   struct Rect2D;

   struct BaseInStructure;

   struct BaseOutStructure;

   struct BufferMemoryBarrier;

   struct DispatchIndirectCommand;

   struct DrawIndexedIndirectCommand;

   struct DrawIndirectCommand;

   struct ImageMemoryBarrier;

   struct MemoryBarrier;

   struct PipelineCacheHeaderVersionOne;

   struct AllocationCallbacks;

   struct ApplicationInfo;

   struct FormatProperties;

   struct ImageFormatProperties;

   struct InstanceCreateInfo;

   struct MemoryHeap;

   struct MemoryType;

   struct PhysicalDeviceFeatures;

   struct PhysicalDeviceLimits;

   struct PhysicalDeviceMemoryProperties;

   struct PhysicalDeviceProperties;

   struct PhysicalDeviceSparseProperties;

   struct QueueFamilyProperties;

   struct DeviceCreateInfo;

   struct DeviceQueueCreateInfo;

   struct ExtensionProperties;

   struct LayerProperties;

   struct SubmitInfo;

   struct MappedMemoryRange;

   struct MemoryAllocateInfo;

   struct MemoryRequirements;

   struct BindSparseInfo;

   struct ImageSubresource;

   struct SparseBufferMemoryBindInfo;

   struct SparseImageFormatProperties;

   struct SparseImageMemoryBind;

   struct SparseImageMemoryBindInfo;

   struct SparseImageMemoryRequirements;

   struct SparseImageOpaqueMemoryBindInfo;

   struct SparseMemoryBind;

   struct FenceCreateInfo;

   struct SemaphoreCreateInfo;

   struct EventCreateInfo;

   struct QueryPoolCreateInfo;

   struct BufferCreateInfo;

   struct BufferViewCreateInfo;

   struct ImageCreateInfo;

   struct SubresourceLayout;

   struct ComponentMapping;

   struct ImageSubresourceRange;

   struct ImageViewCreateInfo;

   struct ShaderModuleCreateInfo;

   struct PipelineCacheCreateInfo;

   struct ComputePipelineCreateInfo;

   struct GraphicsPipelineCreateInfo;

   struct PipelineColorBlendAttachmentState;

   struct PipelineColorBlendStateCreateInfo;

   struct PipelineDepthStencilStateCreateInfo;

   struct PipelineDynamicStateCreateInfo;

   struct PipelineInputAssemblyStateCreateInfo;

   struct PipelineMultisampleStateCreateInfo;

   struct PipelineRasterizationStateCreateInfo;

   struct PipelineShaderStageCreateInfo;

   struct PipelineTessellationStateCreateInfo;

   struct PipelineVertexInputStateCreateInfo;

   struct PipelineViewportStateCreateInfo;

   struct SpecializationInfo;

   struct SpecializationMapEntry;

   struct StencilOpState;

   struct VertexInputAttributeDescription;

   struct VertexInputBindingDescription;

   struct Viewport;

   struct PipelineLayoutCreateInfo;

   struct PushConstantRange;

   struct SamplerCreateInfo;

   struct CopyDescriptorSet;

   struct DescriptorBufferInfo;

   struct DescriptorImageInfo;

   struct DescriptorPoolCreateInfo;

   struct DescriptorPoolSize;

   struct DescriptorSetAllocateInfo;

   struct DescriptorSetLayoutBinding;

   struct DescriptorSetLayoutCreateInfo;

   struct WriteDescriptorSet;

   struct AttachmentDescription;

   struct AttachmentReference;

   struct FramebufferCreateInfo;

   struct RenderPassCreateInfo;

   struct SubpassDependency;

   struct SubpassDescription;

   struct CommandPoolCreateInfo;

   struct CommandBufferAllocateInfo;

   struct CommandBufferBeginInfo;

   struct CommandBufferInheritanceInfo;

   struct BufferCopy;

   struct BufferImageCopy;

   struct ClearAttachment;

   union ClearColorValue;

   struct ClearDepthStencilValue;

   struct ClearRect;

   union ClearValue;

   struct ImageBlit;

   struct ImageCopy;

   struct ImageResolve;

   struct ImageSubresourceLayers;

   struct RenderPassBeginInfo;


   //=== VK_VERSION_1_1 ===

   struct PhysicalDeviceSubgroupProperties;

   struct BindBufferMemoryInfo;

   using BindBufferMemoryInfoKHR = BindBufferMemoryInfo;

   struct BindImageMemoryInfo;

   using BindImageMemoryInfoKHR = BindImageMemoryInfo;

   struct PhysicalDevice16BitStorageFeatures;

   using PhysicalDevice16BitStorageFeaturesKHR = PhysicalDevice16BitStorageFeatures;

   struct MemoryDedicatedRequirements;

   using MemoryDedicatedRequirementsKHR = MemoryDedicatedRequirements;

   struct MemoryDedicatedAllocateInfo;

   using MemoryDedicatedAllocateInfoKHR = MemoryDedicatedAllocateInfo;

   struct MemoryAllocateFlagsInfo;

   using MemoryAllocateFlagsInfoKHR = MemoryAllocateFlagsInfo;

   struct DeviceGroupRenderPassBeginInfo;

   using DeviceGroupRenderPassBeginInfoKHR = DeviceGroupRenderPassBeginInfo;

   struct DeviceGroupCommandBufferBeginInfo;

   using DeviceGroupCommandBufferBeginInfoKHR = DeviceGroupCommandBufferBeginInfo;

   struct DeviceGroupSubmitInfo;

   using DeviceGroupSubmitInfoKHR = DeviceGroupSubmitInfo;

   struct DeviceGroupBindSparseInfo;

   using DeviceGroupBindSparseInfoKHR = DeviceGroupBindSparseInfo;

   struct BindBufferMemoryDeviceGroupInfo;

   using BindBufferMemoryDeviceGroupInfoKHR = BindBufferMemoryDeviceGroupInfo;

   struct BindImageMemoryDeviceGroupInfo;

   using BindImageMemoryDeviceGroupInfoKHR = BindImageMemoryDeviceGroupInfo;

   struct PhysicalDeviceGroupProperties;

   using PhysicalDeviceGroupPropertiesKHR = PhysicalDeviceGroupProperties;

   struct DeviceGroupDeviceCreateInfo;

   using DeviceGroupDeviceCreateInfoKHR = DeviceGroupDeviceCreateInfo;

   struct BufferMemoryRequirementsInfo2;

   using BufferMemoryRequirementsInfo2KHR = BufferMemoryRequirementsInfo2;

   struct ImageMemoryRequirementsInfo2;

   using ImageMemoryRequirementsInfo2KHR = ImageMemoryRequirementsInfo2;

   struct ImageSparseMemoryRequirementsInfo2;

   using ImageSparseMemoryRequirementsInfo2KHR = ImageSparseMemoryRequirementsInfo2;

   struct MemoryRequirements2;

   using MemoryRequirements2KHR = MemoryRequirements2;

   struct SparseImageMemoryRequirements2;

   using SparseImageMemoryRequirements2KHR = SparseImageMemoryRequirements2;

   struct PhysicalDeviceFeatures2;

   using PhysicalDeviceFeatures2KHR = PhysicalDeviceFeatures2;

   struct PhysicalDeviceProperties2;

   using PhysicalDeviceProperties2KHR = PhysicalDeviceProperties2;

   struct FormatProperties2;

   using FormatProperties2KHR = FormatProperties2;

   struct ImageFormatProperties2;

   using ImageFormatProperties2KHR = ImageFormatProperties2;

   struct PhysicalDeviceImageFormatInfo2;

   using PhysicalDeviceImageFormatInfo2KHR = PhysicalDeviceImageFormatInfo2;

   struct QueueFamilyProperties2;

   using QueueFamilyProperties2KHR = QueueFamilyProperties2;

   struct PhysicalDeviceMemoryProperties2;

   using PhysicalDeviceMemoryProperties2KHR = PhysicalDeviceMemoryProperties2;

   struct SparseImageFormatProperties2;

   using SparseImageFormatProperties2KHR = SparseImageFormatProperties2;

   struct PhysicalDeviceSparseImageFormatInfo2;

   using PhysicalDeviceSparseImageFormatInfo2KHR = PhysicalDeviceSparseImageFormatInfo2;

   struct PhysicalDevicePointClippingProperties;

   using PhysicalDevicePointClippingPropertiesKHR = PhysicalDevicePointClippingProperties;

   struct RenderPassInputAttachmentAspectCreateInfo;

   using RenderPassInputAttachmentAspectCreateInfoKHR = RenderPassInputAttachmentAspectCreateInfo;

   struct InputAttachmentAspectReference;

   using InputAttachmentAspectReferenceKHR = InputAttachmentAspectReference;

   struct ImageViewUsageCreateInfo;

   using ImageViewUsageCreateInfoKHR = ImageViewUsageCreateInfo;

   struct PipelineTessellationDomainOriginStateCreateInfo;

   using PipelineTessellationDomainOriginStateCreateInfoKHR = PipelineTessellationDomainOriginStateCreateInfo;

   struct RenderPassMultiviewCreateInfo;

   using RenderPassMultiviewCreateInfoKHR = RenderPassMultiviewCreateInfo;

   struct PhysicalDeviceMultiviewFeatures;

   using PhysicalDeviceMultiviewFeaturesKHR = PhysicalDeviceMultiviewFeatures;

   struct PhysicalDeviceMultiviewProperties;

   using PhysicalDeviceMultiviewPropertiesKHR = PhysicalDeviceMultiviewProperties;

   struct PhysicalDeviceVariablePointersFeatures;

   using PhysicalDeviceVariablePointerFeatures     = PhysicalDeviceVariablePointersFeatures;

   using PhysicalDeviceVariablePointerFeaturesKHR  = PhysicalDeviceVariablePointersFeatures;

   using PhysicalDeviceVariablePointersFeaturesKHR = PhysicalDeviceVariablePointersFeatures;

   struct PhysicalDeviceProtectedMemoryFeatures;

   struct PhysicalDeviceProtectedMemoryProperties;

   struct DeviceQueueInfo2;

   struct ProtectedSubmitInfo;

   struct SamplerYcbcrConversionCreateInfo;

   using SamplerYcbcrConversionCreateInfoKHR = SamplerYcbcrConversionCreateInfo;

   struct SamplerYcbcrConversionInfo;

   using SamplerYcbcrConversionInfoKHR = SamplerYcbcrConversionInfo;

   struct BindImagePlaneMemoryInfo;

   using BindImagePlaneMemoryInfoKHR = BindImagePlaneMemoryInfo;

   struct ImagePlaneMemoryRequirementsInfo;

   using ImagePlaneMemoryRequirementsInfoKHR = ImagePlaneMemoryRequirementsInfo;

   struct PhysicalDeviceSamplerYcbcrConversionFeatures;

   using PhysicalDeviceSamplerYcbcrConversionFeaturesKHR = PhysicalDeviceSamplerYcbcrConversionFeatures;

   struct SamplerYcbcrConversionImageFormatProperties;

   using SamplerYcbcrConversionImageFormatPropertiesKHR = SamplerYcbcrConversionImageFormatProperties;

   struct DescriptorUpdateTemplateEntry;

   using DescriptorUpdateTemplateEntryKHR = DescriptorUpdateTemplateEntry;

   struct DescriptorUpdateTemplateCreateInfo;

   using DescriptorUpdateTemplateCreateInfoKHR = DescriptorUpdateTemplateCreateInfo;

   struct ExternalMemoryProperties;

   using ExternalMemoryPropertiesKHR = ExternalMemoryProperties;

   struct PhysicalDeviceExternalImageFormatInfo;

   using PhysicalDeviceExternalImageFormatInfoKHR = PhysicalDeviceExternalImageFormatInfo;

   struct ExternalImageFormatProperties;

   using ExternalImageFormatPropertiesKHR = ExternalImageFormatProperties;

   struct PhysicalDeviceExternalBufferInfo;

   using PhysicalDeviceExternalBufferInfoKHR = PhysicalDeviceExternalBufferInfo;

   struct ExternalBufferProperties;

   using ExternalBufferPropertiesKHR = ExternalBufferProperties;

   struct PhysicalDeviceIDProperties;

   using PhysicalDeviceIDPropertiesKHR = PhysicalDeviceIDProperties;

   struct ExternalMemoryImageCreateInfo;

   using ExternalMemoryImageCreateInfoKHR = ExternalMemoryImageCreateInfo;

   struct ExternalMemoryBufferCreateInfo;

   using ExternalMemoryBufferCreateInfoKHR = ExternalMemoryBufferCreateInfo;

   struct ExportMemoryAllocateInfo;

   using ExportMemoryAllocateInfoKHR = ExportMemoryAllocateInfo;

   struct PhysicalDeviceExternalFenceInfo;

   using PhysicalDeviceExternalFenceInfoKHR = PhysicalDeviceExternalFenceInfo;

   struct ExternalFenceProperties;

   using ExternalFencePropertiesKHR = ExternalFenceProperties;

   struct ExportFenceCreateInfo;

   using ExportFenceCreateInfoKHR = ExportFenceCreateInfo;

   struct ExportSemaphoreCreateInfo;

   using ExportSemaphoreCreateInfoKHR = ExportSemaphoreCreateInfo;

   struct PhysicalDeviceExternalSemaphoreInfo;

   using PhysicalDeviceExternalSemaphoreInfoKHR = PhysicalDeviceExternalSemaphoreInfo;

   struct ExternalSemaphoreProperties;

   using ExternalSemaphorePropertiesKHR = ExternalSemaphoreProperties;

   struct PhysicalDeviceMaintenance3Properties;

   using PhysicalDeviceMaintenance3PropertiesKHR = PhysicalDeviceMaintenance3Properties;

   struct DescriptorSetLayoutSupport;

   using DescriptorSetLayoutSupportKHR = DescriptorSetLayoutSupport;

   struct PhysicalDeviceShaderDrawParametersFeatures;

   using PhysicalDeviceShaderDrawParameterFeatures = PhysicalDeviceShaderDrawParametersFeatures;


   //=== VK_VERSION_1_2 ===

   struct PhysicalDeviceVulkan11Features;

   struct PhysicalDeviceVulkan11Properties;

   struct PhysicalDeviceVulkan12Features;

   struct PhysicalDeviceVulkan12Properties;

   struct ImageFormatListCreateInfo;

   using ImageFormatListCreateInfoKHR = ImageFormatListCreateInfo;

   struct RenderPassCreateInfo2;

   using RenderPassCreateInfo2KHR = RenderPassCreateInfo2;

   struct AttachmentDescription2;

   using AttachmentDescription2KHR = AttachmentDescription2;

   struct AttachmentReference2;

   using AttachmentReference2KHR = AttachmentReference2;

   struct SubpassDescription2;

   using SubpassDescription2KHR = SubpassDescription2;

   struct SubpassDependency2;

   using SubpassDependency2KHR = SubpassDependency2;

   struct SubpassBeginInfo;

   using SubpassBeginInfoKHR = SubpassBeginInfo;

   struct SubpassEndInfo;

   using SubpassEndInfoKHR = SubpassEndInfo;

   struct PhysicalDevice8BitStorageFeatures;

   using PhysicalDevice8BitStorageFeaturesKHR = PhysicalDevice8BitStorageFeatures;

   struct ConformanceVersion;

   using ConformanceVersionKHR = ConformanceVersion;

   struct PhysicalDeviceDriverProperties;

   using PhysicalDeviceDriverPropertiesKHR = PhysicalDeviceDriverProperties;

   struct PhysicalDeviceShaderAtomicInt64Features;

   using PhysicalDeviceShaderAtomicInt64FeaturesKHR = PhysicalDeviceShaderAtomicInt64Features;

   struct PhysicalDeviceShaderFloat16Int8Features;

   using PhysicalDeviceFloat16Int8FeaturesKHR       = PhysicalDeviceShaderFloat16Int8Features;

   using PhysicalDeviceShaderFloat16Int8FeaturesKHR = PhysicalDeviceShaderFloat16Int8Features;

   struct PhysicalDeviceFloatControlsProperties;

   using PhysicalDeviceFloatControlsPropertiesKHR = PhysicalDeviceFloatControlsProperties;

   struct DescriptorSetLayoutBindingFlagsCreateInfo;

   using DescriptorSetLayoutBindingFlagsCreateInfoEXT = DescriptorSetLayoutBindingFlagsCreateInfo;

   struct PhysicalDeviceDescriptorIndexingFeatures;

   using PhysicalDeviceDescriptorIndexingFeaturesEXT = PhysicalDeviceDescriptorIndexingFeatures;

   struct PhysicalDeviceDescriptorIndexingProperties;

   using PhysicalDeviceDescriptorIndexingPropertiesEXT = PhysicalDeviceDescriptorIndexingProperties;

   struct DescriptorSetVariableDescriptorCountAllocateInfo;

   using DescriptorSetVariableDescriptorCountAllocateInfoEXT = DescriptorSetVariableDescriptorCountAllocateInfo;

   struct DescriptorSetVariableDescriptorCountLayoutSupport;

   using DescriptorSetVariableDescriptorCountLayoutSupportEXT = DescriptorSetVariableDescriptorCountLayoutSupport;

   struct SubpassDescriptionDepthStencilResolve;

   using SubpassDescriptionDepthStencilResolveKHR = SubpassDescriptionDepthStencilResolve;

   struct PhysicalDeviceDepthStencilResolveProperties;

   using PhysicalDeviceDepthStencilResolvePropertiesKHR = PhysicalDeviceDepthStencilResolveProperties;

   struct PhysicalDeviceScalarBlockLayoutFeatures;

   using PhysicalDeviceScalarBlockLayoutFeaturesEXT = PhysicalDeviceScalarBlockLayoutFeatures;

   struct ImageStencilUsageCreateInfo;

   using ImageStencilUsageCreateInfoEXT = ImageStencilUsageCreateInfo;

   struct SamplerReductionModeCreateInfo;

   using SamplerReductionModeCreateInfoEXT = SamplerReductionModeCreateInfo;

   struct PhysicalDeviceSamplerFilterMinmaxProperties;

   using PhysicalDeviceSamplerFilterMinmaxPropertiesEXT = PhysicalDeviceSamplerFilterMinmaxProperties;

   struct PhysicalDeviceVulkanMemoryModelFeatures;

   using PhysicalDeviceVulkanMemoryModelFeaturesKHR = PhysicalDeviceVulkanMemoryModelFeatures;

   struct PhysicalDeviceImagelessFramebufferFeatures;

   using PhysicalDeviceImagelessFramebufferFeaturesKHR = PhysicalDeviceImagelessFramebufferFeatures;

   struct FramebufferAttachmentsCreateInfo;

   using FramebufferAttachmentsCreateInfoKHR = FramebufferAttachmentsCreateInfo;

   struct FramebufferAttachmentImageInfo;

   using FramebufferAttachmentImageInfoKHR = FramebufferAttachmentImageInfo;

   struct RenderPassAttachmentBeginInfo;

   using RenderPassAttachmentBeginInfoKHR = RenderPassAttachmentBeginInfo;

   struct PhysicalDeviceUniformBufferStandardLayoutFeatures;

   using PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR = PhysicalDeviceUniformBufferStandardLayoutFeatures;

   struct PhysicalDeviceShaderSubgroupExtendedTypesFeatures;

   using PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR = PhysicalDeviceShaderSubgroupExtendedTypesFeatures;

   struct PhysicalDeviceSeparateDepthStencilLayoutsFeatures;

   using PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR = PhysicalDeviceSeparateDepthStencilLayoutsFeatures;

   struct AttachmentReferenceStencilLayout;

   using AttachmentReferenceStencilLayoutKHR = AttachmentReferenceStencilLayout;

   struct AttachmentDescriptionStencilLayout;

   using AttachmentDescriptionStencilLayoutKHR = AttachmentDescriptionStencilLayout;

   struct PhysicalDeviceHostQueryResetFeatures;

   using PhysicalDeviceHostQueryResetFeaturesEXT = PhysicalDeviceHostQueryResetFeatures;

   struct PhysicalDeviceTimelineSemaphoreFeatures;

   using PhysicalDeviceTimelineSemaphoreFeaturesKHR = PhysicalDeviceTimelineSemaphoreFeatures;

   struct PhysicalDeviceTimelineSemaphoreProperties;

   using PhysicalDeviceTimelineSemaphorePropertiesKHR = PhysicalDeviceTimelineSemaphoreProperties;

   struct SemaphoreTypeCreateInfo;

   using SemaphoreTypeCreateInfoKHR = SemaphoreTypeCreateInfo;

   struct TimelineSemaphoreSubmitInfo;

   using TimelineSemaphoreSubmitInfoKHR = TimelineSemaphoreSubmitInfo;

   struct SemaphoreWaitInfo;

   using SemaphoreWaitInfoKHR = SemaphoreWaitInfo;

   struct SemaphoreSignalInfo;

   using SemaphoreSignalInfoKHR = SemaphoreSignalInfo;

   struct PhysicalDeviceBufferDeviceAddressFeatures;

   using PhysicalDeviceBufferDeviceAddressFeaturesKHR = PhysicalDeviceBufferDeviceAddressFeatures;

   struct BufferDeviceAddressInfo;

   using BufferDeviceAddressInfoEXT = BufferDeviceAddressInfo;

   using BufferDeviceAddressInfoKHR = BufferDeviceAddressInfo;

   struct BufferOpaqueCaptureAddressCreateInfo;

   using BufferOpaqueCaptureAddressCreateInfoKHR = BufferOpaqueCaptureAddressCreateInfo;

   struct MemoryOpaqueCaptureAddressAllocateInfo;

   using MemoryOpaqueCaptureAddressAllocateInfoKHR = MemoryOpaqueCaptureAddressAllocateInfo;

   struct DeviceMemoryOpaqueCaptureAddressInfo;

   using DeviceMemoryOpaqueCaptureAddressInfoKHR = DeviceMemoryOpaqueCaptureAddressInfo;


   //=== VK_VERSION_1_3 ===

   struct PhysicalDeviceVulkan13Features;

   struct PhysicalDeviceVulkan13Properties;

   struct PipelineCreationFeedbackCreateInfo;

   using PipelineCreationFeedbackCreateInfoEXT = PipelineCreationFeedbackCreateInfo;

   struct PipelineCreationFeedback;

   using PipelineCreationFeedbackEXT = PipelineCreationFeedback;

   struct PhysicalDeviceShaderTerminateInvocationFeatures;

   using PhysicalDeviceShaderTerminateInvocationFeaturesKHR = PhysicalDeviceShaderTerminateInvocationFeatures;

   struct PhysicalDeviceToolProperties;

   using PhysicalDeviceToolPropertiesEXT = PhysicalDeviceToolProperties;

   struct PhysicalDeviceShaderDemoteToHelperInvocationFeatures;

   using PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT = PhysicalDeviceShaderDemoteToHelperInvocationFeatures;

   struct PhysicalDevicePrivateDataFeatures;

   using PhysicalDevicePrivateDataFeaturesEXT = PhysicalDevicePrivateDataFeatures;

   struct DevicePrivateDataCreateInfo;

   using DevicePrivateDataCreateInfoEXT = DevicePrivateDataCreateInfo;

   struct PrivateDataSlotCreateInfo;

   using PrivateDataSlotCreateInfoEXT = PrivateDataSlotCreateInfo;

   struct PhysicalDevicePipelineCreationCacheControlFeatures;

   using PhysicalDevicePipelineCreationCacheControlFeaturesEXT = PhysicalDevicePipelineCreationCacheControlFeatures;

   struct MemoryBarrier2;

   using MemoryBarrier2KHR = MemoryBarrier2;

   struct BufferMemoryBarrier2;

   using BufferMemoryBarrier2KHR = BufferMemoryBarrier2;

   struct ImageMemoryBarrier2;

   using ImageMemoryBarrier2KHR = ImageMemoryBarrier2;

   struct DependencyInfo;

   using DependencyInfoKHR = DependencyInfo;

   struct SubmitInfo2;

   using SubmitInfo2KHR = SubmitInfo2;

   struct SemaphoreSubmitInfo;

   using SemaphoreSubmitInfoKHR = SemaphoreSubmitInfo;

   struct CommandBufferSubmitInfo;

   using CommandBufferSubmitInfoKHR = CommandBufferSubmitInfo;

   struct PhysicalDeviceSynchronization2Features;

   using PhysicalDeviceSynchronization2FeaturesKHR = PhysicalDeviceSynchronization2Features;

   struct PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures;

   using PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR = PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures;

   struct PhysicalDeviceImageRobustnessFeatures;

   using PhysicalDeviceImageRobustnessFeaturesEXT = PhysicalDeviceImageRobustnessFeatures;

   struct CopyBufferInfo2;

   using CopyBufferInfo2KHR = CopyBufferInfo2;

   struct CopyImageInfo2;

   using CopyImageInfo2KHR = CopyImageInfo2;

   struct CopyBufferToImageInfo2;

   using CopyBufferToImageInfo2KHR = CopyBufferToImageInfo2;

   struct CopyImageToBufferInfo2;

   using CopyImageToBufferInfo2KHR = CopyImageToBufferInfo2;

   struct BlitImageInfo2;

   using BlitImageInfo2KHR = BlitImageInfo2;

   struct ResolveImageInfo2;

   using ResolveImageInfo2KHR = ResolveImageInfo2;

   struct BufferCopy2;

   using BufferCopy2KHR = BufferCopy2;

   struct ImageCopy2;

   using ImageCopy2KHR = ImageCopy2;

   struct ImageBlit2;

   using ImageBlit2KHR = ImageBlit2;

   struct BufferImageCopy2;

   using BufferImageCopy2KHR = BufferImageCopy2;

   struct ImageResolve2;

   using ImageResolve2KHR = ImageResolve2;

   struct PhysicalDeviceSubgroupSizeControlFeatures;

   using PhysicalDeviceSubgroupSizeControlFeaturesEXT = PhysicalDeviceSubgroupSizeControlFeatures;

   struct PhysicalDeviceSubgroupSizeControlProperties;

   using PhysicalDeviceSubgroupSizeControlPropertiesEXT = PhysicalDeviceSubgroupSizeControlProperties;

   struct PipelineShaderStageRequiredSubgroupSizeCreateInfo;

   using PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT = PipelineShaderStageRequiredSubgroupSizeCreateInfo;

   struct PhysicalDeviceInlineUniformBlockFeatures;

   using PhysicalDeviceInlineUniformBlockFeaturesEXT = PhysicalDeviceInlineUniformBlockFeatures;

   struct PhysicalDeviceInlineUniformBlockProperties;

   using PhysicalDeviceInlineUniformBlockPropertiesEXT = PhysicalDeviceInlineUniformBlockProperties;

   struct WriteDescriptorSetInlineUniformBlock;

   using WriteDescriptorSetInlineUniformBlockEXT = WriteDescriptorSetInlineUniformBlock;

   struct DescriptorPoolInlineUniformBlockCreateInfo;

   using DescriptorPoolInlineUniformBlockCreateInfoEXT = DescriptorPoolInlineUniformBlockCreateInfo;

   struct PhysicalDeviceTextureCompressionASTCHDRFeatures;

   using PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT = PhysicalDeviceTextureCompressionASTCHDRFeatures;

   struct RenderingInfo;

   using RenderingInfoKHR = RenderingInfo;

   struct RenderingAttachmentInfo;

   using RenderingAttachmentInfoKHR = RenderingAttachmentInfo;

   struct PipelineRenderingCreateInfo;

   using PipelineRenderingCreateInfoKHR = PipelineRenderingCreateInfo;

   struct PhysicalDeviceDynamicRenderingFeatures;

   using PhysicalDeviceDynamicRenderingFeaturesKHR = PhysicalDeviceDynamicRenderingFeatures;

   struct CommandBufferInheritanceRenderingInfo;

   using CommandBufferInheritanceRenderingInfoKHR = CommandBufferInheritanceRenderingInfo;

   struct PhysicalDeviceShaderIntegerDotProductFeatures;

   using PhysicalDeviceShaderIntegerDotProductFeaturesKHR = PhysicalDeviceShaderIntegerDotProductFeatures;

   struct PhysicalDeviceShaderIntegerDotProductProperties;

   using PhysicalDeviceShaderIntegerDotProductPropertiesKHR = PhysicalDeviceShaderIntegerDotProductProperties;

   struct PhysicalDeviceTexelBufferAlignmentProperties;

   using PhysicalDeviceTexelBufferAlignmentPropertiesEXT = PhysicalDeviceTexelBufferAlignmentProperties;

   struct FormatProperties3;

   using FormatProperties3KHR = FormatProperties3;

   struct PhysicalDeviceMaintenance4Features;

   using PhysicalDeviceMaintenance4FeaturesKHR = PhysicalDeviceMaintenance4Features;

   struct PhysicalDeviceMaintenance4Properties;

   using PhysicalDeviceMaintenance4PropertiesKHR = PhysicalDeviceMaintenance4Properties;

   struct DeviceBufferMemoryRequirements;

   using DeviceBufferMemoryRequirementsKHR = DeviceBufferMemoryRequirements;

   struct DeviceImageMemoryRequirements;

   using DeviceImageMemoryRequirementsKHR = DeviceImageMemoryRequirements;


   //=== VK_KHR_surface ===

   struct SurfaceCapabilitiesKHR;

   struct SurfaceFormatKHR;


   //=== VK_KHR_swapchain ===

   struct SwapchainCreateInfoKHR;

   struct PresentInfoKHR;

   struct ImageSwapchainCreateInfoKHR;

   struct BindImageMemorySwapchainInfoKHR;

   struct AcquireNextImageInfoKHR;

   struct DeviceGroupPresentCapabilitiesKHR;

   struct DeviceGroupPresentInfoKHR;

   struct DeviceGroupSwapchainCreateInfoKHR;


   //=== VK_KHR_display ===

   struct DisplayModeCreateInfoKHR;

   struct DisplayModeParametersKHR;

   struct DisplayModePropertiesKHR;

   struct DisplayPlaneCapabilitiesKHR;

   struct DisplayPlanePropertiesKHR;

   struct DisplayPropertiesKHR;

   struct DisplaySurfaceCreateInfoKHR;


   //=== VK_KHR_display_swapchain ===

   struct DisplayPresentInfoKHR;


 #if defined( VK_USE_PLATFORM_XLIB_KHR )

   //=== VK_KHR_xlib_surface ===

   struct XlibSurfaceCreateInfoKHR;

 #endif /*VK_USE_PLATFORM_XLIB_KHR*/


 #if defined( VK_USE_PLATFORM_XCB_KHR )

   //=== VK_KHR_xcb_surface ===

   struct XcbSurfaceCreateInfoKHR;

 #endif /*VK_USE_PLATFORM_XCB_KHR*/


 #if defined( VK_USE_PLATFORM_WAYLAND_KHR )

   //=== VK_KHR_wayland_surface ===

   struct WaylandSurfaceCreateInfoKHR;

 #endif /*VK_USE_PLATFORM_WAYLAND_KHR*/


 #if defined( VK_USE_PLATFORM_ANDROID_KHR )

   //=== VK_KHR_android_surface ===

   struct AndroidSurfaceCreateInfoKHR;

 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/


 #if defined( VK_USE_PLATFORM_WIN32_KHR )

   //=== VK_KHR_win32_surface ===

   struct Win32SurfaceCreateInfoKHR;

 #endif /*VK_USE_PLATFORM_WIN32_KHR*/


   //=== VK_EXT_debug_report ===

   struct DebugReportCallbackCreateInfoEXT;


   //=== VK_AMD_rasterization_order ===

   struct PipelineRasterizationStateRasterizationOrderAMD;


   //=== VK_EXT_debug_marker ===

   struct DebugMarkerObjectNameInfoEXT;

   struct DebugMarkerObjectTagInfoEXT;

   struct DebugMarkerMarkerInfoEXT;


 #if defined( VK_ENABLE_BETA_EXTENSIONS )

   //=== VK_KHR_video_queue ===

   struct QueueFamilyQueryResultStatusPropertiesKHR;

   struct QueueFamilyVideoPropertiesKHR;

   struct VideoProfileInfoKHR;

   struct VideoProfileListInfoKHR;

   struct VideoCapabilitiesKHR;

   struct PhysicalDeviceVideoFormatInfoKHR;

   struct VideoFormatPropertiesKHR;

   struct VideoPictureResourceInfoKHR;

   struct VideoReferenceSlotInfoKHR;

   struct VideoSessionMemoryRequirementsKHR;

   struct BindVideoSessionMemoryInfoKHR;

   struct VideoSessionCreateInfoKHR;

   struct VideoSessionParametersCreateInfoKHR;

   struct VideoSessionParametersUpdateInfoKHR;

   struct VideoBeginCodingInfoKHR;

   struct VideoEndCodingInfoKHR;

   struct VideoCodingControlInfoKHR;

 #endif /*VK_ENABLE_BETA_EXTENSIONS*/


 #if defined( VK_ENABLE_BETA_EXTENSIONS )

   //=== VK_KHR_video_decode_queue ===

   struct VideoDecodeCapabilitiesKHR;

   struct VideoDecodeUsageInfoKHR;

   struct VideoDecodeInfoKHR;

 #endif /*VK_ENABLE_BETA_EXTENSIONS*/


   //=== VK_NV_dedicated_allocation ===

   struct DedicatedAllocationImageCreateInfoNV;

   struct DedicatedAllocationBufferCreateInfoNV;

   struct DedicatedAllocationMemoryAllocateInfoNV;


   //=== VK_EXT_transform_feedback ===

   struct PhysicalDeviceTransformFeedbackFeaturesEXT;

   struct PhysicalDeviceTransformFeedbackPropertiesEXT;

   struct PipelineRasterizationStateStreamCreateInfoEXT;


   //=== VK_NVX_binary_import ===

   struct CuModuleCreateInfoNVX;

   struct CuFunctionCreateInfoNVX;

   struct CuLaunchInfoNVX;


   //=== VK_NVX_image_view_handle ===

   struct ImageViewHandleInfoNVX;

   struct ImageViewAddressPropertiesNVX;


 #if defined( VK_ENABLE_BETA_EXTENSIONS )

   //=== VK_EXT_video_encode_h264 ===

   struct VideoEncodeH264CapabilitiesEXT;

   struct VideoEncodeH264SessionParametersCreateInfoEXT;

   struct VideoEncodeH264SessionParametersAddInfoEXT;

   struct VideoEncodeH264VclFrameInfoEXT;

   struct VideoEncodeH264ReferenceListsInfoEXT;

   struct VideoEncodeH264EmitPictureParametersInfoEXT;

   struct VideoEncodeH264DpbSlotInfoEXT;

   struct VideoEncodeH264NaluSliceInfoEXT;

   struct VideoEncodeH264ProfileInfoEXT;

   struct VideoEncodeH264RateControlInfoEXT;

   struct VideoEncodeH264RateControlLayerInfoEXT;

   struct VideoEncodeH264QpEXT;

   struct VideoEncodeH264FrameSizeEXT;

 #endif /*VK_ENABLE_BETA_EXTENSIONS*/


 #if defined( VK_ENABLE_BETA_EXTENSIONS )

   //=== VK_EXT_video_encode_h265 ===

   struct VideoEncodeH265CapabilitiesEXT;

   struct VideoEncodeH265SessionParametersCreateInfoEXT;

   struct VideoEncodeH265SessionParametersAddInfoEXT;

   struct VideoEncodeH265VclFrameInfoEXT;

   struct VideoEncodeH265EmitPictureParametersInfoEXT;

   struct VideoEncodeH265DpbSlotInfoEXT;

   struct VideoEncodeH265NaluSliceSegmentInfoEXT;

   struct VideoEncodeH265ProfileInfoEXT;

   struct VideoEncodeH265ReferenceListsInfoEXT;

   struct VideoEncodeH265RateControlInfoEXT;

   struct VideoEncodeH265RateControlLayerInfoEXT;

   struct VideoEncodeH265QpEXT;

   struct VideoEncodeH265FrameSizeEXT;

 #endif /*VK_ENABLE_BETA_EXTENSIONS*/


 #if defined( VK_ENABLE_BETA_EXTENSIONS )

   //=== VK_EXT_video_decode_h264 ===

   struct VideoDecodeH264ProfileInfoEXT;

   struct VideoDecodeH264CapabilitiesEXT;

   struct VideoDecodeH264SessionParametersCreateInfoEXT;

   struct VideoDecodeH264SessionParametersAddInfoEXT;

   struct VideoDecodeH264PictureInfoEXT;

   struct VideoDecodeH264DpbSlotInfoEXT;

 #endif /*VK_ENABLE_BETA_EXTENSIONS*/


   //=== VK_AMD_texture_gather_bias_lod ===

   struct TextureLODGatherFormatPropertiesAMD;


   //=== VK_AMD_shader_info ===

   struct ShaderResourceUsageAMD;

   struct ShaderStatisticsInfoAMD;


   //=== VK_KHR_dynamic_rendering ===

   struct RenderingFragmentShadingRateAttachmentInfoKHR;

   struct RenderingFragmentDensityMapAttachmentInfoEXT;

   struct AttachmentSampleCountInfoAMD;

   using AttachmentSampleCountInfoNV = AttachmentSampleCountInfoAMD;

   struct MultiviewPerViewAttributesInfoNVX;


 #if defined( VK_USE_PLATFORM_GGP )

   //=== VK_GGP_stream_descriptor_surface ===

   struct StreamDescriptorSurfaceCreateInfoGGP;

 #endif /*VK_USE_PLATFORM_GGP*/


   //=== VK_NV_corner_sampled_image ===

   struct PhysicalDeviceCornerSampledImageFeaturesNV;


   //=== VK_NV_external_memory_capabilities ===

   struct ExternalImageFormatPropertiesNV;


   //=== VK_NV_external_memory ===

   struct ExternalMemoryImageCreateInfoNV;

   struct ExportMemoryAllocateInfoNV;


 #if defined( VK_USE_PLATFORM_WIN32_KHR )

   //=== VK_NV_external_memory_win32 ===

   struct ImportMemoryWin32HandleInfoNV;

   struct ExportMemoryWin32HandleInfoNV;

 #endif /*VK_USE_PLATFORM_WIN32_KHR*/


 #if defined( VK_USE_PLATFORM_WIN32_KHR )

   //=== VK_NV_win32_keyed_mutex ===

   struct Win32KeyedMutexAcquireReleaseInfoNV;

 #endif /*VK_USE_PLATFORM_WIN32_KHR*/


   //=== VK_EXT_validation_flags ===

   struct ValidationFlagsEXT;


 #if defined( VK_USE_PLATFORM_VI_NN )

   //=== VK_NN_vi_surface ===

   struct ViSurfaceCreateInfoNN;

 #endif /*VK_USE_PLATFORM_VI_NN*/


   //=== VK_EXT_astc_decode_mode ===

   struct ImageViewASTCDecodeModeEXT;

   struct PhysicalDeviceASTCDecodeFeaturesEXT;


   //=== VK_EXT_pipeline_robustness ===

   struct PhysicalDevicePipelineRobustnessFeaturesEXT;

   struct PhysicalDevicePipelineRobustnessPropertiesEXT;

   struct PipelineRobustnessCreateInfoEXT;


 #if defined( VK_USE_PLATFORM_WIN32_KHR )

   //=== VK_KHR_external_memory_win32 ===

   struct ImportMemoryWin32HandleInfoKHR;

   struct ExportMemoryWin32HandleInfoKHR;

   struct MemoryWin32HandlePropertiesKHR;

   struct MemoryGetWin32HandleInfoKHR;

 #endif /*VK_USE_PLATFORM_WIN32_KHR*/


   //=== VK_KHR_external_memory_fd ===

   struct ImportMemoryFdInfoKHR;

   struct MemoryFdPropertiesKHR;

   struct MemoryGetFdInfoKHR;


 #if defined( VK_USE_PLATFORM_WIN32_KHR )

   //=== VK_KHR_win32_keyed_mutex ===

   struct Win32KeyedMutexAcquireReleaseInfoKHR;

 #endif /*VK_USE_PLATFORM_WIN32_KHR*/


 #if defined( VK_USE_PLATFORM_WIN32_KHR )

   //=== VK_KHR_external_semaphore_win32 ===

   struct ImportSemaphoreWin32HandleInfoKHR;

   struct ExportSemaphoreWin32HandleInfoKHR;

   struct D3D12FenceSubmitInfoKHR;

   struct SemaphoreGetWin32HandleInfoKHR;

 #endif /*VK_USE_PLATFORM_WIN32_KHR*/


   //=== VK_KHR_external_semaphore_fd ===

   struct ImportSemaphoreFdInfoKHR;

   struct SemaphoreGetFdInfoKHR;


   //=== VK_KHR_push_descriptor ===

   struct PhysicalDevicePushDescriptorPropertiesKHR;


   //=== VK_EXT_conditional_rendering ===

   struct ConditionalRenderingBeginInfoEXT;

   struct PhysicalDeviceConditionalRenderingFeaturesEXT;

   struct CommandBufferInheritanceConditionalRenderingInfoEXT;


   //=== VK_KHR_incremental_present ===

   struct PresentRegionsKHR;

   struct PresentRegionKHR;

   struct RectLayerKHR;


   //=== VK_NV_clip_space_w_scaling ===

   struct ViewportWScalingNV;

   struct PipelineViewportWScalingStateCreateInfoNV;


   //=== VK_EXT_display_surface_counter ===

   struct SurfaceCapabilities2EXT;


   //=== VK_EXT_display_control ===

   struct DisplayPowerInfoEXT;

   struct DeviceEventInfoEXT;

   struct DisplayEventInfoEXT;

   struct SwapchainCounterCreateInfoEXT;


   //=== VK_GOOGLE_display_timing ===

   struct RefreshCycleDurationGOOGLE;

   struct PastPresentationTimingGOOGLE;

   struct PresentTimesInfoGOOGLE;

   struct PresentTimeGOOGLE;


   //=== VK_NVX_multiview_per_view_attributes ===

   struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX;


   //=== VK_NV_viewport_swizzle ===

   struct ViewportSwizzleNV;

   struct PipelineViewportSwizzleStateCreateInfoNV;


   //=== VK_EXT_discard_rectangles ===

   struct PhysicalDeviceDiscardRectanglePropertiesEXT;

   struct PipelineDiscardRectangleStateCreateInfoEXT;


   //=== VK_EXT_conservative_rasterization ===

   struct PhysicalDeviceConservativeRasterizationPropertiesEXT;

   struct PipelineRasterizationConservativeStateCreateInfoEXT;


   //=== VK_EXT_depth_clip_enable ===

   struct PhysicalDeviceDepthClipEnableFeaturesEXT;

   struct PipelineRasterizationDepthClipStateCreateInfoEXT;


   //=== VK_EXT_hdr_metadata ===

   struct HdrMetadataEXT;

   struct XYColorEXT;


   //=== VK_KHR_shared_presentable_image ===

   struct SharedPresentSurfaceCapabilitiesKHR;


 #if defined( VK_USE_PLATFORM_WIN32_KHR )

   //=== VK_KHR_external_fence_win32 ===

   struct ImportFenceWin32HandleInfoKHR;

   struct ExportFenceWin32HandleInfoKHR;

   struct FenceGetWin32HandleInfoKHR;

 #endif /*VK_USE_PLATFORM_WIN32_KHR*/


   //=== VK_KHR_external_fence_fd ===

   struct ImportFenceFdInfoKHR;

   struct FenceGetFdInfoKHR;


   //=== VK_KHR_performance_query ===

   struct PhysicalDevicePerformanceQueryFeaturesKHR;

   struct PhysicalDevicePerformanceQueryPropertiesKHR;

   struct PerformanceCounterKHR;

   struct PerformanceCounterDescriptionKHR;

   struct QueryPoolPerformanceCreateInfoKHR;

   union PerformanceCounterResultKHR;

   struct AcquireProfilingLockInfoKHR;

   struct PerformanceQuerySubmitInfoKHR;


   //=== VK_KHR_get_surface_capabilities2 ===

   struct PhysicalDeviceSurfaceInfo2KHR;

   struct SurfaceCapabilities2KHR;

   struct SurfaceFormat2KHR;


   //=== VK_KHR_get_display_properties2 ===

   struct DisplayProperties2KHR;

   struct DisplayPlaneProperties2KHR;

   struct DisplayModeProperties2KHR;

   struct DisplayPlaneInfo2KHR;

   struct DisplayPlaneCapabilities2KHR;


 #if defined( VK_USE_PLATFORM_IOS_MVK )

   //=== VK_MVK_ios_surface ===

   struct IOSSurfaceCreateInfoMVK;

 #endif /*VK_USE_PLATFORM_IOS_MVK*/


 #if defined( VK_USE_PLATFORM_MACOS_MVK )

   //=== VK_MVK_macos_surface ===

   struct MacOSSurfaceCreateInfoMVK;

 #endif /*VK_USE_PLATFORM_MACOS_MVK*/


   //=== VK_EXT_debug_utils ===

   struct DebugUtilsLabelEXT;

   struct DebugUtilsMessengerCallbackDataEXT;

   struct DebugUtilsMessengerCreateInfoEXT;

   struct DebugUtilsObjectNameInfoEXT;

   struct DebugUtilsObjectTagInfoEXT;


 #if defined( VK_USE_PLATFORM_ANDROID_KHR )

   //=== VK_ANDROID_external_memory_android_hardware_buffer ===

   struct AndroidHardwareBufferUsageANDROID;

   struct AndroidHardwareBufferPropertiesANDROID;

   struct AndroidHardwareBufferFormatPropertiesANDROID;

   struct ImportAndroidHardwareBufferInfoANDROID;

   struct MemoryGetAndroidHardwareBufferInfoANDROID;

   struct ExternalFormatANDROID;

   struct AndroidHardwareBufferFormatProperties2ANDROID;

 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/


   //=== VK_EXT_sample_locations ===

   struct SampleLocationEXT;

   struct SampleLocationsInfoEXT;

   struct AttachmentSampleLocationsEXT;

   struct SubpassSampleLocationsEXT;

   struct RenderPassSampleLocationsBeginInfoEXT;

   struct PipelineSampleLocationsStateCreateInfoEXT;

   struct PhysicalDeviceSampleLocationsPropertiesEXT;

   struct MultisamplePropertiesEXT;


   //=== VK_EXT_blend_operation_advanced ===

   struct PhysicalDeviceBlendOperationAdvancedFeaturesEXT;

   struct PhysicalDeviceBlendOperationAdvancedPropertiesEXT;

   struct PipelineColorBlendAdvancedStateCreateInfoEXT;


   //=== VK_NV_fragment_coverage_to_color ===

   struct PipelineCoverageToColorStateCreateInfoNV;


   //=== VK_KHR_acceleration_structure ===

   union DeviceOrHostAddressKHR;

   union DeviceOrHostAddressConstKHR;

   struct AccelerationStructureBuildRangeInfoKHR;

   struct AabbPositionsKHR;

   using AabbPositionsNV = AabbPositionsKHR;

   struct AccelerationStructureGeometryTrianglesDataKHR;

   struct TransformMatrixKHR;

   using TransformMatrixNV = TransformMatrixKHR;

   struct AccelerationStructureBuildGeometryInfoKHR;

   struct AccelerationStructureGeometryAabbsDataKHR;

   struct AccelerationStructureInstanceKHR;

   using AccelerationStructureInstanceNV = AccelerationStructureInstanceKHR;

   struct AccelerationStructureGeometryInstancesDataKHR;

   union AccelerationStructureGeometryDataKHR;

   struct AccelerationStructureGeometryKHR;

   struct AccelerationStructureCreateInfoKHR;

   struct WriteDescriptorSetAccelerationStructureKHR;

   struct PhysicalDeviceAccelerationStructureFeaturesKHR;

   struct PhysicalDeviceAccelerationStructurePropertiesKHR;

   struct AccelerationStructureDeviceAddressInfoKHR;

   struct AccelerationStructureVersionInfoKHR;

   struct CopyAccelerationStructureToMemoryInfoKHR;

   struct CopyMemoryToAccelerationStructureInfoKHR;

   struct CopyAccelerationStructureInfoKHR;

   struct AccelerationStructureBuildSizesInfoKHR;


   //=== VK_NV_framebuffer_mixed_samples ===

   struct PipelineCoverageModulationStateCreateInfoNV;


   //=== VK_NV_shader_sm_builtins ===

   struct PhysicalDeviceShaderSMBuiltinsPropertiesNV;

   struct PhysicalDeviceShaderSMBuiltinsFeaturesNV;


   //=== VK_EXT_image_drm_format_modifier ===

   struct DrmFormatModifierPropertiesListEXT;

   struct DrmFormatModifierPropertiesEXT;

   struct PhysicalDeviceImageDrmFormatModifierInfoEXT;

   struct ImageDrmFormatModifierListCreateInfoEXT;

   struct ImageDrmFormatModifierExplicitCreateInfoEXT;

   struct ImageDrmFormatModifierPropertiesEXT;

   struct DrmFormatModifierPropertiesList2EXT;

   struct DrmFormatModifierProperties2EXT;


   //=== VK_EXT_validation_cache ===

   struct ValidationCacheCreateInfoEXT;

   struct ShaderModuleValidationCacheCreateInfoEXT;


 #if defined( VK_ENABLE_BETA_EXTENSIONS )

   //=== VK_KHR_portability_subset ===

   struct PhysicalDevicePortabilitySubsetFeaturesKHR;

   struct PhysicalDevicePortabilitySubsetPropertiesKHR;

 #endif /*VK_ENABLE_BETA_EXTENSIONS*/


   //=== VK_NV_shading_rate_image ===

   struct ShadingRatePaletteNV;

   struct PipelineViewportShadingRateImageStateCreateInfoNV;

   struct PhysicalDeviceShadingRateImageFeaturesNV;

   struct PhysicalDeviceShadingRateImagePropertiesNV;

   struct CoarseSampleLocationNV;

   struct CoarseSampleOrderCustomNV;

   struct PipelineViewportCoarseSampleOrderStateCreateInfoNV;


   //=== VK_NV_ray_tracing ===

   struct RayTracingShaderGroupCreateInfoNV;

   struct RayTracingPipelineCreateInfoNV;

   struct GeometryTrianglesNV;

   struct GeometryAABBNV;

   struct GeometryDataNV;

   struct GeometryNV;

   struct AccelerationStructureInfoNV;

   struct AccelerationStructureCreateInfoNV;

   struct BindAccelerationStructureMemoryInfoNV;

   struct WriteDescriptorSetAccelerationStructureNV;

   struct AccelerationStructureMemoryRequirementsInfoNV;

   struct PhysicalDeviceRayTracingPropertiesNV;


   //=== VK_NV_representative_fragment_test ===

   struct PhysicalDeviceRepresentativeFragmentTestFeaturesNV;

   struct PipelineRepresentativeFragmentTestStateCreateInfoNV;


   //=== VK_EXT_filter_cubic ===

   struct PhysicalDeviceImageViewImageFormatInfoEXT;

   struct FilterCubicImageViewImageFormatPropertiesEXT;


   //=== VK_EXT_external_memory_host ===

   struct ImportMemoryHostPointerInfoEXT;

   struct MemoryHostPointerPropertiesEXT;

   struct PhysicalDeviceExternalMemoryHostPropertiesEXT;


   //=== VK_KHR_shader_clock ===

   struct PhysicalDeviceShaderClockFeaturesKHR;


   //=== VK_AMD_pipeline_compiler_control ===

   struct PipelineCompilerControlCreateInfoAMD;


   //=== VK_EXT_calibrated_timestamps ===

   struct CalibratedTimestampInfoEXT;


   //=== VK_AMD_shader_core_properties ===

   struct PhysicalDeviceShaderCorePropertiesAMD;


 #if defined( VK_ENABLE_BETA_EXTENSIONS )

   //=== VK_EXT_video_decode_h265 ===

   struct VideoDecodeH265ProfileInfoEXT;

   struct VideoDecodeH265CapabilitiesEXT;

   struct VideoDecodeH265SessionParametersCreateInfoEXT;

   struct VideoDecodeH265SessionParametersAddInfoEXT;

   struct VideoDecodeH265PictureInfoEXT;

   struct VideoDecodeH265DpbSlotInfoEXT;

 #endif /*VK_ENABLE_BETA_EXTENSIONS*/


   //=== VK_KHR_global_priority ===

   struct DeviceQueueGlobalPriorityCreateInfoKHR;

   using DeviceQueueGlobalPriorityCreateInfoEXT = DeviceQueueGlobalPriorityCreateInfoKHR;

   struct PhysicalDeviceGlobalPriorityQueryFeaturesKHR;

   using PhysicalDeviceGlobalPriorityQueryFeaturesEXT = PhysicalDeviceGlobalPriorityQueryFeaturesKHR;

   struct QueueFamilyGlobalPriorityPropertiesKHR;

   using QueueFamilyGlobalPriorityPropertiesEXT = QueueFamilyGlobalPriorityPropertiesKHR;


   //=== VK_AMD_memory_overallocation_behavior ===

   struct DeviceMemoryOverallocationCreateInfoAMD;


   //=== VK_EXT_vertex_attribute_divisor ===

   struct PhysicalDeviceVertexAttributeDivisorPropertiesEXT;

   struct VertexInputBindingDivisorDescriptionEXT;

   struct PipelineVertexInputDivisorStateCreateInfoEXT;

   struct PhysicalDeviceVertexAttributeDivisorFeaturesEXT;


 #if defined( VK_USE_PLATFORM_GGP )

   //=== VK_GGP_frame_token ===

   struct PresentFrameTokenGGP;

 #endif /*VK_USE_PLATFORM_GGP*/


   //=== VK_NV_compute_shader_derivatives ===

   struct PhysicalDeviceComputeShaderDerivativesFeaturesNV;


   //=== VK_NV_mesh_shader ===

   struct PhysicalDeviceMeshShaderFeaturesNV;

   struct PhysicalDeviceMeshShaderPropertiesNV;

   struct DrawMeshTasksIndirectCommandNV;


   //=== VK_NV_shader_image_footprint ===

   struct PhysicalDeviceShaderImageFootprintFeaturesNV;


   //=== VK_NV_scissor_exclusive ===

   struct PipelineViewportExclusiveScissorStateCreateInfoNV;

   struct PhysicalDeviceExclusiveScissorFeaturesNV;


   //=== VK_NV_device_diagnostic_checkpoints ===

   struct QueueFamilyCheckpointPropertiesNV;

   struct CheckpointDataNV;


   //=== VK_INTEL_shader_integer_functions2 ===

   struct PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL;


   //=== VK_INTEL_performance_query ===

   union PerformanceValueDataINTEL;

   struct PerformanceValueINTEL;

   struct InitializePerformanceApiInfoINTEL;

   struct QueryPoolPerformanceQueryCreateInfoINTEL;

   using QueryPoolCreateInfoINTEL = QueryPoolPerformanceQueryCreateInfoINTEL;

   struct PerformanceMarkerInfoINTEL;

   struct PerformanceStreamMarkerInfoINTEL;

   struct PerformanceOverrideInfoINTEL;

   struct PerformanceConfigurationAcquireInfoINTEL;


   //=== VK_EXT_pci_bus_info ===

   struct PhysicalDevicePCIBusInfoPropertiesEXT;


   //=== VK_AMD_display_native_hdr ===

   struct DisplayNativeHdrSurfaceCapabilitiesAMD;

   struct SwapchainDisplayNativeHdrCreateInfoAMD;


 #if defined( VK_USE_PLATFORM_FUCHSIA )

   //=== VK_FUCHSIA_imagepipe_surface ===

   struct ImagePipeSurfaceCreateInfoFUCHSIA;

 #endif /*VK_USE_PLATFORM_FUCHSIA*/


 #if defined( VK_USE_PLATFORM_METAL_EXT )

   //=== VK_EXT_metal_surface ===

   struct MetalSurfaceCreateInfoEXT;

 #endif /*VK_USE_PLATFORM_METAL_EXT*/


   //=== VK_EXT_fragment_density_map ===

   struct PhysicalDeviceFragmentDensityMapFeaturesEXT;

   struct PhysicalDeviceFragmentDensityMapPropertiesEXT;

   struct RenderPassFragmentDensityMapCreateInfoEXT;


   //=== VK_KHR_fragment_shading_rate ===

   struct FragmentShadingRateAttachmentInfoKHR;

   struct PipelineFragmentShadingRateStateCreateInfoKHR;

   struct PhysicalDeviceFragmentShadingRateFeaturesKHR;

   struct PhysicalDeviceFragmentShadingRatePropertiesKHR;

   struct PhysicalDeviceFragmentShadingRateKHR;


   //=== VK_AMD_shader_core_properties2 ===

   struct PhysicalDeviceShaderCoreProperties2AMD;


   //=== VK_AMD_device_coherent_memory ===

   struct PhysicalDeviceCoherentMemoryFeaturesAMD;


   //=== VK_EXT_shader_image_atomic_int64 ===

   struct PhysicalDeviceShaderImageAtomicInt64FeaturesEXT;


   //=== VK_EXT_memory_budget ===

   struct PhysicalDeviceMemoryBudgetPropertiesEXT;


   //=== VK_EXT_memory_priority ===

   struct PhysicalDeviceMemoryPriorityFeaturesEXT;

   struct MemoryPriorityAllocateInfoEXT;


   //=== VK_KHR_surface_protected_capabilities ===

   struct SurfaceProtectedCapabilitiesKHR;


   //=== VK_NV_dedicated_allocation_image_aliasing ===

   struct PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV;


   //=== VK_EXT_buffer_device_address ===

   struct PhysicalDeviceBufferDeviceAddressFeaturesEXT;

   using PhysicalDeviceBufferAddressFeaturesEXT = PhysicalDeviceBufferDeviceAddressFeaturesEXT;

   struct BufferDeviceAddressCreateInfoEXT;


   //=== VK_EXT_validation_features ===

   struct ValidationFeaturesEXT;


   //=== VK_KHR_present_wait ===

   struct PhysicalDevicePresentWaitFeaturesKHR;


   //=== VK_NV_cooperative_matrix ===

   struct CooperativeMatrixPropertiesNV;

   struct PhysicalDeviceCooperativeMatrixFeaturesNV;

   struct PhysicalDeviceCooperativeMatrixPropertiesNV;


   //=== VK_NV_coverage_reduction_mode ===

   struct PhysicalDeviceCoverageReductionModeFeaturesNV;

   struct PipelineCoverageReductionStateCreateInfoNV;

   struct FramebufferMixedSamplesCombinationNV;


   //=== VK_EXT_fragment_shader_interlock ===

   struct PhysicalDeviceFragmentShaderInterlockFeaturesEXT;


   //=== VK_EXT_ycbcr_image_arrays ===

   struct PhysicalDeviceYcbcrImageArraysFeaturesEXT;


   //=== VK_EXT_provoking_vertex ===

   struct PhysicalDeviceProvokingVertexFeaturesEXT;

   struct PhysicalDeviceProvokingVertexPropertiesEXT;

   struct PipelineRasterizationProvokingVertexStateCreateInfoEXT;


 #if defined( VK_USE_PLATFORM_WIN32_KHR )

   //=== VK_EXT_full_screen_exclusive ===

   struct SurfaceFullScreenExclusiveInfoEXT;

   struct SurfaceCapabilitiesFullScreenExclusiveEXT;

   struct SurfaceFullScreenExclusiveWin32InfoEXT;

 #endif /*VK_USE_PLATFORM_WIN32_KHR*/


   //=== VK_EXT_headless_surface ===

   struct HeadlessSurfaceCreateInfoEXT;


   //=== VK_EXT_line_rasterization ===

   struct PhysicalDeviceLineRasterizationFeaturesEXT;

   struct PhysicalDeviceLineRasterizationPropertiesEXT;

   struct PipelineRasterizationLineStateCreateInfoEXT;


   //=== VK_EXT_shader_atomic_float ===

   struct PhysicalDeviceShaderAtomicFloatFeaturesEXT;


   //=== VK_EXT_index_type_uint8 ===

   struct PhysicalDeviceIndexTypeUint8FeaturesEXT;


   //=== VK_EXT_extended_dynamic_state ===

   struct PhysicalDeviceExtendedDynamicStateFeaturesEXT;


   //=== VK_KHR_pipeline_executable_properties ===

   struct PhysicalDevicePipelineExecutablePropertiesFeaturesKHR;

   struct PipelineInfoKHR;

   using PipelineInfoEXT = PipelineInfoKHR;

   struct PipelineExecutablePropertiesKHR;

   struct PipelineExecutableInfoKHR;

   union PipelineExecutableStatisticValueKHR;

   struct PipelineExecutableStatisticKHR;

   struct PipelineExecutableInternalRepresentationKHR;


   //=== VK_EXT_shader_atomic_float2 ===

   struct PhysicalDeviceShaderAtomicFloat2FeaturesEXT;


   //=== VK_NV_device_generated_commands ===

   struct PhysicalDeviceDeviceGeneratedCommandsPropertiesNV;

   struct PhysicalDeviceDeviceGeneratedCommandsFeaturesNV;

   struct GraphicsShaderGroupCreateInfoNV;

   struct GraphicsPipelineShaderGroupsCreateInfoNV;

   struct BindShaderGroupIndirectCommandNV;

   struct BindIndexBufferIndirectCommandNV;

   struct BindVertexBufferIndirectCommandNV;

   struct SetStateFlagsIndirectCommandNV;

   struct IndirectCommandsStreamNV;

   struct IndirectCommandsLayoutTokenNV;

   struct IndirectCommandsLayoutCreateInfoNV;

   struct GeneratedCommandsInfoNV;

   struct GeneratedCommandsMemoryRequirementsInfoNV;


   //=== VK_NV_inherited_viewport_scissor ===

   struct PhysicalDeviceInheritedViewportScissorFeaturesNV;

   struct CommandBufferInheritanceViewportScissorInfoNV;


   //=== VK_EXT_texel_buffer_alignment ===

   struct PhysicalDeviceTexelBufferAlignmentFeaturesEXT;


   //=== VK_QCOM_render_pass_transform ===

   struct RenderPassTransformBeginInfoQCOM;

   struct CommandBufferInheritanceRenderPassTransformInfoQCOM;


   //=== VK_EXT_device_memory_report ===

   struct PhysicalDeviceDeviceMemoryReportFeaturesEXT;

   struct DeviceDeviceMemoryReportCreateInfoEXT;

   struct DeviceMemoryReportCallbackDataEXT;


   //=== VK_EXT_robustness2 ===

   struct PhysicalDeviceRobustness2FeaturesEXT;

   struct PhysicalDeviceRobustness2PropertiesEXT;


   //=== VK_EXT_custom_border_color ===

   struct SamplerCustomBorderColorCreateInfoEXT;

   struct PhysicalDeviceCustomBorderColorPropertiesEXT;

   struct PhysicalDeviceCustomBorderColorFeaturesEXT;


   //=== VK_KHR_pipeline_library ===

   struct PipelineLibraryCreateInfoKHR;


   //=== VK_NV_present_barrier ===

   struct PhysicalDevicePresentBarrierFeaturesNV;

   struct SurfaceCapabilitiesPresentBarrierNV;

   struct SwapchainPresentBarrierCreateInfoNV;


   //=== VK_KHR_present_id ===

   struct PresentIdKHR;

   struct PhysicalDevicePresentIdFeaturesKHR;


 #if defined( VK_ENABLE_BETA_EXTENSIONS )

   //=== VK_KHR_video_encode_queue ===

   struct VideoEncodeInfoKHR;

   struct VideoEncodeCapabilitiesKHR;

   struct VideoEncodeUsageInfoKHR;

   struct VideoEncodeRateControlInfoKHR;

   struct VideoEncodeRateControlLayerInfoKHR;

 #endif /*VK_ENABLE_BETA_EXTENSIONS*/


   //=== VK_NV_device_diagnostics_config ===

   struct PhysicalDeviceDiagnosticsConfigFeaturesNV;

   struct DeviceDiagnosticsConfigCreateInfoNV;


 #if defined( VK_USE_PLATFORM_METAL_EXT )

   //=== VK_EXT_metal_objects ===

   struct ExportMetalObjectCreateInfoEXT;

   struct ExportMetalObjectsInfoEXT;

   struct ExportMetalDeviceInfoEXT;

   struct ExportMetalCommandQueueInfoEXT;

   struct ExportMetalBufferInfoEXT;

   struct ImportMetalBufferInfoEXT;

   struct ExportMetalTextureInfoEXT;

   struct ImportMetalTextureInfoEXT;

   struct ExportMetalIOSurfaceInfoEXT;

   struct ImportMetalIOSurfaceInfoEXT;

   struct ExportMetalSharedEventInfoEXT;

   struct ImportMetalSharedEventInfoEXT;

 #endif /*VK_USE_PLATFORM_METAL_EXT*/


   //=== VK_KHR_synchronization2 ===

   struct QueueFamilyCheckpointProperties2NV;

   struct CheckpointData2NV;


   //=== VK_EXT_descriptor_buffer ===

   struct PhysicalDeviceDescriptorBufferPropertiesEXT;

   struct PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT;

   struct PhysicalDeviceDescriptorBufferFeaturesEXT;

   struct DescriptorAddressInfoEXT;

   struct DescriptorBufferBindingInfoEXT;

   struct DescriptorBufferBindingPushDescriptorBufferHandleEXT;

   union DescriptorDataEXT;

   struct DescriptorGetInfoEXT;

   struct BufferCaptureDescriptorDataInfoEXT;

   struct ImageCaptureDescriptorDataInfoEXT;

   struct ImageViewCaptureDescriptorDataInfoEXT;

   struct SamplerCaptureDescriptorDataInfoEXT;

   struct OpaqueCaptureDescriptorDataCreateInfoEXT;

   struct AccelerationStructureCaptureDescriptorDataInfoEXT;


   //=== VK_EXT_graphics_pipeline_library ===

   struct PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT;

   struct PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT;

   struct GraphicsPipelineLibraryCreateInfoEXT;


   //=== VK_AMD_shader_early_and_late_fragment_tests ===

   struct PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD;


   //=== VK_KHR_fragment_shader_barycentric ===

   struct PhysicalDeviceFragmentShaderBarycentricFeaturesKHR;

   using PhysicalDeviceFragmentShaderBarycentricFeaturesNV = PhysicalDeviceFragmentShaderBarycentricFeaturesKHR;

   struct PhysicalDeviceFragmentShaderBarycentricPropertiesKHR;


   //=== VK_KHR_shader_subgroup_uniform_control_flow ===

   struct PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR;


   //=== VK_NV_fragment_shading_rate_enums ===

   struct PhysicalDeviceFragmentShadingRateEnumsFeaturesNV;

   struct PhysicalDeviceFragmentShadingRateEnumsPropertiesNV;

   struct PipelineFragmentShadingRateEnumStateCreateInfoNV;


   //=== VK_NV_ray_tracing_motion_blur ===

   struct AccelerationStructureGeometryMotionTrianglesDataNV;

   struct AccelerationStructureMotionInfoNV;

   struct AccelerationStructureMotionInstanceNV;

   union AccelerationStructureMotionInstanceDataNV;

   struct AccelerationStructureMatrixMotionInstanceNV;

   struct AccelerationStructureSRTMotionInstanceNV;

   struct SRTDataNV;

   struct PhysicalDeviceRayTracingMotionBlurFeaturesNV;


   //=== VK_EXT_mesh_shader ===

   struct PhysicalDeviceMeshShaderFeaturesEXT;

   struct PhysicalDeviceMeshShaderPropertiesEXT;

   struct DrawMeshTasksIndirectCommandEXT;


   //=== VK_EXT_ycbcr_2plane_444_formats ===

   struct PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT;


   //=== VK_EXT_fragment_density_map2 ===

   struct PhysicalDeviceFragmentDensityMap2FeaturesEXT;

   struct PhysicalDeviceFragmentDensityMap2PropertiesEXT;


   //=== VK_QCOM_rotated_copy_commands ===

   struct CopyCommandTransformInfoQCOM;


   //=== VK_KHR_workgroup_memory_explicit_layout ===

   struct PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR;


   //=== VK_EXT_image_compression_control ===

   struct PhysicalDeviceImageCompressionControlFeaturesEXT;

   struct ImageCompressionControlEXT;

   struct SubresourceLayout2EXT;

   struct ImageSubresource2EXT;

   struct ImageCompressionPropertiesEXT;


   //=== VK_EXT_attachment_feedback_loop_layout ===

   struct PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT;


   //=== VK_EXT_4444_formats ===

   struct PhysicalDevice4444FormatsFeaturesEXT;


   //=== VK_EXT_device_fault ===

   struct PhysicalDeviceFaultFeaturesEXT;

   struct DeviceFaultCountsEXT;

   struct DeviceFaultInfoEXT;

   struct DeviceFaultAddressInfoEXT;

   struct DeviceFaultVendorInfoEXT;

   struct DeviceFaultVendorBinaryHeaderVersionOneEXT;


   //=== VK_EXT_rgba10x6_formats ===

   struct PhysicalDeviceRGBA10X6FormatsFeaturesEXT;


 #if defined( VK_USE_PLATFORM_DIRECTFB_EXT )

   //=== VK_EXT_directfb_surface ===

   struct DirectFBSurfaceCreateInfoEXT;

 #endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/


   //=== VK_KHR_ray_tracing_pipeline ===

   struct RayTracingShaderGroupCreateInfoKHR;

   struct RayTracingPipelineCreateInfoKHR;

   struct PhysicalDeviceRayTracingPipelineFeaturesKHR;

   struct PhysicalDeviceRayTracingPipelinePropertiesKHR;

   struct StridedDeviceAddressRegionKHR;

   struct TraceRaysIndirectCommandKHR;

   struct RayTracingPipelineInterfaceCreateInfoKHR;


   //=== VK_KHR_ray_query ===

   struct PhysicalDeviceRayQueryFeaturesKHR;


   //=== VK_EXT_vertex_input_dynamic_state ===

   struct PhysicalDeviceVertexInputDynamicStateFeaturesEXT;

   struct VertexInputBindingDescription2EXT;

   struct VertexInputAttributeDescription2EXT;


   //=== VK_EXT_physical_device_drm ===

   struct PhysicalDeviceDrmPropertiesEXT;


   //=== VK_EXT_device_address_binding_report ===

   struct PhysicalDeviceAddressBindingReportFeaturesEXT;

   struct DeviceAddressBindingCallbackDataEXT;


   //=== VK_EXT_depth_clip_control ===

   struct PhysicalDeviceDepthClipControlFeaturesEXT;

   struct PipelineViewportDepthClipControlCreateInfoEXT;


   //=== VK_EXT_primitive_topology_list_restart ===

   struct PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT;


 #if defined( VK_USE_PLATFORM_FUCHSIA )

   //=== VK_FUCHSIA_external_memory ===

   struct ImportMemoryZirconHandleInfoFUCHSIA;

   struct MemoryZirconHandlePropertiesFUCHSIA;

   struct MemoryGetZirconHandleInfoFUCHSIA;

 #endif /*VK_USE_PLATFORM_FUCHSIA*/


 #if defined( VK_USE_PLATFORM_FUCHSIA )

   //=== VK_FUCHSIA_external_semaphore ===

   struct ImportSemaphoreZirconHandleInfoFUCHSIA;

   struct SemaphoreGetZirconHandleInfoFUCHSIA;

 #endif /*VK_USE_PLATFORM_FUCHSIA*/


 #if defined( VK_USE_PLATFORM_FUCHSIA )

   //=== VK_FUCHSIA_buffer_collection ===

   struct BufferCollectionCreateInfoFUCHSIA;

   struct ImportMemoryBufferCollectionFUCHSIA;

   struct BufferCollectionImageCreateInfoFUCHSIA;

   struct BufferConstraintsInfoFUCHSIA;

   struct BufferCollectionBufferCreateInfoFUCHSIA;

   struct BufferCollectionPropertiesFUCHSIA;

   struct SysmemColorSpaceFUCHSIA;

   struct ImageConstraintsInfoFUCHSIA;

   struct ImageFormatConstraintsInfoFUCHSIA;

   struct BufferCollectionConstraintsInfoFUCHSIA;

 #endif /*VK_USE_PLATFORM_FUCHSIA*/


   //=== VK_HUAWEI_subpass_shading ===

   struct SubpassShadingPipelineCreateInfoHUAWEI;

   struct PhysicalDeviceSubpassShadingFeaturesHUAWEI;

   struct PhysicalDeviceSubpassShadingPropertiesHUAWEI;


   //=== VK_HUAWEI_invocation_mask ===

   struct PhysicalDeviceInvocationMaskFeaturesHUAWEI;


   //=== VK_NV_external_memory_rdma ===

   struct MemoryGetRemoteAddressInfoNV;

   struct PhysicalDeviceExternalMemoryRDMAFeaturesNV;


   //=== VK_EXT_pipeline_properties ===

   struct PipelinePropertiesIdentifierEXT;

   struct PhysicalDevicePipelinePropertiesFeaturesEXT;


   //=== VK_EXT_multisampled_render_to_single_sampled ===

   struct PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT;

   struct SubpassResolvePerformanceQueryEXT;

   struct MultisampledRenderToSingleSampledInfoEXT;


   //=== VK_EXT_extended_dynamic_state2 ===

   struct PhysicalDeviceExtendedDynamicState2FeaturesEXT;


 #if defined( VK_USE_PLATFORM_SCREEN_QNX )

   //=== VK_QNX_screen_surface ===

   struct ScreenSurfaceCreateInfoQNX;

 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/


   //=== VK_EXT_color_write_enable ===

   struct PhysicalDeviceColorWriteEnableFeaturesEXT;

   struct PipelineColorWriteCreateInfoEXT;


   //=== VK_EXT_primitives_generated_query ===

   struct PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT;


   //=== VK_KHR_ray_tracing_maintenance1 ===

   struct PhysicalDeviceRayTracingMaintenance1FeaturesKHR;

   struct TraceRaysIndirectCommand2KHR;


   //=== VK_EXT_image_view_min_lod ===

   struct PhysicalDeviceImageViewMinLodFeaturesEXT;

   struct ImageViewMinLodCreateInfoEXT;


   //=== VK_EXT_multi_draw ===

   struct PhysicalDeviceMultiDrawFeaturesEXT;

   struct PhysicalDeviceMultiDrawPropertiesEXT;

   struct MultiDrawInfoEXT;

   struct MultiDrawIndexedInfoEXT;


   //=== VK_EXT_image_2d_view_of_3d ===

   struct PhysicalDeviceImage2DViewOf3DFeaturesEXT;


   //=== VK_EXT_opacity_micromap ===

   struct MicromapBuildInfoEXT;

   struct MicromapUsageEXT;

   struct MicromapCreateInfoEXT;

   struct PhysicalDeviceOpacityMicromapFeaturesEXT;

   struct PhysicalDeviceOpacityMicromapPropertiesEXT;

   struct MicromapVersionInfoEXT;

   struct CopyMicromapToMemoryInfoEXT;

   struct CopyMemoryToMicromapInfoEXT;

   struct CopyMicromapInfoEXT;

   struct MicromapBuildSizesInfoEXT;

   struct AccelerationStructureTrianglesOpacityMicromapEXT;

   struct MicromapTriangleEXT;


   //=== VK_EXT_border_color_swizzle ===

   struct PhysicalDeviceBorderColorSwizzleFeaturesEXT;

   struct SamplerBorderColorComponentMappingCreateInfoEXT;


   //=== VK_EXT_pageable_device_local_memory ===

   struct PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT;


   //=== VK_VALVE_descriptor_set_host_mapping ===

   struct PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE;

   struct DescriptorSetBindingReferenceVALVE;

   struct DescriptorSetLayoutHostMappingInfoVALVE;


   //=== VK_EXT_depth_clamp_zero_one ===

   struct PhysicalDeviceDepthClampZeroOneFeaturesEXT;


   //=== VK_EXT_non_seamless_cube_map ===

   struct PhysicalDeviceNonSeamlessCubeMapFeaturesEXT;


   //=== VK_QCOM_fragment_density_map_offset ===

   struct PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM;

   struct PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM;

   struct SubpassFragmentDensityMapOffsetEndInfoQCOM;


   //=== VK_NV_copy_memory_indirect ===

   struct CopyMemoryIndirectCommandNV;

   struct CopyMemoryToImageIndirectCommandNV;

   struct PhysicalDeviceCopyMemoryIndirectFeaturesNV;

   struct PhysicalDeviceCopyMemoryIndirectPropertiesNV;


   //=== VK_NV_memory_decompression ===

   struct DecompressMemoryRegionNV;

   struct PhysicalDeviceMemoryDecompressionFeaturesNV;

   struct PhysicalDeviceMemoryDecompressionPropertiesNV;


   //=== VK_NV_linear_color_attachment ===

   struct PhysicalDeviceLinearColorAttachmentFeaturesNV;


   //=== VK_EXT_image_compression_control_swapchain ===

   struct PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT;


   //=== VK_QCOM_image_processing ===

   struct ImageViewSampleWeightCreateInfoQCOM;

   struct PhysicalDeviceImageProcessingFeaturesQCOM;

   struct PhysicalDeviceImageProcessingPropertiesQCOM;


   //=== VK_EXT_extended_dynamic_state3 ===

   struct PhysicalDeviceExtendedDynamicState3FeaturesEXT;

   struct PhysicalDeviceExtendedDynamicState3PropertiesEXT;

   struct ColorBlendEquationEXT;

   struct ColorBlendAdvancedEXT;


   //=== VK_EXT_subpass_merge_feedback ===

   struct PhysicalDeviceSubpassMergeFeedbackFeaturesEXT;

   struct RenderPassCreationControlEXT;

   struct RenderPassCreationFeedbackInfoEXT;

   struct RenderPassCreationFeedbackCreateInfoEXT;

   struct RenderPassSubpassFeedbackInfoEXT;

   struct RenderPassSubpassFeedbackCreateInfoEXT;


   //=== VK_LUNARG_direct_driver_loading ===

   struct DirectDriverLoadingInfoLUNARG;

   struct DirectDriverLoadingListLUNARG;


   //=== VK_EXT_shader_module_identifier ===

   struct PhysicalDeviceShaderModuleIdentifierFeaturesEXT;

   struct PhysicalDeviceShaderModuleIdentifierPropertiesEXT;

   struct PipelineShaderStageModuleIdentifierCreateInfoEXT;

   struct ShaderModuleIdentifierEXT;


   //=== VK_EXT_rasterization_order_attachment_access ===

   struct PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT;

   using PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM = PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT;


   //=== VK_NV_optical_flow ===

   struct PhysicalDeviceOpticalFlowFeaturesNV;

   struct PhysicalDeviceOpticalFlowPropertiesNV;

   struct OpticalFlowImageFormatInfoNV;

   struct OpticalFlowImageFormatPropertiesNV;

   struct OpticalFlowSessionCreateInfoNV;

   struct OpticalFlowSessionCreatePrivateDataInfoNV;

   struct OpticalFlowExecuteInfoNV;


   //=== VK_EXT_legacy_dithering ===

   struct PhysicalDeviceLegacyDitheringFeaturesEXT;


   //=== VK_EXT_pipeline_protected_access ===

   struct PhysicalDevicePipelineProtectedAccessFeaturesEXT;


   //=== VK_QCOM_tile_properties ===

   struct PhysicalDeviceTilePropertiesFeaturesQCOM;

   struct TilePropertiesQCOM;


   //=== VK_SEC_amigo_profiling ===

   struct PhysicalDeviceAmigoProfilingFeaturesSEC;

   struct AmigoProfilingSubmitInfoSEC;


   //=== VK_QCOM_multiview_per_view_viewports ===

   struct PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM;


   //=== VK_NV_ray_tracing_invocation_reorder ===

   struct PhysicalDeviceRayTracingInvocationReorderPropertiesNV;

   struct PhysicalDeviceRayTracingInvocationReorderFeaturesNV;


   //=== VK_EXT_mutable_descriptor_type ===

   struct PhysicalDeviceMutableDescriptorTypeFeaturesEXT;

   using PhysicalDeviceMutableDescriptorTypeFeaturesVALVE = PhysicalDeviceMutableDescriptorTypeFeaturesEXT;

   struct MutableDescriptorTypeListEXT;

   using MutableDescriptorTypeListVALVE = MutableDescriptorTypeListEXT;

   struct MutableDescriptorTypeCreateInfoEXT;

   using MutableDescriptorTypeCreateInfoVALVE = MutableDescriptorTypeCreateInfoEXT;


   //=== VK_ARM_shader_core_builtins ===

   struct PhysicalDeviceShaderCoreBuiltinsFeaturesARM;

   struct PhysicalDeviceShaderCoreBuiltinsPropertiesARM;


   //===============

   //=== HANDLEs ===

   //===============


   template <typename Type>

   struct isVulkanHandleType

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = false;

   };


   class SurfaceKHR

   {

   public:

     using CType      = VkSurfaceKHR;

     using NativeType = VkSurfaceKHR;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eSurfaceKHR;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSurfaceKHR;


   public:

     VULKAN_HPP_CONSTEXPR         SurfaceKHR() = default;

     VULKAN_HPP_CONSTEXPR         SurfaceKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}

     VULKAN_HPP_TYPESAFE_EXPLICIT SurfaceKHR( VkSurfaceKHR surfaceKHR ) VULKAN_HPP_NOEXCEPT : m_surfaceKHR( surfaceKHR ) {}


 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     SurfaceKHR & operator=( VkSurfaceKHR surfaceKHR ) VULKAN_HPP_NOEXCEPT

     {

       m_surfaceKHR = surfaceKHR;

       return *this;

     }

 #endif


     SurfaceKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_surfaceKHR = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( SurfaceKHR const & ) const = default;

 #else

     bool operator==( SurfaceKHR const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_surfaceKHR == rhs.m_surfaceKHR;

     }


     bool operator!=( SurfaceKHR const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_surfaceKHR != rhs.m_surfaceKHR;

     }


     bool operator<( SurfaceKHR const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_surfaceKHR < rhs.m_surfaceKHR;

     }

 #endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSurfaceKHR() const VULKAN_HPP_NOEXCEPT

     {

       return m_surfaceKHR;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_surfaceKHR != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_surfaceKHR == VK_NULL_HANDLE;

     }


   private:

     VkSurfaceKHR m_surfaceKHR = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eSurfaceKHR>

   {

     using Type = VULKAN_HPP_NAMESPACE::SurfaceKHR;

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSurfaceKHR>

   {

     using Type = VULKAN_HPP_NAMESPACE::SurfaceKHR;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::SurfaceKHR>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


   class DebugReportCallbackEXT

   {

   public:

     using CType      = VkDebugReportCallbackEXT;

     using NativeType = VkDebugReportCallbackEXT;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDebugReportCallbackEXT;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDebugReportCallbackEXT;


   public:

     VULKAN_HPP_CONSTEXPR         DebugReportCallbackEXT() = default;

     VULKAN_HPP_CONSTEXPR         DebugReportCallbackEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}

     VULKAN_HPP_TYPESAFE_EXPLICIT DebugReportCallbackEXT( VkDebugReportCallbackEXT debugReportCallbackEXT ) VULKAN_HPP_NOEXCEPT

       : m_debugReportCallbackEXT( debugReportCallbackEXT )

     {

     }


 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     DebugReportCallbackEXT & operator=( VkDebugReportCallbackEXT debugReportCallbackEXT ) VULKAN_HPP_NOEXCEPT

     {

       m_debugReportCallbackEXT = debugReportCallbackEXT;

       return *this;

     }

 #endif


     DebugReportCallbackEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_debugReportCallbackEXT = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( DebugReportCallbackEXT const & ) const = default;

 #else

     bool operator==( DebugReportCallbackEXT const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_debugReportCallbackEXT == rhs.m_debugReportCallbackEXT;

     }


     bool operator!=( DebugReportCallbackEXT const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_debugReportCallbackEXT != rhs.m_debugReportCallbackEXT;

     }


     bool operator<( DebugReportCallbackEXT const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_debugReportCallbackEXT < rhs.m_debugReportCallbackEXT;

     }

 #endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDebugReportCallbackEXT() const VULKAN_HPP_NOEXCEPT

     {

       return m_debugReportCallbackEXT;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_debugReportCallbackEXT != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_debugReportCallbackEXT == VK_NULL_HANDLE;

     }


   private:

     VkDebugReportCallbackEXT m_debugReportCallbackEXT = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDebugReportCallbackEXT>

   {

     using Type = VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT;

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDebugReportCallbackEXT>

   {

     using Type = VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


   class DebugUtilsMessengerEXT

   {

   public:

     using CType      = VkDebugUtilsMessengerEXT;

     using NativeType = VkDebugUtilsMessengerEXT;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDebugUtilsMessengerEXT;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;


   public:

     VULKAN_HPP_CONSTEXPR         DebugUtilsMessengerEXT() = default;

     VULKAN_HPP_CONSTEXPR         DebugUtilsMessengerEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}

     VULKAN_HPP_TYPESAFE_EXPLICIT DebugUtilsMessengerEXT( VkDebugUtilsMessengerEXT debugUtilsMessengerEXT ) VULKAN_HPP_NOEXCEPT

       : m_debugUtilsMessengerEXT( debugUtilsMessengerEXT )

     {

     }


 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     DebugUtilsMessengerEXT & operator=( VkDebugUtilsMessengerEXT debugUtilsMessengerEXT ) VULKAN_HPP_NOEXCEPT

     {

       m_debugUtilsMessengerEXT = debugUtilsMessengerEXT;

       return *this;

     }

 #endif


     DebugUtilsMessengerEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_debugUtilsMessengerEXT = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( DebugUtilsMessengerEXT const & ) const = default;

 #else

     bool operator==( DebugUtilsMessengerEXT const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_debugUtilsMessengerEXT == rhs.m_debugUtilsMessengerEXT;

     }


     bool operator!=( DebugUtilsMessengerEXT const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_debugUtilsMessengerEXT != rhs.m_debugUtilsMessengerEXT;

     }


     bool operator<( DebugUtilsMessengerEXT const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_debugUtilsMessengerEXT < rhs.m_debugUtilsMessengerEXT;

     }

 #endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDebugUtilsMessengerEXT() const VULKAN_HPP_NOEXCEPT

     {

       return m_debugUtilsMessengerEXT;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_debugUtilsMessengerEXT != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_debugUtilsMessengerEXT == VK_NULL_HANDLE;

     }


   private:

     VkDebugUtilsMessengerEXT m_debugUtilsMessengerEXT = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDebugUtilsMessengerEXT>

   {

     using Type = VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


   class DisplayKHR

   {

   public:

     using CType      = VkDisplayKHR;

     using NativeType = VkDisplayKHR;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDisplayKHR;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDisplayKHR;


   public:

     VULKAN_HPP_CONSTEXPR         DisplayKHR() = default;

     VULKAN_HPP_CONSTEXPR         DisplayKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}

     VULKAN_HPP_TYPESAFE_EXPLICIT DisplayKHR( VkDisplayKHR displayKHR ) VULKAN_HPP_NOEXCEPT : m_displayKHR( displayKHR ) {}


 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     DisplayKHR & operator=( VkDisplayKHR displayKHR ) VULKAN_HPP_NOEXCEPT

     {

       m_displayKHR = displayKHR;

       return *this;

     }

 #endif


     DisplayKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_displayKHR = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( DisplayKHR const & ) const = default;

 #else

     bool operator==( DisplayKHR const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_displayKHR == rhs.m_displayKHR;

     }


     bool operator!=( DisplayKHR const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_displayKHR != rhs.m_displayKHR;

     }


     bool operator<( DisplayKHR const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_displayKHR < rhs.m_displayKHR;

     }

 #endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDisplayKHR() const VULKAN_HPP_NOEXCEPT

     {

       return m_displayKHR;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_displayKHR != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_displayKHR == VK_NULL_HANDLE;

     }


   private:

     VkDisplayKHR m_displayKHR = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDisplayKHR>

   {

     using Type = VULKAN_HPP_NAMESPACE::DisplayKHR;

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDisplayKHR>

   {

     using Type = VULKAN_HPP_NAMESPACE::DisplayKHR;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DisplayKHR>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


   class SwapchainKHR

   {

   public:

     using CType      = VkSwapchainKHR;

     using NativeType = VkSwapchainKHR;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eSwapchainKHR;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSwapchainKHR;


   public:

     VULKAN_HPP_CONSTEXPR         SwapchainKHR() = default;

     VULKAN_HPP_CONSTEXPR         SwapchainKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}

     VULKAN_HPP_TYPESAFE_EXPLICIT SwapchainKHR( VkSwapchainKHR swapchainKHR ) VULKAN_HPP_NOEXCEPT : m_swapchainKHR( swapchainKHR ) {}


 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     SwapchainKHR & operator=( VkSwapchainKHR swapchainKHR ) VULKAN_HPP_NOEXCEPT

     {

       m_swapchainKHR = swapchainKHR;

       return *this;

     }

 #endif


     SwapchainKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_swapchainKHR = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( SwapchainKHR const & ) const = default;

 #else

     bool operator==( SwapchainKHR const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_swapchainKHR == rhs.m_swapchainKHR;

     }


     bool operator!=( SwapchainKHR const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_swapchainKHR != rhs.m_swapchainKHR;

     }


     bool operator<( SwapchainKHR const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_swapchainKHR < rhs.m_swapchainKHR;

     }

 #endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSwapchainKHR() const VULKAN_HPP_NOEXCEPT

     {

       return m_swapchainKHR;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_swapchainKHR != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_swapchainKHR == VK_NULL_HANDLE;

     }


   private:

     VkSwapchainKHR m_swapchainKHR = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eSwapchainKHR>

   {

     using Type = VULKAN_HPP_NAMESPACE::SwapchainKHR;

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSwapchainKHR>

   {

     using Type = VULKAN_HPP_NAMESPACE::SwapchainKHR;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::SwapchainKHR>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


   class Semaphore

   {

   public:

     using CType      = VkSemaphore;

     using NativeType = VkSemaphore;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eSemaphore;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSemaphore;


   public:

     VULKAN_HPP_CONSTEXPR         Semaphore() = default;

     VULKAN_HPP_CONSTEXPR         Semaphore( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}

     VULKAN_HPP_TYPESAFE_EXPLICIT Semaphore( VkSemaphore semaphore ) VULKAN_HPP_NOEXCEPT : m_semaphore( semaphore ) {}


 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     Semaphore & operator=( VkSemaphore semaphore ) VULKAN_HPP_NOEXCEPT

     {

       m_semaphore = semaphore;

       return *this;

     }

 #endif


     Semaphore & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_semaphore = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( Semaphore const & ) const = default;

 #else

     bool operator==( Semaphore const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_semaphore == rhs.m_semaphore;

     }


     bool operator!=( Semaphore const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_semaphore != rhs.m_semaphore;

     }


     bool operator<( Semaphore const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_semaphore < rhs.m_semaphore;

     }

 #endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSemaphore() const VULKAN_HPP_NOEXCEPT

     {

       return m_semaphore;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_semaphore != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_semaphore == VK_NULL_HANDLE;

     }


   private:

     VkSemaphore m_semaphore = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eSemaphore>

   {

     using Type = VULKAN_HPP_NAMESPACE::Semaphore;

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSemaphore>

   {

     using Type = VULKAN_HPP_NAMESPACE::Semaphore;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Semaphore>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


   class Fence

   {

   public:

     using CType      = VkFence;

     using NativeType = VkFence;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eFence;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eFence;


   public:

     VULKAN_HPP_CONSTEXPR         Fence() = default;

     VULKAN_HPP_CONSTEXPR         Fence( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}

     VULKAN_HPP_TYPESAFE_EXPLICIT Fence( VkFence fence ) VULKAN_HPP_NOEXCEPT : m_fence( fence ) {}


 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     Fence & operator=( VkFence fence ) VULKAN_HPP_NOEXCEPT

     {

       m_fence = fence;

       return *this;

     }

 #endif


     Fence & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_fence = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( Fence const & ) const = default;

 #else

     bool operator==( Fence const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_fence == rhs.m_fence;

     }


     bool operator!=( Fence const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_fence != rhs.m_fence;

     }


     bool operator<( Fence const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_fence < rhs.m_fence;

     }

 #endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkFence() const VULKAN_HPP_NOEXCEPT

     {

       return m_fence;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_fence != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_fence == VK_NULL_HANDLE;

     }


   private:

     VkFence m_fence = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eFence>

   {

     using Type = VULKAN_HPP_NAMESPACE::Fence;

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eFence>

   {

     using Type = VULKAN_HPP_NAMESPACE::Fence;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Fence>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


   class PerformanceConfigurationINTEL

   {

   public:

     using CType      = VkPerformanceConfigurationINTEL;

     using NativeType = VkPerformanceConfigurationINTEL;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePerformanceConfigurationINTEL;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;


   public:

     VULKAN_HPP_CONSTEXPR         PerformanceConfigurationINTEL() = default;

     VULKAN_HPP_CONSTEXPR         PerformanceConfigurationINTEL( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}

     VULKAN_HPP_TYPESAFE_EXPLICIT PerformanceConfigurationINTEL( VkPerformanceConfigurationINTEL performanceConfigurationINTEL ) VULKAN_HPP_NOEXCEPT

       : m_performanceConfigurationINTEL( performanceConfigurationINTEL )

     {

     }


 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     PerformanceConfigurationINTEL & operator=( VkPerformanceConfigurationINTEL performanceConfigurationINTEL ) VULKAN_HPP_NOEXCEPT

     {

       m_performanceConfigurationINTEL = performanceConfigurationINTEL;

       return *this;

     }

 #endif


     PerformanceConfigurationINTEL & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_performanceConfigurationINTEL = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( PerformanceConfigurationINTEL const & ) const = default;

 #else

     bool operator==( PerformanceConfigurationINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_performanceConfigurationINTEL == rhs.m_performanceConfigurationINTEL;

     }


     bool operator!=( PerformanceConfigurationINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_performanceConfigurationINTEL != rhs.m_performanceConfigurationINTEL;

     }


     bool operator<( PerformanceConfigurationINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_performanceConfigurationINTEL < rhs.m_performanceConfigurationINTEL;

     }

 #endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPerformanceConfigurationINTEL() const VULKAN_HPP_NOEXCEPT

     {

       return m_performanceConfigurationINTEL;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_performanceConfigurationINTEL != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_performanceConfigurationINTEL == VK_NULL_HANDLE;

     }


   private:

     VkPerformanceConfigurationINTEL m_performanceConfigurationINTEL = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePerformanceConfigurationINTEL>

   {

     using Type = VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


   class QueryPool

   {

   public:

     using CType      = VkQueryPool;

     using NativeType = VkQueryPool;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eQueryPool;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eQueryPool;


   public:

     VULKAN_HPP_CONSTEXPR         QueryPool() = default;

     VULKAN_HPP_CONSTEXPR         QueryPool( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}

     VULKAN_HPP_TYPESAFE_EXPLICIT QueryPool( VkQueryPool queryPool ) VULKAN_HPP_NOEXCEPT : m_queryPool( queryPool ) {}


 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     QueryPool & operator=( VkQueryPool queryPool ) VULKAN_HPP_NOEXCEPT

     {

       m_queryPool = queryPool;

       return *this;

     }

 #endif


     QueryPool & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_queryPool = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( QueryPool const & ) const = default;

 #else

     bool operator==( QueryPool const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_queryPool == rhs.m_queryPool;

     }


     bool operator!=( QueryPool const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_queryPool != rhs.m_queryPool;

     }


     bool operator<( QueryPool const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_queryPool < rhs.m_queryPool;

     }

 #endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkQueryPool() const VULKAN_HPP_NOEXCEPT

     {

       return m_queryPool;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_queryPool != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_queryPool == VK_NULL_HANDLE;

     }


   private:

     VkQueryPool m_queryPool = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eQueryPool>

   {

     using Type = VULKAN_HPP_NAMESPACE::QueryPool;

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eQueryPool>

   {

     using Type = VULKAN_HPP_NAMESPACE::QueryPool;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::QueryPool>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


   class Buffer

   {

   public:

     using CType      = VkBuffer;

     using NativeType = VkBuffer;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eBuffer;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBuffer;


   public:

     VULKAN_HPP_CONSTEXPR         Buffer() = default;

     VULKAN_HPP_CONSTEXPR         Buffer( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}

     VULKAN_HPP_TYPESAFE_EXPLICIT Buffer( VkBuffer buffer ) VULKAN_HPP_NOEXCEPT : m_buffer( buffer ) {}


 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     Buffer & operator=( VkBuffer buffer ) VULKAN_HPP_NOEXCEPT

     {

       m_buffer = buffer;

       return *this;

     }

 #endif


     Buffer & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_buffer = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( Buffer const & ) const = default;

 #else

     bool operator==( Buffer const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_buffer == rhs.m_buffer;

     }


     bool operator!=( Buffer const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_buffer != rhs.m_buffer;

     }


     bool operator<( Buffer const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_buffer < rhs.m_buffer;

     }

 #endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkBuffer() const VULKAN_HPP_NOEXCEPT

     {

       return m_buffer;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_buffer != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_buffer == VK_NULL_HANDLE;

     }


   private:

     VkBuffer m_buffer = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eBuffer>

   {

     using Type = VULKAN_HPP_NAMESPACE::Buffer;

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBuffer>

   {

     using Type = VULKAN_HPP_NAMESPACE::Buffer;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Buffer>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


   class PipelineLayout

   {

   public:

     using CType      = VkPipelineLayout;

     using NativeType = VkPipelineLayout;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePipelineLayout;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipelineLayout;


   public:

     VULKAN_HPP_CONSTEXPR         PipelineLayout() = default;

     VULKAN_HPP_CONSTEXPR         PipelineLayout( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}

     VULKAN_HPP_TYPESAFE_EXPLICIT PipelineLayout( VkPipelineLayout pipelineLayout ) VULKAN_HPP_NOEXCEPT : m_pipelineLayout( pipelineLayout ) {}


 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     PipelineLayout & operator=( VkPipelineLayout pipelineLayout ) VULKAN_HPP_NOEXCEPT

     {

       m_pipelineLayout = pipelineLayout;

       return *this;

     }

 #endif


     PipelineLayout & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_pipelineLayout = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( PipelineLayout const & ) const = default;

 #else

     bool operator==( PipelineLayout const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_pipelineLayout == rhs.m_pipelineLayout;

     }


     bool operator!=( PipelineLayout const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_pipelineLayout != rhs.m_pipelineLayout;

     }


     bool operator<( PipelineLayout const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_pipelineLayout < rhs.m_pipelineLayout;

     }

 #endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipelineLayout() const VULKAN_HPP_NOEXCEPT

     {

       return m_pipelineLayout;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_pipelineLayout != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_pipelineLayout == VK_NULL_HANDLE;

     }


   private:

     VkPipelineLayout m_pipelineLayout = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePipelineLayout>

   {

     using Type = VULKAN_HPP_NAMESPACE::PipelineLayout;

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipelineLayout>

   {

     using Type = VULKAN_HPP_NAMESPACE::PipelineLayout;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::PipelineLayout>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


   class DescriptorSet

   {

   public:

     using CType      = VkDescriptorSet;

     using NativeType = VkDescriptorSet;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorSet;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorSet;


   public:

     VULKAN_HPP_CONSTEXPR         DescriptorSet() = default;

     VULKAN_HPP_CONSTEXPR         DescriptorSet( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}

     VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSet( VkDescriptorSet descriptorSet ) VULKAN_HPP_NOEXCEPT : m_descriptorSet( descriptorSet ) {}


 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     DescriptorSet & operator=( VkDescriptorSet descriptorSet ) VULKAN_HPP_NOEXCEPT

     {

       m_descriptorSet = descriptorSet;

       return *this;

     }

 #endif


     DescriptorSet & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_descriptorSet = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( DescriptorSet const & ) const = default;

 #else

     bool operator==( DescriptorSet const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_descriptorSet == rhs.m_descriptorSet;

     }


     bool operator!=( DescriptorSet const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_descriptorSet != rhs.m_descriptorSet;

     }


     bool operator<( DescriptorSet const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_descriptorSet < rhs.m_descriptorSet;

     }

 #endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorSet() const VULKAN_HPP_NOEXCEPT

     {

       return m_descriptorSet;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_descriptorSet != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_descriptorSet == VK_NULL_HANDLE;

     }


   private:

     VkDescriptorSet m_descriptorSet = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorSet>

   {

     using Type = VULKAN_HPP_NAMESPACE::DescriptorSet;

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorSet>

   {

     using Type = VULKAN_HPP_NAMESPACE::DescriptorSet;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DescriptorSet>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


   class ImageView

   {

   public:

     using CType      = VkImageView;

     using NativeType = VkImageView;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eImageView;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eImageView;


   public:

     VULKAN_HPP_CONSTEXPR         ImageView() = default;

     VULKAN_HPP_CONSTEXPR         ImageView( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}

     VULKAN_HPP_TYPESAFE_EXPLICIT ImageView( VkImageView imageView ) VULKAN_HPP_NOEXCEPT : m_imageView( imageView ) {}


 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     ImageView & operator=( VkImageView imageView ) VULKAN_HPP_NOEXCEPT

     {

       m_imageView = imageView;

       return *this;

     }

 #endif


     ImageView & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_imageView = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( ImageView const & ) const = default;

 #else

     bool operator==( ImageView const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_imageView == rhs.m_imageView;

     }


     bool operator!=( ImageView const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_imageView != rhs.m_imageView;

     }


     bool operator<( ImageView const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_imageView < rhs.m_imageView;

     }

 #endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkImageView() const VULKAN_HPP_NOEXCEPT

     {

       return m_imageView;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_imageView != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_imageView == VK_NULL_HANDLE;

     }


   private:

     VkImageView m_imageView = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eImageView>

   {

     using Type = VULKAN_HPP_NAMESPACE::ImageView;

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eImageView>

   {

     using Type = VULKAN_HPP_NAMESPACE::ImageView;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::ImageView>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


   class Pipeline

   {

   public:

     using CType      = VkPipeline;

     using NativeType = VkPipeline;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePipeline;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipeline;


   public:

     VULKAN_HPP_CONSTEXPR         Pipeline() = default;

     VULKAN_HPP_CONSTEXPR         Pipeline( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}

     VULKAN_HPP_TYPESAFE_EXPLICIT Pipeline( VkPipeline pipeline ) VULKAN_HPP_NOEXCEPT : m_pipeline( pipeline ) {}


 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     Pipeline & operator=( VkPipeline pipeline ) VULKAN_HPP_NOEXCEPT

     {

       m_pipeline = pipeline;

       return *this;

     }

 #endif


     Pipeline & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_pipeline = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( Pipeline const & ) const = default;

 #else

     bool operator==( Pipeline const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_pipeline == rhs.m_pipeline;

     }


     bool operator!=( Pipeline const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_pipeline != rhs.m_pipeline;

     }


     bool operator<( Pipeline const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_pipeline < rhs.m_pipeline;

     }

 #endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipeline() const VULKAN_HPP_NOEXCEPT

     {

       return m_pipeline;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_pipeline != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_pipeline == VK_NULL_HANDLE;

     }


   private:

     VkPipeline m_pipeline = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePipeline>

   {

     using Type = VULKAN_HPP_NAMESPACE::Pipeline;

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipeline>

   {

     using Type = VULKAN_HPP_NAMESPACE::Pipeline;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Pipeline>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


   class Image

   {

   public:

     using CType      = VkImage;

     using NativeType = VkImage;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eImage;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eImage;


   public:

     VULKAN_HPP_CONSTEXPR         Image() = default;

     VULKAN_HPP_CONSTEXPR         Image( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}

     VULKAN_HPP_TYPESAFE_EXPLICIT Image( VkImage image ) VULKAN_HPP_NOEXCEPT : m_image( image ) {}


 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     Image & operator=( VkImage image ) VULKAN_HPP_NOEXCEPT

     {

       m_image = image;

       return *this;

     }

 #endif


     Image & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_image = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( Image const & ) const = default;

 #else

     bool operator==( Image const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_image == rhs.m_image;

     }


     bool operator!=( Image const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_image != rhs.m_image;

     }


     bool operator<( Image const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_image < rhs.m_image;

     }

 #endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkImage() const VULKAN_HPP_NOEXCEPT

     {

       return m_image;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_image != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_image == VK_NULL_HANDLE;

     }


   private:

     VkImage m_image = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eImage>

   {

     using Type = VULKAN_HPP_NAMESPACE::Image;

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eImage>

   {

     using Type = VULKAN_HPP_NAMESPACE::Image;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Image>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


   class AccelerationStructureNV

   {

   public:

     using CType      = VkAccelerationStructureNV;

     using NativeType = VkAccelerationStructureNV;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eAccelerationStructureNV;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eAccelerationStructureNV;


   public:

     VULKAN_HPP_CONSTEXPR         AccelerationStructureNV() = default;

     VULKAN_HPP_CONSTEXPR         AccelerationStructureNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}

     VULKAN_HPP_TYPESAFE_EXPLICIT AccelerationStructureNV( VkAccelerationStructureNV accelerationStructureNV ) VULKAN_HPP_NOEXCEPT

       : m_accelerationStructureNV( accelerationStructureNV )

     {

     }


 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     AccelerationStructureNV & operator=( VkAccelerationStructureNV accelerationStructureNV ) VULKAN_HPP_NOEXCEPT

     {

       m_accelerationStructureNV = accelerationStructureNV;

       return *this;

     }

 #endif


     AccelerationStructureNV & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_accelerationStructureNV = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( AccelerationStructureNV const & ) const = default;

 #else

     bool operator==( AccelerationStructureNV const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_accelerationStructureNV == rhs.m_accelerationStructureNV;

     }


     bool operator!=( AccelerationStructureNV const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_accelerationStructureNV != rhs.m_accelerationStructureNV;

     }


     bool operator<( AccelerationStructureNV const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_accelerationStructureNV < rhs.m_accelerationStructureNV;

     }

 #endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkAccelerationStructureNV() const VULKAN_HPP_NOEXCEPT

     {

       return m_accelerationStructureNV;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_accelerationStructureNV != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_accelerationStructureNV == VK_NULL_HANDLE;

     }


   private:

     VkAccelerationStructureNV m_accelerationStructureNV = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eAccelerationStructureNV>

   {

     using Type = VULKAN_HPP_NAMESPACE::AccelerationStructureNV;

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eAccelerationStructureNV>

   {

     using Type = VULKAN_HPP_NAMESPACE::AccelerationStructureNV;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::AccelerationStructureNV>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


   class OpticalFlowSessionNV

   {

   public:

     using CType      = VkOpticalFlowSessionNV;

     using NativeType = VkOpticalFlowSessionNV;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eOpticalFlowSessionNV;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;


   public:

     VULKAN_HPP_CONSTEXPR         OpticalFlowSessionNV() = default;

     VULKAN_HPP_CONSTEXPR         OpticalFlowSessionNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}

     VULKAN_HPP_TYPESAFE_EXPLICIT OpticalFlowSessionNV( VkOpticalFlowSessionNV opticalFlowSessionNV ) VULKAN_HPP_NOEXCEPT

       : m_opticalFlowSessionNV( opticalFlowSessionNV )

     {

     }


 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     OpticalFlowSessionNV & operator=( VkOpticalFlowSessionNV opticalFlowSessionNV ) VULKAN_HPP_NOEXCEPT

     {

       m_opticalFlowSessionNV = opticalFlowSessionNV;

       return *this;

     }

 #endif


     OpticalFlowSessionNV & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_opticalFlowSessionNV = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( OpticalFlowSessionNV const & ) const = default;

 #else

     bool operator==( OpticalFlowSessionNV const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_opticalFlowSessionNV == rhs.m_opticalFlowSessionNV;

     }


     bool operator!=( OpticalFlowSessionNV const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_opticalFlowSessionNV != rhs.m_opticalFlowSessionNV;

     }


     bool operator<( OpticalFlowSessionNV const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_opticalFlowSessionNV < rhs.m_opticalFlowSessionNV;

     }

 #endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkOpticalFlowSessionNV() const VULKAN_HPP_NOEXCEPT

     {

       return m_opticalFlowSessionNV;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_opticalFlowSessionNV != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_opticalFlowSessionNV == VK_NULL_HANDLE;

     }


   private:

     VkOpticalFlowSessionNV m_opticalFlowSessionNV = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eOpticalFlowSessionNV>

   {

     using Type = VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


   class DescriptorUpdateTemplate

   {

   public:

     using CType      = VkDescriptorUpdateTemplate;

     using NativeType = VkDescriptorUpdateTemplate;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorUpdateTemplate;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorUpdateTemplate;


   public:

     VULKAN_HPP_CONSTEXPR         DescriptorUpdateTemplate() = default;

     VULKAN_HPP_CONSTEXPR         DescriptorUpdateTemplate( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}

     VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorUpdateTemplate( VkDescriptorUpdateTemplate descriptorUpdateTemplate ) VULKAN_HPP_NOEXCEPT

       : m_descriptorUpdateTemplate( descriptorUpdateTemplate )

     {

     }


 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     DescriptorUpdateTemplate & operator=( VkDescriptorUpdateTemplate descriptorUpdateTemplate ) VULKAN_HPP_NOEXCEPT

     {

       m_descriptorUpdateTemplate = descriptorUpdateTemplate;

       return *this;

     }

 #endif


     DescriptorUpdateTemplate & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_descriptorUpdateTemplate = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( DescriptorUpdateTemplate const & ) const = default;

 #else

     bool operator==( DescriptorUpdateTemplate const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_descriptorUpdateTemplate == rhs.m_descriptorUpdateTemplate;

     }


     bool operator!=( DescriptorUpdateTemplate const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_descriptorUpdateTemplate != rhs.m_descriptorUpdateTemplate;

     }


     bool operator<( DescriptorUpdateTemplate const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_descriptorUpdateTemplate < rhs.m_descriptorUpdateTemplate;

     }

 #endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorUpdateTemplate() const VULKAN_HPP_NOEXCEPT

     {

       return m_descriptorUpdateTemplate;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_descriptorUpdateTemplate != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_descriptorUpdateTemplate == VK_NULL_HANDLE;

     }


   private:

     VkDescriptorUpdateTemplate m_descriptorUpdateTemplate = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorUpdateTemplate>

   {

     using Type = VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate;

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorUpdateTemplate>

   {

     using Type = VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };

   using DescriptorUpdateTemplateKHR = DescriptorUpdateTemplate;


   class Event

   {

   public:

     using CType      = VkEvent;

     using NativeType = VkEvent;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eEvent;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eEvent;


   public:

     VULKAN_HPP_CONSTEXPR         Event() = default;

     VULKAN_HPP_CONSTEXPR         Event( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}

     VULKAN_HPP_TYPESAFE_EXPLICIT Event( VkEvent event ) VULKAN_HPP_NOEXCEPT : m_event( event ) {}


 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     Event & operator=( VkEvent event ) VULKAN_HPP_NOEXCEPT

     {

       m_event = event;

       return *this;

     }

 #endif


     Event & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_event = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( Event const & ) const = default;

 #else

     bool operator==( Event const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_event == rhs.m_event;

     }


     bool operator!=( Event const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_event != rhs.m_event;

     }


     bool operator<( Event const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_event < rhs.m_event;

     }

 #endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkEvent() const VULKAN_HPP_NOEXCEPT

     {

       return m_event;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_event != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_event == VK_NULL_HANDLE;

     }


   private:

     VkEvent m_event = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eEvent>

   {

     using Type = VULKAN_HPP_NAMESPACE::Event;

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eEvent>

   {

     using Type = VULKAN_HPP_NAMESPACE::Event;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Event>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


   class AccelerationStructureKHR

   {

   public:

     using CType      = VkAccelerationStructureKHR;

     using NativeType = VkAccelerationStructureKHR;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eAccelerationStructureKHR;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eAccelerationStructureKHR;


   public:

     VULKAN_HPP_CONSTEXPR         AccelerationStructureKHR() = default;

     VULKAN_HPP_CONSTEXPR         AccelerationStructureKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}

     VULKAN_HPP_TYPESAFE_EXPLICIT AccelerationStructureKHR( VkAccelerationStructureKHR accelerationStructureKHR ) VULKAN_HPP_NOEXCEPT

       : m_accelerationStructureKHR( accelerationStructureKHR )

     {

     }


 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     AccelerationStructureKHR & operator=( VkAccelerationStructureKHR accelerationStructureKHR ) VULKAN_HPP_NOEXCEPT

     {

       m_accelerationStructureKHR = accelerationStructureKHR;

       return *this;

     }

 #endif


     AccelerationStructureKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_accelerationStructureKHR = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( AccelerationStructureKHR const & ) const = default;

 #else

     bool operator==( AccelerationStructureKHR const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_accelerationStructureKHR == rhs.m_accelerationStructureKHR;

     }


     bool operator!=( AccelerationStructureKHR const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_accelerationStructureKHR != rhs.m_accelerationStructureKHR;

     }


     bool operator<( AccelerationStructureKHR const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_accelerationStructureKHR < rhs.m_accelerationStructureKHR;

     }

 #endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkAccelerationStructureKHR() const VULKAN_HPP_NOEXCEPT

     {

       return m_accelerationStructureKHR;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_accelerationStructureKHR != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_accelerationStructureKHR == VK_NULL_HANDLE;

     }


   private:

     VkAccelerationStructureKHR m_accelerationStructureKHR = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eAccelerationStructureKHR>

   {

     using Type = VULKAN_HPP_NAMESPACE::AccelerationStructureKHR;

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eAccelerationStructureKHR>

   {

     using Type = VULKAN_HPP_NAMESPACE::AccelerationStructureKHR;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::AccelerationStructureKHR>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


   class MicromapEXT

   {

   public:

     using CType      = VkMicromapEXT;

     using NativeType = VkMicromapEXT;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eMicromapEXT;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;


   public:

     VULKAN_HPP_CONSTEXPR         MicromapEXT() = default;

     VULKAN_HPP_CONSTEXPR         MicromapEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}

     VULKAN_HPP_TYPESAFE_EXPLICIT MicromapEXT( VkMicromapEXT micromapEXT ) VULKAN_HPP_NOEXCEPT : m_micromapEXT( micromapEXT ) {}


 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     MicromapEXT & operator=( VkMicromapEXT micromapEXT ) VULKAN_HPP_NOEXCEPT

     {

       m_micromapEXT = micromapEXT;

       return *this;

     }

 #endif


     MicromapEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_micromapEXT = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( MicromapEXT const & ) const = default;

 #else

     bool operator==( MicromapEXT const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_micromapEXT == rhs.m_micromapEXT;

     }


     bool operator!=( MicromapEXT const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_micromapEXT != rhs.m_micromapEXT;

     }


     bool operator<( MicromapEXT const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_micromapEXT < rhs.m_micromapEXT;

     }

 #endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkMicromapEXT() const VULKAN_HPP_NOEXCEPT

     {

       return m_micromapEXT;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_micromapEXT != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_micromapEXT == VK_NULL_HANDLE;

     }


   private:

     VkMicromapEXT m_micromapEXT = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eMicromapEXT>

   {

     using Type = VULKAN_HPP_NAMESPACE::MicromapEXT;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::MicromapEXT>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


   class CommandBuffer

   {

   public:

     using CType      = VkCommandBuffer;

     using NativeType = VkCommandBuffer;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eCommandBuffer;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCommandBuffer;


   public:

     VULKAN_HPP_CONSTEXPR CommandBuffer() = default;

     VULKAN_HPP_CONSTEXPR CommandBuffer( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}

     CommandBuffer( VkCommandBuffer commandBuffer ) VULKAN_HPP_NOEXCEPT : m_commandBuffer( commandBuffer ) {}


     CommandBuffer & operator=( VkCommandBuffer commandBuffer ) VULKAN_HPP_NOEXCEPT

     {

       m_commandBuffer = commandBuffer;

       return *this;

     }


     CommandBuffer & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_commandBuffer = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( CommandBuffer const & ) const = default;

 #else

     bool operator==( CommandBuffer const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_commandBuffer == rhs.m_commandBuffer;

     }


     bool operator!=( CommandBuffer const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_commandBuffer != rhs.m_commandBuffer;

     }


     bool operator<( CommandBuffer const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_commandBuffer < rhs.m_commandBuffer;

     }

 #endif


     //=== VK_VERSION_1_0 ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result begin( const VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo * pBeginInfo,

                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result end( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #else

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type end( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result reset( VULKAN_HPP_NAMESPACE::CommandBufferResetFlags flags,

                                        Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #else

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     typename ResultValueType<void>::type reset( VULKAN_HPP_NAMESPACE::CommandBufferResetFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,

                                                 Dispatch const & d                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void bindPipeline( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,

                        VULKAN_HPP_NAMESPACE::Pipeline          pipeline,

                        Dispatch const & d                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setLineWidth( float lineWidth, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setDepthBias( float              depthBiasConstantFactor,

                        float              depthBiasClamp,

                        float              depthBiasSlopeFactor,

                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setBlendConstants( const float blendConstants[4], Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setDepthBounds( float minDepthBounds, float maxDepthBounds, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setStencilCompareMask( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,

                                 uint32_t                               compareMask,

                                 Dispatch const & d                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setStencilWriteMask( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,

                               uint32_t                               writeMask,

                               Dispatch const & d                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setStencilReference( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,

                               uint32_t                               reference,

                               Dispatch const & d                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void dispatch( uint32_t           groupCountX,

                    uint32_t           groupCountY,

                    uint32_t           groupCountZ,

                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void dispatchIndirect( VULKAN_HPP_NAMESPACE::Buffer     buffer,

                            VULKAN_HPP_NAMESPACE::DeviceSize offset,

                            Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setEvent( VULKAN_HPP_NAMESPACE::Event              event,

                    VULKAN_HPP_NAMESPACE::PipelineStageFlags stageMask,

                    Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void resetEvent( VULKAN_HPP_NAMESPACE::Event              event,

                      VULKAN_HPP_NAMESPACE::PipelineStageFlags stageMask,

                      Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void endQuery( VULKAN_HPP_NAMESPACE::QueryPool queryPool,

                    uint32_t                        query,

                    Dispatch const & d              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename ValuesType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void nextSubpass( VULKAN_HPP_NAMESPACE::SubpassContents contents, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void endRenderPass( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void executeCommands( uint32_t                                    commandBufferCount,

                           const VULKAN_HPP_NAMESPACE::CommandBuffer * pCommandBuffers,

                           Dispatch const & d                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_VERSION_1_1 ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setDeviceMask( uint32_t deviceMask, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;


     //=== VK_VERSION_1_2 ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void endRenderPass2( const VULKAN_HPP_NAMESPACE::SubpassEndInfo * pSubpassEndInfo,

                          Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void endRenderPass2( const VULKAN_HPP_NAMESPACE::SubpassEndInfo & subpassEndInfo,

                          Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_VERSION_1_3 ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void resetEvent2( VULKAN_HPP_NAMESPACE::Event               event,

                       VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stageMask,

                       Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void pipelineBarrier2( const VULKAN_HPP_NAMESPACE::DependencyInfo * pDependencyInfo,

                            Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void pipelineBarrier2( const VULKAN_HPP_NAMESPACE::DependencyInfo & dependencyInfo,

                            Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void copyBuffer2( const VULKAN_HPP_NAMESPACE::CopyBufferInfo2 * pCopyBufferInfo,

                       Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void copyBuffer2( const VULKAN_HPP_NAMESPACE::CopyBufferInfo2 & copyBufferInfo,

                       Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void copyImage2( const VULKAN_HPP_NAMESPACE::CopyImageInfo2 * pCopyImageInfo,

                      Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void copyImage2( const VULKAN_HPP_NAMESPACE::CopyImageInfo2 & copyImageInfo,

                      Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void copyBufferToImage2( const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 * pCopyBufferToImageInfo,

                              Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void copyBufferToImage2( const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 & copyBufferToImageInfo,

                              Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void copyImageToBuffer2( const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 * pCopyImageToBufferInfo,

                              Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void copyImageToBuffer2( const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 & copyImageToBufferInfo,

                              Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void blitImage2( const VULKAN_HPP_NAMESPACE::BlitImageInfo2 * pBlitImageInfo,

                      Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void blitImage2( const VULKAN_HPP_NAMESPACE::BlitImageInfo2 & blitImageInfo,

                      Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void resolveImage2( const VULKAN_HPP_NAMESPACE::ResolveImageInfo2 * pResolveImageInfo,

                         Dispatch const & d                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void resolveImage2( const VULKAN_HPP_NAMESPACE::ResolveImageInfo2 & resolveImageInfo,

                         Dispatch const & d                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void beginRendering( const VULKAN_HPP_NAMESPACE::RenderingInfo * pRenderingInfo,

                          Dispatch const & d                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void beginRendering( const VULKAN_HPP_NAMESPACE::RenderingInfo & renderingInfo,

                          Dispatch const & d                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void endRendering( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setCullMode( VULKAN_HPP_NAMESPACE::CullModeFlags cullMode, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setFrontFace( VULKAN_HPP_NAMESPACE::FrontFace frontFace, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setPrimitiveTopology( VULKAN_HPP_NAMESPACE::PrimitiveTopology primitiveTopology,

                                Dispatch const & d                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setViewportWithCount( uint32_t                               viewportCount,

                                const VULKAN_HPP_NAMESPACE::Viewport * pViewports,

                                Dispatch const & d                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setScissorWithCount( uint32_t                             scissorCount,

                               const VULKAN_HPP_NAMESPACE::Rect2D * pScissors,

                               Dispatch const & d                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setDepthTestEnable( VULKAN_HPP_NAMESPACE::Bool32 depthTestEnable,

                              Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setDepthWriteEnable( VULKAN_HPP_NAMESPACE::Bool32 depthWriteEnable,

                               Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setDepthCompareOp( VULKAN_HPP_NAMESPACE::CompareOp depthCompareOp,

                             Dispatch const & d              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setDepthBoundsTestEnable( VULKAN_HPP_NAMESPACE::Bool32 depthBoundsTestEnable,

                                    Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setStencilTestEnable( VULKAN_HPP_NAMESPACE::Bool32 stencilTestEnable,

                                Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setRasterizerDiscardEnable( VULKAN_HPP_NAMESPACE::Bool32 rasterizerDiscardEnable,

                                      Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setDepthBiasEnable( VULKAN_HPP_NAMESPACE::Bool32 depthBiasEnable,

                              Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setPrimitiveRestartEnable( VULKAN_HPP_NAMESPACE::Bool32 primitiveRestartEnable,

                                     Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     //=== VK_EXT_debug_marker ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void debugMarkerBeginEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT * pMarkerInfo,

                               Dispatch const & d                                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void debugMarkerBeginEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT & markerInfo,

                               Dispatch const & d                                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void debugMarkerEndEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void debugMarkerInsertEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT * pMarkerInfo,

                                Dispatch const & d                                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void debugMarkerInsertEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT & markerInfo,

                                Dispatch const & d                                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


 #if defined( VK_ENABLE_BETA_EXTENSIONS )

     //=== VK_KHR_video_queue ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void beginVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoBeginCodingInfoKHR * pBeginInfo,

                               Dispatch const & d                                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void beginVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoBeginCodingInfoKHR & beginInfo,

                               Dispatch const & d                                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void endVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoEndCodingInfoKHR * pEndCodingInfo,

                             Dispatch const & d                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void endVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoEndCodingInfoKHR & endCodingInfo,

                             Dispatch const & d                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void controlVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoCodingControlInfoKHR * pCodingControlInfo,

                                 Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void controlVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoCodingControlInfoKHR & codingControlInfo,

                                 Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

 #endif   /*VK_ENABLE_BETA_EXTENSIONS*/


 #if defined( VK_ENABLE_BETA_EXTENSIONS )

     //=== VK_KHR_video_decode_queue ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void decodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR * pDecodeInfo,

                          Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void decodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR & decodeInfo,

                          Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

 #endif   /*VK_ENABLE_BETA_EXTENSIONS*/


     //=== VK_EXT_transform_feedback ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void bindTransformFeedbackBuffersEXT( uint32_t                                 firstBinding,

                                           uint32_t                                 bindingCount,

                                           const VULKAN_HPP_NAMESPACE::Buffer *     pBuffers,

                                           const VULKAN_HPP_NAMESPACE::DeviceSize * pOffsets,

                                           const VULKAN_HPP_NAMESPACE::DeviceSize * pSizes,

                                           Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void bindTransformFeedbackBuffersEXT( uint32_t                                                                         firstBinding,

                                           VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const &     buffers,

                                           VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets,

                                           VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes

                                                              VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void beginTransformFeedbackEXT( uint32_t                                 firstCounterBuffer,

                                     uint32_t                                 counterBufferCount,

                                     const VULKAN_HPP_NAMESPACE::Buffer *     pCounterBuffers,

                                     const VULKAN_HPP_NAMESPACE::DeviceSize * pCounterBufferOffsets,

                                     Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void beginTransformFeedbackEXT( uint32_t                                                                     firstCounterBuffer,

                                     VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & counterBuffers,

                                     VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & counterBufferOffsets

                                                        VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void endTransformFeedbackEXT( uint32_t                                 firstCounterBuffer,

                                   uint32_t                                 counterBufferCount,

                                   const VULKAN_HPP_NAMESPACE::Buffer *     pCounterBuffers,

                                   const VULKAN_HPP_NAMESPACE::DeviceSize * pCounterBufferOffsets,

                                   Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void endTransformFeedbackEXT( uint32_t                                                                     firstCounterBuffer,

                                   VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & counterBuffers,

                                   VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & counterBufferOffsets

                                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void beginQueryIndexedEXT( VULKAN_HPP_NAMESPACE::QueryPool         queryPool,

                                uint32_t                                query,

                                VULKAN_HPP_NAMESPACE::QueryControlFlags flags,

                                uint32_t                                index,

                                Dispatch const & d                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void endQueryIndexedEXT( VULKAN_HPP_NAMESPACE::QueryPool queryPool,

                              uint32_t                        query,

                              uint32_t                        index,

                              Dispatch const & d              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void drawIndirectByteCountEXT( uint32_t                         instanceCount,

                                    uint32_t                         firstInstance,

                                    VULKAN_HPP_NAMESPACE::Buffer     counterBuffer,

                                    VULKAN_HPP_NAMESPACE::DeviceSize counterBufferOffset,

                                    uint32_t                         counterOffset,

                                    uint32_t                         vertexStride,

                                    Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     //=== VK_NVX_binary_import ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void cuLaunchKernelNVX( const VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX * pLaunchInfo,

                             Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void cuLaunchKernelNVX( const VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX & launchInfo,

                             Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_AMD_draw_indirect_count ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void drawIndirectCountAMD( VULKAN_HPP_NAMESPACE::Buffer     buffer,

                                VULKAN_HPP_NAMESPACE::DeviceSize offset,

                                VULKAN_HPP_NAMESPACE::Buffer     countBuffer,

                                VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,

                                uint32_t                         maxDrawCount,

                                uint32_t                         stride,

                                Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void drawIndexedIndirectCountAMD( VULKAN_HPP_NAMESPACE::Buffer     buffer,

                                       VULKAN_HPP_NAMESPACE::DeviceSize offset,

                                       VULKAN_HPP_NAMESPACE::Buffer     countBuffer,

                                       VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,

                                       uint32_t                         maxDrawCount,

                                       uint32_t                         stride,

                                       Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     //=== VK_KHR_dynamic_rendering ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void beginRenderingKHR( const VULKAN_HPP_NAMESPACE::RenderingInfo * pRenderingInfo,

                             Dispatch const & d                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void beginRenderingKHR( const VULKAN_HPP_NAMESPACE::RenderingInfo & renderingInfo,

                             Dispatch const & d                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void endRenderingKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     //=== VK_KHR_device_group ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setDeviceMaskKHR( uint32_t deviceMask, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void dispatchBaseKHR( uint32_t           baseGroupX,

                           uint32_t           baseGroupY,

                           uint32_t           baseGroupZ,

                           uint32_t           groupCountX,

                           uint32_t           groupCountY,

                           uint32_t           groupCountZ,

                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     //=== VK_KHR_push_descriptor ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void pushDescriptorSetKHR( VULKAN_HPP_NAMESPACE::PipelineBindPoint          pipelineBindPoint,

                                VULKAN_HPP_NAMESPACE::PipelineLayout             layout,

                                uint32_t                                         set,

                                uint32_t                                         descriptorWriteCount,

                                const VULKAN_HPP_NAMESPACE::WriteDescriptorSet * pDescriptorWrites,

                                Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void pushDescriptorSetKHR( VULKAN_HPP_NAMESPACE::PipelineBindPoint                                                  pipelineBindPoint,

                                VULKAN_HPP_NAMESPACE::PipelineLayout                                                     layout,

                                uint32_t                                                                                 set,

                                VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::WriteDescriptorSet> const & descriptorWrites,

                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void pushDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,

                                            VULKAN_HPP_NAMESPACE::PipelineLayout           layout,

                                            uint32_t                                       set,

                                            const void *                                   pData,

                                            Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void pushDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,

                                            VULKAN_HPP_NAMESPACE::PipelineLayout           layout,

                                            uint32_t                                       set,

                                            DataType const &                               data,

                                            Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_EXT_conditional_rendering ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void beginConditionalRenderingEXT( const VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfoEXT * pConditionalRenderingBegin,

                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void beginConditionalRenderingEXT( const VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfoEXT & conditionalRenderingBegin,

                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void endConditionalRenderingEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     //=== VK_NV_clip_space_w_scaling ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setViewportWScalingNV( uint32_t                                         firstViewport,

                                 uint32_t                                         viewportCount,

                                 const VULKAN_HPP_NAMESPACE::ViewportWScalingNV * pViewportWScalings,

                                 Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setViewportWScalingNV( uint32_t                                                                                 firstViewport,

                                 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ViewportWScalingNV> const & viewportWScalings,

                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_EXT_discard_rectangles ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_KHR_create_renderpass2 ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void beginRenderPass2KHR( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo * pRenderPassBegin,

                               const VULKAN_HPP_NAMESPACE::SubpassBeginInfo *    pSubpassBeginInfo,

                               Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void beginRenderPass2KHR( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo & renderPassBegin,

                               const VULKAN_HPP_NAMESPACE::SubpassBeginInfo &    subpassBeginInfo,

                               Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void nextSubpass2KHR( const VULKAN_HPP_NAMESPACE::SubpassBeginInfo * pSubpassBeginInfo,

                           const VULKAN_HPP_NAMESPACE::SubpassEndInfo *   pSubpassEndInfo,

                           Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void nextSubpass2KHR( const VULKAN_HPP_NAMESPACE::SubpassBeginInfo & subpassBeginInfo,

                           const VULKAN_HPP_NAMESPACE::SubpassEndInfo &   subpassEndInfo,

                           Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void endRenderPass2KHR( const VULKAN_HPP_NAMESPACE::SubpassEndInfo * pSubpassEndInfo,

                             Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void endRenderPass2KHR( const VULKAN_HPP_NAMESPACE::SubpassEndInfo & subpassEndInfo,

                             Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_EXT_debug_utils ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void beginDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * pLabelInfo,

                                   Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void beginDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo,

                                   Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void endDebugUtilsLabelEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void insertDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * pLabelInfo,

                                    Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void insertDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo,

                                    Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_EXT_sample_locations ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setSampleLocationsEXT( const VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT * pSampleLocationsInfo,

                                 Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setSampleLocationsEXT( const VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT & sampleLocationsInfo,

                                 Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_KHR_acceleration_structure ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void buildAccelerationStructuresKHR( uint32_t                                                                     infoCount,

                                          const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR *      pInfos,

                                          const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const * ppBuildRangeInfos,

                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void buildAccelerationStructuresKHR(

       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const &      infos,

       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const> const & pBuildRangeInfos,

       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void buildAccelerationStructuresIndirectKHR( uint32_t                                                                infoCount,

                                                  const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR * pInfos,

                                                  const VULKAN_HPP_NAMESPACE::DeviceAddress *                             pIndirectDeviceAddresses,

                                                  const uint32_t *                                                        pIndirectStrides,

                                                  const uint32_t * const *                                                ppMaxPrimitiveCounts,

                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void buildAccelerationStructuresIndirectKHR(

       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const & infos,

       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceAddress> const &                             indirectDeviceAddresses,

       VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t> const &                                                        indirectStrides,

       VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t * const> const &                                                pMaxPrimitiveCounts,

       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void copyAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR * pInfo,

                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void copyAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR & info,

                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void copyAccelerationStructureToMemoryKHR( const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR * pInfo,

                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void copyAccelerationStructureToMemoryKHR( const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR & info,

                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void copyMemoryToAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR * pInfo,

                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void copyMemoryToAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR & info,

                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void writeAccelerationStructuresPropertiesKHR( uint32_t                                               accelerationStructureCount,

                                                    const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR * pAccelerationStructures,

                                                    VULKAN_HPP_NAMESPACE::QueryType                        queryType,

                                                    VULKAN_HPP_NAMESPACE::QueryPool                        queryPool,

                                                    uint32_t                                               firstQuery,

                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void writeAccelerationStructuresPropertiesKHR(

       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures,

       VULKAN_HPP_NAMESPACE::QueryType                                                                queryType,

       VULKAN_HPP_NAMESPACE::QueryPool                                                                queryPool,

       uint32_t                                                                                       firstQuery,

       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_NV_shading_rate_image ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void bindShadingRateImageNV( VULKAN_HPP_NAMESPACE::ImageView   imageView,

                                  VULKAN_HPP_NAMESPACE::ImageLayout imageLayout,

                                  Dispatch const & d                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setViewportShadingRatePaletteNV( uint32_t                                           firstViewport,

                                           uint32_t                                           viewportCount,

                                           const VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV * pShadingRatePalettes,

                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setViewportShadingRatePaletteNV( uint32_t                                                                                   firstViewport,

                                           VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV> const & shadingRatePalettes,

                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setCoarseSampleOrderNV( VULKAN_HPP_NAMESPACE::CoarseSampleOrderTypeNV           sampleOrderType,

                                  uint32_t                                                customSampleOrderCount,

                                  const VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV * pCustomSampleOrders,

                                  Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setCoarseSampleOrderNV( VULKAN_HPP_NAMESPACE::CoarseSampleOrderTypeNV                                                   sampleOrderType,

                                  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV> const & customSampleOrders,

                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_NV_ray_tracing ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void buildAccelerationStructureNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV * pInfo,

                                        VULKAN_HPP_NAMESPACE::Buffer                              instanceData,

                                        VULKAN_HPP_NAMESPACE::DeviceSize                          instanceOffset,

                                        VULKAN_HPP_NAMESPACE::Bool32                              update,

                                        VULKAN_HPP_NAMESPACE::AccelerationStructureNV             dst,

                                        VULKAN_HPP_NAMESPACE::AccelerationStructureNV             src,

                                        VULKAN_HPP_NAMESPACE::Buffer                              scratch,

                                        VULKAN_HPP_NAMESPACE::DeviceSize                          scratchOffset,

                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void buildAccelerationStructureNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV & info,

                                        VULKAN_HPP_NAMESPACE::Buffer                              instanceData,

                                        VULKAN_HPP_NAMESPACE::DeviceSize                          instanceOffset,

                                        VULKAN_HPP_NAMESPACE::Bool32                              update,

                                        VULKAN_HPP_NAMESPACE::AccelerationStructureNV             dst,

                                        VULKAN_HPP_NAMESPACE::AccelerationStructureNV             src,

                                        VULKAN_HPP_NAMESPACE::Buffer                              scratch,

                                        VULKAN_HPP_NAMESPACE::DeviceSize                          scratchOffset,

                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void copyAccelerationStructureNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV          dst,

                                       VULKAN_HPP_NAMESPACE::AccelerationStructureNV          src,

                                       VULKAN_HPP_NAMESPACE::CopyAccelerationStructureModeKHR mode,

                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void traceRaysNV( VULKAN_HPP_NAMESPACE::Buffer     raygenShaderBindingTableBuffer,

                       VULKAN_HPP_NAMESPACE::DeviceSize raygenShaderBindingOffset,

                       VULKAN_HPP_NAMESPACE::Buffer     missShaderBindingTableBuffer,

                       VULKAN_HPP_NAMESPACE::DeviceSize missShaderBindingOffset,

                       VULKAN_HPP_NAMESPACE::DeviceSize missShaderBindingStride,

                       VULKAN_HPP_NAMESPACE::Buffer     hitShaderBindingTableBuffer,

                       VULKAN_HPP_NAMESPACE::DeviceSize hitShaderBindingOffset,

                       VULKAN_HPP_NAMESPACE::DeviceSize hitShaderBindingStride,

                       VULKAN_HPP_NAMESPACE::Buffer     callableShaderBindingTableBuffer,

                       VULKAN_HPP_NAMESPACE::DeviceSize callableShaderBindingOffset,

                       VULKAN_HPP_NAMESPACE::DeviceSize callableShaderBindingStride,

                       uint32_t                         width,

                       uint32_t                         height,

                       uint32_t                         depth,

                       Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void writeAccelerationStructuresPropertiesNV( uint32_t                                              accelerationStructureCount,

                                                   const VULKAN_HPP_NAMESPACE::AccelerationStructureNV * pAccelerationStructures,

                                                   VULKAN_HPP_NAMESPACE::QueryType                       queryType,

                                                   VULKAN_HPP_NAMESPACE::QueryPool                       queryPool,

                                                   uint32_t                                              firstQuery,

                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void writeAccelerationStructuresPropertiesNV(

       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureNV> const & accelerationStructures,

       VULKAN_HPP_NAMESPACE::QueryType                                                               queryType,

       VULKAN_HPP_NAMESPACE::QueryPool                                                               queryPool,

       uint32_t                                                                                      firstQuery,

       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_KHR_draw_indirect_count ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void drawIndirectCountKHR( VULKAN_HPP_NAMESPACE::Buffer     buffer,

                                VULKAN_HPP_NAMESPACE::DeviceSize offset,

                                VULKAN_HPP_NAMESPACE::Buffer     countBuffer,

                                VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,

                                uint32_t                         maxDrawCount,

                                uint32_t                         stride,

                                Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void drawIndexedIndirectCountKHR( VULKAN_HPP_NAMESPACE::Buffer     buffer,

                                       VULKAN_HPP_NAMESPACE::DeviceSize offset,

                                       VULKAN_HPP_NAMESPACE::Buffer     countBuffer,

                                       VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,

                                       uint32_t                         maxDrawCount,

                                       uint32_t                         stride,

                                       Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     //=== VK_AMD_buffer_marker ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void writeBufferMarkerAMD( VULKAN_HPP_NAMESPACE::PipelineStageFlagBits pipelineStage,

                                VULKAN_HPP_NAMESPACE::Buffer                dstBuffer,

                                VULKAN_HPP_NAMESPACE::DeviceSize            dstOffset,

                                uint32_t                                    marker,

                                Dispatch const & d                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     //=== VK_NV_mesh_shader ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void drawMeshTasksNV( uint32_t taskCount, uint32_t firstTask, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void drawMeshTasksIndirectNV( VULKAN_HPP_NAMESPACE::Buffer     buffer,

                                   VULKAN_HPP_NAMESPACE::DeviceSize offset,

                                   uint32_t                         drawCount,

                                   uint32_t                         stride,

                                   Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void drawMeshTasksIndirectCountNV( VULKAN_HPP_NAMESPACE::Buffer     buffer,

                                        VULKAN_HPP_NAMESPACE::DeviceSize offset,

                                        VULKAN_HPP_NAMESPACE::Buffer     countBuffer,

                                        VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,

                                        uint32_t                         maxDrawCount,

                                        uint32_t                         stride,

                                        Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     //=== VK_NV_scissor_exclusive ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setExclusiveScissorNV( uint32_t                             firstExclusiveScissor,

                                 uint32_t                             exclusiveScissorCount,

                                 const VULKAN_HPP_NAMESPACE::Rect2D * pExclusiveScissors,

                                 Dispatch const & d                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setExclusiveScissorNV( uint32_t                                                                     firstExclusiveScissor,

                                 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & exclusiveScissors,

                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_NV_device_diagnostic_checkpoints ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setCheckpointNV( const void * pCheckpointMarker, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename CheckpointMarkerType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setCheckpointNV( CheckpointMarkerType const & checkpointMarker,

                           Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_INTEL_performance_query ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result setPerformanceMarkerINTEL( const VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL * pMarkerInfo,

                                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type

       setPerformanceMarkerINTEL( const VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL & markerInfo,

                                  Dispatch const & d                                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result setPerformanceStreamMarkerINTEL( const VULKAN_HPP_NAMESPACE::PerformanceStreamMarkerInfoINTEL * pMarkerInfo,

                                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type

       setPerformanceStreamMarkerINTEL( const VULKAN_HPP_NAMESPACE::PerformanceStreamMarkerInfoINTEL & markerInfo,

                                        Dispatch const & d                                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result setPerformanceOverrideINTEL( const VULKAN_HPP_NAMESPACE::PerformanceOverrideInfoINTEL * pOverrideInfo,

                                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type

       setPerformanceOverrideINTEL( const VULKAN_HPP_NAMESPACE::PerformanceOverrideInfoINTEL & overrideInfo,

                                    Dispatch const & d                                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_KHR_fragment_shading_rate ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_EXT_line_rasterization ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setLineStippleEXT( uint32_t           lineStippleFactor,

                             uint16_t           lineStipplePattern,

                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     //=== VK_EXT_extended_dynamic_state ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setCullModeEXT( VULKAN_HPP_NAMESPACE::CullModeFlags cullMode, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setFrontFaceEXT( VULKAN_HPP_NAMESPACE::FrontFace frontFace, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setPrimitiveTopologyEXT( VULKAN_HPP_NAMESPACE::PrimitiveTopology primitiveTopology,

                                   Dispatch const & d                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setViewportWithCountEXT( uint32_t                               viewportCount,

                                   const VULKAN_HPP_NAMESPACE::Viewport * pViewports,

                                   Dispatch const & d                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setScissorWithCountEXT( uint32_t                             scissorCount,

                                  const VULKAN_HPP_NAMESPACE::Rect2D * pScissors,

                                  Dispatch const & d                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setDepthTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthTestEnable,

                                 Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setDepthWriteEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthWriteEnable,

                                  Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setDepthCompareOpEXT( VULKAN_HPP_NAMESPACE::CompareOp depthCompareOp,

                                Dispatch const & d              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setDepthBoundsTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthBoundsTestEnable,

                                       Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setStencilTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 stencilTestEnable,

                                   Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;


     //=== VK_NV_device_generated_commands ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void preprocessGeneratedCommandsNV( const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV * pGeneratedCommandsInfo,

                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void preprocessGeneratedCommandsNV( const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV & generatedCommandsInfo,

                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void executeGeneratedCommandsNV( VULKAN_HPP_NAMESPACE::Bool32                          isPreprocessed,

                                      const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV * pGeneratedCommandsInfo,

                                      Dispatch const & d                                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void executeGeneratedCommandsNV( VULKAN_HPP_NAMESPACE::Bool32                          isPreprocessed,

                                      const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV & generatedCommandsInfo,

                                      Dispatch const & d                                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void bindPipelineShaderGroupNV( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,

                                     VULKAN_HPP_NAMESPACE::Pipeline          pipeline,

                                     uint32_t                                groupIndex,

                                     Dispatch const & d                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


 #if defined( VK_ENABLE_BETA_EXTENSIONS )

     //=== VK_KHR_video_encode_queue ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void encodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeInfoKHR * pEncodeInfo,

                          Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void encodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeInfoKHR & encodeInfo,

                          Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

 #endif   /*VK_ENABLE_BETA_EXTENSIONS*/


     //=== VK_KHR_synchronization2 ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void resetEvent2KHR( VULKAN_HPP_NAMESPACE::Event               event,

                          VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stageMask,

                          Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void pipelineBarrier2KHR( const VULKAN_HPP_NAMESPACE::DependencyInfo * pDependencyInfo,

                               Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void pipelineBarrier2KHR( const VULKAN_HPP_NAMESPACE::DependencyInfo & dependencyInfo,

                               Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;


     //=== VK_EXT_descriptor_buffer ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void bindDescriptorBuffersEXT( uint32_t                                                     bufferCount,

                                    const VULKAN_HPP_NAMESPACE::DescriptorBufferBindingInfoEXT * pBindingInfos,

                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void bindDescriptorBuffersEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorBufferBindingInfoEXT> const & bindingInfos,

                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setDescriptorBufferOffsetsEXT( VULKAN_HPP_NAMESPACE::PipelineBindPoint  pipelineBindPoint,

                                         VULKAN_HPP_NAMESPACE::PipelineLayout     layout,

                                         uint32_t                                 firstSet,

                                         uint32_t                                 setCount,

                                         const uint32_t *                         pBufferIndices,

                                         const VULKAN_HPP_NAMESPACE::DeviceSize * pOffsets,

                                         Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setDescriptorBufferOffsetsEXT( VULKAN_HPP_NAMESPACE::PipelineBindPoint                                          pipelineBindPoint,

                                         VULKAN_HPP_NAMESPACE::PipelineLayout                                             layout,

                                         uint32_t                                                                         firstSet,

                                         VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t> const &                         bufferIndices,

                                         VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets,

                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void bindDescriptorBufferEmbeddedSamplersEXT( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,

                                                   VULKAN_HPP_NAMESPACE::PipelineLayout    layout,

                                                   uint32_t                                set,

                                                   Dispatch const & d                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     //=== VK_NV_fragment_shading_rate_enums ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setFragmentShadingRateEnumNV( VULKAN_HPP_NAMESPACE::FragmentShadingRateNV                  shadingRate,

                                        const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2],

                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     //=== VK_EXT_mesh_shader ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void drawMeshTasksEXT( uint32_t           groupCountX,

                            uint32_t           groupCountY,

                            uint32_t           groupCountZ,

                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void drawMeshTasksIndirectEXT( VULKAN_HPP_NAMESPACE::Buffer     buffer,

                                    VULKAN_HPP_NAMESPACE::DeviceSize offset,

                                    uint32_t                         drawCount,

                                    uint32_t                         stride,

                                    Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void drawMeshTasksIndirectCountEXT( VULKAN_HPP_NAMESPACE::Buffer     buffer,

                                         VULKAN_HPP_NAMESPACE::DeviceSize offset,

                                         VULKAN_HPP_NAMESPACE::Buffer     countBuffer,

                                         VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,

                                         uint32_t                         maxDrawCount,

                                         uint32_t                         stride,

                                         Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     //=== VK_KHR_copy_commands2 ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void copyBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferInfo2 * pCopyBufferInfo,

                          Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void copyBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferInfo2 & copyBufferInfo,

                          Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void copyImage2KHR( const VULKAN_HPP_NAMESPACE::CopyImageInfo2 * pCopyImageInfo,

                         Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void copyImage2KHR( const VULKAN_HPP_NAMESPACE::CopyImageInfo2 & copyImageInfo,

                         Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void copyBufferToImage2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 * pCopyBufferToImageInfo,

                                 Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void copyBufferToImage2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 & copyBufferToImageInfo,

                                 Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void copyImageToBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 * pCopyImageToBufferInfo,

                                 Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void copyImageToBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 & copyImageToBufferInfo,

                                 Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void blitImage2KHR( const VULKAN_HPP_NAMESPACE::BlitImageInfo2 * pBlitImageInfo,

                         Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void blitImage2KHR( const VULKAN_HPP_NAMESPACE::BlitImageInfo2 & blitImageInfo,

                         Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void resolveImage2KHR( const VULKAN_HPP_NAMESPACE::ResolveImageInfo2 * pResolveImageInfo,

                            Dispatch const & d                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void resolveImage2KHR( const VULKAN_HPP_NAMESPACE::ResolveImageInfo2 & resolveImageInfo,

                            Dispatch const & d                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_KHR_ray_tracing_pipeline ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void traceRaysKHR( const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pRaygenShaderBindingTable,

                        const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pMissShaderBindingTable,

                        const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pHitShaderBindingTable,

                        const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pCallableShaderBindingTable,

                        uint32_t                                                    width,

                        uint32_t                                                    height,

                        uint32_t                                                    depth,

                        Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void traceRaysKHR( const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & raygenShaderBindingTable,

                        const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & missShaderBindingTable,

                        const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & hitShaderBindingTable,

                        const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & callableShaderBindingTable,

                        uint32_t                                                    width,

                        uint32_t                                                    height,

                        uint32_t                                                    depth,

                        Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void traceRaysIndirectKHR( const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pRaygenShaderBindingTable,

                                const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pMissShaderBindingTable,

                                const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pHitShaderBindingTable,

                                const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pCallableShaderBindingTable,

                                VULKAN_HPP_NAMESPACE::DeviceAddress                         indirectDeviceAddress,

                                Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void traceRaysIndirectKHR( const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & raygenShaderBindingTable,

                                const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & missShaderBindingTable,

                                const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & hitShaderBindingTable,

                                const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & callableShaderBindingTable,

                                VULKAN_HPP_NAMESPACE::DeviceAddress                         indirectDeviceAddress,

                                Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setRayTracingPipelineStackSizeKHR( uint32_t pipelineStackSize, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     //=== VK_EXT_vertex_input_dynamic_state ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_HUAWEI_subpass_shading ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void subpassShadingHUAWEI( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     //=== VK_HUAWEI_invocation_mask ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void bindInvocationMaskHUAWEI( VULKAN_HPP_NAMESPACE::ImageView   imageView,

                                    VULKAN_HPP_NAMESPACE::ImageLayout imageLayout,

                                    Dispatch const & d                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     //=== VK_EXT_extended_dynamic_state2 ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setPatchControlPointsEXT( uint32_t patchControlPoints, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setRasterizerDiscardEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 rasterizerDiscardEnable,

                                         Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setDepthBiasEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthBiasEnable,

                                 Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setLogicOpEXT( VULKAN_HPP_NAMESPACE::LogicOp logicOp, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setPrimitiveRestartEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 primitiveRestartEnable,

                                        Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     //=== VK_EXT_color_write_enable ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setColorWriteEnableEXT( uint32_t                             attachmentCount,

                                  const VULKAN_HPP_NAMESPACE::Bool32 * pColorWriteEnables,

                                  Dispatch const & d                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_KHR_ray_tracing_maintenance1 ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void traceRaysIndirect2KHR( VULKAN_HPP_NAMESPACE::DeviceAddress indirectDeviceAddress,

                                 Dispatch const & d                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     //=== VK_EXT_multi_draw ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void drawMultiEXT( uint32_t                                       drawCount,

                        const VULKAN_HPP_NAMESPACE::MultiDrawInfoEXT * pVertexInfo,

                        uint32_t                                       instanceCount,

                        uint32_t                                       firstInstance,

                        uint32_t                                       stride,

                        Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void drawMultiEXT( VULKAN_HPP_NAMESPACE::StridedArrayProxy<const VULKAN_HPP_NAMESPACE::MultiDrawInfoEXT> const & vertexInfo,

                        uint32_t                                                                                      instanceCount,

                        uint32_t                                                                                      firstInstance,

                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void drawMultiIndexedEXT( uint32_t                                              drawCount,

                               const VULKAN_HPP_NAMESPACE::MultiDrawIndexedInfoEXT * pIndexInfo,

                               uint32_t                                              instanceCount,

                               uint32_t                                              firstInstance,

                               uint32_t                                              stride,

                               const int32_t *                                       pVertexOffset,

                               Dispatch const & d                                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void drawMultiIndexedEXT( VULKAN_HPP_NAMESPACE::StridedArrayProxy<const VULKAN_HPP_NAMESPACE::MultiDrawIndexedInfoEXT> const & indexInfo,

                               uint32_t                                                                                             instanceCount,

                               uint32_t                                                                                             firstInstance,

                               Optional<const int32_t> vertexOffset VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                               Dispatch const & d                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_EXT_opacity_micromap ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void buildMicromapsEXT( uint32_t                                           infoCount,

                             const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT * pInfos,

                             Dispatch const & d                                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void buildMicromapsEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT> const & infos,

                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void copyMicromapEXT( const VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT * pInfo,

                           Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void copyMicromapEXT( const VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT & info,

                           Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void copyMicromapToMemoryEXT( const VULKAN_HPP_NAMESPACE::CopyMicromapToMemoryInfoEXT * pInfo,

                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void copyMicromapToMemoryEXT( const VULKAN_HPP_NAMESPACE::CopyMicromapToMemoryInfoEXT & info,

                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void copyMemoryToMicromapEXT( const VULKAN_HPP_NAMESPACE::CopyMemoryToMicromapInfoEXT * pInfo,

                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void copyMemoryToMicromapEXT( const VULKAN_HPP_NAMESPACE::CopyMemoryToMicromapInfoEXT & info,

                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void writeMicromapsPropertiesEXT( uint32_t                                  micromapCount,

                                       const VULKAN_HPP_NAMESPACE::MicromapEXT * pMicromaps,

                                       VULKAN_HPP_NAMESPACE::QueryType           queryType,

                                       VULKAN_HPP_NAMESPACE::QueryPool           queryPool,

                                       uint32_t                                  firstQuery,

                                       Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void writeMicromapsPropertiesEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MicromapEXT> const & micromaps,

                                       VULKAN_HPP_NAMESPACE::QueryType                                                   queryType,

                                       VULKAN_HPP_NAMESPACE::QueryPool                                                   queryPool,

                                       uint32_t                                                                          firstQuery,

                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_NV_copy_memory_indirect ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void copyMemoryIndirectNV( VULKAN_HPP_NAMESPACE::DeviceAddress copyBufferAddress,

                                uint32_t                            copyCount,

                                uint32_t                            stride,

                                Dispatch const & d                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void copyMemoryToImageIndirectNV( VULKAN_HPP_NAMESPACE::DeviceAddress                  copyBufferAddress,

                                       uint32_t                                             copyCount,

                                       uint32_t                                             stride,

                                       VULKAN_HPP_NAMESPACE::Image                          dstImage,

                                       VULKAN_HPP_NAMESPACE::ImageLayout                    dstImageLayout,

                                       const VULKAN_HPP_NAMESPACE::ImageSubresourceLayers * pImageSubresources,

                                       Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void copyMemoryToImageIndirectNV( VULKAN_HPP_NAMESPACE::DeviceAddress                                                          copyBufferAddress,

                                       uint32_t                                                                                     stride,

                                       VULKAN_HPP_NAMESPACE::Image                                                                  dstImage,

                                       VULKAN_HPP_NAMESPACE::ImageLayout                                                            dstImageLayout,

                                       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageSubresourceLayers> const & imageSubresources,

                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_NV_memory_decompression ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void decompressMemoryNV( uint32_t                                               decompressRegionCount,

                              const VULKAN_HPP_NAMESPACE::DecompressMemoryRegionNV * pDecompressMemoryRegions,

                              Dispatch const & d                                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void decompressMemoryNV( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DecompressMemoryRegionNV> const & decompressMemoryRegions,

                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void decompressMemoryIndirectCountNV( VULKAN_HPP_NAMESPACE::DeviceAddress indirectCommandsAddress,

                                           VULKAN_HPP_NAMESPACE::DeviceAddress indirectCommandsCountAddress,

                                           uint32_t                            stride,

                                           Dispatch const & d                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     //=== VK_EXT_extended_dynamic_state3 ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setTessellationDomainOriginEXT( VULKAN_HPP_NAMESPACE::TessellationDomainOrigin domainOrigin,

                                          Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setDepthClampEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthClampEnable,

                                  Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setPolygonModeEXT( VULKAN_HPP_NAMESPACE::PolygonMode polygonMode,

                             Dispatch const & d                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setRasterizationSamplesEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits rasterizationSamples,

                                      Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setSampleMaskEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples,

                            const VULKAN_HPP_NAMESPACE::SampleMask *  pSampleMask,

                            Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setSampleMaskEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits                                        samples,

                            VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SampleMask> const & sampleMask,

                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setAlphaToCoverageEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 alphaToCoverageEnable,

                                       Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setAlphaToOneEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 alphaToOneEnable,

                                  Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setLogicOpEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 logicOpEnable,

                               Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setColorBlendEnableEXT( uint32_t                             firstAttachment,

                                  uint32_t                             attachmentCount,

                                  const VULKAN_HPP_NAMESPACE::Bool32 * pColorBlendEnables,

                                  Dispatch const & d                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setColorBlendEnableEXT( uint32_t                                                                     firstAttachment,

                                  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Bool32> const & colorBlendEnables,

                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setColorBlendEquationEXT( uint32_t                                            firstAttachment,

                                    uint32_t                                            attachmentCount,

                                    const VULKAN_HPP_NAMESPACE::ColorBlendEquationEXT * pColorBlendEquations,

                                    Dispatch const & d                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setColorBlendEquationEXT( uint32_t                                                                                    firstAttachment,

                                    VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ColorBlendEquationEXT> const & colorBlendEquations,

                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setColorWriteMaskEXT( uint32_t                                          firstAttachment,

                                uint32_t                                          attachmentCount,

                                const VULKAN_HPP_NAMESPACE::ColorComponentFlags * pColorWriteMasks,

                                Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setColorWriteMaskEXT( uint32_t                                                                                  firstAttachment,

                                VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ColorComponentFlags> const & colorWriteMasks,

                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setRasterizationStreamEXT( uint32_t rasterizationStream, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setConservativeRasterizationModeEXT( VULKAN_HPP_NAMESPACE::ConservativeRasterizationModeEXT conservativeRasterizationMode,

                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setExtraPrimitiveOverestimationSizeEXT( float              extraPrimitiveOverestimationSize,

                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setDepthClipEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthClipEnable,

                                 Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setSampleLocationsEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 sampleLocationsEnable,

                                       Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setColorBlendAdvancedEXT( uint32_t                                            firstAttachment,

                                    uint32_t                                            attachmentCount,

                                    const VULKAN_HPP_NAMESPACE::ColorBlendAdvancedEXT * pColorBlendAdvanced,

                                    Dispatch const & d                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setColorBlendAdvancedEXT( uint32_t                                                                                    firstAttachment,

                                    VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ColorBlendAdvancedEXT> const & colorBlendAdvanced,

                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setProvokingVertexModeEXT( VULKAN_HPP_NAMESPACE::ProvokingVertexModeEXT provokingVertexMode,

                                     Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setLineRasterizationModeEXT( VULKAN_HPP_NAMESPACE::LineRasterizationModeEXT lineRasterizationMode,

                                       Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setLineStippleEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 stippledLineEnable,

                                   Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setDepthClipNegativeOneToOneEXT( VULKAN_HPP_NAMESPACE::Bool32 negativeOneToOne,

                                           Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setViewportWScalingEnableNV( VULKAN_HPP_NAMESPACE::Bool32 viewportWScalingEnable,

                                       Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setViewportSwizzleNV( uint32_t                                        firstViewport,

                                uint32_t                                        viewportCount,

                                const VULKAN_HPP_NAMESPACE::ViewportSwizzleNV * pViewportSwizzles,

                                Dispatch const & d                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setViewportSwizzleNV( uint32_t                                                                                firstViewport,

                                VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ViewportSwizzleNV> const & viewportSwizzles,

                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setCoverageToColorEnableNV( VULKAN_HPP_NAMESPACE::Bool32 coverageToColorEnable,

                                      Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setCoverageToColorLocationNV( uint32_t           coverageToColorLocation,

                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setCoverageModulationModeNV( VULKAN_HPP_NAMESPACE::CoverageModulationModeNV coverageModulationMode,

                                       Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setCoverageModulationTableEnableNV( VULKAN_HPP_NAMESPACE::Bool32 coverageModulationTableEnable,

                                              Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setCoverageModulationTableNV( uint32_t           coverageModulationTableCount,

                                        const float *      pCoverageModulationTable,

                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setCoverageModulationTableNV( VULKAN_HPP_NAMESPACE::ArrayProxy<const float> const & coverageModulationTable,

                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setShadingRateImageEnableNV( VULKAN_HPP_NAMESPACE::Bool32 shadingRateImageEnable,

                                       Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setRepresentativeFragmentTestEnableNV( VULKAN_HPP_NAMESPACE::Bool32 representativeFragmentTestEnable,

                                                 Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setCoverageReductionModeNV( VULKAN_HPP_NAMESPACE::CoverageReductionModeNV coverageReductionMode,

                                      Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     //=== VK_NV_optical_flow ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void opticalFlowExecuteNV( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV             session,

                                const VULKAN_HPP_NAMESPACE::OpticalFlowExecuteInfoNV * pExecuteInfo,

                                Dispatch const & d                                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void opticalFlowExecuteNV( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV             session,

                                const VULKAN_HPP_NAMESPACE::OpticalFlowExecuteInfoNV & executeInfo,

                                Dispatch const & d                                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     operator VkCommandBuffer() const VULKAN_HPP_NOEXCEPT

     {

       return m_commandBuffer;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_commandBuffer != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_commandBuffer == VK_NULL_HANDLE;

     }


   private:

     VkCommandBuffer m_commandBuffer = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eCommandBuffer>

   {

     using Type = VULKAN_HPP_NAMESPACE::CommandBuffer;

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCommandBuffer>

   {

     using Type = VULKAN_HPP_NAMESPACE::CommandBuffer;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::CommandBuffer>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


   class DeviceMemory

   {

   public:

     using CType      = VkDeviceMemory;

     using NativeType = VkDeviceMemory;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDeviceMemory;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDeviceMemory;


   public:

     VULKAN_HPP_CONSTEXPR         DeviceMemory() = default;

     VULKAN_HPP_CONSTEXPR         DeviceMemory( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}

     VULKAN_HPP_TYPESAFE_EXPLICIT DeviceMemory( VkDeviceMemory deviceMemory ) VULKAN_HPP_NOEXCEPT : m_deviceMemory( deviceMemory ) {}


 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     DeviceMemory & operator=( VkDeviceMemory deviceMemory ) VULKAN_HPP_NOEXCEPT

     {

       m_deviceMemory = deviceMemory;

       return *this;

     }

 #endif


     DeviceMemory & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_deviceMemory = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( DeviceMemory const & ) const = default;

 #else

     bool                                 operator==( DeviceMemory const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_deviceMemory == rhs.m_deviceMemory;

     }


     bool operator!=( DeviceMemory const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_deviceMemory != rhs.m_deviceMemory;

     }


     bool operator<( DeviceMemory const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_deviceMemory < rhs.m_deviceMemory;

     }

 #endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDeviceMemory() const VULKAN_HPP_NOEXCEPT

     {

       return m_deviceMemory;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_deviceMemory != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_deviceMemory == VK_NULL_HANDLE;

     }


   private:

     VkDeviceMemory m_deviceMemory = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDeviceMemory>

   {

     using Type = VULKAN_HPP_NAMESPACE::DeviceMemory;

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDeviceMemory>

   {

     using Type = VULKAN_HPP_NAMESPACE::DeviceMemory;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DeviceMemory>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


 #if defined( VK_ENABLE_BETA_EXTENSIONS )

   class VideoSessionKHR

   {

   public:

     using CType      = VkVideoSessionKHR;

     using NativeType = VkVideoSessionKHR;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eVideoSessionKHR;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;


   public:

     VULKAN_HPP_CONSTEXPR         VideoSessionKHR() = default;

     VULKAN_HPP_CONSTEXPR         VideoSessionKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}

     VULKAN_HPP_TYPESAFE_EXPLICIT VideoSessionKHR( VkVideoSessionKHR videoSessionKHR ) VULKAN_HPP_NOEXCEPT : m_videoSessionKHR( videoSessionKHR ) {}


 #  if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     VideoSessionKHR & operator=( VkVideoSessionKHR videoSessionKHR ) VULKAN_HPP_NOEXCEPT

     {

       m_videoSessionKHR = videoSessionKHR;

       return *this;

     }

 #  endif


     VideoSessionKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_videoSessionKHR = {};

       return *this;

     }


 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( VideoSessionKHR const & ) const = default;

 #  else

     bool operator==( VideoSessionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_videoSessionKHR == rhs.m_videoSessionKHR;

     }


     bool operator!=( VideoSessionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_videoSessionKHR != rhs.m_videoSessionKHR;

     }


     bool operator<( VideoSessionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_videoSessionKHR < rhs.m_videoSessionKHR;

     }

 #  endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkVideoSessionKHR() const VULKAN_HPP_NOEXCEPT

     {

       return m_videoSessionKHR;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_videoSessionKHR != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_videoSessionKHR == VK_NULL_HANDLE;

     }


   private:

     VkVideoSessionKHR m_videoSessionKHR = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eVideoSessionKHR>

   {

     using Type = VULKAN_HPP_NAMESPACE::VideoSessionKHR;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::VideoSessionKHR>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };

 #endif /*VK_ENABLE_BETA_EXTENSIONS*/


   class DeferredOperationKHR

   {

   public:

     using CType      = VkDeferredOperationKHR;

     using NativeType = VkDeferredOperationKHR;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDeferredOperationKHR;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;


   public:

     VULKAN_HPP_CONSTEXPR         DeferredOperationKHR() = default;

     VULKAN_HPP_CONSTEXPR         DeferredOperationKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}

     VULKAN_HPP_TYPESAFE_EXPLICIT DeferredOperationKHR( VkDeferredOperationKHR deferredOperationKHR ) VULKAN_HPP_NOEXCEPT

       : m_deferredOperationKHR( deferredOperationKHR )

     {

     }


 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     DeferredOperationKHR & operator=( VkDeferredOperationKHR deferredOperationKHR ) VULKAN_HPP_NOEXCEPT

     {

       m_deferredOperationKHR = deferredOperationKHR;

       return *this;

     }

 #endif


     DeferredOperationKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_deferredOperationKHR = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( DeferredOperationKHR const & ) const = default;

 #else

     bool operator==( DeferredOperationKHR const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_deferredOperationKHR == rhs.m_deferredOperationKHR;

     }


     bool operator!=( DeferredOperationKHR const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_deferredOperationKHR != rhs.m_deferredOperationKHR;

     }


     bool operator<( DeferredOperationKHR const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_deferredOperationKHR < rhs.m_deferredOperationKHR;

     }

 #endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDeferredOperationKHR() const VULKAN_HPP_NOEXCEPT

     {

       return m_deferredOperationKHR;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_deferredOperationKHR != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_deferredOperationKHR == VK_NULL_HANDLE;

     }


   private:

     VkDeferredOperationKHR m_deferredOperationKHR = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDeferredOperationKHR>

   {

     using Type = VULKAN_HPP_NAMESPACE::DeferredOperationKHR;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DeferredOperationKHR>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


 #if defined( VK_USE_PLATFORM_FUCHSIA )

   class BufferCollectionFUCHSIA

   {

   public:

     using CType      = VkBufferCollectionFUCHSIA;

     using NativeType = VkBufferCollectionFUCHSIA;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eBufferCollectionFUCHSIA;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBufferCollectionFUCHSIA;


   public:

     VULKAN_HPP_CONSTEXPR         BufferCollectionFUCHSIA() = default;

     VULKAN_HPP_CONSTEXPR         BufferCollectionFUCHSIA( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}

     VULKAN_HPP_TYPESAFE_EXPLICIT BufferCollectionFUCHSIA( VkBufferCollectionFUCHSIA bufferCollectionFUCHSIA ) VULKAN_HPP_NOEXCEPT

       : m_bufferCollectionFUCHSIA( bufferCollectionFUCHSIA )

     {

     }


 #  if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     BufferCollectionFUCHSIA & operator=( VkBufferCollectionFUCHSIA bufferCollectionFUCHSIA ) VULKAN_HPP_NOEXCEPT

     {

       m_bufferCollectionFUCHSIA = bufferCollectionFUCHSIA;

       return *this;

     }

 #  endif


     BufferCollectionFUCHSIA & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_bufferCollectionFUCHSIA = {};

       return *this;

     }


 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( BufferCollectionFUCHSIA const & ) const = default;

 #  else

     bool operator==( BufferCollectionFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_bufferCollectionFUCHSIA == rhs.m_bufferCollectionFUCHSIA;

     }


     bool operator!=( BufferCollectionFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_bufferCollectionFUCHSIA != rhs.m_bufferCollectionFUCHSIA;

     }


     bool operator<( BufferCollectionFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_bufferCollectionFUCHSIA < rhs.m_bufferCollectionFUCHSIA;

     }

 #  endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkBufferCollectionFUCHSIA() const VULKAN_HPP_NOEXCEPT

     {

       return m_bufferCollectionFUCHSIA;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_bufferCollectionFUCHSIA != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_bufferCollectionFUCHSIA == VK_NULL_HANDLE;

     }


   private:

     VkBufferCollectionFUCHSIA m_bufferCollectionFUCHSIA = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eBufferCollectionFUCHSIA>

   {

     using Type = VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA;

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBufferCollectionFUCHSIA>

   {

     using Type = VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };

 #endif /*VK_USE_PLATFORM_FUCHSIA*/


   class BufferView

   {

   public:

     using CType      = VkBufferView;

     using NativeType = VkBufferView;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eBufferView;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBufferView;


   public:

     VULKAN_HPP_CONSTEXPR         BufferView() = default;

     VULKAN_HPP_CONSTEXPR         BufferView( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}

     VULKAN_HPP_TYPESAFE_EXPLICIT BufferView( VkBufferView bufferView ) VULKAN_HPP_NOEXCEPT : m_bufferView( bufferView ) {}


 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     BufferView & operator=( VkBufferView bufferView ) VULKAN_HPP_NOEXCEPT

     {

       m_bufferView = bufferView;

       return *this;

     }

 #endif


     BufferView & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_bufferView = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( BufferView const & ) const = default;

 #else

     bool operator==( BufferView const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_bufferView == rhs.m_bufferView;

     }


     bool operator!=( BufferView const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_bufferView != rhs.m_bufferView;

     }


     bool operator<( BufferView const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_bufferView < rhs.m_bufferView;

     }

 #endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkBufferView() const VULKAN_HPP_NOEXCEPT

     {

       return m_bufferView;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_bufferView != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_bufferView == VK_NULL_HANDLE;

     }


   private:

     VkBufferView m_bufferView = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eBufferView>

   {

     using Type = VULKAN_HPP_NAMESPACE::BufferView;

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBufferView>

   {

     using Type = VULKAN_HPP_NAMESPACE::BufferView;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::BufferView>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


   class CommandPool

   {

   public:

     using CType      = VkCommandPool;

     using NativeType = VkCommandPool;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eCommandPool;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCommandPool;


   public:

     VULKAN_HPP_CONSTEXPR         CommandPool() = default;

     VULKAN_HPP_CONSTEXPR         CommandPool( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}

     VULKAN_HPP_TYPESAFE_EXPLICIT CommandPool( VkCommandPool commandPool ) VULKAN_HPP_NOEXCEPT : m_commandPool( commandPool ) {}


 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     CommandPool & operator=( VkCommandPool commandPool ) VULKAN_HPP_NOEXCEPT

     {

       m_commandPool = commandPool;

       return *this;

     }

 #endif


     CommandPool & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_commandPool = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( CommandPool const & ) const = default;

 #else

     bool operator==( CommandPool const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_commandPool == rhs.m_commandPool;

     }


     bool operator!=( CommandPool const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_commandPool != rhs.m_commandPool;

     }


     bool operator<( CommandPool const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_commandPool < rhs.m_commandPool;

     }

 #endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCommandPool() const VULKAN_HPP_NOEXCEPT

     {

       return m_commandPool;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_commandPool != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_commandPool == VK_NULL_HANDLE;

     }


   private:

     VkCommandPool m_commandPool = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eCommandPool>

   {

     using Type = VULKAN_HPP_NAMESPACE::CommandPool;

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCommandPool>

   {

     using Type = VULKAN_HPP_NAMESPACE::CommandPool;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::CommandPool>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


   class PipelineCache

   {

   public:

     using CType      = VkPipelineCache;

     using NativeType = VkPipelineCache;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePipelineCache;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipelineCache;


   public:

     VULKAN_HPP_CONSTEXPR         PipelineCache() = default;

     VULKAN_HPP_CONSTEXPR         PipelineCache( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}

     VULKAN_HPP_TYPESAFE_EXPLICIT PipelineCache( VkPipelineCache pipelineCache ) VULKAN_HPP_NOEXCEPT : m_pipelineCache( pipelineCache ) {}


 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     PipelineCache & operator=( VkPipelineCache pipelineCache ) VULKAN_HPP_NOEXCEPT

     {

       m_pipelineCache = pipelineCache;

       return *this;

     }

 #endif


     PipelineCache & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_pipelineCache = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( PipelineCache const & ) const = default;

 #else

     bool operator==( PipelineCache const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_pipelineCache == rhs.m_pipelineCache;

     }


     bool operator!=( PipelineCache const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_pipelineCache != rhs.m_pipelineCache;

     }


     bool operator<( PipelineCache const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_pipelineCache < rhs.m_pipelineCache;

     }

 #endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipelineCache() const VULKAN_HPP_NOEXCEPT

     {

       return m_pipelineCache;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_pipelineCache != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_pipelineCache == VK_NULL_HANDLE;

     }


   private:

     VkPipelineCache m_pipelineCache = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePipelineCache>

   {

     using Type = VULKAN_HPP_NAMESPACE::PipelineCache;

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipelineCache>

   {

     using Type = VULKAN_HPP_NAMESPACE::PipelineCache;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::PipelineCache>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


   class CuFunctionNVX

   {

   public:

     using CType      = VkCuFunctionNVX;

     using NativeType = VkCuFunctionNVX;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eCuFunctionNVX;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCuFunctionNVX;


   public:

     VULKAN_HPP_CONSTEXPR         CuFunctionNVX() = default;

     VULKAN_HPP_CONSTEXPR         CuFunctionNVX( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}

     VULKAN_HPP_TYPESAFE_EXPLICIT CuFunctionNVX( VkCuFunctionNVX cuFunctionNVX ) VULKAN_HPP_NOEXCEPT : m_cuFunctionNVX( cuFunctionNVX ) {}


 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     CuFunctionNVX & operator=( VkCuFunctionNVX cuFunctionNVX ) VULKAN_HPP_NOEXCEPT

     {

       m_cuFunctionNVX = cuFunctionNVX;

       return *this;

     }

 #endif


     CuFunctionNVX & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_cuFunctionNVX = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( CuFunctionNVX const & ) const = default;

 #else

     bool operator==( CuFunctionNVX const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_cuFunctionNVX == rhs.m_cuFunctionNVX;

     }


     bool operator!=( CuFunctionNVX const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_cuFunctionNVX != rhs.m_cuFunctionNVX;

     }


     bool operator<( CuFunctionNVX const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_cuFunctionNVX < rhs.m_cuFunctionNVX;

     }

 #endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCuFunctionNVX() const VULKAN_HPP_NOEXCEPT

     {

       return m_cuFunctionNVX;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_cuFunctionNVX != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_cuFunctionNVX == VK_NULL_HANDLE;

     }


   private:

     VkCuFunctionNVX m_cuFunctionNVX = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eCuFunctionNVX>

   {

     using Type = VULKAN_HPP_NAMESPACE::CuFunctionNVX;

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCuFunctionNVX>

   {

     using Type = VULKAN_HPP_NAMESPACE::CuFunctionNVX;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::CuFunctionNVX>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


   class CuModuleNVX

   {

   public:

     using CType      = VkCuModuleNVX;

     using NativeType = VkCuModuleNVX;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eCuModuleNVX;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCuModuleNVX;


   public:

     VULKAN_HPP_CONSTEXPR         CuModuleNVX() = default;

     VULKAN_HPP_CONSTEXPR         CuModuleNVX( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}

     VULKAN_HPP_TYPESAFE_EXPLICIT CuModuleNVX( VkCuModuleNVX cuModuleNVX ) VULKAN_HPP_NOEXCEPT : m_cuModuleNVX( cuModuleNVX ) {}


 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     CuModuleNVX & operator=( VkCuModuleNVX cuModuleNVX ) VULKAN_HPP_NOEXCEPT

     {

       m_cuModuleNVX = cuModuleNVX;

       return *this;

     }

 #endif


     CuModuleNVX & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_cuModuleNVX = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( CuModuleNVX const & ) const = default;

 #else

     bool operator==( CuModuleNVX const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_cuModuleNVX == rhs.m_cuModuleNVX;

     }


     bool operator!=( CuModuleNVX const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_cuModuleNVX != rhs.m_cuModuleNVX;

     }


     bool operator<( CuModuleNVX const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_cuModuleNVX < rhs.m_cuModuleNVX;

     }

 #endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCuModuleNVX() const VULKAN_HPP_NOEXCEPT

     {

       return m_cuModuleNVX;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_cuModuleNVX != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_cuModuleNVX == VK_NULL_HANDLE;

     }


   private:

     VkCuModuleNVX m_cuModuleNVX = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eCuModuleNVX>

   {

     using Type = VULKAN_HPP_NAMESPACE::CuModuleNVX;

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCuModuleNVX>

   {

     using Type = VULKAN_HPP_NAMESPACE::CuModuleNVX;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::CuModuleNVX>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


   class DescriptorPool

   {

   public:

     using CType      = VkDescriptorPool;

     using NativeType = VkDescriptorPool;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorPool;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorPool;


   public:

     VULKAN_HPP_CONSTEXPR         DescriptorPool() = default;

     VULKAN_HPP_CONSTEXPR         DescriptorPool( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}

     VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorPool( VkDescriptorPool descriptorPool ) VULKAN_HPP_NOEXCEPT : m_descriptorPool( descriptorPool ) {}


 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     DescriptorPool & operator=( VkDescriptorPool descriptorPool ) VULKAN_HPP_NOEXCEPT

     {

       m_descriptorPool = descriptorPool;

       return *this;

     }

 #endif


     DescriptorPool & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_descriptorPool = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( DescriptorPool const & ) const = default;

 #else

     bool operator==( DescriptorPool const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_descriptorPool == rhs.m_descriptorPool;

     }


     bool operator!=( DescriptorPool const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_descriptorPool != rhs.m_descriptorPool;

     }


     bool operator<( DescriptorPool const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_descriptorPool < rhs.m_descriptorPool;

     }

 #endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorPool() const VULKAN_HPP_NOEXCEPT

     {

       return m_descriptorPool;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_descriptorPool != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_descriptorPool == VK_NULL_HANDLE;

     }


   private:

     VkDescriptorPool m_descriptorPool = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorPool>

   {

     using Type = VULKAN_HPP_NAMESPACE::DescriptorPool;

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorPool>

   {

     using Type = VULKAN_HPP_NAMESPACE::DescriptorPool;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DescriptorPool>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


   class DescriptorSetLayout

   {

   public:

     using CType      = VkDescriptorSetLayout;

     using NativeType = VkDescriptorSetLayout;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorSetLayout;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorSetLayout;


   public:

     VULKAN_HPP_CONSTEXPR         DescriptorSetLayout() = default;

     VULKAN_HPP_CONSTEXPR         DescriptorSetLayout( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}

     VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSetLayout( VkDescriptorSetLayout descriptorSetLayout ) VULKAN_HPP_NOEXCEPT

       : m_descriptorSetLayout( descriptorSetLayout )

     {

     }


 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     DescriptorSetLayout & operator=( VkDescriptorSetLayout descriptorSetLayout ) VULKAN_HPP_NOEXCEPT

     {

       m_descriptorSetLayout = descriptorSetLayout;

       return *this;

     }

 #endif


     DescriptorSetLayout & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_descriptorSetLayout = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( DescriptorSetLayout const & ) const = default;

 #else

     bool operator==( DescriptorSetLayout const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_descriptorSetLayout == rhs.m_descriptorSetLayout;

     }


     bool operator!=( DescriptorSetLayout const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_descriptorSetLayout != rhs.m_descriptorSetLayout;

     }


     bool operator<( DescriptorSetLayout const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_descriptorSetLayout < rhs.m_descriptorSetLayout;

     }

 #endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorSetLayout() const VULKAN_HPP_NOEXCEPT

     {

       return m_descriptorSetLayout;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_descriptorSetLayout != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_descriptorSetLayout == VK_NULL_HANDLE;

     }


   private:

     VkDescriptorSetLayout m_descriptorSetLayout = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorSetLayout>

   {

     using Type = VULKAN_HPP_NAMESPACE::DescriptorSetLayout;

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorSetLayout>

   {

     using Type = VULKAN_HPP_NAMESPACE::DescriptorSetLayout;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DescriptorSetLayout>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


   class Framebuffer

   {

   public:

     using CType      = VkFramebuffer;

     using NativeType = VkFramebuffer;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eFramebuffer;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eFramebuffer;


   public:

     VULKAN_HPP_CONSTEXPR         Framebuffer() = default;

     VULKAN_HPP_CONSTEXPR         Framebuffer( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}

     VULKAN_HPP_TYPESAFE_EXPLICIT Framebuffer( VkFramebuffer framebuffer ) VULKAN_HPP_NOEXCEPT : m_framebuffer( framebuffer ) {}


 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     Framebuffer & operator=( VkFramebuffer framebuffer ) VULKAN_HPP_NOEXCEPT

     {

       m_framebuffer = framebuffer;

       return *this;

     }

 #endif


     Framebuffer & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_framebuffer = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( Framebuffer const & ) const = default;

 #else

     bool operator==( Framebuffer const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_framebuffer == rhs.m_framebuffer;

     }


     bool operator!=( Framebuffer const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_framebuffer != rhs.m_framebuffer;

     }


     bool operator<( Framebuffer const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_framebuffer < rhs.m_framebuffer;

     }

 #endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkFramebuffer() const VULKAN_HPP_NOEXCEPT

     {

       return m_framebuffer;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_framebuffer != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_framebuffer == VK_NULL_HANDLE;

     }


   private:

     VkFramebuffer m_framebuffer = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eFramebuffer>

   {

     using Type = VULKAN_HPP_NAMESPACE::Framebuffer;

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eFramebuffer>

   {

     using Type = VULKAN_HPP_NAMESPACE::Framebuffer;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Framebuffer>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


   class IndirectCommandsLayoutNV

   {

   public:

     using CType      = VkIndirectCommandsLayoutNV;

     using NativeType = VkIndirectCommandsLayoutNV;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eIndirectCommandsLayoutNV;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;


   public:

     VULKAN_HPP_CONSTEXPR         IndirectCommandsLayoutNV() = default;

     VULKAN_HPP_CONSTEXPR         IndirectCommandsLayoutNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}

     VULKAN_HPP_TYPESAFE_EXPLICIT IndirectCommandsLayoutNV( VkIndirectCommandsLayoutNV indirectCommandsLayoutNV ) VULKAN_HPP_NOEXCEPT

       : m_indirectCommandsLayoutNV( indirectCommandsLayoutNV )

     {

     }


 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     IndirectCommandsLayoutNV & operator=( VkIndirectCommandsLayoutNV indirectCommandsLayoutNV ) VULKAN_HPP_NOEXCEPT

     {

       m_indirectCommandsLayoutNV = indirectCommandsLayoutNV;

       return *this;

     }

 #endif


     IndirectCommandsLayoutNV & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_indirectCommandsLayoutNV = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( IndirectCommandsLayoutNV const & ) const = default;

 #else

     bool operator==( IndirectCommandsLayoutNV const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_indirectCommandsLayoutNV == rhs.m_indirectCommandsLayoutNV;

     }


     bool operator!=( IndirectCommandsLayoutNV const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_indirectCommandsLayoutNV != rhs.m_indirectCommandsLayoutNV;

     }


     bool operator<( IndirectCommandsLayoutNV const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_indirectCommandsLayoutNV < rhs.m_indirectCommandsLayoutNV;

     }

 #endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkIndirectCommandsLayoutNV() const VULKAN_HPP_NOEXCEPT

     {

       return m_indirectCommandsLayoutNV;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_indirectCommandsLayoutNV != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_indirectCommandsLayoutNV == VK_NULL_HANDLE;

     }


   private:

     VkIndirectCommandsLayoutNV m_indirectCommandsLayoutNV = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eIndirectCommandsLayoutNV>

   {

     using Type = VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


   class PrivateDataSlot

   {

   public:

     using CType      = VkPrivateDataSlot;

     using NativeType = VkPrivateDataSlot;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePrivateDataSlot;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;


   public:

     VULKAN_HPP_CONSTEXPR         PrivateDataSlot() = default;

     VULKAN_HPP_CONSTEXPR         PrivateDataSlot( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}

     VULKAN_HPP_TYPESAFE_EXPLICIT PrivateDataSlot( VkPrivateDataSlot privateDataSlot ) VULKAN_HPP_NOEXCEPT : m_privateDataSlot( privateDataSlot ) {}


 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     PrivateDataSlot & operator=( VkPrivateDataSlot privateDataSlot ) VULKAN_HPP_NOEXCEPT

     {

       m_privateDataSlot = privateDataSlot;

       return *this;

     }

 #endif


     PrivateDataSlot & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_privateDataSlot = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( PrivateDataSlot const & ) const = default;

 #else

     bool operator==( PrivateDataSlot const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_privateDataSlot == rhs.m_privateDataSlot;

     }


     bool operator!=( PrivateDataSlot const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_privateDataSlot != rhs.m_privateDataSlot;

     }


     bool operator<( PrivateDataSlot const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_privateDataSlot < rhs.m_privateDataSlot;

     }

 #endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPrivateDataSlot() const VULKAN_HPP_NOEXCEPT

     {

       return m_privateDataSlot;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_privateDataSlot != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_privateDataSlot == VK_NULL_HANDLE;

     }


   private:

     VkPrivateDataSlot m_privateDataSlot = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePrivateDataSlot>

   {

     using Type = VULKAN_HPP_NAMESPACE::PrivateDataSlot;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::PrivateDataSlot>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };

   using PrivateDataSlotEXT = PrivateDataSlot;


   class RenderPass

   {

   public:

     using CType      = VkRenderPass;

     using NativeType = VkRenderPass;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eRenderPass;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eRenderPass;


   public:

     VULKAN_HPP_CONSTEXPR         RenderPass() = default;

     VULKAN_HPP_CONSTEXPR         RenderPass( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}

     VULKAN_HPP_TYPESAFE_EXPLICIT RenderPass( VkRenderPass renderPass ) VULKAN_HPP_NOEXCEPT : m_renderPass( renderPass ) {}


 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     RenderPass & operator=( VkRenderPass renderPass ) VULKAN_HPP_NOEXCEPT

     {

       m_renderPass = renderPass;

       return *this;

     }

 #endif


     RenderPass & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_renderPass = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( RenderPass const & ) const = default;

 #else

     bool operator==( RenderPass const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_renderPass == rhs.m_renderPass;

     }


     bool operator!=( RenderPass const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_renderPass != rhs.m_renderPass;

     }


     bool operator<( RenderPass const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_renderPass < rhs.m_renderPass;

     }

 #endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkRenderPass() const VULKAN_HPP_NOEXCEPT

     {

       return m_renderPass;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_renderPass != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_renderPass == VK_NULL_HANDLE;

     }


   private:

     VkRenderPass m_renderPass = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eRenderPass>

   {

     using Type = VULKAN_HPP_NAMESPACE::RenderPass;

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eRenderPass>

   {

     using Type = VULKAN_HPP_NAMESPACE::RenderPass;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::RenderPass>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


   class Sampler

   {

   public:

     using CType      = VkSampler;

     using NativeType = VkSampler;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eSampler;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSampler;


   public:

     VULKAN_HPP_CONSTEXPR         Sampler() = default;

     VULKAN_HPP_CONSTEXPR         Sampler( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}

     VULKAN_HPP_TYPESAFE_EXPLICIT Sampler( VkSampler sampler ) VULKAN_HPP_NOEXCEPT : m_sampler( sampler ) {}


 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     Sampler & operator=( VkSampler sampler ) VULKAN_HPP_NOEXCEPT

     {

       m_sampler = sampler;

       return *this;

     }

 #endif


     Sampler & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_sampler = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( Sampler const & ) const = default;

 #else

     bool operator==( Sampler const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_sampler == rhs.m_sampler;

     }


     bool operator!=( Sampler const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_sampler != rhs.m_sampler;

     }


     bool operator<( Sampler const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_sampler < rhs.m_sampler;

     }

 #endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSampler() const VULKAN_HPP_NOEXCEPT

     {

       return m_sampler;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_sampler != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_sampler == VK_NULL_HANDLE;

     }


   private:

     VkSampler m_sampler = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eSampler>

   {

     using Type = VULKAN_HPP_NAMESPACE::Sampler;

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSampler>

   {

     using Type = VULKAN_HPP_NAMESPACE::Sampler;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Sampler>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


   class SamplerYcbcrConversion

   {

   public:

     using CType      = VkSamplerYcbcrConversion;

     using NativeType = VkSamplerYcbcrConversion;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eSamplerYcbcrConversion;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSamplerYcbcrConversion;


   public:

     VULKAN_HPP_CONSTEXPR         SamplerYcbcrConversion() = default;

     VULKAN_HPP_CONSTEXPR         SamplerYcbcrConversion( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}

     VULKAN_HPP_TYPESAFE_EXPLICIT SamplerYcbcrConversion( VkSamplerYcbcrConversion samplerYcbcrConversion ) VULKAN_HPP_NOEXCEPT

       : m_samplerYcbcrConversion( samplerYcbcrConversion )

     {

     }


 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     SamplerYcbcrConversion & operator=( VkSamplerYcbcrConversion samplerYcbcrConversion ) VULKAN_HPP_NOEXCEPT

     {

       m_samplerYcbcrConversion = samplerYcbcrConversion;

       return *this;

     }

 #endif


     SamplerYcbcrConversion & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_samplerYcbcrConversion = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( SamplerYcbcrConversion const & ) const = default;

 #else

     bool operator==( SamplerYcbcrConversion const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_samplerYcbcrConversion == rhs.m_samplerYcbcrConversion;

     }


     bool operator!=( SamplerYcbcrConversion const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_samplerYcbcrConversion != rhs.m_samplerYcbcrConversion;

     }


     bool operator<( SamplerYcbcrConversion const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_samplerYcbcrConversion < rhs.m_samplerYcbcrConversion;

     }

 #endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSamplerYcbcrConversion() const VULKAN_HPP_NOEXCEPT

     {

       return m_samplerYcbcrConversion;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_samplerYcbcrConversion != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_samplerYcbcrConversion == VK_NULL_HANDLE;

     }


   private:

     VkSamplerYcbcrConversion m_samplerYcbcrConversion = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eSamplerYcbcrConversion>

   {

     using Type = VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion;

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSamplerYcbcrConversion>

   {

     using Type = VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };

   using SamplerYcbcrConversionKHR = SamplerYcbcrConversion;


   class ShaderModule

   {

   public:

     using CType      = VkShaderModule;

     using NativeType = VkShaderModule;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eShaderModule;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eShaderModule;


   public:

     VULKAN_HPP_CONSTEXPR         ShaderModule() = default;

     VULKAN_HPP_CONSTEXPR         ShaderModule( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}

     VULKAN_HPP_TYPESAFE_EXPLICIT ShaderModule( VkShaderModule shaderModule ) VULKAN_HPP_NOEXCEPT : m_shaderModule( shaderModule ) {}


 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     ShaderModule & operator=( VkShaderModule shaderModule ) VULKAN_HPP_NOEXCEPT

     {

       m_shaderModule = shaderModule;

       return *this;

     }

 #endif


     ShaderModule & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_shaderModule = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( ShaderModule const & ) const = default;

 #else

     bool operator==( ShaderModule const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_shaderModule == rhs.m_shaderModule;

     }


     bool operator!=( ShaderModule const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_shaderModule != rhs.m_shaderModule;

     }


     bool operator<( ShaderModule const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_shaderModule < rhs.m_shaderModule;

     }

 #endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkShaderModule() const VULKAN_HPP_NOEXCEPT

     {

       return m_shaderModule;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_shaderModule != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_shaderModule == VK_NULL_HANDLE;

     }


   private:

     VkShaderModule m_shaderModule = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eShaderModule>

   {

     using Type = VULKAN_HPP_NAMESPACE::ShaderModule;

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eShaderModule>

   {

     using Type = VULKAN_HPP_NAMESPACE::ShaderModule;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::ShaderModule>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


   class ValidationCacheEXT

   {

   public:

     using CType      = VkValidationCacheEXT;

     using NativeType = VkValidationCacheEXT;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eValidationCacheEXT;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eValidationCacheEXT;


   public:

     VULKAN_HPP_CONSTEXPR         ValidationCacheEXT() = default;

     VULKAN_HPP_CONSTEXPR         ValidationCacheEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}

     VULKAN_HPP_TYPESAFE_EXPLICIT ValidationCacheEXT( VkValidationCacheEXT validationCacheEXT ) VULKAN_HPP_NOEXCEPT : m_validationCacheEXT( validationCacheEXT )

     {

     }


 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     ValidationCacheEXT & operator=( VkValidationCacheEXT validationCacheEXT ) VULKAN_HPP_NOEXCEPT

     {

       m_validationCacheEXT = validationCacheEXT;

       return *this;

     }

 #endif


     ValidationCacheEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_validationCacheEXT = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( ValidationCacheEXT const & ) const = default;

 #else

     bool operator==( ValidationCacheEXT const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_validationCacheEXT == rhs.m_validationCacheEXT;

     }


     bool operator!=( ValidationCacheEXT const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_validationCacheEXT != rhs.m_validationCacheEXT;

     }


     bool operator<( ValidationCacheEXT const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_validationCacheEXT < rhs.m_validationCacheEXT;

     }

 #endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkValidationCacheEXT() const VULKAN_HPP_NOEXCEPT

     {

       return m_validationCacheEXT;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_validationCacheEXT != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_validationCacheEXT == VK_NULL_HANDLE;

     }


   private:

     VkValidationCacheEXT m_validationCacheEXT = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eValidationCacheEXT>

   {

     using Type = VULKAN_HPP_NAMESPACE::ValidationCacheEXT;

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eValidationCacheEXT>

   {

     using Type = VULKAN_HPP_NAMESPACE::ValidationCacheEXT;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::ValidationCacheEXT>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


 #if defined( VK_ENABLE_BETA_EXTENSIONS )

   class VideoSessionParametersKHR

   {

   public:

     using CType      = VkVideoSessionParametersKHR;

     using NativeType = VkVideoSessionParametersKHR;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eVideoSessionParametersKHR;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;


   public:

     VULKAN_HPP_CONSTEXPR         VideoSessionParametersKHR() = default;

     VULKAN_HPP_CONSTEXPR         VideoSessionParametersKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}

     VULKAN_HPP_TYPESAFE_EXPLICIT VideoSessionParametersKHR( VkVideoSessionParametersKHR videoSessionParametersKHR ) VULKAN_HPP_NOEXCEPT

       : m_videoSessionParametersKHR( videoSessionParametersKHR )

     {

     }


 #  if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     VideoSessionParametersKHR & operator=( VkVideoSessionParametersKHR videoSessionParametersKHR ) VULKAN_HPP_NOEXCEPT

     {

       m_videoSessionParametersKHR = videoSessionParametersKHR;

       return *this;

     }

 #  endif


     VideoSessionParametersKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_videoSessionParametersKHR = {};

       return *this;

     }


 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( VideoSessionParametersKHR const & ) const = default;

 #  else

     bool operator==( VideoSessionParametersKHR const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_videoSessionParametersKHR == rhs.m_videoSessionParametersKHR;

     }


     bool operator!=( VideoSessionParametersKHR const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_videoSessionParametersKHR != rhs.m_videoSessionParametersKHR;

     }


     bool operator<( VideoSessionParametersKHR const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_videoSessionParametersKHR < rhs.m_videoSessionParametersKHR;

     }

 #  endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkVideoSessionParametersKHR() const VULKAN_HPP_NOEXCEPT

     {

       return m_videoSessionParametersKHR;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_videoSessionParametersKHR != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_videoSessionParametersKHR == VK_NULL_HANDLE;

     }


   private:

     VkVideoSessionParametersKHR m_videoSessionParametersKHR = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eVideoSessionParametersKHR>

   {

     using Type = VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };

 #endif /*VK_ENABLE_BETA_EXTENSIONS*/


   class Queue

   {

   public:

     using CType      = VkQueue;

     using NativeType = VkQueue;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eQueue;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eQueue;


   public:

     VULKAN_HPP_CONSTEXPR Queue() = default;

     VULKAN_HPP_CONSTEXPR Queue( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}

     Queue( VkQueue queue ) VULKAN_HPP_NOEXCEPT : m_queue( queue ) {}


     Queue & operator=( VkQueue queue ) VULKAN_HPP_NOEXCEPT

     {

       m_queue = queue;

       return *this;

     }


     Queue & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_queue = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( Queue const & ) const = default;

 #else

     bool operator==( Queue const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_queue == rhs.m_queue;

     }


     bool operator!=( Queue const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_queue != rhs.m_queue;

     }


     bool operator<( Queue const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_queue < rhs.m_queue;

     }

 #endif


     //=== VK_VERSION_1_0 ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result waitIdle( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #else

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type waitIdle( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result bindSparse( uint32_t                                     bindInfoCount,

                                             const VULKAN_HPP_NAMESPACE::BindSparseInfo * pBindInfo,

                                             VULKAN_HPP_NAMESPACE::Fence                  fence,

                                             Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type

       bindSparse( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindSparseInfo> const & bindInfo,

                   VULKAN_HPP_NAMESPACE::Fence fence                                                    VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,

                   Dispatch const & d                                                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_VERSION_1_3 ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_KHR_swapchain ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result presentKHR( const VULKAN_HPP_NAMESPACE::PresentInfoKHR * pPresentInfo,

                                             Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result presentKHR( const VULKAN_HPP_NAMESPACE::PresentInfoKHR & presentInfo,

                                                                   Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_EXT_debug_utils ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void beginDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * pLabelInfo,

                                   Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void beginDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo,

                                   Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void endDebugUtilsLabelEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void insertDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * pLabelInfo,

                                    Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void insertDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo,

                                    Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_NV_device_diagnostic_checkpoints ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getCheckpointDataNV( uint32_t *                               pCheckpointDataCount,

                               VULKAN_HPP_NAMESPACE::CheckpointDataNV * pCheckpointData,

                               Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename CheckpointDataNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CheckpointDataNV>,

               typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::CheckpointDataNV, CheckpointDataNVAllocator>

                          getCheckpointDataNV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename CheckpointDataNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CheckpointDataNV>,

               typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename B1                        = CheckpointDataNVAllocator,

               typename std::enable_if<std::is_same<typename B1::value_type, CheckpointDataNV>::value, int>::type = 0>

     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::CheckpointDataNV, CheckpointDataNVAllocator>

       getCheckpointDataNV( CheckpointDataNVAllocator & checkpointDataNVAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_INTEL_performance_query ===


 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result setPerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration,

                                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #else

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type

          setPerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration,

                                            Dispatch const & d                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


     //=== VK_KHR_synchronization2 ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getCheckpointData2NV( uint32_t *                                pCheckpointDataCount,

                                VULKAN_HPP_NAMESPACE::CheckpointData2NV * pCheckpointData,

                                Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename CheckpointData2NVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CheckpointData2NV>,

               typename Dispatch                   = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::CheckpointData2NV, CheckpointData2NVAllocator>

                          getCheckpointData2NV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     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>

     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::CheckpointData2NV, CheckpointData2NVAllocator>

       getCheckpointData2NV( CheckpointData2NVAllocator & checkpointData2NVAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     operator VkQueue() const VULKAN_HPP_NOEXCEPT

     {

       return m_queue;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_queue != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_queue == VK_NULL_HANDLE;

     }


   private:

     VkQueue m_queue = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eQueue>

   {

     using Type = VULKAN_HPP_NAMESPACE::Queue;

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eQueue>

   {

     using Type = VULKAN_HPP_NAMESPACE::Queue;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Queue>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


 #ifndef VULKAN_HPP_NO_SMART_HANDLE

   class Device;

   template <typename Dispatch>

   class UniqueHandleTraits<AccelerationStructureKHR, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<Device, Dispatch>;

   };

   using UniqueAccelerationStructureKHR = UniqueHandle<AccelerationStructureKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

   template <typename Dispatch>

   class UniqueHandleTraits<AccelerationStructureNV, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<Device, Dispatch>;

   };

   using UniqueAccelerationStructureNV = UniqueHandle<AccelerationStructureNV, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

   template <typename Dispatch>

   class UniqueHandleTraits<Buffer, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<Device, Dispatch>;

   };

   using UniqueBuffer = UniqueHandle<Buffer, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

 #  if defined( VK_USE_PLATFORM_FUCHSIA )

   template <typename Dispatch>

   class UniqueHandleTraits<BufferCollectionFUCHSIA, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<Device, Dispatch>;

   };

   using UniqueBufferCollectionFUCHSIA = UniqueHandle<BufferCollectionFUCHSIA, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

 #  endif /*VK_USE_PLATFORM_FUCHSIA*/

   template <typename Dispatch>

   class UniqueHandleTraits<BufferView, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<Device, Dispatch>;

   };

   using UniqueBufferView = UniqueHandle<BufferView, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

   template <typename Dispatch>

   class UniqueHandleTraits<CommandBuffer, Dispatch>

   {

   public:

     using deleter = PoolFree<Device, CommandPool, Dispatch>;

   };

   using UniqueCommandBuffer = UniqueHandle<CommandBuffer, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

   template <typename Dispatch>

   class UniqueHandleTraits<CommandPool, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<Device, Dispatch>;

   };

   using UniqueCommandPool = UniqueHandle<CommandPool, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

   template <typename Dispatch>

   class UniqueHandleTraits<CuFunctionNVX, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<Device, Dispatch>;

   };

   using UniqueCuFunctionNVX = UniqueHandle<CuFunctionNVX, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

   template <typename Dispatch>

   class UniqueHandleTraits<CuModuleNVX, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<Device, Dispatch>;

   };

   using UniqueCuModuleNVX = UniqueHandle<CuModuleNVX, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

   template <typename Dispatch>

   class UniqueHandleTraits<DeferredOperationKHR, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<Device, Dispatch>;

   };

   using UniqueDeferredOperationKHR = UniqueHandle<DeferredOperationKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

   template <typename Dispatch>

   class UniqueHandleTraits<DescriptorPool, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<Device, Dispatch>;

   };

   using UniqueDescriptorPool = UniqueHandle<DescriptorPool, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

   template <typename Dispatch>

   class UniqueHandleTraits<DescriptorSet, Dispatch>

   {

   public:

     using deleter = PoolFree<Device, DescriptorPool, Dispatch>;

   };

   using UniqueDescriptorSet = UniqueHandle<DescriptorSet, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

   template <typename Dispatch>

   class UniqueHandleTraits<DescriptorSetLayout, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<Device, Dispatch>;

   };

   using UniqueDescriptorSetLayout = UniqueHandle<DescriptorSetLayout, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

   template <typename Dispatch>

   class UniqueHandleTraits<DescriptorUpdateTemplate, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<Device, Dispatch>;

   };

   using UniqueDescriptorUpdateTemplate    = UniqueHandle<DescriptorUpdateTemplate, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

   using UniqueDescriptorUpdateTemplateKHR = UniqueHandle<DescriptorUpdateTemplate, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

   template <typename Dispatch>

   class UniqueHandleTraits<DeviceMemory, Dispatch>

   {

   public:

     using deleter = ObjectFree<Device, Dispatch>;

   };

   using UniqueDeviceMemory = UniqueHandle<DeviceMemory, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

   template <typename Dispatch>

   class UniqueHandleTraits<Event, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<Device, Dispatch>;

   };

   using UniqueEvent = UniqueHandle<Event, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

   template <typename Dispatch>

   class UniqueHandleTraits<Fence, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<Device, Dispatch>;

   };

   using UniqueFence = UniqueHandle<Fence, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

   template <typename Dispatch>

   class UniqueHandleTraits<Framebuffer, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<Device, Dispatch>;

   };

   using UniqueFramebuffer = UniqueHandle<Framebuffer, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

   template <typename Dispatch>

   class UniqueHandleTraits<Image, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<Device, Dispatch>;

   };

   using UniqueImage = UniqueHandle<Image, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

   template <typename Dispatch>

   class UniqueHandleTraits<ImageView, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<Device, Dispatch>;

   };

   using UniqueImageView = UniqueHandle<ImageView, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

   template <typename Dispatch>

   class UniqueHandleTraits<IndirectCommandsLayoutNV, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<Device, Dispatch>;

   };

   using UniqueIndirectCommandsLayoutNV = UniqueHandle<IndirectCommandsLayoutNV, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

   template <typename Dispatch>

   class UniqueHandleTraits<MicromapEXT, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<Device, Dispatch>;

   };

   using UniqueMicromapEXT = UniqueHandle<MicromapEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

   template <typename Dispatch>

   class UniqueHandleTraits<OpticalFlowSessionNV, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<Device, Dispatch>;

   };

   using UniqueOpticalFlowSessionNV = UniqueHandle<OpticalFlowSessionNV, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

   template <typename Dispatch>

   class UniqueHandleTraits<Pipeline, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<Device, Dispatch>;

   };

   using UniquePipeline = UniqueHandle<Pipeline, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

   template <typename Dispatch>

   class UniqueHandleTraits<PipelineCache, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<Device, Dispatch>;

   };

   using UniquePipelineCache = UniqueHandle<PipelineCache, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

   template <typename Dispatch>

   class UniqueHandleTraits<PipelineLayout, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<Device, Dispatch>;

   };

   using UniquePipelineLayout = UniqueHandle<PipelineLayout, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

   template <typename Dispatch>

   class UniqueHandleTraits<PrivateDataSlot, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<Device, Dispatch>;

   };

   using UniquePrivateDataSlot    = UniqueHandle<PrivateDataSlot, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

   using UniquePrivateDataSlotEXT = UniqueHandle<PrivateDataSlot, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

   template <typename Dispatch>

   class UniqueHandleTraits<QueryPool, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<Device, Dispatch>;

   };

   using UniqueQueryPool = UniqueHandle<QueryPool, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

   template <typename Dispatch>

   class UniqueHandleTraits<RenderPass, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<Device, Dispatch>;

   };

   using UniqueRenderPass = UniqueHandle<RenderPass, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

   template <typename Dispatch>

   class UniqueHandleTraits<Sampler, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<Device, Dispatch>;

   };

   using UniqueSampler = UniqueHandle<Sampler, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

   template <typename Dispatch>

   class UniqueHandleTraits<SamplerYcbcrConversion, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<Device, Dispatch>;

   };

   using UniqueSamplerYcbcrConversion    = UniqueHandle<SamplerYcbcrConversion, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

   using UniqueSamplerYcbcrConversionKHR = UniqueHandle<SamplerYcbcrConversion, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

   template <typename Dispatch>

   class UniqueHandleTraits<Semaphore, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<Device, Dispatch>;

   };

   using UniqueSemaphore = UniqueHandle<Semaphore, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

   template <typename Dispatch>

   class UniqueHandleTraits<ShaderModule, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<Device, Dispatch>;

   };

   using UniqueShaderModule = UniqueHandle<ShaderModule, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

   template <typename Dispatch>

   class UniqueHandleTraits<SwapchainKHR, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<Device, Dispatch>;

   };

   using UniqueSwapchainKHR = UniqueHandle<SwapchainKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

   template <typename Dispatch>

   class UniqueHandleTraits<ValidationCacheEXT, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<Device, Dispatch>;

   };

   using UniqueValidationCacheEXT = UniqueHandle<ValidationCacheEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

 #  if defined( VK_ENABLE_BETA_EXTENSIONS )

   template <typename Dispatch>

   class UniqueHandleTraits<VideoSessionKHR, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<Device, Dispatch>;

   };

   using UniqueVideoSessionKHR = UniqueHandle<VideoSessionKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

 #  endif /*VK_ENABLE_BETA_EXTENSIONS*/

 #  if defined( VK_ENABLE_BETA_EXTENSIONS )

   template <typename Dispatch>

   class UniqueHandleTraits<VideoSessionParametersKHR, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<Device, Dispatch>;

   };

   using UniqueVideoSessionParametersKHR = UniqueHandle<VideoSessionParametersKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

 #  endif /*VK_ENABLE_BETA_EXTENSIONS*/

 #endif   /*VULKAN_HPP_NO_SMART_HANDLE*/


   class Device

   {

   public:

     using CType      = VkDevice;

     using NativeType = VkDevice;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDevice;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDevice;


   public:

     VULKAN_HPP_CONSTEXPR Device() = default;

     VULKAN_HPP_CONSTEXPR Device( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}

     Device( VkDevice device ) VULKAN_HPP_NOEXCEPT : m_device( device ) {}


     Device & operator=( VkDevice device ) VULKAN_HPP_NOEXCEPT

     {

       m_device = device;

       return *this;

     }


     Device & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_device = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( Device const & ) const = default;

 #else

     bool operator==( Device const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_device == rhs.m_device;

     }


     bool operator!=( Device const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_device != rhs.m_device;

     }


     bool operator<( Device const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_device < rhs.m_device;

     }

 #endif


     //=== VK_VERSION_1_0 ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     PFN_vkVoidFunction getProcAddr( const char * pName, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     PFN_vkVoidFunction getProcAddr( const std::string & name, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result waitIdle( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #else

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type waitIdle( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void freeMemory( VULKAN_HPP_NAMESPACE::DeviceMemory                memory,

                      const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                      Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void freeMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory                           VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,

                      Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                      Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void( free )( VULKAN_HPP_NAMESPACE::DeviceMemory                memory,

                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void( free )( VULKAN_HPP_NAMESPACE::DeviceMemory                                  memory,

                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void unmapMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getMemoryCommitment( VULKAN_HPP_NAMESPACE::DeviceMemory memory,

                               VULKAN_HPP_NAMESPACE::DeviceSize * pCommittedMemoryInBytes,

                               Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #else

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #else

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getBufferMemoryRequirements( VULKAN_HPP_NAMESPACE::Buffer               buffer,

                                       VULKAN_HPP_NAMESPACE::MemoryRequirements * pMemoryRequirements,

                                       Dispatch const & d                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getImageMemoryRequirements( VULKAN_HPP_NAMESPACE::Image                image,

                                      VULKAN_HPP_NAMESPACE::MemoryRequirements * pMemoryRequirements,

                                      Dispatch const & d                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getImageSparseMemoryRequirements( VULKAN_HPP_NAMESPACE::Image                           image,

                                            uint32_t *                                            pSparseMemoryRequirementCount,

                                            VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements * pSparseMemoryRequirements,

                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename SparseImageMemoryRequirementsAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements>,

               typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements, SparseImageMemoryRequirementsAllocator>

       getImageSparseMemoryRequirements( VULKAN_HPP_NAMESPACE::Image image, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename SparseImageMemoryRequirementsAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements>,

               typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename B1                                     = SparseImageMemoryRequirementsAllocator,

               typename std::enable_if<std::is_same<typename B1::value_type, SparseImageMemoryRequirements>::value, int>::type = 0>

     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements, SparseImageMemoryRequirementsAllocator>

                          getImageSparseMemoryRequirements( VULKAN_HPP_NAMESPACE::Image              image,

                                                            SparseImageMemoryRequirementsAllocator & sparseImageMemoryRequirementsAllocator,

                                                            Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getFenceStatus( VULKAN_HPP_NAMESPACE::Fence fence,

                                                 Dispatch const & d          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #else

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result getFenceStatus( VULKAN_HPP_NAMESPACE::Fence fence,

                                                                       Dispatch const & d          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getEventStatus( VULKAN_HPP_NAMESPACE::Event event,

                                                 Dispatch const & d          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #else

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result getEventStatus( VULKAN_HPP_NAMESPACE::Event event,

                                                                       Dispatch const & d          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result setEvent( VULKAN_HPP_NAMESPACE::Event event,

                                           Dispatch const & d          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #else

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result resetEvent( VULKAN_HPP_NAMESPACE::Event event,

                                             Dispatch const & d          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #else

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     typename ResultValueType<void>::type resetEvent( VULKAN_HPP_NAMESPACE::Event event, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyQueryPool( VULKAN_HPP_NAMESPACE::QueryPool                   queryPool,

                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                            Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyQueryPool( VULKAN_HPP_NAMESPACE::QueryPool queryPool                           VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,

                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::QueryPool                   queryPool,

                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::QueryPool                                     queryPool,

                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename DataType, typename DataTypeAllocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createShaderModule( const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo * pCreateInfo,

                                                     const VULKAN_HPP_NAMESPACE::AllocationCallbacks *    pAllocator,

                                                     VULKAN_HPP_NAMESPACE::ShaderModule *                 pShaderModule,

                                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ShaderModule>::type

       createShaderModule( const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo &                createInfo,

                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                           Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderModule, Dispatch>>::type

       createShaderModuleUnique( const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo &                createInfo,

                                 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                 Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyShaderModule( VULKAN_HPP_NAMESPACE::ShaderModule                shaderModule,

                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                               Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyShaderModule( VULKAN_HPP_NAMESPACE::ShaderModule shaderModule                     VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,

                               Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::ShaderModule                shaderModule,

                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::ShaderModule                                  shaderModule,

                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getPipelineCacheData( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,

                                                       size_t *                            pDataSize,

                                                       void *                              pData,

                                                       Dispatch const & d                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Uint8_tAllocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type

       getPipelineCacheData( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename Uint8_tAllocator                                                                 = std::allocator<uint8_t>,

               typename Dispatch                                                                         = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename B1                                                                               = Uint8_tAllocator,

               typename std::enable_if<std::is_same<typename B1::value_type, uint8_t>::value, int>::type = 0>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type

       getPipelineCacheData( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,

                             Uint8_tAllocator &                  uint8_tAllocator,

                             Dispatch const & d                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result mergePipelineCaches( VULKAN_HPP_NAMESPACE::PipelineCache         dstCache,

                                                      uint32_t                                    srcCacheCount,

                                                      const VULKAN_HPP_NAMESPACE::PipelineCache * pSrcCaches,

                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type

       mergePipelineCaches( VULKAN_HPP_NAMESPACE::PipelineCache                                                 dstCache,

                            VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::PipelineCache> const & srcCaches,

                            Dispatch const & d                                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

     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>

     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;

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>>

     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;

     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>

     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;

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

     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>

     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;

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>>

     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;

     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>

     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;

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPool              descriptorPool,

                                 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                                 Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool                 VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,

                                 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::DescriptorPool              descriptorPool,

                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::DescriptorPool                                descriptorPool,

                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     Result resetDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPool           descriptorPool,

                                 VULKAN_HPP_NAMESPACE::DescriptorPoolResetFlags flags,

                                 Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #else

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename DescriptorSetAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DescriptorSet>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

     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>

     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;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename DescriptorSetAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSet, Dispatch>>>

     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;

     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>

     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;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getRenderAreaGranularity( VULKAN_HPP_NAMESPACE::RenderPass renderPass,

                                    VULKAN_HPP_NAMESPACE::Extent2D * pGranularity,

                                    Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyCommandPool( VULKAN_HPP_NAMESPACE::CommandPool                 commandPool,

                              const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                              Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyCommandPool( VULKAN_HPP_NAMESPACE::CommandPool commandPool                       VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,

                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::CommandPool                 commandPool,

                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::CommandPool                                   commandPool,

                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #else

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename CommandBufferAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CommandBuffer>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

     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>

     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;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename CommandBufferAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::CommandBuffer, Dispatch>>>

     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;

     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>

     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;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_VERSION_1_1 ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>

                          getImageMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info,

                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>

                          getBufferMemoryRequirements2( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info,

                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getImageSparseMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 * pInfo,

                                             uint32_t *                                                       pSparseMemoryRequirementCount,

                                             VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 *           pSparseMemoryRequirements,

                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename SparseImageMemoryRequirements2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>,

               typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>

                          getImageSparseMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 & info,

                                                             Dispatch const & d                                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     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>

     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>

                          getImageSparseMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 & info,

                                                             SparseImageMemoryRequirements2Allocator &                        sparseImageMemoryRequirements2Allocator,

                                                             Dispatch const & d                                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void trimCommandPool( VULKAN_HPP_NAMESPACE::CommandPool          commandPool,

                           VULKAN_HPP_NAMESPACE::CommandPoolTrimFlags flags,

                           Dispatch const & d                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createDescriptorUpdateTemplate( const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo * pCreateInfo,

                                                                 const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                pAllocator,

                                                                 VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate *                 pDescriptorUpdateTemplate,

                                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate>::type

       createDescriptorUpdateTemplate( const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo &    createInfo,

                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                       Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate, Dispatch>>::type

       createDescriptorUpdateTemplateUnique( const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo &    createInfo,

                                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyDescriptorUpdateTemplate( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate    descriptorUpdateTemplate,

                                           const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyDescriptorUpdateTemplate( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,

                                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate    descriptorUpdateTemplate,

                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate                      descriptorUpdateTemplate,

                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void updateDescriptorSetWithTemplate( VULKAN_HPP_NAMESPACE::DescriptorSet            descriptorSet,

                                           VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,

                                           const void *                                   pData,

                                           Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void updateDescriptorSetWithTemplate( VULKAN_HPP_NAMESPACE::DescriptorSet            descriptorSet,

                                           VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,

                                           DataType const &                               data,

                                           Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>

                          getDescriptorSetLayoutSupport( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo,

                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_VERSION_1_2 ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<uint64_t>::type getSemaphoreCounterValue( VULKAN_HPP_NAMESPACE::Semaphore semaphore,

                                                                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result signalSemaphore( const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo * pSignalInfo,

                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     DeviceAddress getBufferAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo,

                                     Dispatch const & d                                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NAMESPACE::DeviceAddress getBufferAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info,

                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     uint64_t getBufferOpaqueCaptureAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo,

                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     uint64_t getBufferOpaqueCaptureAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info,

                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     uint64_t getMemoryOpaqueCaptureAddress( const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo * pInfo,

                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     uint64_t getMemoryOpaqueCaptureAddress( const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo & info,

                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_VERSION_1_3 ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #else

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>

                          getBufferMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements & info,

                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>

                          getImageMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info,

                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename SparseImageMemoryRequirements2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>,

               typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

     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>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_KHR_swapchain ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroySwapchainKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR                swapchain,

                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                               Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroySwapchainKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain                        VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,

                               Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::SwapchainKHR                swapchain,

                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::SwapchainKHR                                  swapchain,

                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename ImageAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Image>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

     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>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getGroupPresentCapabilitiesKHR( VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR * pDeviceGroupPresentCapabilities,

                                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR>::type

       getGroupPresentCapabilitiesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD ResultValue<uint32_t> acquireNextImage2KHR( const VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR & acquireInfo,

                                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_KHR_display_swapchain ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename SwapchainKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SwapchainKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

     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>

     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;

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename SwapchainKHRAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>>>

     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;

     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>

     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;

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_EXT_debug_marker ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result debugMarkerSetObjectTagEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT * pTagInfo,

                                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type

       debugMarkerSetObjectTagEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT & tagInfo,

                                   Dispatch const & d                                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result debugMarkerSetObjectNameEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT * pNameInfo,

                                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type

       debugMarkerSetObjectNameEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT & nameInfo,

                                    Dispatch const & d                                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


 #if defined( VK_ENABLE_BETA_EXTENSIONS )

     //=== VK_KHR_video_queue ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createVideoSessionKHR( const VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR * pCreateInfo,

                                                        const VULKAN_HPP_NAMESPACE::AllocationCallbacks *       pAllocator,

                                                        VULKAN_HPP_NAMESPACE::VideoSessionKHR *                 pVideoSession,

                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::VideoSessionKHR>::type

       createVideoSessionKHR( const VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR &             createInfo,

                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                              Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #    ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::VideoSessionKHR, Dispatch>>::type

       createVideoSessionKHRUnique( const VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR &             createInfo,

                                    Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                    Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #    endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyVideoSessionKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR             videoSession,

                                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                                  Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyVideoSessionKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession                  VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,

                                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::VideoSessionKHR             videoSession,

                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::VideoSessionKHR                               videoSession,

                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getVideoSessionMemoryRequirementsKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR                     videoSession,

                                                                       uint32_t *                                                pMemoryRequirementsCount,

                                                                       VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR * pMemoryRequirements,

                                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename VideoSessionMemoryRequirementsKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR>,

               typename Dispatch                                   = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD

       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR, VideoSessionMemoryRequirementsKHRAllocator>>::type

       getVideoSessionMemoryRequirementsKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession,

                                             Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename VideoSessionMemoryRequirementsKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR>,

               typename Dispatch                                   = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename B1                                         = VideoSessionMemoryRequirementsKHRAllocator,

               typename std::enable_if<std::is_same<typename B1::value_type, VideoSessionMemoryRequirementsKHR>::value, int>::type = 0>

     VULKAN_HPP_NODISCARD

       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR, VideoSessionMemoryRequirementsKHRAllocator>>::type

       getVideoSessionMemoryRequirementsKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR        videoSession,

                                             VideoSessionMemoryRequirementsKHRAllocator & videoSessionMemoryRequirementsKHRAllocator,

                                             Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result bindVideoSessionMemoryKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR                       videoSession,

                                                            uint32_t                                                    bindSessionMemoryInfoCount,

                                                            const VULKAN_HPP_NAMESPACE::BindVideoSessionMemoryInfoKHR * pBindSessionMemoryInfos,

                                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type

       bindVideoSessionMemoryKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR                                                               videoSession,

                                  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindVideoSessionMemoryInfoKHR> const & bindSessionMemoryInfos,

                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR * pCreateInfo,

                                                                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                 pAllocator,

                                                                  VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR *                 pVideoSessionParameters,

                                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR>::type

       createVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR &   createInfo,

                                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                        Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #    ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR, Dispatch>>::type

       createVideoSessionParametersKHRUnique( const VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR &   createInfo,

                                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #    endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result updateVideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR                   videoSessionParameters,

                                                                  const VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR * pUpdateInfo,

                                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type

       updateVideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR                   videoSessionParameters,

                                        const VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR & updateInfo,

                                        Dispatch const & d                                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyVideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR   videoSessionParameters,

                                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyVideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,

                                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR   videoSessionParameters,

                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR                     videoSessionParameters,

                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

 #endif   /*VK_ENABLE_BETA_EXTENSIONS*/


     //=== VK_NVX_binary_import ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createCuModuleNVX( const VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX * pCreateInfo,

                                                    const VULKAN_HPP_NAMESPACE::AllocationCallbacks *   pAllocator,

                                                    VULKAN_HPP_NAMESPACE::CuModuleNVX *                 pModule,

                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::CuModuleNVX>::type

       createCuModuleNVX( const VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX &                 createInfo,

                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                          Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::CuModuleNVX, Dispatch>>::type

       createCuModuleNVXUnique( const VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX &                 createInfo,

                                Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createCuFunctionNVX( const VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX * pCreateInfo,

                                                      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *     pAllocator,

                                                      VULKAN_HPP_NAMESPACE::CuFunctionNVX *                 pFunction,

                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::CuFunctionNVX>::type

       createCuFunctionNVX( const VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX &               createInfo,

                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                            Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::CuFunctionNVX, Dispatch>>::type

       createCuFunctionNVXUnique( const VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX &               createInfo,

                                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyCuModuleNVX( VULKAN_HPP_NAMESPACE::CuModuleNVX                 module,

                              const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                              Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyCuModuleNVX( VULKAN_HPP_NAMESPACE::CuModuleNVX                                   module,

                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::CuModuleNVX                 module,

                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::CuModuleNVX                                   module,

                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyCuFunctionNVX( VULKAN_HPP_NAMESPACE::CuFunctionNVX               function,

                                const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                                Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyCuFunctionNVX( VULKAN_HPP_NAMESPACE::CuFunctionNVX                                 function,

                                Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::CuFunctionNVX               function,

                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::CuFunctionNVX                                 function,

                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_NVX_image_view_handle ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     uint32_t getImageViewHandleNVX( const VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX * pInfo,

                                     Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     uint32_t getImageViewHandleNVX( const VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX & info,

                                     Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getImageViewAddressNVX( VULKAN_HPP_NAMESPACE::ImageView                       imageView,

                                                         VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX * pProperties,

                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX>::type

       getImageViewAddressNVX( VULKAN_HPP_NAMESPACE::ImageView imageView, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_AMD_shader_info ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getShaderInfoAMD( VULKAN_HPP_NAMESPACE::Pipeline            pipeline,

                                                   VULKAN_HPP_NAMESPACE::ShaderStageFlagBits shaderStage,

                                                   VULKAN_HPP_NAMESPACE::ShaderInfoTypeAMD   infoType,

                                                   size_t *                                  pInfoSize,

                                                   void *                                    pInfo,

                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Uint8_tAllocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type

       getShaderInfoAMD( VULKAN_HPP_NAMESPACE::Pipeline            pipeline,

                         VULKAN_HPP_NAMESPACE::ShaderStageFlagBits shaderStage,

                         VULKAN_HPP_NAMESPACE::ShaderInfoTypeAMD   infoType,

                         Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename Uint8_tAllocator                                                                 = std::allocator<uint8_t>,

               typename Dispatch                                                                         = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename B1                                                                               = Uint8_tAllocator,

               typename std::enable_if<std::is_same<typename B1::value_type, uint8_t>::value, int>::type = 0>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type

       getShaderInfoAMD( VULKAN_HPP_NAMESPACE::Pipeline            pipeline,

                         VULKAN_HPP_NAMESPACE::ShaderStageFlagBits shaderStage,

                         VULKAN_HPP_NAMESPACE::ShaderInfoTypeAMD   infoType,

                         Uint8_tAllocator &                        uint8_tAllocator,

                         Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


 #if defined( VK_USE_PLATFORM_WIN32_KHR )

     //=== VK_NV_external_memory_win32 ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getMemoryWin32HandleNV( VULKAN_HPP_NAMESPACE::DeviceMemory                    memory,

                                                         VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV handleType,

                                                         HANDLE *                                              pHandle,

                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<HANDLE>::type getMemoryWin32HandleNV( VULKAN_HPP_NAMESPACE::DeviceMemory                    memory,

                                                                                         VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV handleType,

                                                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

 #endif   /*VK_USE_PLATFORM_WIN32_KHR*/


     //=== VK_KHR_device_group ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getGroupPeerMemoryFeaturesKHR( uint32_t                                       heapIndex,

                                         uint32_t                                       localDeviceIndex,

                                         uint32_t                                       remoteDeviceIndex,

                                         VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags * pPeerMemoryFeatures,

                                         Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags

                          getGroupPeerMemoryFeaturesKHR( uint32_t           heapIndex,

                                                         uint32_t           localDeviceIndex,

                                                         uint32_t           remoteDeviceIndex,

                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_KHR_maintenance1 ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void trimCommandPoolKHR( VULKAN_HPP_NAMESPACE::CommandPool          commandPool,

                              VULKAN_HPP_NAMESPACE::CommandPoolTrimFlags flags,

                              Dispatch const & d                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


 #if defined( VK_USE_PLATFORM_WIN32_KHR )

     //=== VK_KHR_external_memory_win32 ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getMemoryWin32HandleKHR( const VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR * pGetWin32HandleInfo,

                                                          HANDLE *                                                  pHandle,

                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<HANDLE>::type

       getMemoryWin32HandleKHR( const VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR & getWin32HandleInfo,

                                Dispatch const & d                                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getMemoryWin32HandlePropertiesKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,

                                                                    HANDLE                                                 handle,

                                                                    VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR * pMemoryWin32HandleProperties,

                                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR>::type getMemoryWin32HandlePropertiesKHR(

       VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

 #endif   /*VK_USE_PLATFORM_WIN32_KHR*/


     //=== VK_KHR_external_memory_fd ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<int>::type getMemoryFdKHR( const VULKAN_HPP_NAMESPACE::MemoryGetFdInfoKHR & getFdInfo,

                                                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


 #if defined( VK_USE_PLATFORM_WIN32_KHR )

     //=== VK_KHR_external_semaphore_win32 ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result importSemaphoreWin32HandleKHR( const VULKAN_HPP_NAMESPACE::ImportSemaphoreWin32HandleInfoKHR * pImportSemaphoreWin32HandleInfo,

                                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type

       importSemaphoreWin32HandleKHR( const VULKAN_HPP_NAMESPACE::ImportSemaphoreWin32HandleInfoKHR & importSemaphoreWin32HandleInfo,

                                      Dispatch const & d                                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getSemaphoreWin32HandleKHR( const VULKAN_HPP_NAMESPACE::SemaphoreGetWin32HandleInfoKHR * pGetWin32HandleInfo,

                                                             HANDLE *                                                     pHandle,

                                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<HANDLE>::type

       getSemaphoreWin32HandleKHR( const VULKAN_HPP_NAMESPACE::SemaphoreGetWin32HandleInfoKHR & getWin32HandleInfo,

                                   Dispatch const & d                                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

 #endif   /*VK_USE_PLATFORM_WIN32_KHR*/


     //=== VK_KHR_external_semaphore_fd ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result importSemaphoreFdKHR( const VULKAN_HPP_NAMESPACE::ImportSemaphoreFdInfoKHR * pImportSemaphoreFdInfo,

                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<int>::type getSemaphoreFdKHR( const VULKAN_HPP_NAMESPACE::SemaphoreGetFdInfoKHR & getFdInfo,

                                                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_KHR_descriptor_update_template ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createDescriptorUpdateTemplateKHR( const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo * pCreateInfo,

                                                                    const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                pAllocator,

                                                                    VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate *                 pDescriptorUpdateTemplate,

                                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate>::type

       createDescriptorUpdateTemplateKHR( const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo &    createInfo,

                                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                          Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate, Dispatch>>::type

       createDescriptorUpdateTemplateKHRUnique( const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo & createInfo,

                                                Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator

                                                                   VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyDescriptorUpdateTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate    descriptorUpdateTemplate,

                                              const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyDescriptorUpdateTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,

                                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void updateDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorSet            descriptorSet,

                                              VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,

                                              const void *                                   pData,

                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void updateDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorSet            descriptorSet,

                                              VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,

                                              DataType const &                               data,

                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_EXT_display_control ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_GOOGLE_display_timing ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getRefreshCycleDurationGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR                 swapchain,

                                                                VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE * pDisplayTimingProperties,

                                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE>::type

       getRefreshCycleDurationGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getPastPresentationTimingGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR                   swapchain,

                                                                  uint32_t *                                           pPresentationTimingCount,

                                                                  VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE * pPresentationTimings,

                                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename PastPresentationTimingGOOGLEAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE>,

               typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE, PastPresentationTimingGOOGLEAllocator>>::type

       getPastPresentationTimingGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename PastPresentationTimingGOOGLEAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE>,

               typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename B1                                    = PastPresentationTimingGOOGLEAllocator,

               typename std::enable_if<std::is_same<typename B1::value_type, PastPresentationTimingGOOGLE>::value, int>::type = 0>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE, PastPresentationTimingGOOGLEAllocator>>::type

       getPastPresentationTimingGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR      swapchain,

                                        PastPresentationTimingGOOGLEAllocator & pastPresentationTimingGOOGLEAllocator,

                                        Dispatch const & d                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_EXT_hdr_metadata ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_KHR_create_renderpass2 ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createRenderPass2KHR( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 * pCreateInfo,

                                                       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *   pAllocator,

                                                       VULKAN_HPP_NAMESPACE::RenderPass *                  pRenderPass,

                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::RenderPass>::type

       createRenderPass2KHR( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 &                 createInfo,

                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                             Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>>::type

       createRenderPass2KHRUnique( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 &                 createInfo,

                                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_KHR_shared_presentable_image ===


 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getSwapchainStatusKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,

                                                        Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #else

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result getSwapchainStatusKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,

                                                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


 #if defined( VK_USE_PLATFORM_WIN32_KHR )

     //=== VK_KHR_external_fence_win32 ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result importFenceWin32HandleKHR( const VULKAN_HPP_NAMESPACE::ImportFenceWin32HandleInfoKHR * pImportFenceWin32HandleInfo,

                                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type

       importFenceWin32HandleKHR( const VULKAN_HPP_NAMESPACE::ImportFenceWin32HandleInfoKHR & importFenceWin32HandleInfo,

                                  Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getFenceWin32HandleKHR( const VULKAN_HPP_NAMESPACE::FenceGetWin32HandleInfoKHR * pGetWin32HandleInfo,

                                                         HANDLE *                                                 pHandle,

                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<HANDLE>::type

       getFenceWin32HandleKHR( const VULKAN_HPP_NAMESPACE::FenceGetWin32HandleInfoKHR & getWin32HandleInfo,

                               Dispatch const & d                                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

 #endif   /*VK_USE_PLATFORM_WIN32_KHR*/


     //=== VK_KHR_external_fence_fd ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result importFenceFdKHR( const VULKAN_HPP_NAMESPACE::ImportFenceFdInfoKHR * pImportFenceFdInfo,

                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<int>::type getFenceFdKHR( const VULKAN_HPP_NAMESPACE::FenceGetFdInfoKHR & getFdInfo,

                                                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_KHR_performance_query ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result acquireProfilingLockKHR( const VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR * pInfo,

                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void releaseProfilingLockKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     //=== VK_EXT_debug_utils ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result setDebugUtilsObjectNameEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT * pNameInfo,

                                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result setDebugUtilsObjectTagEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT * pTagInfo,

                                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


 #if defined( VK_USE_PLATFORM_ANDROID_KHR )

     //=== VK_ANDROID_external_memory_android_hardware_buffer ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result

       getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer *                                 buffer,

                                                  VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID * pProperties,

                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID>::type

       getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<StructureChain<X, Y, Z...>>::type

       getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getMemoryAndroidHardwareBufferANDROID( const VULKAN_HPP_NAMESPACE::MemoryGetAndroidHardwareBufferInfoANDROID * pInfo,

                                                                        struct AHardwareBuffer **                                               pBuffer,

                                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<struct AHardwareBuffer *>::type

       getMemoryAndroidHardwareBufferANDROID( const VULKAN_HPP_NAMESPACE::MemoryGetAndroidHardwareBufferInfoANDROID & info,

                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

 #endif   /*VK_USE_PLATFORM_ANDROID_KHR*/


     //=== VK_KHR_get_memory_requirements2 ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getImageMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 * pInfo,

                                          VULKAN_HPP_NAMESPACE::MemoryRequirements2 *                pMemoryRequirements,

                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2

                          getImageMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info,

                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>

                          getImageMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info,

                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getBufferMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 * pInfo,

                                           VULKAN_HPP_NAMESPACE::MemoryRequirements2 *                 pMemoryRequirements,

                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2

                          getBufferMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info,

                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>

                          getBufferMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info,

                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getImageSparseMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 * pInfo,

                                                uint32_t *                                                       pSparseMemoryRequirementCount,

                                                VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 *           pSparseMemoryRequirements,

                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename SparseImageMemoryRequirements2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>,

               typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>

                          getImageSparseMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 & info,

                                                                Dispatch const & d                                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     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>

     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>

                          getImageSparseMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 & info,

                                                                SparseImageMemoryRequirements2Allocator &                        sparseImageMemoryRequirements2Allocator,

                                                                Dispatch const & d                                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_KHR_acceleration_structure ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR * pCreateInfo,

                                                                 const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                pAllocator,

                                                                 VULKAN_HPP_NAMESPACE::AccelerationStructureKHR *                 pAccelerationStructure,

                                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::AccelerationStructureKHR>::type

       createAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR &    createInfo,

                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                       Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::AccelerationStructureKHR, Dispatch>>::type

       createAccelerationStructureKHRUnique( const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR &    createInfo,

                                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR    accelerationStructure,

                                           const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,

                                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator  VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR    accelerationStructure,

                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR                      accelerationStructure,

                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result buildAccelerationStructuresKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                                   deferredOperation,

                                                                 uint32_t                                                                     infoCount,

                                                                 const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR *      pInfos,

                                                                 const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const * ppBuildRangeInfos,

                                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result buildAccelerationStructuresKHR(

       VULKAN_HPP_NAMESPACE::DeferredOperationKHR                                                                           deferredOperation,

       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const &      infos,

       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const> const & pBuildRangeInfos,

       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result copyAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                     deferredOperation,

                                                               const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR * pInfo,

                                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result copyAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,

                                                                                     const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR & info,

                                                                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result copyAccelerationStructureToMemoryKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                             deferredOperation,

                                                                       const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR * pInfo,

                                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result

                          copyAccelerationStructureToMemoryKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                             deferredOperation,

                                                                const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR & info,

                                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result copyMemoryToAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                             deferredOperation,

                                                                       const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR * pInfo,

                                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result

                          copyMemoryToAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                             deferredOperation,

                                                                const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR & info,

                                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result

       writeAccelerationStructuresPropertiesKHR( uint32_t                                               accelerationStructureCount,

                                                 const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR * pAccelerationStructures,

                                                 VULKAN_HPP_NAMESPACE::QueryType                        queryType,

                                                 size_t                                                 dataSize,

                                                 void *                                                 pData,

                                                 size_t                                                 stride,

                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename DataType, typename DataTypeAllocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type writeAccelerationStructuresPropertiesKHR(

       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures,

       VULKAN_HPP_NAMESPACE::QueryType                                                                queryType,

       size_t                                                                                         dataSize,

       size_t                                                                                         stride,

       Dispatch const & d                                                                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type writeAccelerationStructuresPropertyKHR(

       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures,

       VULKAN_HPP_NAMESPACE::QueryType                                                                queryType,

       size_t                                                                                         stride,

       Dispatch const & d                                                                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     DeviceAddress getAccelerationStructureAddressKHR( const VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR * pInfo,

                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NAMESPACE::DeviceAddress

       getAccelerationStructureAddressKHR( const VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR & info,

                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getAccelerationStructureCompatibilityKHR( const VULKAN_HPP_NAMESPACE::AccelerationStructureVersionInfoKHR * pVersionInfo,

                                                    VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR *     pCompatibility,

                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR

                          getAccelerationStructureCompatibilityKHR( const VULKAN_HPP_NAMESPACE::AccelerationStructureVersionInfoKHR & versionInfo,

                                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getAccelerationStructureBuildSizesKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR                 buildType,

                                                 const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR * pBuildInfo,

                                                 const uint32_t *                                                        pMaxPrimitiveCounts,

                                                 VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR *          pSizeInfo,

                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR getAccelerationStructureBuildSizesKHR(

       VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR                     buildType,

       const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR &     buildInfo,

       VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t> const & maxPrimitiveCounts VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_KHR_sampler_ycbcr_conversion ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createSamplerYcbcrConversionKHR( const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo * pCreateInfo,

                                                                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks *              pAllocator,

                                                                  VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion *                 pYcbcrConversion,

                                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion>::type

       createSamplerYcbcrConversionKHR( const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo &      createInfo,

                                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                        Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion, Dispatch>>::type

       createSamplerYcbcrConversionKHRUnique( const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo &      createInfo,

                                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroySamplerYcbcrConversionKHR( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion      ycbcrConversion,

                                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroySamplerYcbcrConversionKHR( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion        VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,

                                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_KHR_bind_memory2 ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result bindBufferMemory2KHR( uint32_t                                           bindInfoCount,

                                                       const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo * pBindInfos,

                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type

       bindBufferMemory2KHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo> const & bindInfos,

                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result bindImageMemory2KHR( uint32_t                                          bindInfoCount,

                                                      const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo * pBindInfos,

                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type

       bindImageMemory2KHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo> const & bindInfos,

                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_EXT_image_drm_format_modifier ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_EXT_validation_cache ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createValidationCacheEXT( const VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT * pCreateInfo,

                                                           const VULKAN_HPP_NAMESPACE::AllocationCallbacks *          pAllocator,

                                                           VULKAN_HPP_NAMESPACE::ValidationCacheEXT *                 pValidationCache,

                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ValidationCacheEXT>::type

       createValidationCacheEXT( const VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT &          createInfo,

                                 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                 Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::ValidationCacheEXT, Dispatch>>::type

       createValidationCacheEXTUnique( const VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT &          createInfo,

                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                       Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyValidationCacheEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT          validationCache,

                                     const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                                     Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyValidationCacheEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache            VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,

                                     Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::ValidationCacheEXT          validationCache,

                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::ValidationCacheEXT                            validationCache,

                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result mergeValidationCachesEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT         dstCache,

                                                           uint32_t                                         srcCacheCount,

                                                           const VULKAN_HPP_NAMESPACE::ValidationCacheEXT * pSrcCaches,

                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type

       mergeValidationCachesEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT                                                 dstCache,

                                 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ValidationCacheEXT> const & srcCaches,

                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getValidationCacheDataEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache,

                                                            size_t *                                 pDataSize,

                                                            void *                                   pData,

                                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Uint8_tAllocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type

       getValidationCacheDataEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename Uint8_tAllocator                                                                 = std::allocator<uint8_t>,

               typename Dispatch                                                                         = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename B1                                                                               = Uint8_tAllocator,

               typename std::enable_if<std::is_same<typename B1::value_type, uint8_t>::value, int>::type = 0>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type

       getValidationCacheDataEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache,

                                  Uint8_tAllocator &                       uint8_tAllocator,

                                  Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_NV_ray_tracing ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createAccelerationStructureNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV * pCreateInfo,

                                                                const VULKAN_HPP_NAMESPACE::AllocationCallbacks *               pAllocator,

                                                                VULKAN_HPP_NAMESPACE::AccelerationStructureNV *                 pAccelerationStructure,

                                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::AccelerationStructureNV>::type

       createAccelerationStructureNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV &     createInfo,

                                      Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                      Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::AccelerationStructureNV, Dispatch>>::type

       createAccelerationStructureNVUnique( const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV &     createInfo,

                                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                            Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyAccelerationStructureNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV     accelerationStructure,

                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                                          Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyAccelerationStructureNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,

                                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::AccelerationStructureNV     accelerationStructure,

                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::AccelerationStructureNV                       accelerationStructure,

                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getAccelerationStructureMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV * pInfo,

                                                        VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR *                              pMemoryRequirements,

                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR

                          getAccelerationStructureMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV & info,

                                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>

                          getAccelerationStructureMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV & info,

                                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result bindAccelerationStructureMemoryNV( uint32_t                                                            bindInfoCount,

                                                                    const VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV * pBindInfos,

                                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type

       bindAccelerationStructureMemoryNV( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV> const & bindInfos,

                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createRayTracingPipelinesNV( VULKAN_HPP_NAMESPACE::PipelineCache                          pipelineCache,

                                                              uint32_t                                                     createInfoCount,

                                                              const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV * pCreateInfos,

                                                              const VULKAN_HPP_NAMESPACE::AllocationCallbacks *            pAllocator,

                                                              VULKAN_HPP_NAMESPACE::Pipeline *                             pPipelines,

                                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>

                          createRayTracingPipelinesNV( VULKAN_HPP_NAMESPACE::PipelineCache                                                                  pipelineCache,

                                                       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos,

                                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                                       Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     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>

     VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>

                          createRayTracingPipelinesNV( VULKAN_HPP_NAMESPACE::PipelineCache                                                                  pipelineCache,

                                                       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos,

                                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                                            allocator,

                                                       PipelineAllocator &                                                                                  pipelineAllocator,

                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD ResultValue<VULKAN_HPP_NAMESPACE::Pipeline>

                          createRayTracingPipelineNV( VULKAN_HPP_NAMESPACE::PipelineCache                                 pipelineCache,

                                                      const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV &        createInfo,

                                                      Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                                      Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>>

     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>

                          createRayTracingPipelinesNVUnique( VULKAN_HPP_NAMESPACE::PipelineCache                                                                  pipelineCache,

                                                             VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos,

                                                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                                             Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     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>

     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>

                          createRayTracingPipelinesNVUnique( VULKAN_HPP_NAMESPACE::PipelineCache                                                                  pipelineCache,

                                                             VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos,

                                                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                                            allocator,

                                                             PipelineAllocator &                                                                                  pipelineAllocator,

                                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD ResultValue<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>

                          createRayTracingPipelineNVUnique( VULKAN_HPP_NAMESPACE::PipelineCache                                 pipelineCache,

                                                            const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV &        createInfo,

                                                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                                            Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getRayTracingShaderGroupHandlesNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline,

                                                                    uint32_t                       firstGroup,

                                                                    uint32_t                       groupCount,

                                                                    size_t                         dataSize,

                                                                    void *                         pData,

                                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename DataType, typename DataTypeAllocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type

       getRayTracingShaderGroupHandlesNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline,

                                          uint32_t                       firstGroup,

                                          uint32_t                       groupCount,

                                          size_t                         dataSize,

                                          Dispatch const & d             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type getRayTracingShaderGroupHandleNV(

       VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getAccelerationStructureHandleNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure,

                                                                   size_t                                        dataSize,

                                                                   void *                                        pData,

                                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename DataType, typename DataTypeAllocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type getAccelerationStructureHandleNV(

       VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure, size_t dataSize, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type

       getAccelerationStructureHandleNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure,

                                         Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result compileDeferredNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline,

                                                    uint32_t                       shader,

                                                    Dispatch const & d             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #else

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type

       compileDeferredNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t shader, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


     //=== VK_KHR_maintenance3 ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getDescriptorSetLayoutSupportKHR( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo * pCreateInfo,

                                            VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport *          pSupport,

                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport

                          getDescriptorSetLayoutSupportKHR( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo,

                                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>

                          getDescriptorSetLayoutSupportKHR( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo,

                                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_EXT_external_memory_host ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_EXT_calibrated_timestamps ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Uint64_tAllocator = std::allocator<uint64_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

     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>

     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;

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_KHR_timeline_semaphore ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getSemaphoreCounterValueKHR( VULKAN_HPP_NAMESPACE::Semaphore semaphore,

                                                              uint64_t *                      pValue,

                                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<uint64_t>::type

       getSemaphoreCounterValueKHR( VULKAN_HPP_NAMESPACE::Semaphore semaphore, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result waitSemaphoresKHR( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo * pWaitInfo,

                                                    uint64_t                                        timeout,

                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result waitSemaphoresKHR( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo & waitInfo,

                                                                          uint64_t                                        timeout,

                                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result signalSemaphoreKHR( const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo * pSignalInfo,

                                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type

       signalSemaphoreKHR( const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo & signalInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_INTEL_performance_query ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result initializePerformanceApiINTEL( const VULKAN_HPP_NAMESPACE::InitializePerformanceApiInfoINTEL * pInitializeInfo,

                                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type

       initializePerformanceApiINTEL( const VULKAN_HPP_NAMESPACE::InitializePerformanceApiInfoINTEL & initializeInfo,

                                      Dispatch const & d                                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void uninitializePerformanceApiINTEL( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result acquirePerformanceConfigurationINTEL( const VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL * pAcquireInfo,

                                                                       VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL *                  pConfiguration,

                                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL>::type

       acquirePerformanceConfigurationINTEL( const VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL & acquireInfo,

                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL, Dispatch>>::type

       acquirePerformanceConfigurationINTELUnique( const VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL & acquireInfo,

                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result releasePerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration,

                                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #else

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type

       releasePerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,

                                             Dispatch const & d                                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result release( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration,

                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #else

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type release( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration,

                                                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getPerformanceParameterINTEL( VULKAN_HPP_NAMESPACE::PerformanceParameterTypeINTEL parameter,

                                                               VULKAN_HPP_NAMESPACE::PerformanceValueINTEL *       pValue,

                                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::PerformanceValueINTEL>::type

       getPerformanceParameterINTEL( VULKAN_HPP_NAMESPACE::PerformanceParameterTypeINTEL parameter,

                                     Dispatch const & d                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_AMD_display_native_hdr ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setLocalDimmingAMD( VULKAN_HPP_NAMESPACE::SwapchainKHR swapChain,

                              VULKAN_HPP_NAMESPACE::Bool32       localDimmingEnable,

                              Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     //=== VK_EXT_buffer_device_address ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     DeviceAddress getBufferAddressEXT( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo,

                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NAMESPACE::DeviceAddress getBufferAddressEXT( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info,

                                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_KHR_present_wait ===


 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result waitForPresentKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,

                                                    uint64_t                           presentId,

                                                    uint64_t                           timeout,

                                                    Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #else

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result waitForPresentKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,

                                                                          uint64_t                           presentId,

                                                                          uint64_t                           timeout,

                                                                          Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


 #if defined( VK_USE_PLATFORM_WIN32_KHR )

     //=== VK_EXT_full_screen_exclusive ===


 #  ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result acquireFullScreenExclusiveModeEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,

                                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  else

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type

       acquireFullScreenExclusiveModeEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


 #  ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result releaseFullScreenExclusiveModeEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,

                                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  else

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type

       releaseFullScreenExclusiveModeEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getGroupSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,

                                                                  VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR *      pModes,

                                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR>::type

       getGroupSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,

                                        Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

 #endif   /*VK_USE_PLATFORM_WIN32_KHR*/


     //=== VK_KHR_buffer_device_address ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     DeviceAddress getBufferAddressKHR( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo,

                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NAMESPACE::DeviceAddress getBufferAddressKHR( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info,

                                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     uint64_t getBufferOpaqueCaptureAddressKHR( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo,

                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     uint64_t getBufferOpaqueCaptureAddressKHR( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info,

                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     uint64_t getMemoryOpaqueCaptureAddressKHR( const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo * pInfo,

                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     uint64_t getMemoryOpaqueCaptureAddressKHR( const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo & info,

                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_EXT_host_query_reset ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void resetQueryPoolEXT( VULKAN_HPP_NAMESPACE::QueryPool queryPool,

                             uint32_t                        firstQuery,

                             uint32_t                        queryCount,

                             Dispatch const & d              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     //=== VK_KHR_deferred_host_operations ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createDeferredOperationKHR( const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                                                             VULKAN_HPP_NAMESPACE::DeferredOperationKHR *      pDeferredOperation,

                                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DeferredOperationKHR>::type

       createDeferredOperationKHR( Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DeferredOperationKHR, Dispatch>>::type

       createDeferredOperationKHRUnique( Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                         Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyDeferredOperationKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR        operation,

                                       const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                                       Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyDeferredOperationKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation                VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,

                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::DeferredOperationKHR        operation,

                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                          operation,

                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     uint32_t getDeferredOperationMaxConcurrencyKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation,

                                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getDeferredOperationResultKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation,

                                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #else

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result

                          getDeferredOperationResultKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation,

                                                         Dispatch const & d                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result deferredOperationJoinKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation,

                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #else

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result deferredOperationJoinKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation,

                                                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


     //=== VK_KHR_pipeline_executable_properties ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getPipelineExecutablePropertiesKHR( const VULKAN_HPP_NAMESPACE::PipelineInfoKHR *           pPipelineInfo,

                                                                     uint32_t *                                              pExecutableCount,

                                                                     VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR * pProperties,

                                                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename PipelineExecutablePropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR>,

               typename Dispatch                                 = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD

       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR, PipelineExecutablePropertiesKHRAllocator>>::type

       getPipelineExecutablePropertiesKHR( const VULKAN_HPP_NAMESPACE::PipelineInfoKHR & pipelineInfo,

                                           Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename PipelineExecutablePropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR>,

               typename Dispatch                                 = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename B1                                       = PipelineExecutablePropertiesKHRAllocator,

               typename std::enable_if<std::is_same<typename B1::value_type, PipelineExecutablePropertiesKHR>::value, int>::type = 0>

     VULKAN_HPP_NODISCARD

       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR, PipelineExecutablePropertiesKHRAllocator>>::type

       getPipelineExecutablePropertiesKHR( const VULKAN_HPP_NAMESPACE::PipelineInfoKHR & pipelineInfo,

                                           PipelineExecutablePropertiesKHRAllocator &    pipelineExecutablePropertiesKHRAllocator,

                                           Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getPipelineExecutableStatisticsKHR( const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR * pExecutableInfo,

                                                                     uint32_t *                                              pStatisticCount,

                                                                     VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR *  pStatistics,

                                                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename PipelineExecutableStatisticKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR>,

               typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD

       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR, PipelineExecutableStatisticKHRAllocator>>::type

       getPipelineExecutableStatisticsKHR( const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR & executableInfo,

                                           Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename PipelineExecutableStatisticKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR>,

               typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename B1                                      = PipelineExecutableStatisticKHRAllocator,

               typename std::enable_if<std::is_same<typename B1::value_type, PipelineExecutableStatisticKHR>::value, int>::type = 0>

     VULKAN_HPP_NODISCARD

       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR, PipelineExecutableStatisticKHRAllocator>>::type

       getPipelineExecutableStatisticsKHR( const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR & executableInfo,

                                           PipelineExecutableStatisticKHRAllocator &               pipelineExecutableStatisticKHRAllocator,

                                           Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result

       getPipelineExecutableInternalRepresentationsKHR( const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR *             pExecutableInfo,

                                                        uint32_t *                                                          pInternalRepresentationCount,

                                                        VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR * pInternalRepresentations,

                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename PipelineExecutableInternalRepresentationKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR>,

               typename Dispatch                                             = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<

       std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR, PipelineExecutableInternalRepresentationKHRAllocator>>::type

       getPipelineExecutableInternalRepresentationsKHR( const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR & executableInfo,

                                                        Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename PipelineExecutableInternalRepresentationKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR>,

               typename Dispatch                                             = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename B1                                                   = PipelineExecutableInternalRepresentationKHRAllocator,

               typename std::enable_if<std::is_same<typename B1::value_type, PipelineExecutableInternalRepresentationKHR>::value, int>::type = 0>

     VULKAN_HPP_NODISCARD typename ResultValueType<

       std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR, PipelineExecutableInternalRepresentationKHRAllocator>>::type

       getPipelineExecutableInternalRepresentationsKHR(

         const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR & executableInfo,

         PipelineExecutableInternalRepresentationKHRAllocator &  pipelineExecutableInternalRepresentationKHRAllocator,

         Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_NV_device_generated_commands ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getGeneratedCommandsMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV * pInfo,

                                                    VULKAN_HPP_NAMESPACE::MemoryRequirements2 *                             pMemoryRequirements,

                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2

                          getGeneratedCommandsMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV & info,

                                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>

                          getGeneratedCommandsMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV & info,

                                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createIndirectCommandsLayoutNV( const VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV * pCreateInfo,

                                                                 const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                pAllocator,

                                                                 VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV *                 pIndirectCommandsLayout,

                                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV>::type

       createIndirectCommandsLayoutNV( const VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV &    createInfo,

                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                       Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV, Dispatch>>::type

       createIndirectCommandsLayoutNVUnique( const VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV &    createInfo,

                                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyIndirectCommandsLayoutNV( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV    indirectCommandsLayout,

                                           const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyIndirectCommandsLayoutNV( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV indirectCommandsLayout VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,

                                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator   VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV    indirectCommandsLayout,

                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV                      indirectCommandsLayout,

                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_EXT_private_data ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createPrivateDataSlotEXT( const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo * pCreateInfo,

                                                           const VULKAN_HPP_NAMESPACE::AllocationCallbacks *       pAllocator,

                                                           VULKAN_HPP_NAMESPACE::PrivateDataSlot *                 pPrivateDataSlot,

                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::PrivateDataSlot>::type

       createPrivateDataSlotEXT( const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo &             createInfo,

                                 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                 Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PrivateDataSlot, Dispatch>>::type

       createPrivateDataSlotEXTUnique( const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo &             createInfo,

                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                       Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyPrivateDataSlotEXT( VULKAN_HPP_NAMESPACE::PrivateDataSlot             privateDataSlot,

                                     const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                                     Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyPrivateDataSlotEXT( VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot               VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,

                                     Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result setPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType      objectType,

                                                    uint64_t                              objectHandle,

                                                    VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot,

                                                    uint64_t                              data,

                                                    Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #else

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     typename ResultValueType<void>::type setPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType      objectType,

                                                             uint64_t                              objectHandle,

                                                             VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot,

                                                             uint64_t                              data,

                                                             Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType      objectType,

                             uint64_t                              objectHandle,

                             VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot,

                             uint64_t *                            pData,

                             Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD uint64_t getPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType      objectType,

                                                      uint64_t                              objectHandle,

                                                      VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot,

                                                      Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


 #if defined( VK_USE_PLATFORM_METAL_EXT )

     //=== VK_EXT_metal_objects ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void exportMetalObjectsEXT( VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT * pMetalObjectsInfo,

                                 Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT

                          exportMetalObjectsEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>

                          exportMetalObjectsEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

 #endif   /*VK_USE_PLATFORM_METAL_EXT*/


     //=== VK_EXT_descriptor_buffer ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getDescriptorSetLayoutSizeEXT( VULKAN_HPP_NAMESPACE::DescriptorSetLayout layout,

                                         VULKAN_HPP_NAMESPACE::DeviceSize *        pLayoutSizeInBytes,

                                         Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceSize

                          getDescriptorSetLayoutSizeEXT( VULKAN_HPP_NAMESPACE::DescriptorSetLayout layout,

                                                         Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getDescriptorSetLayoutBindingOffsetEXT( VULKAN_HPP_NAMESPACE::DescriptorSetLayout layout,

                                                  uint32_t                                  binding,

                                                  VULKAN_HPP_NAMESPACE::DeviceSize *        pOffset,

                                                  Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceSize

                          getDescriptorSetLayoutBindingOffsetEXT( VULKAN_HPP_NAMESPACE::DescriptorSetLayout layout,

                                                                  uint32_t                                  binding,

                                                                  Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getDescriptorEXT( const VULKAN_HPP_NAMESPACE::DescriptorGetInfoEXT * pDescriptorInfo,

                            size_t                                             dataSize,

                            void *                                             pDescriptor,

                            Dispatch const & d                                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename DescriptorType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD DescriptorType getDescriptorEXT( const VULKAN_HPP_NAMESPACE::DescriptorGetInfoEXT & descriptorInfo,

                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result

       getBufferOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::BufferCaptureDescriptorDataInfoEXT * pInfo,

                                                void *                                                           pData,

                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type

       getBufferOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::BufferCaptureDescriptorDataInfoEXT & info,

                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getImageOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::ImageCaptureDescriptorDataInfoEXT * pInfo,

                                                                         void *                                                          pData,

                                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type

       getImageOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::ImageCaptureDescriptorDataInfoEXT & info,

                                               Dispatch const & d                                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result

       getImageViewOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::ImageViewCaptureDescriptorDataInfoEXT * pInfo,

                                                   void *                                                              pData,

                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type

       getImageViewOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::ImageViewCaptureDescriptorDataInfoEXT & info,

                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result

       getSamplerOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::SamplerCaptureDescriptorDataInfoEXT * pInfo,

                                                 void *                                                            pData,

                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type

       getSamplerOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::SamplerCaptureDescriptorDataInfoEXT & info,

                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result

       getAccelerationStructureOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::AccelerationStructureCaptureDescriptorDataInfoEXT * pInfo,

                                                               void *                                                                          pData,

                                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type

       getAccelerationStructureOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::AccelerationStructureCaptureDescriptorDataInfoEXT & info,

                                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_EXT_image_compression_control ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getImageSubresourceLayout2EXT( VULKAN_HPP_NAMESPACE::Image                        image,

                                         const VULKAN_HPP_NAMESPACE::ImageSubresource2EXT * pSubresource,

                                         VULKAN_HPP_NAMESPACE::SubresourceLayout2EXT *      pLayout,

                                         Dispatch const & d                                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::SubresourceLayout2EXT

                          getImageSubresourceLayout2EXT( VULKAN_HPP_NAMESPACE::Image                        image,

                                                         const VULKAN_HPP_NAMESPACE::ImageSubresource2EXT & subresource,

                                                         Dispatch const & d                                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>

                          getImageSubresourceLayout2EXT( VULKAN_HPP_NAMESPACE::Image                        image,

                                                         const VULKAN_HPP_NAMESPACE::ImageSubresource2EXT & subresource,

                                                         Dispatch const & d                                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_EXT_device_fault ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getFaultInfoEXT( VULKAN_HPP_NAMESPACE::DeviceFaultCountsEXT * pFaultCounts,

                                                  VULKAN_HPP_NAMESPACE::DeviceFaultInfoEXT *   pFaultInfo,

                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD ResultValue<std::pair<VULKAN_HPP_NAMESPACE::DeviceFaultCountsEXT, VULKAN_HPP_NAMESPACE::DeviceFaultInfoEXT>>

                          getFaultInfoEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_KHR_ray_tracing_pipeline ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createRayTracingPipelinesKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                    deferredOperation,

                                                               VULKAN_HPP_NAMESPACE::PipelineCache                           pipelineCache,

                                                               uint32_t                                                      createInfoCount,

                                                               const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR * pCreateInfos,

                                                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks *             pAllocator,

                                                               VULKAN_HPP_NAMESPACE::Pipeline *                              pPipelines,

                                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>

                          createRayTracingPipelinesKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                                                            deferredOperation,

                                                        VULKAN_HPP_NAMESPACE::PipelineCache                                                                   pipelineCache,

                                                        VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos,

                                                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                                        Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     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>

     VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>

                          createRayTracingPipelinesKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                                                            deferredOperation,

                                                        VULKAN_HPP_NAMESPACE::PipelineCache                                                                   pipelineCache,

                                                        VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos,

                                                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                                             allocator,

                                                        PipelineAllocator &                                                                                   pipelineAllocator,

                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD ResultValue<VULKAN_HPP_NAMESPACE::Pipeline>

                          createRayTracingPipelineKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                          deferredOperation,

                                                       VULKAN_HPP_NAMESPACE::PipelineCache                                 pipelineCache,

                                                       const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR &       createInfo,

                                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                                       Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>>

     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>

                          createRayTracingPipelinesKHRUnique( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,

                                                              VULKAN_HPP_NAMESPACE::PipelineCache        pipelineCache,

                                                              VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos,

                                                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                                              Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     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>

     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>

                          createRayTracingPipelinesKHRUnique( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,

                                                              VULKAN_HPP_NAMESPACE::PipelineCache        pipelineCache,

                                                              VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos,

                                                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                                             allocator,

                                                              PipelineAllocator & pipelineAllocator,

                                                              Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD ResultValue<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>

                          createRayTracingPipelineKHRUnique( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                          deferredOperation,

                                                             VULKAN_HPP_NAMESPACE::PipelineCache                                 pipelineCache,

                                                             const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR &       createInfo,

                                                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                                             Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getRayTracingShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline,

                                                                     uint32_t                       firstGroup,

                                                                     uint32_t                       groupCount,

                                                                     size_t                         dataSize,

                                                                     void *                         pData,

                                                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename DataType, typename DataTypeAllocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type

       getRayTracingShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline,

                                           uint32_t                       firstGroup,

                                           uint32_t                       groupCount,

                                           size_t                         dataSize,

                                           Dispatch const & d             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type getRayTracingShaderGroupHandleKHR(

       VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result

       getRayTracingCaptureReplayShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline,

                                                        uint32_t                       firstGroup,

                                                        uint32_t                       groupCount,

                                                        size_t                         dataSize,

                                                        void *                         pData,

                                                        Dispatch const & d             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename DataType, typename DataTypeAllocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type

       getRayTracingCaptureReplayShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline,

                                                        uint32_t                       firstGroup,

                                                        uint32_t                       groupCount,

                                                        size_t                         dataSize,

                                                        Dispatch const & d             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type getRayTracingCaptureReplayShaderGroupHandleKHR(

       VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     DeviceSize getRayTracingShaderGroupStackSizeKHR( VULKAN_HPP_NAMESPACE::Pipeline             pipeline,

                                                      uint32_t                                   group,

                                                      VULKAN_HPP_NAMESPACE::ShaderGroupShaderKHR groupShader,

                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


 #if defined( VK_USE_PLATFORM_FUCHSIA )

     //=== VK_FUCHSIA_external_memory ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getMemoryZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::MemoryGetZirconHandleInfoFUCHSIA * pGetZirconHandleInfo,

                                                               zx_handle_t *                                                  pZirconHandle,

                                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<zx_handle_t>::type

       getMemoryZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::MemoryGetZirconHandleInfoFUCHSIA & getZirconHandleInfo,

                                     Dispatch const & d                                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result

       getMemoryZirconHandlePropertiesFUCHSIA( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits      handleType,

                                               zx_handle_t                                                 zirconHandle,

                                               VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA * pMemoryZirconHandleProperties,

                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA>::type

       getMemoryZirconHandlePropertiesFUCHSIA( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,

                                               zx_handle_t                                            zirconHandle,

                                               Dispatch const & d                                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

 #endif   /*VK_USE_PLATFORM_FUCHSIA*/


 #if defined( VK_USE_PLATFORM_FUCHSIA )

     //=== VK_FUCHSIA_external_semaphore ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result

       importSemaphoreZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::ImportSemaphoreZirconHandleInfoFUCHSIA * pImportSemaphoreZirconHandleInfo,

                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type

       importSemaphoreZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::ImportSemaphoreZirconHandleInfoFUCHSIA & importSemaphoreZirconHandleInfo,

                                           Dispatch const & d                                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getSemaphoreZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::SemaphoreGetZirconHandleInfoFUCHSIA * pGetZirconHandleInfo,

                                                                  zx_handle_t *                                                     pZirconHandle,

                                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<zx_handle_t>::type

       getSemaphoreZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::SemaphoreGetZirconHandleInfoFUCHSIA & getZirconHandleInfo,

                                        Dispatch const & d                                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

 #endif   /*VK_USE_PLATFORM_FUCHSIA*/


 #if defined( VK_USE_PLATFORM_FUCHSIA )

     //=== VK_FUCHSIA_buffer_collection ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createBufferCollectionFUCHSIA( const VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA * pCreateInfo,

                                                                const VULKAN_HPP_NAMESPACE::AllocationCallbacks *               pAllocator,

                                                                VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA *                 pCollection,

                                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA>::type

       createBufferCollectionFUCHSIA( const VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA &     createInfo,

                                      Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                      Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #    ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA, Dispatch>>::type

       createBufferCollectionFUCHSIAUnique( const VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA &     createInfo,

                                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                            Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #    endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result

       setBufferCollectionImageConstraintsFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA             collection,

                                                   const VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFUCHSIA * pImageConstraintsInfo,

                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type

       setBufferCollectionImageConstraintsFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA             collection,

                                                   const VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFUCHSIA & imageConstraintsInfo,

                                                   Dispatch const & d                                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result

       setBufferCollectionBufferConstraintsFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA              collection,

                                                    const VULKAN_HPP_NAMESPACE::BufferConstraintsInfoFUCHSIA * pBufferConstraintsInfo,

                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type

       setBufferCollectionBufferConstraintsFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA              collection,

                                                    const VULKAN_HPP_NAMESPACE::BufferConstraintsInfoFUCHSIA & bufferConstraintsInfo,

                                                    Dispatch const & d                                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyBufferCollectionFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA     collection,

                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                                          Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyBufferCollectionFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA                       collection,

                                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA     collection,

                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA                       collection,

                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getBufferCollectionPropertiesFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA             collection,

                                                                       VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA * pProperties,

                                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA>::type

       getBufferCollectionPropertiesFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection,

                                             Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

 #endif   /*VK_USE_PLATFORM_FUCHSIA*/


     //=== VK_HUAWEI_subpass_shading ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result

       getSubpassShadingMaxWorkgroupSizeHUAWEI( VULKAN_HPP_NAMESPACE::RenderPass renderpass,

                                                VULKAN_HPP_NAMESPACE::Extent2D * pMaxWorkgroupSize,

                                                Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD ResultValue<VULKAN_HPP_NAMESPACE::Extent2D>

       getSubpassShadingMaxWorkgroupSizeHUAWEI( VULKAN_HPP_NAMESPACE::RenderPass renderpass, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_NV_external_memory_rdma ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getMemoryRemoteAddressNV( const VULKAN_HPP_NAMESPACE::MemoryGetRemoteAddressInfoNV * pMemoryGetRemoteAddressInfo,

                                                           VULKAN_HPP_NAMESPACE::RemoteAddressNV *                    pAddress,

                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::RemoteAddressNV>::type

       getMemoryRemoteAddressNV( const VULKAN_HPP_NAMESPACE::MemoryGetRemoteAddressInfoNV & memoryGetRemoteAddressInfo,

                                 Dispatch const & d                                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_EXT_pipeline_properties ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getPipelinePropertiesEXT( const VULKAN_HPP_NAMESPACE::PipelineInfoEXT * pPipelineInfo,

                                                           VULKAN_HPP_NAMESPACE::BaseOutStructure *      pPipelineProperties,

                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::BaseOutStructure>::type

       getPipelinePropertiesEXT( const VULKAN_HPP_NAMESPACE::PipelineInfoEXT & pipelineInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_EXT_opacity_micromap ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createMicromapEXT( const VULKAN_HPP_NAMESPACE::MicromapCreateInfoEXT * pCreateInfo,

                                                    const VULKAN_HPP_NAMESPACE::AllocationCallbacks *   pAllocator,

                                                    VULKAN_HPP_NAMESPACE::MicromapEXT *                 pMicromap,

                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::MicromapEXT>::type

       createMicromapEXT( const VULKAN_HPP_NAMESPACE::MicromapCreateInfoEXT &                 createInfo,

                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                          Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::MicromapEXT, Dispatch>>::type

       createMicromapEXTUnique( const VULKAN_HPP_NAMESPACE::MicromapCreateInfoEXT &                 createInfo,

                                Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyMicromapEXT( VULKAN_HPP_NAMESPACE::MicromapEXT                 micromap,

                              const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                              Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyMicromapEXT( VULKAN_HPP_NAMESPACE::MicromapEXT micromap                          VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,

                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::MicromapEXT                 micromap,

                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::MicromapEXT                                   micromap,

                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result buildMicromapsEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR         deferredOperation,

                                                    uint32_t                                           infoCount,

                                                    const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT * pInfos,

                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result

                          buildMicromapsEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                                                 deferredOperation,

                                             VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT> const & infos,

                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result copyMicromapEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR        deferredOperation,

                                                  const VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT * pInfo,

                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result copyMicromapEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR        deferredOperation,

                                                                        const VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT & info,

                                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result copyMicromapToMemoryEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                deferredOperation,

                                                          const VULKAN_HPP_NAMESPACE::CopyMicromapToMemoryInfoEXT * pInfo,

                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result copyMicromapToMemoryEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                deferredOperation,

                                                                                const VULKAN_HPP_NAMESPACE::CopyMicromapToMemoryInfoEXT & info,

                                                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result copyMemoryToMicromapEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                deferredOperation,

                                                          const VULKAN_HPP_NAMESPACE::CopyMemoryToMicromapInfoEXT * pInfo,

                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result copyMemoryToMicromapEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                deferredOperation,

                                                                                const VULKAN_HPP_NAMESPACE::CopyMemoryToMicromapInfoEXT & info,

                                                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result writeMicromapsPropertiesEXT( uint32_t                                  micromapCount,

                                                              const VULKAN_HPP_NAMESPACE::MicromapEXT * pMicromaps,

                                                              VULKAN_HPP_NAMESPACE::QueryType           queryType,

                                                              size_t                                    dataSize,

                                                              void *                                    pData,

                                                              size_t                                    stride,

                                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename DataType, typename DataTypeAllocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type

       writeMicromapsPropertiesEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MicromapEXT> const & micromaps,

                                    VULKAN_HPP_NAMESPACE::QueryType                                                   queryType,

                                    size_t                                                                            dataSize,

                                    size_t                                                                            stride,

                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type

       writeMicromapsPropertyEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MicromapEXT> const & micromaps,

                                  VULKAN_HPP_NAMESPACE::QueryType                                                   queryType,

                                  size_t                                                                            stride,

                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getMicromapCompatibilityEXT( const VULKAN_HPP_NAMESPACE::MicromapVersionInfoEXT *          pVersionInfo,

                                       VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR * pCompatibility,

                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR

                          getMicromapCompatibilityEXT( const VULKAN_HPP_NAMESPACE::MicromapVersionInfoEXT & versionInfo,

                                                       Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getMicromapBuildSizesEXT( VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR buildType,

                                    const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT *      pBuildInfo,

                                    VULKAN_HPP_NAMESPACE::MicromapBuildSizesInfoEXT *       pSizeInfo,

                                    Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MicromapBuildSizesInfoEXT

                          getMicromapBuildSizesEXT( VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR buildType,

                                                    const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT &      buildInfo,

                                                    Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_EXT_pageable_device_local_memory ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setMemoryPriorityEXT( VULKAN_HPP_NAMESPACE::DeviceMemory memory,

                                float                              priority,

                                Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     //=== VK_KHR_maintenance4 ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getBufferMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements * pInfo,

                                          VULKAN_HPP_NAMESPACE::MemoryRequirements2 *                  pMemoryRequirements,

                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2

                          getBufferMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements & info,

                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>

                          getBufferMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements & info,

                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getImageMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements * pInfo,

                                         VULKAN_HPP_NAMESPACE::MemoryRequirements2 *                 pMemoryRequirements,

                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2

                          getImageMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info,

                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>

                          getImageMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info,

                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getImageSparseMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements * pInfo,

                                               uint32_t *                                                  pSparseMemoryRequirementCount,

                                               VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 *      pSparseMemoryRequirements,

                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename SparseImageMemoryRequirements2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>,

               typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>

                          getImageSparseMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info,

                                                               Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     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>

     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>

                          getImageSparseMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info,

                                                               SparseImageMemoryRequirements2Allocator &                   sparseImageMemoryRequirements2Allocator,

                                                               Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_VALVE_descriptor_set_host_mapping ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getDescriptorSetLayoutHostMappingInfoVALVE( const VULKAN_HPP_NAMESPACE::DescriptorSetBindingReferenceVALVE * pBindingReference,

                                                      VULKAN_HPP_NAMESPACE::DescriptorSetLayoutHostMappingInfoVALVE *  pHostMapping,

                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DescriptorSetLayoutHostMappingInfoVALVE

                          getDescriptorSetLayoutHostMappingInfoVALVE( const VULKAN_HPP_NAMESPACE::DescriptorSetBindingReferenceVALVE & bindingReference,

                                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getDescriptorSetHostMappingVALVE( VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet,

                                            void **                             ppData,

                                            Dispatch const & d                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD void * getDescriptorSetHostMappingVALVE( VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet,

                                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_EXT_shader_module_identifier ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getShaderModuleIdentifierEXT( VULKAN_HPP_NAMESPACE::ShaderModule                shaderModule,

                                        VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT * pIdentifier,

                                        Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT

                          getShaderModuleIdentifierEXT( VULKAN_HPP_NAMESPACE::ShaderModule shaderModule,

                                                        Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getShaderModuleCreateInfoIdentifierEXT( const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo * pCreateInfo,

                                                  VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT *    pIdentifier,

                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT

                          getShaderModuleCreateInfoIdentifierEXT( const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo & createInfo,

                                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_NV_optical_flow ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createOpticalFlowSessionNV( const VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreateInfoNV * pCreateInfo,

                                                             const VULKAN_HPP_NAMESPACE::AllocationCallbacks *            pAllocator,

                                                             VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV *                 pSession,

                                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV>::type

       createOpticalFlowSessionNV( const VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreateInfoNV &        createInfo,

                                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV, Dispatch>>::type

       createOpticalFlowSessionNVUnique( const VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreateInfoNV &        createInfo,

                                         Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                         Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyOpticalFlowSessionNV( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV        session,

                                       const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                                       Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyOpticalFlowSessionNV( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV                          session,

                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV        session,

                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV                          session,

                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result bindOpticalFlowSessionImageNV( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV             session,

                                                                VULKAN_HPP_NAMESPACE::OpticalFlowSessionBindingPointNV bindingPoint,

                                                                VULKAN_HPP_NAMESPACE::ImageView                        view,

                                                                VULKAN_HPP_NAMESPACE::ImageLayout                      layout,

                                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #else

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type

          bindOpticalFlowSessionImageNV( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV             session,

                                         VULKAN_HPP_NAMESPACE::OpticalFlowSessionBindingPointNV bindingPoint,

                                         VULKAN_HPP_NAMESPACE::ImageView                        view,

                                         VULKAN_HPP_NAMESPACE::ImageLayout                      layout,

                                         Dispatch const & d                                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


     //=== VK_QCOM_tile_properties ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getFramebufferTilePropertiesQCOM( VULKAN_HPP_NAMESPACE::Framebuffer          framebuffer,

                                                                   uint32_t *                                 pPropertiesCount,

                                                                   VULKAN_HPP_NAMESPACE::TilePropertiesQCOM * pProperties,

                                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename TilePropertiesQCOMAllocator = std::allocator<VULKAN_HPP_NAMESPACE::TilePropertiesQCOM>,

               typename Dispatch                    = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::TilePropertiesQCOM, TilePropertiesQCOMAllocator>>::type

       getFramebufferTilePropertiesQCOM( VULKAN_HPP_NAMESPACE::Framebuffer framebuffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename TilePropertiesQCOMAllocator = std::allocator<VULKAN_HPP_NAMESPACE::TilePropertiesQCOM>,

               typename Dispatch                    = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename B1                          = TilePropertiesQCOMAllocator,

               typename std::enable_if<std::is_same<typename B1::value_type, TilePropertiesQCOM>::value, int>::type = 0>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::TilePropertiesQCOM, TilePropertiesQCOMAllocator>>::type

       getFramebufferTilePropertiesQCOM( VULKAN_HPP_NAMESPACE::Framebuffer framebuffer,

                                         TilePropertiesQCOMAllocator &     tilePropertiesQCOMAllocator,

                                         Dispatch const & d                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     Result getDynamicRenderingTilePropertiesQCOM( const VULKAN_HPP_NAMESPACE::RenderingInfo * pRenderingInfo,

                                                   VULKAN_HPP_NAMESPACE::TilePropertiesQCOM *  pProperties,

                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::TilePropertiesQCOM

                          getDynamicRenderingTilePropertiesQCOM( const VULKAN_HPP_NAMESPACE::RenderingInfo & renderingInfo,

                                                                 Dispatch const & d                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     operator VkDevice() const VULKAN_HPP_NOEXCEPT

     {

       return m_device;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_device != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_device == VK_NULL_HANDLE;

     }


   private:

     VkDevice m_device = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDevice>

   {

     using Type = VULKAN_HPP_NAMESPACE::Device;

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDevice>

   {

     using Type = VULKAN_HPP_NAMESPACE::Device;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Device>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


   class DisplayModeKHR

   {

   public:

     using CType      = VkDisplayModeKHR;

     using NativeType = VkDisplayModeKHR;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDisplayModeKHR;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDisplayModeKHR;


   public:

     VULKAN_HPP_CONSTEXPR         DisplayModeKHR() = default;

     VULKAN_HPP_CONSTEXPR         DisplayModeKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}

     VULKAN_HPP_TYPESAFE_EXPLICIT DisplayModeKHR( VkDisplayModeKHR displayModeKHR ) VULKAN_HPP_NOEXCEPT : m_displayModeKHR( displayModeKHR ) {}


 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     DisplayModeKHR & operator=( VkDisplayModeKHR displayModeKHR ) VULKAN_HPP_NOEXCEPT

     {

       m_displayModeKHR = displayModeKHR;

       return *this;

     }

 #endif


     DisplayModeKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_displayModeKHR = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( DisplayModeKHR const & ) const = default;

 #else

     bool operator==( DisplayModeKHR const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_displayModeKHR == rhs.m_displayModeKHR;

     }


     bool operator!=( DisplayModeKHR const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_displayModeKHR != rhs.m_displayModeKHR;

     }


     bool operator<( DisplayModeKHR const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_displayModeKHR < rhs.m_displayModeKHR;

     }

 #endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDisplayModeKHR() const VULKAN_HPP_NOEXCEPT

     {

       return m_displayModeKHR;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_displayModeKHR != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_displayModeKHR == VK_NULL_HANDLE;

     }


   private:

     VkDisplayModeKHR m_displayModeKHR = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDisplayModeKHR>

   {

     using Type = VULKAN_HPP_NAMESPACE::DisplayModeKHR;

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDisplayModeKHR>

   {

     using Type = VULKAN_HPP_NAMESPACE::DisplayModeKHR;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DisplayModeKHR>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


 #ifndef VULKAN_HPP_NO_SMART_HANDLE

   template <typename Dispatch>

   class UniqueHandleTraits<Device, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<NoParent, Dispatch>;

   };

   using UniqueDevice = UniqueHandle<Device, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

 #endif /*VULKAN_HPP_NO_SMART_HANDLE*/


   class PhysicalDevice

   {

   public:

     using CType      = VkPhysicalDevice;

     using NativeType = VkPhysicalDevice;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePhysicalDevice;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePhysicalDevice;


   public:

     VULKAN_HPP_CONSTEXPR PhysicalDevice() = default;

     VULKAN_HPP_CONSTEXPR PhysicalDevice( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}

     PhysicalDevice( VkPhysicalDevice physicalDevice ) VULKAN_HPP_NOEXCEPT : m_physicalDevice( physicalDevice ) {}


     PhysicalDevice & operator=( VkPhysicalDevice physicalDevice ) VULKAN_HPP_NOEXCEPT

     {

       m_physicalDevice = physicalDevice;

       return *this;

     }


     PhysicalDevice & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_physicalDevice = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( PhysicalDevice const & ) const = default;

 #else

     bool operator==( PhysicalDevice const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_physicalDevice == rhs.m_physicalDevice;

     }


     bool operator!=( PhysicalDevice const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_physicalDevice != rhs.m_physicalDevice;

     }


     bool operator<( PhysicalDevice const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_physicalDevice < rhs.m_physicalDevice;

     }

 #endif


     //=== VK_VERSION_1_0 ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getFeatures( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures * pFeatures,

                       Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures

                          getFeatures( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getFormatProperties( VULKAN_HPP_NAMESPACE::Format             format,

                               VULKAN_HPP_NAMESPACE::FormatProperties * pFormatProperties,

                               Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getProperties( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties * pProperties,

                         Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties

                          getProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getQueueFamilyProperties( uint32_t *                                    pQueueFamilyPropertyCount,

                                    VULKAN_HPP_NAMESPACE::QueueFamilyProperties * pQueueFamilyProperties,

                                    Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename QueueFamilyPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::QueueFamilyProperties>,

               typename Dispatch                       = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties, QueueFamilyPropertiesAllocator>

                          getQueueFamilyProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     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>

     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties, QueueFamilyPropertiesAllocator>

                          getQueueFamilyProperties( QueueFamilyPropertiesAllocator & queueFamilyPropertiesAllocator,

                                                    Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getMemoryProperties( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties * pMemoryProperties,

                               Dispatch const & d                                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties

                          getMemoryProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename ExtensionPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::ExtensionProperties>,

               typename Dispatch                     = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

     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>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result enumerateDeviceLayerProperties( uint32_t *                              pPropertyCount,

                                                                 VULKAN_HPP_NAMESPACE::LayerProperties * pProperties,

                                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename LayerPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::LayerProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::LayerProperties, LayerPropertiesAllocator>>::type

       enumerateDeviceLayerProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     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>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::LayerProperties, LayerPropertiesAllocator>>::type

       enumerateDeviceLayerProperties( LayerPropertiesAllocator & layerPropertiesAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getSparseImageFormatProperties( VULKAN_HPP_NAMESPACE::Format                        format,

                                          VULKAN_HPP_NAMESPACE::ImageType                     type,

                                          VULKAN_HPP_NAMESPACE::SampleCountFlagBits           samples,

                                          VULKAN_HPP_NAMESPACE::ImageUsageFlags               usage,

                                          VULKAN_HPP_NAMESPACE::ImageTiling                   tiling,

                                          uint32_t *                                          pPropertyCount,

                                          VULKAN_HPP_NAMESPACE::SparseImageFormatProperties * pProperties,

                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename SparseImageFormatPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties>,

               typename Dispatch                             = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties, SparseImageFormatPropertiesAllocator>

                          getSparseImageFormatProperties( VULKAN_HPP_NAMESPACE::Format              format,

                                                          VULKAN_HPP_NAMESPACE::ImageType           type,

                                                          VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples,

                                                          VULKAN_HPP_NAMESPACE::ImageUsageFlags     usage,

                                                          VULKAN_HPP_NAMESPACE::ImageTiling         tiling,

                                                          Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename SparseImageFormatPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties>,

               typename Dispatch                             = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename B1                                   = SparseImageFormatPropertiesAllocator,

               typename std::enable_if<std::is_same<typename B1::value_type, SparseImageFormatProperties>::value, int>::type = 0>

     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties, SparseImageFormatPropertiesAllocator>

                          getSparseImageFormatProperties( VULKAN_HPP_NAMESPACE::Format              format,

                                                          VULKAN_HPP_NAMESPACE::ImageType           type,

                                                          VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples,

                                                          VULKAN_HPP_NAMESPACE::ImageUsageFlags     usage,

                                                          VULKAN_HPP_NAMESPACE::ImageTiling         tiling,

                                                          SparseImageFormatPropertiesAllocator &    sparseImageFormatPropertiesAllocator,

                                                          Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_VERSION_1_1 ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getFeatures2( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 * pFeatures,

                        Dispatch const & d                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2

                          getFeatures2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getFeatures2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getProperties2( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 * pProperties,

                          Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2

                          getProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getFormatProperties2( VULKAN_HPP_NAMESPACE::Format              format,

                                VULKAN_HPP_NAMESPACE::FormatProperties2 * pFormatProperties,

                                Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>

       getFormatProperties2( VULKAN_HPP_NAMESPACE::Format format, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<StructureChain<X, Y, Z...>>::type

       getImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo,

                                  Dispatch const & d                                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getQueueFamilyProperties2( uint32_t *                                     pQueueFamilyPropertyCount,

                                     VULKAN_HPP_NAMESPACE::QueueFamilyProperties2 * pQueueFamilyProperties,

                                     Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename QueueFamilyProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>,

               typename Dispatch                        = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2, QueueFamilyProperties2Allocator>

                          getQueueFamilyProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     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>

     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2, QueueFamilyProperties2Allocator>

                          getQueueFamilyProperties2( QueueFamilyProperties2Allocator & queueFamilyProperties2Allocator,

                                                     Dispatch const & d                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename StructureChain,

               typename StructureChainAllocator = std::allocator<StructureChain>,

               typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD std::vector<StructureChain, StructureChainAllocator>

                          getQueueFamilyProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     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>

     VULKAN_HPP_NODISCARD std::vector<StructureChain, StructureChainAllocator>

       getQueueFamilyProperties2( StructureChainAllocator & structureChainAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getMemoryProperties2( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 * pMemoryProperties,

                                Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2

                          getMemoryProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>

                          getMemoryProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getSparseImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,

                                           uint32_t *                                                         pPropertyCount,

                                           VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2 *               pProperties,

                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename SparseImageFormatProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>,

               typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>

                          getSparseImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 & formatInfo,

                                                           Dispatch const & d                                                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename SparseImageFormatProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>,

               typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename B1                                    = SparseImageFormatProperties2Allocator,

               typename std::enable_if<std::is_same<typename B1::value_type, SparseImageFormatProperties2>::value, int>::type = 0>

     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>

                          getSparseImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 & formatInfo,

                                                           SparseImageFormatProperties2Allocator &                            sparseImageFormatProperties2Allocator,

                                                           Dispatch const & d                                                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_VERSION_1_3 ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename PhysicalDeviceToolPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties>,

               typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties, PhysicalDeviceToolPropertiesAllocator>>::type

       getToolProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     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>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_KHR_surface ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename SurfaceFormatKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SurfaceFormatKHR>,

               typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

     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>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename PresentModeKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PresentModeKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

     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>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_KHR_swapchain ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Rect2DAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Rect2D>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

     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>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_KHR_display ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename DisplayPropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR>,

               typename Dispatch                      = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR, DisplayPropertiesKHRAllocator>>::type

       getDisplayPropertiesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     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>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename DisplayPlanePropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR>,

               typename Dispatch                           = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR, DisplayPlanePropertiesKHRAllocator>>::type

       getDisplayPlanePropertiesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     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>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename DisplayKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

     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>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename DisplayModePropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR>,

               typename Dispatch                          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

     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>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


 #if defined( VK_USE_PLATFORM_XLIB_KHR )

     //=== VK_KHR_xlib_surface ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     Bool32 getXlibPresentationSupportKHR( uint32_t           queueFamilyIndex,

                                           Display *          dpy,

                                           VisualID           visualID,

                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NAMESPACE::Bool32 getXlibPresentationSupportKHR( uint32_t           queueFamilyIndex,

                                                                 Display &          dpy,

                                                                 VisualID           visualID,

                                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

 #endif   /*VK_USE_PLATFORM_XLIB_KHR*/


 #if defined( VK_USE_PLATFORM_XCB_KHR )

     //=== VK_KHR_xcb_surface ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     Bool32 getXcbPresentationSupportKHR( uint32_t           queueFamilyIndex,

                                          xcb_connection_t * connection,

                                          xcb_visualid_t     visual_id,

                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NAMESPACE::Bool32 getXcbPresentationSupportKHR( uint32_t           queueFamilyIndex,

                                                                xcb_connection_t & connection,

                                                                xcb_visualid_t     visual_id,

                                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

 #endif   /*VK_USE_PLATFORM_XCB_KHR*/


 #if defined( VK_USE_PLATFORM_WAYLAND_KHR )

     //=== VK_KHR_wayland_surface ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     Bool32 getWaylandPresentationSupportKHR( uint32_t            queueFamilyIndex,

                                              struct wl_display * display,

                                              Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NAMESPACE::Bool32 getWaylandPresentationSupportKHR( uint32_t            queueFamilyIndex,

                                                                    struct wl_display & display,

                                                                    Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

 #endif   /*VK_USE_PLATFORM_WAYLAND_KHR*/


 #if defined( VK_USE_PLATFORM_WIN32_KHR )

     //=== VK_KHR_win32_surface ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     Bool32 getWin32PresentationSupportKHR( uint32_t queueFamilyIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /*VK_USE_PLATFORM_WIN32_KHR*/


 #if defined( VK_ENABLE_BETA_EXTENSIONS )

     //=== VK_KHR_video_queue ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getVideoCapabilitiesKHR( const VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR * pVideoProfile,

                                                          VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR *      pCapabilities,

                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR>::type

       getVideoCapabilitiesKHR( const VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR & videoProfile,

                                Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<StructureChain<X, Y, Z...>>::type

       getVideoCapabilitiesKHR( const VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR & videoProfile,

                                Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getVideoFormatPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR * pVideoFormatInfo,

                                                              uint32_t *                                                     pVideoFormatPropertyCount,

                                                              VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR *               pVideoFormatProperties,

                                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename VideoFormatPropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR>,

               typename Dispatch                          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR, VideoFormatPropertiesKHRAllocator>>::type

       getVideoFormatPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo,

                                    Dispatch const & d                                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename VideoFormatPropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR>,

               typename Dispatch                          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename B1                                = VideoFormatPropertiesKHRAllocator,

               typename std::enable_if<std::is_same<typename B1::value_type, VideoFormatPropertiesKHR>::value, int>::type = 0>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR, VideoFormatPropertiesKHRAllocator>>::type

       getVideoFormatPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo,

                                    VideoFormatPropertiesKHRAllocator &                            videoFormatPropertiesKHRAllocator,

                                    Dispatch const & d                                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

 #endif   /*VK_ENABLE_BETA_EXTENSIONS*/


     //=== VK_NV_external_memory_capabilities ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getExternalImageFormatPropertiesNV( VULKAN_HPP_NAMESPACE::Format                            format,

                                                                     VULKAN_HPP_NAMESPACE::ImageType                         type,

                                                                     VULKAN_HPP_NAMESPACE::ImageTiling                       tiling,

                                                                     VULKAN_HPP_NAMESPACE::ImageUsageFlags                   usage,

                                                                     VULKAN_HPP_NAMESPACE::ImageCreateFlags                  flags,

                                                                     VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV   externalHandleType,

                                                                     VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV * pExternalImageFormatProperties,

                                                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV>::type

       getExternalImageFormatPropertiesNV( VULKAN_HPP_NAMESPACE::Format                                             format,

                                           VULKAN_HPP_NAMESPACE::ImageType                                          type,

                                           VULKAN_HPP_NAMESPACE::ImageTiling                                        tiling,

                                           VULKAN_HPP_NAMESPACE::ImageUsageFlags                                    usage,

                                           VULKAN_HPP_NAMESPACE::ImageCreateFlags flags                             VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,

                                           VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV externalHandleType VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,

                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_KHR_get_physical_device_properties2 ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getFeatures2KHR( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 * pFeatures,

                           Dispatch const & d                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2

                          getFeatures2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getFeatures2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getProperties2KHR( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 * pProperties,

                             Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2

                          getProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format              format,

                                   VULKAN_HPP_NAMESPACE::FormatProperties2 * pFormatProperties,

                                   Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::FormatProperties2

       getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format format, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>

       getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format format, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 * pImageFormatInfo,

                                                               VULKAN_HPP_NAMESPACE::ImageFormatProperties2 *               pImageFormatProperties,

                                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageFormatProperties2>::type

       getImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo,

                                     Dispatch const & d                                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<StructureChain<X, Y, Z...>>::type

       getImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo,

                                     Dispatch const & d                                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getQueueFamilyProperties2KHR( uint32_t *                                     pQueueFamilyPropertyCount,

                                        VULKAN_HPP_NAMESPACE::QueueFamilyProperties2 * pQueueFamilyProperties,

                                        Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename QueueFamilyProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>,

               typename Dispatch                        = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2, QueueFamilyProperties2Allocator>

                          getQueueFamilyProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     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>

     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2, QueueFamilyProperties2Allocator>

                          getQueueFamilyProperties2KHR( QueueFamilyProperties2Allocator & queueFamilyProperties2Allocator,

                                                        Dispatch const & d                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename StructureChain,

               typename StructureChainAllocator = std::allocator<StructureChain>,

               typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD std::vector<StructureChain, StructureChainAllocator>

                          getQueueFamilyProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     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>

     VULKAN_HPP_NODISCARD std::vector<StructureChain, StructureChainAllocator>

       getQueueFamilyProperties2KHR( StructureChainAllocator & structureChainAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getMemoryProperties2KHR( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 * pMemoryProperties,

                                   Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2

                          getMemoryProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>

                          getMemoryProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getSparseImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,

                                              uint32_t *                                                         pPropertyCount,

                                              VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2 *               pProperties,

                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename SparseImageFormatProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>,

               typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>

                          getSparseImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 & formatInfo,

                                                              Dispatch const & d                                                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename SparseImageFormatProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>,

               typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename B1                                    = SparseImageFormatProperties2Allocator,

               typename std::enable_if<std::is_same<typename B1::value_type, SparseImageFormatProperties2>::value, int>::type = 0>

     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>

                          getSparseImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 & formatInfo,

                                                              SparseImageFormatProperties2Allocator &                            sparseImageFormatProperties2Allocator,

                                                              Dispatch const & d                                                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_KHR_external_memory_capabilities ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getExternalBufferPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo * pExternalBufferInfo,

                                          VULKAN_HPP_NAMESPACE::ExternalBufferProperties *               pExternalBufferProperties,

                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalBufferProperties

                          getExternalBufferPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo & externalBufferInfo,

                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_KHR_external_semaphore_capabilities ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getExternalSemaphorePropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,

                                             VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties *               pExternalSemaphoreProperties,

                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties

                          getExternalSemaphorePropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo,

                                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_EXT_direct_mode_display ===


 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     Result releaseDisplayEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #else

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void releaseDisplayEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


 #if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT )

     //=== VK_EXT_acquire_xlib_display ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result acquireXlibDisplayEXT( Display *                        dpy,

                                                        VULKAN_HPP_NAMESPACE::DisplayKHR display,

                                                        Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type

       acquireXlibDisplayEXT( Display & dpy, VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getRandROutputDisplayEXT( Display *                          dpy,

                                                           RROutput                           rrOutput,

                                                           VULKAN_HPP_NAMESPACE::DisplayKHR * pDisplay,

                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayKHR>::type

       getRandROutputDisplayEXT( Display & dpy, RROutput rrOutput, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #    ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>>::type

       getRandROutputDisplayEXTUnique( Display & dpy, RROutput rrOutput, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #    endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

 #endif     /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/


     //=== VK_EXT_display_surface_counter ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_KHR_external_fence_capabilities ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getExternalFencePropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo * pExternalFenceInfo,

                                         VULKAN_HPP_NAMESPACE::ExternalFenceProperties *               pExternalFenceProperties,

                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalFenceProperties

                          getExternalFencePropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo & externalFenceInfo,

                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_KHR_performance_query ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename PerformanceCounterKHRAllocator            = std::allocator<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR>,

               typename PerformanceCounterDescriptionKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR>,

               typename Dispatch                                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

     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>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getQueueFamilyPerformanceQueryPassesKHR( const VULKAN_HPP_NAMESPACE::QueryPoolPerformanceCreateInfoKHR * pPerformanceQueryCreateInfo,

                                                   uint32_t *                                                      pNumPasses,

                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD uint32_t

       getQueueFamilyPerformanceQueryPassesKHR( const VULKAN_HPP_NAMESPACE::QueryPoolPerformanceCreateInfoKHR & performanceQueryCreateInfo,

                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_KHR_get_surface_capabilities2 ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<StructureChain<X, Y, Z...>>::type

       getSurfaceCapabilities2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,

                                   Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename SurfaceFormat2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR>,

               typename Dispatch                   = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

     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>

     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;

     template <typename StructureChain,

               typename StructureChainAllocator = std::allocator<StructureChain>,

               typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

     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>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_KHR_get_display_properties2 ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename DisplayProperties2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayProperties2KHR>,

               typename Dispatch                       = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayProperties2KHR, DisplayProperties2KHRAllocator>>::type

       getDisplayProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     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>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename DisplayPlaneProperties2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR>,

               typename Dispatch                            = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR, DisplayPlaneProperties2KHRAllocator>>::type

       getDisplayPlaneProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     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>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename DisplayModeProperties2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR>,

               typename Dispatch                           = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

     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>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_EXT_sample_locations ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getMultisamplePropertiesEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits        samples,

                                       VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT * pMultisampleProperties,

                                       Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_EXT_calibrated_timestamps ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename TimeDomainEXTAllocator = std::allocator<VULKAN_HPP_NAMESPACE::TimeDomainEXT>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::TimeDomainEXT, TimeDomainEXTAllocator>>::type

       getCalibrateableTimeDomainsEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     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>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_KHR_fragment_shading_rate ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename PhysicalDeviceFragmentShadingRateKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR>,

               typename Dispatch                                      = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD

       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR, PhysicalDeviceFragmentShadingRateKHRAllocator>>::type

       getFragmentShadingRatesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     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>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_EXT_tooling_info ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getToolPropertiesEXT( uint32_t *                                           pToolCount,

                                                       VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties * pToolProperties,

                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename PhysicalDeviceToolPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties>,

               typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties, PhysicalDeviceToolPropertiesAllocator>>::type

       getToolPropertiesEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     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>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties, PhysicalDeviceToolPropertiesAllocator>>::type

       getToolPropertiesEXT( PhysicalDeviceToolPropertiesAllocator & physicalDeviceToolPropertiesAllocator,

                             Dispatch const & d                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_NV_cooperative_matrix ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getCooperativeMatrixPropertiesNV( uint32_t *                                            pPropertyCount,

                                                                   VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV * pProperties,

                                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename CooperativeMatrixPropertiesNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV>,

               typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD

       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV, CooperativeMatrixPropertiesNVAllocator>>::type

       getCooperativeMatrixPropertiesNV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename CooperativeMatrixPropertiesNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV>,

               typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename B1                                     = CooperativeMatrixPropertiesNVAllocator,

               typename std::enable_if<std::is_same<typename B1::value_type, CooperativeMatrixPropertiesNV>::value, int>::type = 0>

     VULKAN_HPP_NODISCARD

       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV, CooperativeMatrixPropertiesNVAllocator>>::type

       getCooperativeMatrixPropertiesNV( CooperativeMatrixPropertiesNVAllocator & cooperativeMatrixPropertiesNVAllocator,

                                         Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_NV_coverage_reduction_mode ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result

       getSupportedFramebufferMixedSamplesCombinationsNV( uint32_t *                                                   pCombinationCount,

                                                          VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV * pCombinations,

                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename FramebufferMixedSamplesCombinationNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV>,

               typename Dispatch                                      = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD

       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV, FramebufferMixedSamplesCombinationNVAllocator>>::type

       getSupportedFramebufferMixedSamplesCombinationsNV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename FramebufferMixedSamplesCombinationNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV>,

               typename Dispatch                                      = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename B1                                            = FramebufferMixedSamplesCombinationNVAllocator,

               typename std::enable_if<std::is_same<typename B1::value_type, FramebufferMixedSamplesCombinationNV>::value, int>::type = 0>

     VULKAN_HPP_NODISCARD

       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV, FramebufferMixedSamplesCombinationNVAllocator>>::type

       getSupportedFramebufferMixedSamplesCombinationsNV( FramebufferMixedSamplesCombinationNVAllocator & framebufferMixedSamplesCombinationNVAllocator,

                                                          Dispatch const & d                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


 #if defined( VK_USE_PLATFORM_WIN32_KHR )

     //=== VK_EXT_full_screen_exclusive ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,

                                                             uint32_t *                                                  pPresentModeCount,

                                                             VULKAN_HPP_NAMESPACE::PresentModeKHR *                      pPresentModes,

                                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename PresentModeKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PresentModeKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR, PresentModeKHRAllocator>>::type

       getSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,

                                   Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     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>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR, PresentModeKHRAllocator>>::type

       getSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,

                                   PresentModeKHRAllocator &                                   presentModeKHRAllocator,

                                   Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

 #endif   /*VK_USE_PLATFORM_WIN32_KHR*/


     //=== VK_EXT_acquire_drm_display ===


 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result acquireDrmDisplayEXT( int32_t                          drmFd,

                                                       VULKAN_HPP_NAMESPACE::DisplayKHR display,

                                                       Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #else

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     typename ResultValueType<void>::type

          acquireDrmDisplayEXT( int32_t drmFd, VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getDrmDisplayEXT( int32_t                            drmFd,

                                                   uint32_t                           connectorId,

                                                   VULKAN_HPP_NAMESPACE::DisplayKHR * display,

                                                   Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayKHR>::type

       getDrmDisplayEXT( int32_t drmFd, uint32_t connectorId, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>>::type

       getDrmDisplayEXTUnique( int32_t drmFd, uint32_t connectorId, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


 #if defined( VK_USE_PLATFORM_WIN32_KHR )

     //=== VK_NV_acquire_winrt_display ===


 #  ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result acquireWinrtDisplayNV( VULKAN_HPP_NAMESPACE::DisplayKHR display,

                                                        Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  else

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type

       acquireWinrtDisplayNV( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getWinrtDisplayNV( uint32_t                           deviceRelativeId,

                                                    VULKAN_HPP_NAMESPACE::DisplayKHR * pDisplay,

                                                    Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayKHR>::type

       getWinrtDisplayNV( uint32_t deviceRelativeId, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #    ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>>::type

       getWinrtDisplayNVUnique( uint32_t deviceRelativeId, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #    endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

 #endif     /*VK_USE_PLATFORM_WIN32_KHR*/


 #if defined( VK_USE_PLATFORM_DIRECTFB_EXT )

     //=== VK_EXT_directfb_surface ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     Bool32 getDirectFBPresentationSupportEXT( uint32_t           queueFamilyIndex,

                                               IDirectFB *        dfb,

                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NAMESPACE::Bool32 getDirectFBPresentationSupportEXT( uint32_t           queueFamilyIndex,

                                                                     IDirectFB &        dfb,

                                                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

 #endif   /*VK_USE_PLATFORM_DIRECTFB_EXT*/


 #if defined( VK_USE_PLATFORM_SCREEN_QNX )

     //=== VK_QNX_screen_surface ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     Bool32 getScreenPresentationSupportQNX( uint32_t                queueFamilyIndex,

                                             struct _screen_window * window,

                                             Dispatch const & d      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NAMESPACE::Bool32 getScreenPresentationSupportQNX( uint32_t                queueFamilyIndex,

                                                                   struct _screen_window & window,

                                                                   Dispatch const & d      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

 #endif   /*VK_USE_PLATFORM_SCREEN_QNX*/


     //=== VK_NV_optical_flow ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getOpticalFlowImageFormatsNV( const VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatInfoNV * pOpticalFlowImageFormatInfo,

                                                               uint32_t *                                                 pFormatCount,

                                                               VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV * pImageFormatProperties,

                                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename OpticalFlowImageFormatPropertiesNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV>,

               typename Dispatch                                    = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD

       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV, OpticalFlowImageFormatPropertiesNVAllocator>>::type

       getOpticalFlowImageFormatsNV( const VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatInfoNV & opticalFlowImageFormatInfo,

                                     Dispatch const & d                                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename OpticalFlowImageFormatPropertiesNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV>,

               typename Dispatch                                    = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename B1                                          = OpticalFlowImageFormatPropertiesNVAllocator,

               typename std::enable_if<std::is_same<typename B1::value_type, OpticalFlowImageFormatPropertiesNV>::value, int>::type = 0>

     VULKAN_HPP_NODISCARD

       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV, OpticalFlowImageFormatPropertiesNVAllocator>>::type

       getOpticalFlowImageFormatsNV( const VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatInfoNV & opticalFlowImageFormatInfo,

                                     OpticalFlowImageFormatPropertiesNVAllocator &              opticalFlowImageFormatPropertiesNVAllocator,

                                     Dispatch const & d                                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     operator VkPhysicalDevice() const VULKAN_HPP_NOEXCEPT

     {

       return m_physicalDevice;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_physicalDevice != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_physicalDevice == VK_NULL_HANDLE;

     }


   private:

     VkPhysicalDevice m_physicalDevice = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePhysicalDevice>

   {

     using Type = VULKAN_HPP_NAMESPACE::PhysicalDevice;

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePhysicalDevice>

   {

     using Type = VULKAN_HPP_NAMESPACE::PhysicalDevice;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::PhysicalDevice>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


 #ifndef VULKAN_HPP_NO_SMART_HANDLE

   class Instance;

   template <typename Dispatch>

   class UniqueHandleTraits<DebugReportCallbackEXT, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<Instance, Dispatch>;

   };

   using UniqueDebugReportCallbackEXT = UniqueHandle<DebugReportCallbackEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

   template <typename Dispatch>

   class UniqueHandleTraits<DebugUtilsMessengerEXT, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<Instance, Dispatch>;

   };

   using UniqueDebugUtilsMessengerEXT = UniqueHandle<DebugUtilsMessengerEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

   template <typename Dispatch>

   class UniqueHandleTraits<SurfaceKHR, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<Instance, Dispatch>;

   };

   using UniqueSurfaceKHR = UniqueHandle<SurfaceKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

 #endif /*VULKAN_HPP_NO_SMART_HANDLE*/


   class Instance

   {

   public:

     using CType      = VkInstance;

     using NativeType = VkInstance;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eInstance;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eInstance;


   public:

     VULKAN_HPP_CONSTEXPR Instance() = default;

     VULKAN_HPP_CONSTEXPR Instance( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}

     Instance( VkInstance instance ) VULKAN_HPP_NOEXCEPT : m_instance( instance ) {}


     Instance & operator=( VkInstance instance ) VULKAN_HPP_NOEXCEPT

     {

       m_instance = instance;

       return *this;

     }


     Instance & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_instance = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( Instance const & ) const = default;

 #else

     bool operator==( Instance const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_instance == rhs.m_instance;

     }


     bool operator!=( Instance const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_instance != rhs.m_instance;

     }


     bool operator<( Instance const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_instance < rhs.m_instance;

     }

 #endif


     //=== VK_VERSION_1_0 ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename PhysicalDeviceAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDevice>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDevice, PhysicalDeviceAllocator>>::type

       enumeratePhysicalDevices( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     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>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     PFN_vkVoidFunction getProcAddr( const char * pName, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     PFN_vkVoidFunction getProcAddr( const std::string & name, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_VERSION_1_1 ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename PhysicalDeviceGroupPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties>,

               typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD

       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type

       enumeratePhysicalDeviceGroups( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     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>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_KHR_surface ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_KHR_display ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


 #if defined( VK_USE_PLATFORM_XLIB_KHR )

     //=== VK_KHR_xlib_surface ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createXlibSurfaceKHR( const VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR * pCreateInfo,

                                                       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *      pAllocator,

                                                       VULKAN_HPP_NAMESPACE::SurfaceKHR *                     pSurface,

                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type

       createXlibSurfaceKHR( const VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR &              createInfo,

                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                             Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #    ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type

       createXlibSurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR &              createInfo,

                                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #    endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

 #endif     /*VK_USE_PLATFORM_XLIB_KHR*/


 #if defined( VK_USE_PLATFORM_XCB_KHR )

     //=== VK_KHR_xcb_surface ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createXcbSurfaceKHR( const VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR * pCreateInfo,

                                                      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *     pAllocator,

                                                      VULKAN_HPP_NAMESPACE::SurfaceKHR *                    pSurface,

                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type

       createXcbSurfaceKHR( const VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR &               createInfo,

                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                            Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #    ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type

       createXcbSurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR &               createInfo,

                                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #    endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

 #endif     /*VK_USE_PLATFORM_XCB_KHR*/


 #if defined( VK_USE_PLATFORM_WAYLAND_KHR )

     //=== VK_KHR_wayland_surface ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createWaylandSurfaceKHR( const VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR * pCreateInfo,

                                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks *         pAllocator,

                                                          VULKAN_HPP_NAMESPACE::SurfaceKHR *                        pSurface,

                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type

       createWaylandSurfaceKHR( const VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR &           createInfo,

                                Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #    ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type

       createWaylandSurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR &           createInfo,

                                      Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                      Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #    endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

 #endif     /*VK_USE_PLATFORM_WAYLAND_KHR*/


 #if defined( VK_USE_PLATFORM_ANDROID_KHR )

     //=== VK_KHR_android_surface ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createAndroidSurfaceKHR( const VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR * pCreateInfo,

                                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks *         pAllocator,

                                                          VULKAN_HPP_NAMESPACE::SurfaceKHR *                        pSurface,

                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type

       createAndroidSurfaceKHR( const VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR &           createInfo,

                                Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #    ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type

       createAndroidSurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR &           createInfo,

                                      Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                      Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #    endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

 #endif     /*VK_USE_PLATFORM_ANDROID_KHR*/


 #if defined( VK_USE_PLATFORM_WIN32_KHR )

     //=== VK_KHR_win32_surface ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createWin32SurfaceKHR( const VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR * pCreateInfo,

                                                        const VULKAN_HPP_NAMESPACE::AllocationCallbacks *       pAllocator,

                                                        VULKAN_HPP_NAMESPACE::SurfaceKHR *                      pSurface,

                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type

       createWin32SurfaceKHR( const VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR &             createInfo,

                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                              Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #    ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type

       createWin32SurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR &             createInfo,

                                    Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                    Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #    endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

 #endif     /*VK_USE_PLATFORM_WIN32_KHR*/


     //=== VK_EXT_debug_report ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createDebugReportCallbackEXT( const VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT * pCreateInfo,

                                                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks *              pAllocator,

                                                               VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT *                 pCallback,

                                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT>::type

       createDebugReportCallbackEXT( const VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT &      createInfo,

                                     Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                     Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT, Dispatch>>::type

       createDebugReportCallbackEXTUnique( const VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT &      createInfo,

                                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                           Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyDebugReportCallbackEXT( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT      callback,

                                         const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                                         Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyDebugReportCallbackEXT( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT callback               VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,

                                         Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT      callback,

                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT                        callback,

                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void debugReportMessageEXT( VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT      flags,

                                 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT objectType,

                                 uint64_t                                       object,

                                 size_t                                         location,

                                 int32_t                                        messageCode,

                                 const char *                                   pLayerPrefix,

                                 const char *                                   pMessage,

                                 Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void debugReportMessageEXT( VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT      flags,

                                 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT objectType,

                                 uint64_t                                       object,

                                 size_t                                         location,

                                 int32_t                                        messageCode,

                                 const std::string &                            layerPrefix,

                                 const std::string &                            message,

                                 Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


 #if defined( VK_USE_PLATFORM_GGP )

     //=== VK_GGP_stream_descriptor_surface ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createStreamDescriptorSurfaceGGP( const VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP * pCreateInfo,

                                                                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                  pAllocator,

                                                                   VULKAN_HPP_NAMESPACE::SurfaceKHR *                                 pSurface,

                                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type

       createStreamDescriptorSurfaceGGP( const VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP &  createInfo,

                                         Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                         Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #    ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type createStreamDescriptorSurfaceGGPUnique(

       const VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP &  createInfo,

       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

       Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #    endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

 #endif     /*VK_USE_PLATFORM_GGP*/


 #if defined( VK_USE_PLATFORM_VI_NN )

     //=== VK_NN_vi_surface ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createViSurfaceNN( const VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN * pCreateInfo,

                                                    const VULKAN_HPP_NAMESPACE::AllocationCallbacks *   pAllocator,

                                                    VULKAN_HPP_NAMESPACE::SurfaceKHR *                  pSurface,

                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type

       createViSurfaceNN( const VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN &                 createInfo,

                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                          Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #    ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type

       createViSurfaceNNUnique( const VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN &                 createInfo,

                                Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #    endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

 #endif     /*VK_USE_PLATFORM_VI_NN*/


     //=== VK_KHR_device_group_creation ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result enumeratePhysicalDeviceGroupsKHR( uint32_t *                                            pPhysicalDeviceGroupCount,

                                                                   VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties,

                                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename PhysicalDeviceGroupPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties>,

               typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD

       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type

       enumeratePhysicalDeviceGroupsKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     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>

     VULKAN_HPP_NODISCARD

       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type

       enumeratePhysicalDeviceGroupsKHR( PhysicalDeviceGroupPropertiesAllocator & physicalDeviceGroupPropertiesAllocator,

                                         Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


 #if defined( VK_USE_PLATFORM_IOS_MVK )

     //=== VK_MVK_ios_surface ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createIOSSurfaceMVK( const VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK * pCreateInfo,

                                                      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *     pAllocator,

                                                      VULKAN_HPP_NAMESPACE::SurfaceKHR *                    pSurface,

                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type

       createIOSSurfaceMVK( const VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK &               createInfo,

                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                            Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #    ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type

       createIOSSurfaceMVKUnique( const VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK &               createInfo,

                                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #    endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

 #endif     /*VK_USE_PLATFORM_IOS_MVK*/


 #if defined( VK_USE_PLATFORM_MACOS_MVK )

     //=== VK_MVK_macos_surface ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createMacOSSurfaceMVK( const VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK * pCreateInfo,

                                                        const VULKAN_HPP_NAMESPACE::AllocationCallbacks *       pAllocator,

                                                        VULKAN_HPP_NAMESPACE::SurfaceKHR *                      pSurface,

                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type

       createMacOSSurfaceMVK( const VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK &             createInfo,

                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                              Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #    ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type

       createMacOSSurfaceMVKUnique( const VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK &             createInfo,

                                    Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                    Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #    endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

 #endif     /*VK_USE_PLATFORM_MACOS_MVK*/


     //=== VK_EXT_debug_utils ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


 #if defined( VK_USE_PLATFORM_FUCHSIA )

     //=== VK_FUCHSIA_imagepipe_surface ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createImagePipeSurfaceFUCHSIA( const VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA * pCreateInfo,

                                                                const VULKAN_HPP_NAMESPACE::AllocationCallbacks *               pAllocator,

                                                                VULKAN_HPP_NAMESPACE::SurfaceKHR *                              pSurface,

                                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type

       createImagePipeSurfaceFUCHSIA( const VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA &     createInfo,

                                      Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                      Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #    ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type

       createImagePipeSurfaceFUCHSIAUnique( const VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA &     createInfo,

                                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                            Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #    endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

 #endif     /*VK_USE_PLATFORM_FUCHSIA*/


 #if defined( VK_USE_PLATFORM_METAL_EXT )

     //=== VK_EXT_metal_surface ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createMetalSurfaceEXT( const VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT * pCreateInfo,

                                                        const VULKAN_HPP_NAMESPACE::AllocationCallbacks *       pAllocator,

                                                        VULKAN_HPP_NAMESPACE::SurfaceKHR *                      pSurface,

                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type

       createMetalSurfaceEXT( const VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT &             createInfo,

                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                              Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #    ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type

       createMetalSurfaceEXTUnique( const VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT &             createInfo,

                                    Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                    Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #    endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

 #endif     /*VK_USE_PLATFORM_METAL_EXT*/


     //=== VK_EXT_headless_surface ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     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;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


 #if defined( VK_USE_PLATFORM_DIRECTFB_EXT )

     //=== VK_EXT_directfb_surface ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createDirectFBSurfaceEXT( const VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT * pCreateInfo,

                                                           const VULKAN_HPP_NAMESPACE::AllocationCallbacks *          pAllocator,

                                                           VULKAN_HPP_NAMESPACE::SurfaceKHR *                         pSurface,

                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type

       createDirectFBSurfaceEXT( const VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT &          createInfo,

                                 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                 Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #    ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type

       createDirectFBSurfaceEXTUnique( const VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT &          createInfo,

                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                       Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #    endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

 #endif     /*VK_USE_PLATFORM_DIRECTFB_EXT*/


 #if defined( VK_USE_PLATFORM_SCREEN_QNX )

     //=== VK_QNX_screen_surface ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createScreenSurfaceQNX( const VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX * pCreateInfo,

                                                         const VULKAN_HPP_NAMESPACE::AllocationCallbacks *        pAllocator,

                                                         VULKAN_HPP_NAMESPACE::SurfaceKHR *                       pSurface,

                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type

       createScreenSurfaceQNX( const VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX &            createInfo,

                               Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                               Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #    ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type

       createScreenSurfaceQNXUnique( const VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX &            createInfo,

                                     Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                     Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #    endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

 #endif     /*VK_USE_PLATFORM_SCREEN_QNX*/


     operator VkInstance() const VULKAN_HPP_NOEXCEPT

     {

       return m_instance;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_instance != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_instance == VK_NULL_HANDLE;

     }


   private:

     VkInstance m_instance = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eInstance>

   {

     using Type = VULKAN_HPP_NAMESPACE::Instance;

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eInstance>

   {

     using Type = VULKAN_HPP_NAMESPACE::Instance;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Instance>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


   //=== VK_VERSION_1_0 ===


 #ifndef VULKAN_HPP_NO_SMART_HANDLE

   template <typename Dispatch>

   class UniqueHandleTraits<Instance, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<NoParent, Dispatch>;

   };

   using UniqueInstance = UniqueHandle<Instance, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

 #endif /*VULKAN_HPP_NO_SMART_HANDLE*/


   template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

   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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

   template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

   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 );

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

   template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

   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 );

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


   template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

   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;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

   template <typename ExtensionPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::ExtensionProperties>,

             typename Dispatch                     = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

   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 );

   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>

   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 );

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


   template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

   VULKAN_HPP_NODISCARD Result enumerateInstanceLayerProperties( uint32_t *                              pPropertyCount,

                                                                 VULKAN_HPP_NAMESPACE::LayerProperties * pProperties,

                                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

   template <typename LayerPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::LayerProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

   VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::LayerProperties, LayerPropertiesAllocator>>::type

     enumerateInstanceLayerProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );

   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>

   VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::LayerProperties, LayerPropertiesAllocator>>::type

     enumerateInstanceLayerProperties( LayerPropertiesAllocator & layerPropertiesAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


   //=== VK_VERSION_1_1 ===


   template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

   VULKAN_HPP_NODISCARD Result enumerateInstanceVersion( uint32_t *         pApiVersion,

                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

   template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

   VULKAN_HPP_NODISCARD typename ResultValueType<uint32_t>::type enumerateInstanceVersion( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


 }  // namespace VULKAN_HPP_NAMESPACE

 #endif

VULKAN_HPP_NAMESPACE::Instance::enumeratePhysicalDeviceGroups
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

memory
GLsizei GLenum GLsizei GLsizei GLuint memory
Definition: RE_OGL.h:202

VULKAN_HPP_NAMESPACE::PhysicalDevice::objectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
Definition: vulkan_handles.hpp:12405

VULKAN_HPP_NAMESPACE::RenderPass::RenderPass
VULKAN_HPP_CONSTEXPR RenderPass(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6722

VULKAN_HPP_NAMESPACE::ShaderStageFlagBits
ShaderStageFlagBits
Definition: vulkan_enums.hpp:2574

VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT
Definition: vulkan_structs.hpp:45858

VULKAN_HPP_NAMESPACE::DisplayModeParametersKHR
Definition: vulkan_structs.hpp:27806

VULKAN_HPP_NAMESPACE::DisplayKHR::DisplayKHR
VULKAN_HPP_CONSTEXPR DisplayKHR(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:1832

VULKAN_HPP_NAMESPACE::ImagePlaneMemoryRequirementsInfo
Definition: vulkan_structs.hpp:39965

VULKAN_HPP_NAMESPACE::CommandBuffer::dispatchBaseKHR
void dispatchBaseKHR(uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion::SamplerYcbcrConversion
VULKAN_HPP_CONSTEXPR SamplerYcbcrConversion(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6892

VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate::operator==
bool operator==(DescriptorUpdateTemplate const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3042

VULKAN_HPP_NAMESPACE::Device::importFenceFdKHR
VULKAN_HPP_NODISCARD Result importFenceFdKHR(const VULKAN_HPP_NAMESPACE::ImportFenceFdInfoKHR *pImportFenceFdInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::SwapchainCounterCreateInfoEXT
Definition: vulkan_structs.hpp:95442

VULKAN_HPP_NAMESPACE::ObjectType::eSemaphore

VULKAN_HPP_NAMESPACE::PhysicalDeviceTransformFeedbackFeaturesEXT
Definition: vulkan_structs.hpp:74282

VULKAN_HPP_NAMESPACE::MappedMemoryRange
Definition: vulkan_structs.hpp:44537

VULKAN_HPP_NAMESPACE::Fence::debugReportObjectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
Definition: vulkan_handles.hpp:2082

VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR
Definition: vulkan_structs.hpp:28903

VULKAN_HPP_NAMESPACE::PhysicalDeviceImage2DViewOf3DFeaturesEXT
Definition: vulkan_structs.hpp:59235

VULKAN_HPP_NAMESPACE::Event::operator=
Event & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3119

VULKAN_HPP_NAMESPACE::Device::getMemoryOpaqueCaptureAddressKHR
uint64_t getMemoryOpaqueCaptureAddressKHR(const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::EventCreateInfo
Definition: vulkan_structs.hpp:30021

sizes
GLuint GLsizei const GLuint const GLintptr const GLsizeiptr * sizes
Definition: glcorearb.h:2621

VULKAN_HPP_NAMESPACE::CommandBuffer::writeAccelerationStructuresPropertiesNV
void writeAccelerationStructuresPropertiesNV(uint32_t accelerationStructureCount, const VULKAN_HPP_NAMESPACE::AccelerationStructureNV *pAccelerationStructures, VULKAN_HPP_NAMESPACE::QueryType queryType, VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationFeaturesEXT
Definition: vulkan_structs.hpp:61721

VULKAN_HPP_NAMESPACE::Device::buildMicromapsEXT
VULKAN_HPP_NODISCARD Result buildMicromapsEXT(VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, uint32_t infoCount, const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT *pInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::DeferredOperationKHR::operator=
DeferredOperationKHR & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:5719

VULKAN_HPP_NAMESPACE::PrivateDataSlot::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6688

VULKAN_HPP_NAMESPACE::PipelineCoverageReductionStateCreateInfoNV
Definition: vulkan_structs.hpp:78566

query
GLenum query
Definition: glad.h:2772

VULKAN_HPP_NAMESPACE::CommandBuffer::setViewportWScalingEnableNV
void setViewportWScalingEnableNV(VULKAN_HPP_NAMESPACE::Bool32 viewportWScalingEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::MicromapCreateInfoEXT
Definition: vulkan_structs.hpp:46995

VULKAN_HPP_NAMESPACE::PhysicalDevice::getSparseImageFormatProperties2
void getSparseImageFormatProperties2(const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 *pFormatInfo, uint32_t *pPropertyCount, VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2 *pProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::DisplayProperties2KHR
Definition: vulkan_structs.hpp:29015

VULKAN_HPP_NAMESPACE::PhysicalDevice::getSurfacePresentModesKHR
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

VULKAN_HPP_NAMESPACE::DescriptorPool::DescriptorPool
VULKAN_HPP_CONSTEXPR DescriptorPool(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6302

VULKAN_HPP_NAMESPACE::AccelerationStructureNV::operator=
AccelerationStructureNV & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2863

VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupExtendedTypesFeatures
Definition: vulkan_structs.hpp:72171

VULKAN_HPP_NAMESPACE::Framebuffer::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6521

VULKAN_HPP_NAMESPACE::ObjectType::ePhysicalDevice

message
GLuint GLsizei const GLchar * message
Definition: glcorearb.h:2543

VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR
Definition: vulkan_structs.hpp:25573

VULKAN_HPP_NAMESPACE::PipelineCache::NativeType
VkPipelineCache NativeType
Definition: vulkan_handles.hpp:6039

VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPipelineFeaturesKHR
Definition: vulkan_structs.hpp:68369

VULKAN_HPP_NAMESPACE::BufferMemoryBarrier2
Definition: vulkan_structs.hpp:11727

VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL::PerformanceConfigurationINTEL
VULKAN_HPP_CONSTEXPR PerformanceConfigurationINTEL(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2172

VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClipEnableFeaturesEXT
Definition: vulkan_structs.hpp:53006

VULKAN_HPP_NAMESPACE::Device::getImageMemoryRequirements2
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

VULKAN_HPP_NAMESPACE::Device::destroyQueryPool
void destroyQueryPool(VULKAN_HPP_NAMESPACE::QueryPool queryPool, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::CommandBuffer::drawMeshTasksIndirectEXT
void drawMeshTasksIndirectEXT(VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Device::copyAccelerationStructureToMemoryKHR
VULKAN_HPP_NODISCARD Result copyAccelerationStructureToMemoryKHR(VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::ValidationCacheEXT::ValidationCacheEXT
VULKAN_HPP_CONSTEXPR ValidationCacheEXT()=default

VULKAN_HPP_NAMESPACE::ShaderModule::operator!=
bool operator!=(ShaderModule const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7006

VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderModuleIdentifierFeaturesEXT
Definition: vulkan_structs.hpp:71804

VULKAN_HPP_NAMESPACE::ObjectType::eDebugUtilsMessengerEXT

VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceQueryPropertiesKHR
Definition: vulkan_structs.hpp:65126

VULKAN_HPP_NAMESPACE::Instance::createDebugUtilsMessengerEXT
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

VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR
Definition: vulkan_structs.hpp:79402

VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan11Properties
Definition: vulkan_structs.hpp:75367

VULKAN_HPP_NAMESPACE::CommandBuffer::setPrimitiveTopologyEXT
void setPrimitiveTopologyEXT(VULKAN_HPP_NAMESPACE::PrimitiveTopology primitiveTopology, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL::operator<
bool operator<(PerformanceConfigurationINTEL const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2205

VULKAN_HPP_NAMESPACE::Device::createSamplerYcbcrConversionKHR
VULKAN_HPP_NODISCARD Result createSamplerYcbcrConversionKHR(const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo *pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion *pYcbcrConversion, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Device::getDescriptorSetLayoutHostMappingInfoVALVE
void getDescriptorSetLayoutHostMappingInfoVALVE(const VULKAN_HPP_NAMESPACE::DescriptorSetBindingReferenceVALVE *pBindingReference, VULKAN_HPP_NAMESPACE::DescriptorSetLayoutHostMappingInfoVALVE *pHostMapping, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::PhysicalDevice::releaseDisplayEXT
void releaseDisplayEXT(VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::CommandBuffer::copyAccelerationStructureNV
void copyAccelerationStructureNV(VULKAN_HPP_NAMESPACE::AccelerationStructureNV dst, VULKAN_HPP_NAMESPACE::AccelerationStructureNV src, VULKAN_HPP_NAMESPACE::CopyAccelerationStructureModeKHR mode, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Device
Definition: vulkan_handles.hpp:7729

VULKAN_HPP_NAMESPACE::FenceGetFdInfoKHR
Definition: vulkan_structs.hpp:33006

VULKAN_HPP_NAMESPACE::PhysicalDevice::createDisplayModeKHR
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

flags
GLbitfield flags
Definition: glcorearb.h:1596

VULKAN_HPP_NAMESPACE::Queue::endDebugUtilsLabelEXT
void endDebugUtilsLabelEXT(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Device::getQueue
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

VULKAN_HPP_NAMESPACE::Image::objectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
Definition: vulkan_handles.hpp:2758

VULKAN_HPP_NAMESPACE::PipelineLayout::operator!=
bool operator!=(PipelineLayout const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2449

VULKAN_HPP_NAMESPACE::RenderPass::NativeType
VkRenderPass NativeType
Definition: vulkan_handles.hpp:6714

VULKAN_HPP_NAMESPACE::PhysicalDeviceVariablePointersFeatures
Definition: vulkan_structs.hpp:74630

VULKAN_HPP_NAMESPACE::PipelineLibraryCreateInfoKHR
Definition: vulkan_structs.hpp:80246

VULKAN_HPP_NAMESPACE::Framebuffer::debugReportObjectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
Definition: vulkan_handles.hpp:6470

VULKAN_HPP_NAMESPACE::Device::createSwapchainKHR
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

VULKAN_HPP_NAMESPACE::AccelerationStructureKHR::AccelerationStructureKHR
VULKAN_HPP_TYPESAFE_EXPLICIT AccelerationStructureKHR(VkAccelerationStructureKHR accelerationStructureKHR) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3194

VULKAN_HPP_NAMESPACE::AttachmentReferenceStencilLayout
Definition: vulkan_structs.hpp:5864

VULKAN_HPP_NAMESPACE::DescriptorPool::operator!=
bool operator!=(DescriptorPool const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6327

VULKAN_HPP_NAMESPACE::CommandBuffer::setLineStippleEnableEXT
void setLineStippleEnableEXT(VULKAN_HPP_NAMESPACE::Bool32 stippledLineEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Framebuffer
Definition: vulkan_handles.hpp:6463

VULKAN_HPP_NAMESPACE::SurfaceKHR::operator<
bool operator<(SurfaceKHR const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:1607

VULKAN_HPP_NAMESPACE::Device::getPipelineExecutableStatisticsKHR
VULKAN_HPP_NODISCARD Result getPipelineExecutableStatisticsKHR(const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR *pExecutableInfo, uint32_t *pStatisticCount, VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR *pStatistics, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Device::registerEventEXT
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

VULKAN_HPP_NAMESPACE::TessellationDomainOrigin
TessellationDomainOrigin
Definition: vulkan_enums.hpp:3234

VULKAN_HPP_NAMESPACE::QueryPool::operator==
bool operator==(QueryPool const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2274

VULKAN_HPP_NAMESPACE::AccelerationStructureKHR::AccelerationStructureKHR
VULKAN_HPP_CONSTEXPR AccelerationStructureKHR(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3193

VULKAN_HPP_NAMESPACE::PipelineColorBlendAdvancedStateCreateInfoEXT
Definition: vulkan_structs.hpp:78046

VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT
Definition: vulkan_structs.hpp:6275

VULKAN_HPP_NAMESPACE::Sampler::debugReportObjectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
Definition: vulkan_handles.hpp:6802

VULKAN_HPP_NAMESPACE::AccelerationStructureKHR::debugReportObjectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
Definition: vulkan_handles.hpp:3188

VULKAN_HPP_NAMESPACE::ImageMemoryBarrier
Definition: vulkan_structs.hpp:39579

VULKAN_HPP_NAMESPACE::CommandBuffer::pushConstants
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

VULKAN_HPP_NAMESPACE::QueryPool::NativeType
VkQueryPool NativeType
Definition: vulkan_handles.hpp:2246

VULKAN_HPP_NAMESPACE::QueryPool::operator<
bool operator<(QueryPool const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2284

VULKAN_HPP_NAMESPACE::Result
Result
Definition: vulkan_enums.hpp:24

VULKAN_HPP_NAMESPACE::PhysicalDeviceTexelBufferAlignmentProperties
Definition: vulkan_structs.hpp:73693

VULKAN_HPP_NAMESPACE::Device::setEvent
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type setEvent(VULKAN_HPP_NAMESPACE::Event event, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

VULKAN_HPP_NAMESPACE::DescriptorSet::NativeType
VkDescriptorSet NativeType
Definition: vulkan_handles.hpp:2501

VULKAN_HPP_NAMESPACE::IndirectCommandsStreamNV
Definition: vulkan_structs.hpp:34286

VULKAN_HPP_NAMESPACE::DevicePrivateDataCreateInfo
Definition: vulkan_structs.hpp:26939

VULKAN_HPP_NAMESPACE::Buffer
Definition: vulkan_handles.hpp:2327

VULKAN_HPP_NAMESPACE::PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT
Definition: vulkan_structs.hpp:58827

VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBindingFlagsCreateInfo
Definition: vulkan_structs.hpp:21968

VULKAN_HPP_NAMESPACE::Device::getBufferMemoryRequirements2KHR
void getBufferMemoryRequirements2KHR(const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 *pInfo, VULKAN_HPP_NAMESPACE::MemoryRequirements2 *pMemoryRequirements, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::CommandBuffer::setLogicOpEXT
void setLogicOpEXT(VULKAN_HPP_NAMESPACE::LogicOp logicOp, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Device::getAccelerationStructureMemoryRequirementsNV
void getAccelerationStructureMemoryRequirementsNV(const VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV *pInfo, VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR *pMemoryRequirements, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::ObjectType::ePrivateDataSlot

VULKAN_HPP_NAMESPACE::Device::setMemoryPriorityEXT
void setMemoryPriorityEXT(VULKAN_HPP_NAMESPACE::DeviceMemory memory, float priority, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Image::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2810

VULKAN_HPP_NAMESPACE::CommandBuffer::decompressMemoryNV
void decompressMemoryNV(uint32_t decompressRegionCount, const VULKAN_HPP_NAMESPACE::DecompressMemoryRegionNV *pDecompressMemoryRegions, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Sampler::Sampler
VULKAN_HPP_CONSTEXPR Sampler(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6807

VULKAN_HPP_NAMESPACE::DeviceGroupCommandBufferBeginInfo
Definition: vulkan_structs.hpp:25349

VULKAN_HPP_NAMESPACE::CommandBuffer::pipelineBarrier
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

VULKAN_HPP_NAMESPACE::CommandBuffer::setDepthBounds
void setDepthBounds(float minDepthBounds, float maxDepthBounds, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL
Definition: vulkan_structs.hpp:48854

VULKAN_HPP_NAMESPACE::CoverageModulationModeNV
CoverageModulationModeNV
Definition: vulkan_enums.hpp:5305

VULKAN_HPP_NAMESPACE::CommandBuffer::drawMeshTasksEXT
void drawMeshTasksEXT(uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VK_NULL_HANDLE
#define VK_NULL_HANDLE
Definition: vulkan_core.h:45

VULKAN_HPP_NAMESPACE::PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR
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

VULKAN_HPP_NAMESPACE::Device::deferredOperationJoinKHR
VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result deferredOperationJoinKHR(VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

VULKAN_HPP_NAMESPACE::PhysicalDeviceCoverageReductionModeFeaturesNV
Definition: vulkan_structs.hpp:52418

VULKAN_HPP_NAMESPACE::CommandBuffer::traceRaysNV
void traceRaysNV(VULKAN_HPP_NAMESPACE::Buffer raygenShaderBindingTableBuffer, VULKAN_HPP_NAMESPACE::DeviceSize raygenShaderBindingOffset, VULKAN_HPP_NAMESPACE::Buffer missShaderBindingTableBuffer, VULKAN_HPP_NAMESPACE::DeviceSize missShaderBindingOffset, VULKAN_HPP_NAMESPACE::DeviceSize missShaderBindingStride, VULKAN_HPP_NAMESPACE::Buffer hitShaderBindingTableBuffer, VULKAN_HPP_NAMESPACE::DeviceSize hitShaderBindingOffset, VULKAN_HPP_NAMESPACE::DeviceSize hitShaderBindingStride, VULKAN_HPP_NAMESPACE::Buffer callableShaderBindingTableBuffer, VULKAN_HPP_NAMESPACE::DeviceSize callableShaderBindingOffset, VULKAN_HPP_NAMESPACE::DeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferPropertiesEXT
Definition: vulkan_structs.hpp:53425

VULKAN_HPP_NAMESPACE::CommandBuffer::setDepthCompareOp
void setDepthCompareOp(VULKAN_HPP_NAMESPACE::CompareOp depthCompareOp, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::PoolFree
Definition: vulkan.hpp:6033

VULKAN_HPP_NAMESPACE::CuFunctionNVX::CuFunctionNVX
VULKAN_HPP_CONSTEXPR CuFunctionNVX(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6132

VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfoEXT
Definition: vulkan_structs.hpp:15108

VULKAN_HPP_NAMESPACE::CommandBuffer::bindDescriptorSets
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

VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR
Definition: vulkan_structs.hpp:65310

VULKAN_HPP_NAMESPACE::PhysicalDeviceSampleLocationsPropertiesEXT
Definition: vulkan_structs.hpp:69084

VULKAN_HPP_NAMESPACE::DeferredOperationKHR::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:5754

VULKAN_HPP_NAMESPACE::AccelerationStructureKHR::operator=
AccelerationStructureKHR & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3207

VULKAN_HPP_NAMESPACE::PhysicalDeviceLegacyDitheringFeaturesEXT
Definition: vulkan_structs.hpp:60968

VULKAN_HPP_NAMESPACE::Device::destroyBufferView
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

VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion::operator<
bool operator<(SamplerYcbcrConversion const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6925

VULKAN_HPP_NAMESPACE::ImageSubresource
Definition: vulkan_structs.hpp:8259

VULKAN_HPP_NAMESPACE::Queue::Queue
VULKAN_HPP_CONSTEXPR Queue()=default

VULKAN_HPP_NAMESPACE::CommandBuffer::setExclusiveScissorNV
void setExclusiveScissorNV(uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VULKAN_HPP_NAMESPACE::Rect2D *pExclusiveScissors, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::SubpassFragmentDensityMapOffsetEndInfoQCOM
Definition: vulkan_structs.hpp:94075

VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo
Definition: vulkan_structs.hpp:11194

VULKAN_HPP_NAMESPACE::AccelerationStructureSRTMotionInstanceNV
Definition: vulkan_structs.hpp:3236

VULKAN_HPP_NOEXCEPT
#define VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:200

VULKAN_HPP_NAMESPACE::CommandBuffer::writeBufferMarker2AMD
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

VULKAN_HPP_NAMESPACE::RenderPassCreateInfo
Definition: vulkan_structs.hpp:87118

VULKAN_HPP_NAMESPACE::ShaderGroupShaderKHR
ShaderGroupShaderKHR
Definition: vulkan_enums.hpp:6093

VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInfoNV
Definition: vulkan_structs.hpp:2899

VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesListEXT
Definition: vulkan_structs.hpp:29923

VULKAN_HPP_NAMESPACE::CommandBuffer::setPrimitiveTopology
void setPrimitiveTopology(VULKAN_HPP_NAMESPACE::PrimitiveTopology primitiveTopology, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::SwapchainKHR::operator=
SwapchainKHR & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:1928

VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInstanceDataNV
Definition: vulkan_structs.hpp:3380

VULKAN_HPP_NAMESPACE::Sampler::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6853

VULKAN_HPP_NAMESPACE::Device::getRayTracingCaptureReplayShaderGroupHandleKHR
VULKAN_HPP_NODISCARD ResultValueType< DataType >::type getRayTracingCaptureReplayShaderGroupHandleKHR(VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

VULKAN_HPP_NAMESPACE::Device::createSamplerUnique
VULKAN_HPP_NODISCARD 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

VULKAN_HPP_NAMESPACE::Device::createQueryPoolUnique
VULKAN_HPP_NODISCARD 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

VULKAN_HPP_NAMESPACE::GraphicsShaderGroupCreateInfoNV
Definition: vulkan_structs.hpp:37219

VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCoreBuiltinsPropertiesARM
Definition: vulkan_structs.hpp:70380

VULKAN_HPP_NAMESPACE::Device::getMemoryFdPropertiesKHR
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

VULKAN_HPP_NAMESPACE::DeviceFaultVendorBinaryHeaderVersionOneEXT
Definition: vulkan_structs.hpp:25077

VULKAN_HPP_NAMESPACE::PhysicalDevice::getMemoryProperties
void getMemoryProperties(VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties *pMemoryProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::DescriptorSetLayout::DescriptorSetLayout
VULKAN_HPP_CONSTEXPR DescriptorSetLayout(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6387

VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV::NativeType
VkOpticalFlowSessionNV NativeType
Definition: vulkan_handles.hpp:2929

VULKAN_HPP_NAMESPACE::Device::destroySampler
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

VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderBarycentricFeaturesKHR
Definition: vulkan_structs.hpp:57695

VULKAN_HPP_NAMESPACE::BindImageMemorySwapchainInfoKHR
Definition: vulkan_structs.hpp:7539

VULKAN_HPP_NAMESPACE::CommandBuffer::setPerformanceStreamMarkerINTEL
VULKAN_HPP_NODISCARD Result setPerformanceStreamMarkerINTEL(const VULKAN_HPP_NAMESPACE::PerformanceStreamMarkerInfoINTEL *pMarkerInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState3FeaturesEXT
Definition: vulkan_structs.hpp:55411

VULKAN_HPP_NAMESPACE::CopyMemoryToImageIndirectCommandNV
Definition: vulkan_structs.hpp:16970

VULKAN_HPP_NAMESPACE::Device::registerDisplayEventEXTUnique
VULKAN_HPP_NODISCARD 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

VULKAN_HPP_NAMESPACE::Device::destroyCommandPool
void destroyCommandPool(VULKAN_HPP_NAMESPACE::CommandPool commandPool, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV::OpticalFlowSessionNV
VULKAN_HPP_CONSTEXPR OpticalFlowSessionNV()=default

VULKAN_HPP_NAMESPACE::Device::getSwapchainCounterEXT
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

VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupSizeControlFeatures
Definition: vulkan_structs.hpp:72912

VULKAN_HPP_NAMESPACE::TilePropertiesQCOM
Definition: vulkan_structs.hpp:96139

VULKAN_HPP_NAMESPACE::PerformanceStreamMarkerInfoINTEL
Definition: vulkan_structs.hpp:49538

VULKAN_HPP_NAMESPACE::Device::getDeferredOperationResultKHR
VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result getDeferredOperationResultKHR(VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
#define VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
Definition: vulkan.hpp:205

VULKAN_HPP_NAMESPACE::FramebufferCreateInfo
Definition: vulkan_structs.hpp:33996

VULKAN_HPP_NAMESPACE::CommandBuffer::setCoverageModulationTableNV
void setCoverageModulationTableNV(uint32_t coverageModulationTableCount, const float *pCoverageModulationTable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::ImageViewASTCDecodeModeEXT
Definition: vulkan_structs.hpp:40705

VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV
Definition: vulkan_structs.hpp:43747

VULKAN_HPP_NAMESPACE::Pipeline
Definition: vulkan_handles.hpp:2667

VULKAN_HPP_NAMESPACE::CommandBuffer::beginRenderPass2
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

VULKAN_HPP_NAMESPACE::PipelineLayout::operator<
bool operator<(PipelineLayout const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2454

VULKAN_HPP_NAMESPACE::Device::createMicromapEXT
VULKAN_HPP_NODISCARD Result createMicromapEXT(const VULKAN_HPP_NAMESPACE::MicromapCreateInfoEXT *pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, VULKAN_HPP_NAMESPACE::MicromapEXT *pMicromap, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::CommandBuffer::drawMultiEXT
void drawMultiEXT(uint32_t drawCount, const VULKAN_HPP_NAMESPACE::MultiDrawInfoEXT *pVertexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::SwapchainKHR::debugReportObjectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
Definition: vulkan_handles.hpp:1912

VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatInfoNV
Definition: vulkan_structs.hpp:48291

Y
Y
Definition: ImathEuler.h:184

VULKAN_HPP_NAMESPACE::CommandBuffer::writeMicromapsPropertiesEXT
void writeMicromapsPropertiesEXT(uint32_t micromapCount, const VULKAN_HPP_NAMESPACE::MicromapEXT *pMicromaps, VULKAN_HPP_NAMESPACE::QueryType queryType, VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Device::createPrivateDataSlot
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

VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo
Definition: vulkan_structs.hpp:22095

VULKAN_HPP_NAMESPACE::DisplayModeKHR::DisplayModeKHR
VULKAN_HPP_CONSTEXPR DisplayModeKHR(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:12316

VULKAN_HPP_NAMESPACE::Device::allocateDescriptorSetsUnique
VULKAN_HPP_NODISCARD 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

VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties
Definition: vulkan_structs.hpp:58939

VULKAN_HPP_NAMESPACE::Device::createBufferViewUnique
VULKAN_HPP_NODISCARD 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

VULKAN_HPP_NAMESPACE::Device::getRayTracingShaderGroupHandlesNV
VULKAN_HPP_NODISCARD Result getRayTracingShaderGroupHandlesNV(VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::ShaderModuleValidationCacheCreateInfoEXT
Definition: vulkan_structs.hpp:92419

VULKAN_HPP_NAMESPACE::Device::getRayTracingShaderGroupHandleKHR
VULKAN_HPP_NODISCARD ResultValueType< DataType >::type getRayTracingShaderGroupHandleKHR(VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

VULKAN_HPP_NAMESPACE::BindShaderGroupIndirectCommandNV
Definition: vulkan_structs.hpp:7840

VULKAN_HPP_NAMESPACE::DeviceMemory::DeviceMemory
VULKAN_HPP_CONSTEXPR DeviceMemory(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:5539

VULKAN_HPP_NAMESPACE::Device::createSamplerYcbcrConversion
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

VULKAN_HPP_NAMESPACE::CommandBuffer::setStencilTestEnableEXT
void setStencilTestEnableEXT(VULKAN_HPP_NAMESPACE::Bool32 stencilTestEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::SubresourceLayout
Definition: vulkan_structs.hpp:38902

VULKAN_HPP_NAMESPACE::ColorBlendEquationEXT
Definition: vulkan_structs.hpp:13207

VULKAN_HPP_NAMESPACE::BufferView::operator==
bool operator==(BufferView const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:5897

VULKAN_HPP_NAMESPACE::MicromapEXT::operator!=
bool operator!=(MicromapEXT const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3306

VULKAN_HPP_NAMESPACE::Device::getBufferOpaqueCaptureDescriptorDataEXT
VULKAN_HPP_NODISCARD Result getBufferOpaqueCaptureDescriptorDataEXT(const VULKAN_HPP_NAMESPACE::BufferCaptureDescriptorDataInfoEXT *pInfo, void *pData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::ExternalMemoryImageCreateInfo
Definition: vulkan_structs.hpp:32621

VULKAN_HPP_NAMESPACE::Device::Device
Device(VkDevice device) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7742

VULKAN_HPP_NAMESPACE::ImageViewMinLodCreateInfoEXT
Definition: vulkan_structs.hpp:41256

VULKAN_HPP_NAMESPACE::SurfaceKHR::operator==
bool operator==(SurfaceKHR const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:1597

VULKAN_HPP_NAMESPACE::RenderPass::objectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
Definition: vulkan_handles.hpp:6716

VULKAN_HPP_NAMESPACE::Device::getImageSubresourceLayout2EXT
void getImageSubresourceLayout2EXT(VULKAN_HPP_NAMESPACE::Image image, const VULKAN_HPP_NAMESPACE::ImageSubresource2EXT *pSubresource, VULKAN_HPP_NAMESPACE::SubresourceLayout2EXT *pLayout, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Queue::debugReportObjectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
Definition: vulkan_handles.hpp:7232

VULKAN_HPP_NAMESPACE::SwapchainKHR::operator<
bool operator<(SwapchainKHR const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:1947

VULKAN_HPP_NAMESPACE::ObjectDestroy< NoParent, Dispatch >
Definition: vulkan.hpp:5933

VULKAN_HPP_NAMESPACE::Semaphore::operator!=
bool operator!=(Semaphore const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2027

VULKAN_HPP_NAMESPACE::DeviceMemory::DeviceMemory
VULKAN_HPP_TYPESAFE_EXPLICIT DeviceMemory(VkDeviceMemory deviceMemory) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:5540

VULKAN_HPP_NAMESPACE::PhysicalDeviceSeparateDepthStencilLayoutsFeatures
Definition: vulkan_structs.hpp:69479

VULKAN_HPP_NAMESPACE::CommandBuffer::dispatch
void dispatch(uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT
Definition: vulkan_structs.hpp:59441

VULKAN_HPP_NAMESPACE::BindImageMemoryDeviceGroupInfo
Definition: vulkan_structs.hpp:7255

VULKAN_HPP_NAMESPACE::BindSparseInfo
Definition: vulkan_structs.hpp:8780

VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderDemoteToHelperInvocationFeatures
Definition: vulkan_structs.hpp:70716

VULKAN_HPP_NAMESPACE::Fence::operator=
Fence & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2098

VULKAN_HPP_NAMESPACE::Device::getPrivateData
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

VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion::SamplerYcbcrConversion
VULKAN_HPP_CONSTEXPR SamplerYcbcrConversion()=default

VULKAN_HPP_NAMESPACE::CommandBuffer::setProvokingVertexModeEXT
void setProvokingVertexModeEXT(VULKAN_HPP_NAMESPACE::ProvokingVertexModeEXT provokingVertexMode, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

void
void
Definition: png.h:1083

VULKAN_HPP_NAMESPACE::CommandBuffer::setViewport
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

VULKAN_HPP_NAMESPACE::Device::setPrivateData
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

VULKAN_HPP_NAMESPACE::CommandBuffer::resolveImage2
void resolveImage2(const VULKAN_HPP_NAMESPACE::ResolveImageInfo2 *pResolveImageInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::CommandBuffer::subpassShadingHUAWEI
void subpassShadingHUAWEI(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::CommandBuffer::blitImage2KHR
void blitImage2KHR(const VULKAN_HPP_NAMESPACE::BlitImageInfo2 *pBlitImageInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::DescriptorSetLayoutHostMappingInfoVALVE
Definition: vulkan_structs.hpp:22235

VULKAN_HPP_NAMESPACE::FormatProperties2
Definition: vulkan_structs.hpp:33387

VULKAN_HPP_NAMESPACE::Device::allocateDescriptorSets
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

VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate::DescriptorUpdateTemplate
VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplate()=default

VULKAN_HPP_NAMESPACE::Device::setHdrMetadataEXT
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

VULKAN_HPP_NAMESPACE::Framebuffer::operator=
Framebuffer & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6486

VULKAN_HPP_NAMESPACE::PhysicalDevicePipelinePropertiesFeaturesEXT
Definition: vulkan_structs.hpp:65410

VULKAN_HPP_NAMESPACE::PhysicalDeviceDrmPropertiesEXT
Definition: vulkan_structs.hpp:54984

VULKAN_HPP_NAMESPACE::MultisampledRenderToSingleSampledInfoEXT
Definition: vulkan_structs.hpp:47593

VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT::debugReportObjectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
Definition: vulkan_handles.hpp:1745

VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo
Definition: vulkan_structs.hpp:91949

VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryBudgetPropertiesEXT
Definition: vulkan_structs.hpp:62326

VULKAN_HPP_NAMESPACE::Device::writeMicromapsPropertiesEXT
VULKAN_HPP_NODISCARD Result writeMicromapsPropertiesEXT(uint32_t micromapCount, const VULKAN_HPP_NAMESPACE::MicromapEXT *pMicromaps, VULKAN_HPP_NAMESPACE::QueryType queryType, size_t dataSize, void *pData, size_t stride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::CommandBuffer::copyAccelerationStructureToMemoryKHR
void copyAccelerationStructureToMemoryKHR(const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::PhysicalDeviceOpacityMicromapPropertiesEXT
Definition: vulkan_structs.hpp:64503

VULKAN_HPP_NAMESPACE::ShaderInfoTypeAMD
ShaderInfoTypeAMD
Definition: vulkan_enums.hpp:4735

VULKAN_HPP_NAMESPACE::Device::getFenceStatus
VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result getFenceStatus(VULKAN_HPP_NAMESPACE::Fence fence, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT
Definition: vulkan_structs.hpp:97322

VULKAN_HPP_NAMESPACE::QueryPool
Definition: vulkan_handles.hpp:2242

VULKAN_HPP_NAMESPACE::Device::flushMappedMemoryRanges
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

VULKAN_HPP_NAMESPACE::CommandBuffer::beginTransformFeedbackEXT
void beginTransformFeedbackEXT(uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VULKAN_HPP_NAMESPACE::Buffer *pCounterBuffers, const VULKAN_HPP_NAMESPACE::DeviceSize *pCounterBufferOffsets, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Device::getPerformanceParameterINTEL
VULKAN_HPP_NODISCARD Result getPerformanceParameterINTEL(VULKAN_HPP_NAMESPACE::PerformanceParameterTypeINTEL parameter, VULKAN_HPP_NAMESPACE::PerformanceValueINTEL *pValue, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::ViewportSwizzleNV
Definition: vulkan_structs.hpp:82832

VULKAN_HPP_NAMESPACE::ShaderResourceUsageAMD
Definition: vulkan_structs.hpp:92517

VULKAN_HPP_NAMESPACE::Device::createFramebuffer
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

VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT::operator==
bool operator==(DebugReportCallbackEXT const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:1685

VULKAN_HPP_NAMESPACE::CommandBuffer::beginConditionalRenderingEXT
void beginConditionalRenderingEXT(const VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfoEXT *pConditionalRenderingBegin, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::PhysicalDeviceSynchronization2Features
Definition: vulkan_structs.hpp:73496

VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties
Definition: vulkan_structs.hpp:32818

VULKAN_HPP_NAMESPACE::PhysicalDeviceImageRobustnessFeatures
Definition: vulkan_structs.hpp:60061

VULKAN_HPP_NAMESPACE::Instance::operator=
Instance & operator=(VkInstance instance) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:13795

SOP_AttribCreate_2_0Enums::Type
Type
Definition: SOP_AttribCreate-2.0.proto.h:47

VULKAN_HPP_NAMESPACE::Semaphore::operator==
bool operator==(Semaphore const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2022

VULKAN_HPP_NAMESPACE::CommandBuffer::bindDescriptorBufferEmbeddedSamplersEXT
void bindDescriptorBufferEmbeddedSamplersEXT(VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, VULKAN_HPP_NAMESPACE::PipelineLayout layout, uint32_t set, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Device::createAccelerationStructureKHRUnique
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< VULKAN_HPP_NAMESPACE::AccelerationStructureKHR, Dispatch > >::type createAccelerationStructureKHRUnique(const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR &createInfo, Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL
Definition: vulkan_structs.hpp:71704

VULKAN_HPP_NAMESPACE::CommandBuffer::endRenderPass
void endRenderPass(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Device::getDescriptorSetHostMappingVALVE
void getDescriptorSetHostMappingVALVE(VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet, void **ppData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Semaphore
Definition: vulkan_handles.hpp:1990

VULKAN_HPP_NAMESPACE::BindIndexBufferIndirectCommandNV
Definition: vulkan_structs.hpp:7743

VULKAN_HPP_NAMESPACE::SubpassSampleLocationsEXT
Definition: vulkan_structs.hpp:88734

VULKAN_HPP_NAMESPACE::BufferView::debugReportObjectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
Definition: vulkan_handles.hpp:5872

VULKAN_HPP_NAMESPACE::PresentRegionsKHR
Definition: vulkan_structs.hpp:83944

VULKAN_HPP_NAMESPACE::PipelineViewportShadingRateImageStateCreateInfoNV
Definition: vulkan_structs.hpp:82685

VULKAN_HPP_NAMESPACE::CommandBuffer::begin
VULKAN_HPP_NODISCARD Result begin(const VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo *pBeginInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::CommandBuffer::endRenderPass2KHR
void endRenderPass2KHR(const VULKAN_HPP_NAMESPACE::SubpassEndInfo *pSubpassEndInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Instance::createDebugUtilsMessengerEXTUnique
VULKAN_HPP_NODISCARD 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

VULKAN_HPP_NAMESPACE::ShaderModule::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7027

VULKAN_HPP_NAMESPACE::Instance::getProcAddr
PFN_vkVoidFunction getProcAddr(const char *pName, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Device::acquireNextImage2KHR
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

VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstKHR
Definition: vulkan_structs.hpp:136

VULKAN_HPP_NAMESPACE::RenderPassSubpassFeedbackCreateInfoEXT
Definition: vulkan_structs.hpp:89073

VULKAN_HPP_NAMESPACE::DeviceQueueInfo2
Definition: vulkan_structs.hpp:27136

VULKAN_HPP_NAMESPACE::PipelineVertexInputDivisorStateCreateInfoEXT
Definition: vulkan_structs.hpp:82066

VULKAN_HPP_NAMESPACE::ImageView::ImageView
VULKAN_HPP_CONSTEXPR ImageView(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2594

VULKAN_HPP_NAMESPACE::DeviceGroupSwapchainCreateInfoKHR
Definition: vulkan_structs.hpp:26148

VULKAN_HPP_NAMESPACE::Device::updateDescriptorSets
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

VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSMBuiltinsPropertiesNV
Definition: vulkan_structs.hpp:72086

VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthStencilResolveProperties
Definition: vulkan_structs.hpp:53103

VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryDecompressionFeaturesNV
Definition: vulkan_structs.hpp:62415

VULKAN_HPP_NAMESPACE::Device::createDescriptorPool
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

string
GLsizei const GLchar *const * string
Definition: glcorearb.h:814

VULKAN_HPP_NAMESPACE::QueueFamilyCheckpointProperties2NV
Definition: vulkan_structs.hpp:84833

VULKAN_HPP_NAMESPACE::Device::createIndirectCommandsLayoutNV
VULKAN_HPP_NODISCARD Result createIndirectCommandsLayoutNV(const VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV *pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV *pIndirectCommandsLayout, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::SemaphoreTypeCreateInfo
Definition: vulkan_structs.hpp:91842

VULKAN_HPP_NAMESPACE::Extent2D
Definition: vulkan_structs.hpp:6109

value
GLsizei const GLfloat * value
Definition: glcorearb.h:824

VULKAN_HPP_NAMESPACE::Buffer::Buffer
VULKAN_HPP_CONSTEXPR Buffer(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2339

VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorSet

VULKAN_HPP_NAMESPACE::Device::getDescriptorSetLayoutSupport
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

VULKAN_HPP_NAMESPACE::Device::createSamplerYcbcrConversionKHRUnique
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion, Dispatch > >::type createSamplerYcbcrConversionKHRUnique(const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo &createInfo, Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

VULKAN_HPP_NAMESPACE::Device::waitSemaphores
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

VULKAN_HPP_NAMESPACE::PhysicalDevice::getDisplayPropertiesKHR
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

VULKAN_HPP_NAMESPACE::CommandBuffer::drawMultiIndexedEXT
void drawMultiIndexedEXT(uint32_t drawCount, const VULKAN_HPP_NAMESPACE::MultiDrawIndexedInfoEXT *pIndexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride, const int32_t *pVertexOffset, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate::operator<
bool operator<(DescriptorUpdateTemplate const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3052

VULKAN_HPP_NAMESPACE::AttachmentDescription2
Definition: vulkan_structs.hpp:5363

VULKAN_HPP_NAMESPACE::Queue::submit
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

VULKAN_HPP_NAMESPACE::CommandBuffer::setColorBlendEnableEXT
void setColorBlendEnableEXT(uint32_t firstAttachment, uint32_t attachmentCount, const VULKAN_HPP_NAMESPACE::Bool32 *pColorBlendEnables, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV::OpticalFlowSessionNV
VULKAN_HPP_CONSTEXPR OpticalFlowSessionNV(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2937

VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT
Definition: vulkan_structs.hpp:27709

VULKAN_HPP_NAMESPACE::CommandBuffer::setPolygonModeEXT
void setPolygonModeEXT(VULKAN_HPP_NAMESPACE::PolygonMode polygonMode, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::CommandBuffer::resetEvent2KHR
void resetEvent2KHR(VULKAN_HPP_NAMESPACE::Event event, VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stageMask, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::PhysicalDeviceImageDrmFormatModifierInfoEXT
Definition: vulkan_structs.hpp:59543

VULKAN_HPP_NAMESPACE::Device::getBufferAddressKHR
DeviceAddress getBufferAddressKHR(const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Device::destroyFramebuffer
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

VULKAN_HPP_NAMESPACE::CommandBuffer::setVertexInputEXT
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

VULKAN_HPP_NAMESPACE::CommandBuffer::setViewportShadingRatePaletteNV
void setViewportShadingRatePaletteNV(uint32_t firstViewport, uint32_t viewportCount, const VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV *pShadingRatePalettes, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Device::updateDescriptorSetWithTemplateKHR
void updateDescriptorSetWithTemplateKHR(VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet, VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, const void *pData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT
Definition: vulkan_structs.hpp:46636

VULKAN_HPP_NAMESPACE::PhysicalDevice::getDisplayPlaneCapabilitiesKHR
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

VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryMotionTrianglesDataNV
Definition: vulkan_structs.hpp:2354

VULKAN_HPP_NAMESPACE::PhysicalDeviceOpacityMicromapFeaturesEXT
Definition: vulkan_structs.hpp:64381

VULKAN_HPP_NAMESPACE::Instance::operator<
bool operator<(Instance const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:13820

VULKAN_HPP_NAMESPACE::RenderPassSubpassFeedbackInfoEXT
Definition: vulkan_structs.hpp:88995

VULKAN_HPP_NAMESPACE::PhysicalDevice::getQueueFamilyPerformanceQueryPassesKHR
void getQueueFamilyPerformanceQueryPassesKHR(const VULKAN_HPP_NAMESPACE::QueryPoolPerformanceCreateInfoKHR *pPerformanceQueryCreateInfo, uint32_t *pNumPasses, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Device::destroyDescriptorUpdateTemplateKHR
void destroyDescriptorUpdateTemplateKHR(VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::CommandPool::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6008

VULKAN_HPP_NAMESPACE::Pipeline::operator<
bool operator<(Pipeline const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2709

VULKAN_HPP_NAMESPACE::DeferredOperationKHR
Definition: vulkan_handles.hpp:5693

VULKAN_HPP_NAMESPACE::Device::createSharedSwapchainKHRUnique
VULKAN_HPP_NODISCARD 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

VULKAN_HPP_NAMESPACE::DeviceSize
uint64_t DeviceSize
Definition: vulkan.hpp:6075

VULKAN_HPP_NAMESPACE::PhysicalDevice::getDisplayPlaneProperties2KHR
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

VULKAN_HPP_NAMESPACE::PhysicalDeviceExclusiveScissorFeaturesNV
Definition: vulkan_structs.hpp:55189

VULKAN_HPP_NAMESPACE::Instance::createDisplayPlaneSurfaceKHRUnique
VULKAN_HPP_NODISCARD 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

VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR
Definition: vulkan_structs.hpp:28532

VULKAN_HPP_NAMESPACE::Buffer::operator=
Buffer & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2350

VULKAN_HPP_NAMESPACE::PhysicalDevicePointClippingProperties
Definition: vulkan_structs.hpp:65813

VULKAN_HPP_NAMESPACE::PhysicalDevice::getFeatures2
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain< X, Y, Z...> getFeatures2() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:12571

VULKAN_HPP_NAMESPACE::CommandBuffer::objectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
Definition: vulkan_handles.hpp:3354

VULKAN_HPP_NAMESPACE::CommandBuffer::copyQueryPoolResults
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

VULKAN_HPP_NAMESPACE::FormatProperties
Definition: vulkan_structs.hpp:33311

VULKAN_HPP_NAMESPACE::Device::resetFences
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

VULKAN_HPP_NAMESPACE::Device::createRayTracingPipelinesNV
VULKAN_HPP_NODISCARD Result createRayTracingPipelinesNV(VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, uint32_t createInfoCount, const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV *pCreateInfos, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, VULKAN_HPP_NAMESPACE::Pipeline *pPipelines, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

handleType
GLuint64 GLenum handleType
Definition: RE_OGL.h:262

VULKAN_HPP_NAMESPACE::CommandBuffer::copyBuffer2
void copyBuffer2(const VULKAN_HPP_NAMESPACE::CopyBufferInfo2 *pCopyBufferInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::DeviceGroupDeviceCreateInfo
Definition: vulkan_structs.hpp:25446

VULKAN_HPP_NAMESPACE::PipelineCache::PipelineCache
VULKAN_HPP_CONSTEXPR PipelineCache(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6047

VULKAN_HPP_NAMESPACE::CommandBuffer::clearColorImage
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

VULKAN_HPP_NAMESPACE::ExportMemoryAllocateInfo
Definition: vulkan_structs.hpp:30329

VULKAN_HPP_NAMESPACE::CommandBuffer::setRasterizerDiscardEnable
void setRasterizerDiscardEnable(VULKAN_HPP_NAMESPACE::Bool32 rasterizerDiscardEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::CommandBuffer::opticalFlowExecuteNV
void opticalFlowExecuteNV(VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV session, const VULKAN_HPP_NAMESPACE::OpticalFlowExecuteInfoNV *pExecuteInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Instance::objectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
Definition: vulkan_handles.hpp:13786

VULKAN_HPP_NAMESPACE::ObjectType::eDebugReportCallbackEXT

VULKAN_HPP_NAMESPACE::BufferView::NativeType
VkBufferView NativeType
Definition: vulkan_handles.hpp:5869

VULKAN_HPP_NAMESPACE::ImageCompressionPropertiesEXT
Definition: vulkan_structs.hpp:38352

VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCoreProperties2AMD
Definition: vulkan_structs.hpp:70471

VULKAN_HPP_NAMESPACE::ShaderModule::ShaderModule
VULKAN_HPP_TYPESAFE_EXPLICIT ShaderModule(VkShaderModule shaderModule) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6982

VULKAN_HPP_NAMESPACE::MultiDrawIndexedInfoEXT
Definition: vulkan_structs.hpp:47334

VULKAN_HPP_NAMESPACE::SurfaceKHR
Definition: vulkan_handles.hpp:1565

VULKAN_HPP_NAMESPACE::Device::destroyDescriptorPool
void destroyDescriptorPool(VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate::operator!=
bool operator!=(DescriptorUpdateTemplate const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3047

VULKAN_HPP_NAMESPACE::DrmFormatModifierProperties2EXT
Definition: vulkan_structs.hpp:29671

VULKAN_HPP_NAMESPACE::DescriptorSetLayout
Definition: vulkan_handles.hpp:6375

VULKAN_HPP_NAMESPACE::Device::getImageSubresourceLayout
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

VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT::operator<
bool operator<(DebugReportCallbackEXT const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:1695

VULKAN_HPP_NAMESPACE::SemaphoreGetFdInfoKHR
Definition: vulkan_structs.hpp:91271

VULKAN_HPP_NAMESPACE::DescriptorSet::operator==
bool operator==(DescriptorSet const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2529

VULKAN_HPP_NAMESPACE::ObjectType::eSurfaceKHR

VULKAN_HPP_NAMESPACE::CommandBuffer::bindVertexBuffers2EXT
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

VULKAN_HPP_NAMESPACE::Device::mergeValidationCachesEXT
VULKAN_HPP_NODISCARD Result mergeValidationCachesEXT(VULKAN_HPP_NAMESPACE::ValidationCacheEXT dstCache, uint32_t srcCacheCount, const VULKAN_HPP_NAMESPACE::ValidationCacheEXT *pSrcCaches, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Fence::NativeType
VkFence NativeType
Definition: vulkan_handles.hpp:2079

VULKAN_HPP_NAMESPACE::CommandBuffer::setRasterizerDiscardEnableEXT
void setRasterizerDiscardEnableEXT(VULKAN_HPP_NAMESPACE::Bool32 rasterizerDiscardEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::PrivateDataSlot::operator=
PrivateDataSlot & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6653

VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT
Definition: vulkan_structs.hpp:12243

VULKAN_HPP_NAMESPACE::ImageBlit2
Definition: vulkan_structs.hpp:9387

VULKAN_HPP_NAMESPACE::ImageView::operator=
ImageView & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2605

VULKAN_HPP_NAMESPACE::enumerateInstanceVersion
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result enumerateInstanceVersion(uint32_t *pApiVersion, Dispatch const &d) VULKAN_HPP_NOEXCEPT
Definition: vulkan_funcs.hpp:5182

VULKAN_HPP_NAMESPACE::ImageView::NativeType
VkImageView NativeType
Definition: vulkan_handles.hpp:2586

VULKAN_HPP_NAMESPACE::PhysicalDevice::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:13728

VULKAN_HPP_NAMESPACE::CommandBuffer::copyMemoryIndirectNV
void copyMemoryIndirectNV(VULKAN_HPP_NAMESPACE::DeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::CommandBuffer::resetEvent
void resetEvent(VULKAN_HPP_NAMESPACE::Event event, VULKAN_HPP_NAMESPACE::PipelineStageFlags stageMask, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::SurfaceFormatKHR
Definition: vulkan_structs.hpp:94996

VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion::NativeType
VkSamplerYcbcrConversion NativeType
Definition: vulkan_handles.hpp:6884

VULKAN_HPP_NAMESPACE::DeviceAddress
uint64_t DeviceAddress
Definition: vulkan.hpp:6074

VULKAN_HPP_NAMESPACE::PhysicalDeviceTimelineSemaphoreFeatures
Definition: vulkan_structs.hpp:73996

VULKAN_HPP_NAMESPACE::RenderPassTransformBeginInfoQCOM
Definition: vulkan_structs.hpp:89171

VULKAN_HPP_NAMESPACE::MemoryAllocateInfo
Definition: vulkan_structs.hpp:44760

VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderImageAtomicInt64FeaturesEXT
Definition: vulkan_structs.hpp:71125

VULKAN_HPP_NAMESPACE::Instance::NativeType
VkInstance NativeType
Definition: vulkan_handles.hpp:13784

VULKAN_HPP_NAMESPACE::CommandBuffer::setEvent2KHR
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

VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateFeaturesKHR
Definition: vulkan_structs.hpp:58234

VULKAN_HPP_NAMESPACE::PhysicalDevice::getExternalBufferPropertiesKHR
void getExternalBufferPropertiesKHR(const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo *pExternalBufferInfo, VULKAN_HPP_NAMESPACE::ExternalBufferProperties *pExternalBufferProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE
Definition: vulkan_structs.hpp:54272

VULKAN_HPP_NAMESPACE::Image::operator=
Image & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2775

VULKAN_HPP_NAMESPACE::PhysicalDeviceRayQueryFeaturesKHR
Definition: vulkan_structs.hpp:67866

VULKAN_HPP_NAMESPACE::Device::resetQueryPool
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

VULKAN_HPP_NAMESPACE::Framebuffer::operator==
bool operator==(Framebuffer const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6495

VULKAN_HPP_NAMESPACE::ImageResolve2
Definition: vulkan_structs.hpp:40180

VULKAN_HPP_NAMESPACE::Image::Image
VULKAN_HPP_CONSTEXPR Image(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2764

VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiDrawPropertiesEXT
Definition: vulkan_structs.hpp:63603

VULKAN_HPP_NAMESPACE::CommandBufferInheritanceRenderingInfo
Definition: vulkan_structs.hpp:13932

VULKAN_HPP_NAMESPACE::Device::createCuFunctionNVXUnique
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< VULKAN_HPP_NAMESPACE::CuFunctionNVX, Dispatch > >::type createCuFunctionNVXUnique(const VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX &createInfo, Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

VULKAN_HPP_NAMESPACE::Rect2D
Definition: vulkan_structs.hpp:7172

VULKAN_HPP_NAMESPACE::Device::bindBufferMemory
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS 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

VULKAN_HPP_NAMESPACE::MemoryGetRemoteAddressInfoNV
Definition: vulkan_structs.hpp:45452

VULKAN_HPP_NAMESPACE::CuFunctionNVX::CuFunctionNVX
VULKAN_HPP_TYPESAFE_EXPLICIT CuFunctionNVX(VkCuFunctionNVX cuFunctionNVX) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6133

VULKAN_HPP_NAMESPACE::PrivateDataSlot::debugReportObjectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
Definition: vulkan_handles.hpp:6637

VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT
Definition: vulkan_structs.hpp:92330

VULKAN_HPP_NAMESPACE::CommandBuffer::setViewportSwizzleNV
void setViewportSwizzleNV(uint32_t firstViewport, uint32_t viewportCount, const VULKAN_HPP_NAMESPACE::ViewportSwizzleNV *pViewportSwizzles, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::ObjectType
ObjectType
Definition: vulkan_enums.hpp:1058

VULKAN_HPP_NAMESPACE::Device::waitForPresentKHR
VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result waitForPresentKHR(VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, uint64_t presentId, uint64_t timeout, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

VULKAN_HPP_NAMESPACE::ObjectType::eDisplayModeKHR

VULKAN_HPP_NAMESPACE::PipelineRasterizationConservativeStateCreateInfoEXT
Definition: vulkan_structs.hpp:80467

VULKAN_HPP_NAMESPACE::Device::destroyPrivateDataSlotEXT
void destroyPrivateDataSlotEXT(VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance4Properties
Definition: vulkan_structs.hpp:62242

VULKAN_HPP_NAMESPACE::CommandBuffer::setFragmentShadingRateEnumNV
void setFragmentShadingRateEnumNV(VULKAN_HPP_NAMESPACE::FragmentShadingRateNV shadingRate, const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2], Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::FilterCubicImageViewImageFormatPropertiesEXT
Definition: vulkan_structs.hpp:33225

VULKAN_HPP_NAMESPACE::MicromapEXT::objectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
Definition: vulkan_handles.hpp:3275

VULKAN_HPP_NAMESPACE::DescriptorSetLayout::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6436

VULKAN_HPP_NAMESPACE::CommandBuffer::beginDebugUtilsLabelEXT
void beginDebugUtilsLabelEXT(const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT *pLabelInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE
Definition: vulkan_structs.hpp:48771

VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderBarycentricPropertiesKHR
Definition: vulkan_structs.hpp:57796

VULKAN_HPP_NAMESPACE::Fence::operator==
bool operator==(Fence const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2107

VULKAN_HPP_NAMESPACE::Device::updateDescriptorSetWithTemplate
void updateDescriptorSetWithTemplate(VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet, VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, const void *pData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::PhysicalDevice::createDevice
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

VULKAN_HPP_NAMESPACE::PhysicalDevice::getFormatProperties2
void getFormatProperties2(VULKAN_HPP_NAMESPACE::Format format, VULKAN_HPP_NAMESPACE::FormatProperties2 *pFormatProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Queue::beginDebugUtilsLabelEXT
void beginDebugUtilsLabelEXT(const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT *pLabelInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV
Definition: vulkan_structs.hpp:2786

VULKAN_HPP_NAMESPACE::PhysicalDevice::getImageFormatProperties2
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

VULKAN_HPP_NAMESPACE::Device::allocateMemoryUnique
VULKAN_HPP_NODISCARD 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

VULKAN_HPP_NAMESPACE::Device::copyMemoryToAccelerationStructureKHR
VULKAN_HPP_NODISCARD Result copyMemoryToAccelerationStructureKHR(VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Device::getShaderModuleIdentifierEXT
void getShaderModuleIdentifierEXT(VULKAN_HPP_NAMESPACE::ShaderModule shaderModule, VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT *pIdentifier, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::RenderPass::operator==
bool operator==(RenderPass const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6742

VULKAN_HPP_NAMESPACE::DescriptorPool
Definition: vulkan_handles.hpp:6290

VULKAN_HPP_NAMESPACE::DrawMeshTasksIndirectCommandEXT
Definition: vulkan_structs.hpp:29490

VULKAN_HPP_NAMESPACE::DisplayKHR::operator!=
bool operator!=(DisplayKHR const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:1857

VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2221

VULKAN_HPP_NAMESPACE::PhysicalDevice::getToolProperties
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

VULKAN_HPP_NAMESPACE::ExternalMemoryImageCreateInfoNV
Definition: vulkan_structs.hpp:32720

X
X
Definition: ImathEuler.h:183

VULKAN_HPP_NAMESPACE::QueryPool::QueryPool
VULKAN_HPP_CONSTEXPR QueryPool(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2254

VULKAN_HPP_NAMESPACE::Device::getDynamicRenderingTilePropertiesQCOM
Result getDynamicRenderingTilePropertiesQCOM(const VULKAN_HPP_NAMESPACE::RenderingInfo *pRenderingInfo, VULKAN_HPP_NAMESPACE::TilePropertiesQCOM *pProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2
Definition: vulkan_structs.hpp:67095

VULKAN_HPP_NAMESPACE::CommandBuffer::blitImage
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

VULKAN_HPP_NAMESPACE::Device::createDescriptorSetLayoutUnique
VULKAN_HPP_NODISCARD 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

VULKAN_HPP_NAMESPACE::DeviceFaultAddressInfoEXT
Definition: vulkan_structs.hpp:24641

VULKAN_HPP_NAMESPACE::CommandBuffer::beginQueryIndexedEXT
void beginQueryIndexedEXT(VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query, VULKAN_HPP_NAMESPACE::QueryControlFlags flags, uint32_t index, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::RenderPassCreationFeedbackCreateInfoEXT
Definition: vulkan_structs.hpp:88211

VULKAN_HPP_NAMESPACE::BufferView::operator<
bool operator<(BufferView const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:5907

VULKAN_HPP_NAMESPACE::DescriptorSet::DescriptorSet
VULKAN_HPP_CONSTEXPR DescriptorSet(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2509

VULKAN_HPP_NAMESPACE::Fence::Fence
VULKAN_HPP_TYPESAFE_EXPLICIT Fence(VkFence fence) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2088

VULKAN_HPP_NAMESPACE::PresentIdKHR
Definition: vulkan_structs.hpp:83412

VULKAN_HPP_NAMESPACE::PhysicalDeviceIDProperties
Definition: vulkan_structs.hpp:59132

VULKAN_HPP_NAMESPACE::MemoryBarrier
Definition: vulkan_structs.hpp:44863

VULKAN_HPP_NAMESPACE::RenderPass::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6768

VULKAN_HPP_NAMESPACE::DeviceAddressBindingCallbackDataEXT
Definition: vulkan_structs.hpp:22975

VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo
Definition: vulkan_structs.hpp:56226

VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT::operator!=
bool operator!=(DebugUtilsMessengerEXT const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:1778

VULKAN_HPP_NAMESPACE::CommandBuffer::bindIndexBuffer
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

VULKAN_HPP_NAMESPACE::CommandBuffer::bindVertexBuffers
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

VULKAN_HPP_NAMESPACE::AccelerationStructureInstanceKHR
Definition: vulkan_structs.hpp:2509

VULKAN_HPP_NAMESPACE::DeviceGroupBindSparseInfo
Definition: vulkan_structs.hpp:25242

VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingMaintenance1FeaturesKHR
Definition: vulkan_structs.hpp:68150

VULKAN_HPP_NAMESPACE::Device::createPipelineCacheUnique
VULKAN_HPP_NODISCARD 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

VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion::debugReportObjectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
Definition: vulkan_handles.hpp:6887

VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties
Definition: vulkan_structs.hpp:62698

VULKAN_HPP_NAMESPACE::Semaphore::operator<
bool operator<(Semaphore const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2032

VULKAN_HPP_NAMESPACE::PrivateDataSlot::PrivateDataSlot
VULKAN_HPP_TYPESAFE_EXPLICIT PrivateDataSlot(VkPrivateDataSlot privateDataSlot) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6643

VULKAN_HPP_NAMESPACE::RenderPass::operator<
bool operator<(RenderPass const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6752

VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV
Definition: vulkan_structs.hpp:86143

VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate::objectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
Definition: vulkan_handles.hpp:3013

VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo
Definition: vulkan_structs.hpp:13336

VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements
Definition: vulkan_structs.hpp:23107

VULKAN_HPP_NAMESPACE::DescriptorPool::DescriptorPool
VULKAN_HPP_CONSTEXPR DescriptorPool()=default

VULKAN_HPP_NAMESPACE::GeometryDataNV
Definition: vulkan_structs.hpp:1781

image
GLenum GLenum GLsizei void * image
Definition: glad.h:5132

VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderDrawParametersFeatures
Definition: vulkan_structs.hpp:70817

VULKAN_HPP_NAMESPACE::CommandBuffer::endConditionalRenderingEXT
void endConditionalRenderingEXT(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::PhysicalDeviceTransformFeedbackPropertiesEXT
Definition: vulkan_structs.hpp:74389

VULKAN_HPP_NAMESPACE::Queue::getCheckpointDataNV
void getCheckpointDataNV(uint32_t *pCheckpointDataCount, VULKAN_HPP_NAMESPACE::CheckpointDataNV *pCheckpointData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Device::createDescriptorUpdateTemplateUnique
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate, Dispatch > >::type createDescriptorUpdateTemplateUnique(const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo &createInfo, Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

VULKAN_HPP_NAMESPACE::Event
Definition: vulkan_handles.hpp:3096

VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR
Definition: vulkan_structs.hpp:16866

VULKAN_HPP_NAMESPACE::ImportSemaphoreFdInfoKHR
Definition: vulkan_structs.hpp:43022

VULKAN_HPP_NAMESPACE::CommandBuffer::setPrimitiveRestartEnable
void setPrimitiveRestartEnable(VULKAN_HPP_NAMESPACE::Bool32 primitiveRestartEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::ValidationCacheEXT::ValidationCacheEXT
VULKAN_HPP_CONSTEXPR ValidationCacheEXT(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7066

VULKAN_HPP_NAMESPACE::PhysicalDevice16BitStorageFeatures
Definition: vulkan_structs.hpp:49775

VULKAN_HPP_NAMESPACE::CommandBuffer::setViewportWScalingNV
void setViewportWScalingNV(uint32_t firstViewport, uint32_t viewportCount, const VULKAN_HPP_NAMESPACE::ViewportWScalingNV *pViewportWScalings, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Bool32
uint32_t Bool32
Definition: vulkan.hpp:6073

VULKAN_HPP_NAMESPACE::MemoryDedicatedRequirements
Definition: vulkan_structs.hpp:45076

VULKAN_HPP_NAMESPACE::CommandBuffer::setDepthBoundsTestEnableEXT
void setDepthBoundsTestEnableEXT(VULKAN_HPP_NAMESPACE::Bool32 depthBoundsTestEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Device::getGeneratedCommandsMemoryRequirementsNV
void getGeneratedCommandsMemoryRequirementsNV(const VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV *pInfo, VULKAN_HPP_NAMESPACE::MemoryRequirements2 *pMemoryRequirements, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::RenderPassSampleLocationsBeginInfoEXT
Definition: vulkan_structs.hpp:88822

VULKAN_HPP_NAMESPACE::PhysicalDeviceCornerSampledImageFeaturesNV
Definition: vulkan_structs.hpp:52320

VULKAN_HPP_NAMESPACE::CuFunctionNVX::NativeType
VkCuFunctionNVX NativeType
Definition: vulkan_handles.hpp:6124

VULKAN_HPP_NAMESPACE::ImageFormatProperties2
Definition: vulkan_structs.hpp:39495

VULKAN_HPP_NAMESPACE::CommandBuffer::operator!=
bool operator!=(CommandBuffer const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3383

VULKAN_HPP_NAMESPACE::PipelineViewportExclusiveScissorStateCreateInfoNV
Definition: vulkan_structs.hpp:82449

VULKAN_HPP_NAMESPACE::RenderPass::debugReportObjectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
Definition: vulkan_handles.hpp:6717

VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance4Features
Definition: vulkan_structs.hpp:62145

VULKAN_HPP_NAMESPACE::ObjectType::eRenderPass

VULKAN_HPP_NAMESPACE::ClearAttachment
Definition: vulkan_structs.hpp:12695

VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT
Definition: vulkan_handles.hpp:1650

VULKAN_HPP_NAMESPACE::CuFunctionNVX::operator!=
bool operator!=(CuFunctionNVX const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6157

VULKAN_HPP_NAMESPACE::CuFunctionNVX::CuFunctionNVX
VULKAN_HPP_CONSTEXPR CuFunctionNVX()=default

VULKAN_HPP_NAMESPACE::Device::getMemoryFdKHR
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

VULKAN_HPP_NAMESPACE::RenderPass::operator!=
bool operator!=(RenderPass const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6747

VULKAN_HPP_NAMESPACE::PhysicalDevice::getDisplayModeProperties2KHR
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

VULKAN_HPP_NAMESPACE::CommandBuffer::setColorBlendAdvancedEXT
void setColorBlendAdvancedEXT(uint32_t firstAttachment, uint32_t attachmentCount, const VULKAN_HPP_NAMESPACE::ColorBlendAdvancedEXT *pColorBlendAdvanced, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown

VULKAN_HPP_NAMESPACE::QueueFamilyCheckpointPropertiesNV
Definition: vulkan_structs.hpp:84916

VULKAN_HPP_NAMESPACE::BufferView::objectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
Definition: vulkan_handles.hpp:5871

VULKAN_HPP_NAMESPACE::ImageView::objectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
Definition: vulkan_handles.hpp:2588

VULKAN_HPP_NAMESPACE::MemoryAllocateFlagsInfo
Definition: vulkan_structs.hpp:44653

VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR
AccelerationStructureBuildTypeKHR
Definition: vulkan_enums.hpp:5176

VULKAN_HPP_NAMESPACE::DisplayModeKHR::DisplayModeKHR
VULKAN_HPP_CONSTEXPR DisplayModeKHR()=default

VULKAN_HPP_NAMESPACE::CommandBuffer::setPrimitiveRestartEnableEXT
void setPrimitiveRestartEnableEXT(VULKAN_HPP_NAMESPACE::Bool32 primitiveRestartEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion::operator=
SamplerYcbcrConversion & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6906

VULKAN_HPP_NAMESPACE::PhysicalDeviceMutableDescriptorTypeFeaturesEXT
Definition: vulkan_structs.hpp:64183

VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2
Definition: vulkan_structs.hpp:92855

VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState2FeaturesEXT
Definition: vulkan_structs.hpp:55286

sampler
GLuint sampler
Definition: glcorearb.h:1656

VULKAN_HPP_NAMESPACE::PhysicalDeviceFaultFeaturesEXT
Definition: vulkan_structs.hpp:56708

VULKAN_HPP_NAMESPACE::AccelerationStructureNV::operator==
bool operator==(AccelerationStructureNV const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2872

VULKAN_HPP_NAMESPACE::CommandBuffer::drawMeshTasksNV
void drawMeshTasksNV(uint32_t taskCount, uint32_t firstTask, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::ObjectType::ePipelineLayout

VULKAN_HPP_NAMESPACE::Instance::Instance
VULKAN_HPP_CONSTEXPR Instance()=default

VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR
Definition: vulkan_structs.hpp:95067

VULKAN_HPP_NAMESPACE::AccelerationStructureNV
Definition: vulkan_handles.hpp:2837

VULKAN_HPP_NAMESPACE::PhysicalDevice::getPresentRectanglesKHR
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

VULKAN_HPP_NAMESPACE::PipelineCompilerControlCreateInfoAMD
Definition: vulkan_structs.hpp:78295

VULKAN_HPP_NAMESPACE::PipelineCache::objectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
Definition: vulkan_handles.hpp:6041

VULKAN_HPP_NAMESPACE::Event::operator!=
bool operator!=(Event const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3133

VULKAN_HPP_NAMESPACE::PrivateDataSlot::operator!=
bool operator!=(PrivateDataSlot const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6667

VULKAN_HPP_NAMESPACE::Event::debugReportObjectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
Definition: vulkan_handles.hpp:3103

VULKAN_HPP_NAMESPACE::PhysicalDeviceProvokingVertexFeaturesEXT
Definition: vulkan_structs.hpp:67359

VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesList2EXT
Definition: vulkan_structs.hpp:29825

VULKAN_HPP_NAMESPACE::Device::copyMemoryToMicromapEXT
VULKAN_HPP_NODISCARD Result copyMemoryToMicromapEXT(VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, const VULKAN_HPP_NAMESPACE::CopyMemoryToMicromapInfoEXT *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Semaphore::NativeType
VkSemaphore NativeType
Definition: vulkan_handles.hpp:1994

VULKAN_HPP_NAMESPACE::DisplayModeKHR::debugReportObjectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
Definition: vulkan_handles.hpp:12311

VULKAN_HPP_NAMESPACE::Device::createGraphicsPipelinesUnique
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

VULKAN_HPP_NAMESPACE::PhysicalDevice::getCalibrateableTimeDomainsEXT
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

VULKAN_HPP_NAMESPACE::PhysicalDeviceFloatControlsProperties
Definition: vulkan_structs.hpp:56913

VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryInstancesDataKHR
Definition: vulkan_structs.hpp:418

VULKAN_HPP_NAMESPACE::PhysicalDevice::PhysicalDevice
PhysicalDevice(VkPhysicalDevice physicalDevice) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:12412

VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineRobustnessFeaturesEXT
Definition: vulkan_structs.hpp:65607

VULKAN_HPP_NAMESPACE::Queue::Queue
Queue(VkQueue queue) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7238

VULKAN_HPP_NAMESPACE::Device::acquireNextImageKHR
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

VULKAN_HPP_NAMESPACE::Image::operator<
bool operator<(Image const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2794

VULKAN_HPP_NAMESPACE::Device::getMemoryCommitment
void getMemoryCommitment(VULKAN_HPP_NAMESPACE::DeviceMemory memory, VULKAN_HPP_NAMESPACE::DeviceSize *pCommittedMemoryInBytes, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassShadingPropertiesHUAWEI
Definition: vulkan_structs.hpp:73317

VULKAN_HPP_NAMESPACE::PhysicalDevice::getDisplayPlaneCapabilities2KHR
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

VULKAN_HPP_NAMESPACE::CommandBuffer::debugMarkerInsertEXT
void debugMarkerInsertEXT(const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT *pMarkerInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::PhysicalDevice::getFormatProperties
void getFormatProperties(VULKAN_HPP_NAMESPACE::Format format, VULKAN_HPP_NAMESPACE::FormatProperties *pFormatProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::ImageSwapchainCreateInfoKHR
Definition: vulkan_structs.hpp:40609

VULKAN_HPP_NAMESPACE::PhysicalDevice::getSurfaceCapabilitiesKHR
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

VULKAN_HPP_NAMESPACE::Queue::operator=
Queue & operator=(VkQueue queue) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7240

VULKAN_HPP_NAMESPACE::BufferMemoryBarrier
Definition: vulkan_structs.hpp:11567

VULKAN_HPP_NAMESPACE::PhysicalDeviceShadingRateImageFeaturesNV
Definition: vulkan_structs.hpp:72474

VULKAN_HPP_NAMESPACE::DescriptorSetLayout::DescriptorSetLayout
VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSetLayout(VkDescriptorSetLayout descriptorSetLayout) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6388

VULKAN_HPP_NAMESPACE::Queue::operator=
Queue & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7246

VULKAN_HPP_NAMESPACE::ImageView::debugReportObjectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
Definition: vulkan_handles.hpp:2589

VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR
Definition: vulkan_structs.hpp:2256

VULKAN_HPP_NAMESPACE::Device::getGroupPeerMemoryFeatures
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

VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT::NativeType
VkDebugReportCallbackEXT NativeType
Definition: vulkan_handles.hpp:1654

buffer
GLuint buffer
Definition: glcorearb.h:660

VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6609

VULKAN_HPP_NAMESPACE::QueueFamilyProperties2
Definition: vulkan_structs.hpp:85207

VULKAN_HPP_NAMESPACE::ImageViewSampleWeightCreateInfoQCOM
Definition: vulkan_structs.hpp:41352

VULKAN_HPP_NAMESPACE::ImageSubresourceLayers
Definition: vulkan_structs.hpp:9282

VULKAN_HPP_NAMESPACE::DescriptorSetLayout::operator<
bool operator<(DescriptorSetLayout const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6420

VULKAN_HPP_NAMESPACE::Device::createPrivateDataSlotUnique
VULKAN_HPP_NODISCARD 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

VULKAN_HPP_NAMESPACE::Device::createBuffer
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

VULKAN_HPP_NAMESPACE::ObjectType::eCuFunctionNVX

VULKAN_HPP_NAMESPACE::Queue::operator!=
bool operator!=(Queue const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7260

VULKAN_HPP_NAMESPACE::CommandBuffer::writeAccelerationStructuresPropertiesKHR
void writeAccelerationStructuresPropertiesKHR(uint32_t accelerationStructureCount, const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR *pAccelerationStructures, VULKAN_HPP_NAMESPACE::QueryType queryType, VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::CommandBuffer::setPerformanceOverrideINTEL
VULKAN_HPP_NODISCARD Result setPerformanceOverrideINTEL(const VULKAN_HPP_NAMESPACE::PerformanceOverrideInfoINTEL *pOverrideInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT
Definition: vulkan_structs.hpp:18604

VULKAN_HPP_NAMESPACE::PrivateDataSlot
Definition: vulkan_handles.hpp:6630

VULKAN_HPP_NAMESPACE::CommandBuffer::drawIndexedIndirectCount
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

VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT::DebugReportCallbackEXT
VULKAN_HPP_CONSTEXPR DebugReportCallbackEXT(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:1662

VULKAN_HPP_NAMESPACE::SurfaceProtectedCapabilitiesKHR
Definition: vulkan_structs.hpp:95345

VULKAN_HPP_NAMESPACE::CommandBuffer::debugMarkerEndEXT
void debugMarkerEndEXT(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::DisplayKHR::operator=
DisplayKHR & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:1843

VULKAN_HPP_NAMESPACE::CommandBuffer::traceRaysIndirect2KHR
void traceRaysIndirect2KHR(VULKAN_HPP_NAMESPACE::DeviceAddress indirectDeviceAddress, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo
Definition: vulkan_structs.hpp:84465

VULKAN_HPP_NAMESPACE::AccelerationStructureKHR::operator<
bool operator<(AccelerationStructureKHR const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3226

VULKAN_HPP_NAMESPACE::QueryPool::QueryPool
VULKAN_HPP_TYPESAFE_EXPLICIT QueryPool(VkQueryPool queryPool) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2255

VULKAN_HPP_NAMESPACE::ExternalFenceProperties
Definition: vulkan_structs.hpp:32074

VULKAN_HPP_NAMESPACE::Framebuffer::Framebuffer
VULKAN_HPP_TYPESAFE_EXPLICIT Framebuffer(VkFramebuffer framebuffer) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6476

VULKAN_HPP_NAMESPACE::CommandBuffer::setCoverageModulationModeNV
void setCoverageModulationModeNV(VULKAN_HPP_NAMESPACE::CoverageModulationModeNV coverageModulationMode, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::CommandBuffer::buildAccelerationStructuresKHR
void buildAccelerationStructuresKHR(uint32_t infoCount, const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR *pInfos, const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR *const *ppBuildRangeInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::CommandBuffer::dispatchBase
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

VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClipControlFeaturesEXT
Definition: vulkan_structs.hpp:52908

VULKAN_HPP_NAMESPACE::PhysicalDeviceTextureCompressionASTCHDRFeatures
Definition: vulkan_structs.hpp:73799

VULKAN_HPP_NAMESPACE::CommandBuffer::writeTimestamp
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

VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapFeaturesEXT
Definition: vulkan_structs.hpp:57291

VULKAN_HPP_NAMESPACE::Device::createIndirectCommandsLayoutNVUnique
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV, Dispatch > >::type createIndirectCommandsLayoutNVUnique(const VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV &createInfo, Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

VULKAN_HPP_NAMESPACE::Device::createDescriptorUpdateTemplateKHR
VULKAN_HPP_NODISCARD Result createDescriptorUpdateTemplateKHR(const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo *pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate *pDescriptorUpdateTemplate, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::SwapchainKHR::NativeType
VkSwapchainKHR NativeType
Definition: vulkan_handles.hpp:1909

VULKAN_HPP_NAMESPACE::ObjectType::eDeferredOperationKHR

VULKAN_HPP_NAMESPACE::Device::acquirePerformanceConfigurationINTEL
VULKAN_HPP_NODISCARD Result acquirePerformanceConfigurationINTEL(const VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL *pAcquireInfo, VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL *pConfiguration, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::BufferView::BufferView
VULKAN_HPP_CONSTEXPR BufferView()=default

VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsFeaturesNV
Definition: vulkan_structs.hpp:54372

VULKAN_HPP_NAMESPACE::CuModuleNVX::operator!=
bool operator!=(CuModuleNVX const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6242

VULKAN_HPP_NAMESPACE::PresentInfoKHR
Definition: vulkan_structs.hpp:83529

VULKAN_HPP_NAMESPACE::Event::operator==
bool operator==(Event const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3128

VULKAN_HPP_NAMESPACE::CommandBuffer::setDepthBiasEnableEXT
void setDepthBiasEnableEXT(VULKAN_HPP_NAMESPACE::Bool32 depthBiasEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::BindVertexBufferIndirectCommandNV
Definition: vulkan_structs.hpp:9054

VULKAN_HPP_NAMESPACE::Fence::Fence
VULKAN_HPP_CONSTEXPR Fence(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2087

VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT::NativeType
VkDebugUtilsMessengerEXT NativeType
Definition: vulkan_handles.hpp:1742

VULKAN_HPP_NAMESPACE::Device::destroyShaderModule
void destroyShaderModule(VULKAN_HPP_NAMESPACE::ShaderModule shaderModule, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Sampler::operator==
bool operator==(Sampler const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6827

VULKAN_HPP_NAMESPACE::BindImagePlaneMemoryInfo
Definition: vulkan_structs.hpp:7645

VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorPropertiesEXT
Definition: vulkan_structs.hpp:74851

VULKAN_HPP_NAMESPACE::Device::getPipelineCacheData
VULKAN_HPP_NODISCARD Result getPipelineCacheData(VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, size_t *pDataSize, void *pData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::DisplayKHR::DisplayKHR
VULKAN_HPP_CONSTEXPR DisplayKHR()=default

VULKAN_HPP_NAMESPACE::ImageCopy2
Definition: vulkan_structs.hpp:16290

VULKAN_HPP_NAMESPACE::Pipeline::debugReportObjectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
Definition: vulkan_handles.hpp:2674

VULKAN_HPP_NAMESPACE::SwapchainDisplayNativeHdrCreateInfoAMD
Definition: vulkan_structs.hpp:95860

VULKAN_HPP_NAMESPACE::Device::destroyPipeline
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

VULKAN_HPP_NAMESPACE::DeviceMemory::DeviceMemory
VULKAN_HPP_CONSTEXPR DeviceMemory()=default

VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2
Definition: vulkan_structs.hpp:40318

VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixPropertiesNV
Definition: vulkan_structs.hpp:52057

VULKAN_HPP_NAMESPACE::ResolveImageInfo2
Definition: vulkan_structs.hpp:89856

VULKAN_HPP_NAMESPACE::PhysicalDeviceDiagnosticsConfigFeaturesNV
Definition: vulkan_structs.hpp:54705

VULKAN_HPP_NAMESPACE::SurfaceKHR::objectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
Definition: vulkan_handles.hpp:1571

VULKAN_HPP_NAMESPACE::Device::createRenderPass2KHRUnique
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< VULKAN_HPP_NAMESPACE::RenderPass, Dispatch > >::type createRenderPass2KHRUnique(const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 &createInfo, Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

VULKAN_HPP_NAMESPACE::Device::operator==
bool operator==(Device const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7759

VULKAN_HPP_NAMESPACE::CopyAccelerationStructureModeKHR
CopyAccelerationStructureModeKHR
Definition: vulkan_enums.hpp:5256

VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateEntry
Definition: vulkan_structs.hpp:22636

VULKAN_HPP_NAMESPACE::Queue::submit2
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

VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo
Definition: vulkan_structs.hpp:21330

VULKAN_HPP_NAMESPACE::ColorBlendAdvancedEXT
Definition: vulkan_structs.hpp:13088

VULKAN_HPP_NAMESPACE::Device::getBufferOpaqueCaptureAddressKHR
uint64_t getBufferOpaqueCaptureAddressKHR(const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::ShaderModule::debugReportObjectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
Definition: vulkan_handles.hpp:6976

VULKAN_HPP_NAMESPACE::PhysicalDevice::getSurfaceCapabilities2KHR
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

VULKAN_HPP_NAMESPACE::Device::copyMicromapEXT
VULKAN_HPP_NODISCARD Result copyMicromapEXT(VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, const VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::CommandBuffer::endRenderPass2
void endRenderPass2(const VULKAN_HPP_NAMESPACE::SubpassEndInfo *pSubpassEndInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderFeaturesNV
Definition: vulkan_structs.hpp:67962

VULKAN_HPP_NAMESPACE::PipelineLayout
Definition: vulkan_handles.hpp:2412

VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV
Definition: vulkan_structs.hpp:82577

VULKAN_HPP_NAMESPACE::PipelineSampleLocationsStateCreateInfoEXT
Definition: vulkan_structs.hpp:81557

VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport
Definition: vulkan_structs.hpp:22340

VULKAN_HPP_NAMESPACE::PhysicalDevice::getProperties2KHR
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain< X, Y, Z...> getProperties2KHR() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:14360

VULKAN_HPP_NAMESPACE::MicromapEXT::operator==
bool operator==(MicromapEXT const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3301

VULKAN_HPP_NAMESPACE::MemoryGetFdInfoKHR
Definition: vulkan_structs.hpp:45345

VULKAN_HPP_NAMESPACE::Device::getEventStatus
VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result getEventStatus(VULKAN_HPP_NAMESPACE::Event event, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

offsets
GLuint GLsizei const GLuint const GLintptr * offsets
Definition: glcorearb.h:2621

VULKAN_HPP_NAMESPACE::CommandBuffer::copyBufferToImage2
void copyBufferToImage2(const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 *pCopyBufferToImageInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Device::getPrivateDataEXT
void getPrivateDataEXT(VULKAN_HPP_NAMESPACE::ObjectType objectType, uint64_t objectHandle, VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, uint64_t *pData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::CommandBuffer::cuLaunchKernelNVX
void cuLaunchKernelNVX(const VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX *pLaunchInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::BindBufferMemoryDeviceGroupInfo
Definition: vulkan_structs.hpp:6845

VULKAN_HPP_NAMESPACE::Sampler::Sampler
VULKAN_HPP_TYPESAFE_EXPLICIT Sampler(VkSampler sampler) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6808

VULKAN_HPP_NAMESPACE::CommandBuffer::drawIndirect
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

VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo
Definition: vulkan_structs.hpp:77785

VULKAN_HPP_NAMESPACE::IndexType
IndexType
Definition: vulkan_enums.hpp:3114

Z
Definition: UI_DeviceEvent.h:55

VULKAN_HPP_NAMESPACE::RenderingFragmentDensityMapAttachmentInfoEXT
Definition: vulkan_structs.hpp:89421

event
struct _cl_event * event
Definition: glcorearb.h:2961

VULKAN_HPP_NAMESPACE::MutableDescriptorTypeListEXT
Definition: vulkan_structs.hpp:47814

VULKAN_HPP_NAMESPACE::PipelineFragmentShadingRateEnumStateCreateInfoNV
Definition: vulkan_structs.hpp:79643

VULKAN_HPP_NAMESPACE::Event::NativeType
VkEvent NativeType
Definition: vulkan_handles.hpp:3100

VULKAN_HPP_NAMESPACE::SwapchainKHR::SwapchainKHR
VULKAN_HPP_TYPESAFE_EXPLICIT SwapchainKHR(VkSwapchainKHR swapchainKHR) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:1918

VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV
Definition: vulkan_structs.hpp:6678

VULKAN_HPP_NAMESPACE::SamplerCaptureDescriptorDataInfoEXT
Definition: vulkan_structs.hpp:90143

VULKAN_HPP_NAMESPACE::PhysicalDevice::getExternalSemaphorePropertiesKHR
void getExternalSemaphorePropertiesKHR(const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo *pExternalSemaphoreInfo, VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties *pExternalSemaphoreProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Device::getImageOpaqueCaptureDescriptorDataEXT
VULKAN_HPP_NODISCARD Result getImageOpaqueCaptureDescriptorDataEXT(const VULKAN_HPP_NAMESPACE::ImageCaptureDescriptorDataInfoEXT *pInfo, void *pData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::CommandBuffer::draw
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

VULKAN_HPP_NAMESPACE::MemoryPriorityAllocateInfoEXT
Definition: vulkan_structs.hpp:46037

VULKAN_HPP_NAMESPACE::Device::createComputePipelinesUnique
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

VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM
Definition: vulkan_structs.hpp:57515

VULKAN_HPP_NAMESPACE::ClearDepthStencilValue
Definition: vulkan_structs.hpp:12566

VULKAN_HPP_NAMESPACE::ExportSemaphoreCreateInfo
Definition: vulkan_structs.hpp:31622

VULKAN_HPP_NAMESPACE::Queue
Definition: vulkan_handles.hpp:7225

VULKAN_HPP_NAMESPACE::Device::getCalibratedTimestampsEXT
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

VULKAN_HPP_NAMESPACE::DisplayPlaneInfo2KHR
Definition: vulkan_structs.hpp:28427

VULKAN_HPP_NAMESPACE::CommandBuffer::blitImage2
void blitImage2(const VULKAN_HPP_NAMESPACE::BlitImageInfo2 *pBlitImageInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::DescriptorSetVariableDescriptorCountLayoutSupport
Definition: vulkan_structs.hpp:22550

VULKAN_HPP_NAMESPACE::PhysicalDeviceRGBA10X6FormatsFeaturesEXT
Definition: vulkan_structs.hpp:67637

VULKAN_HPP_NAMESPACE::DeviceMemory::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:5585

VULKAN_HPP_NAMESPACE::Device::waitIdle
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type waitIdle(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

VULKAN_HPP_NAMESPACE::PhysicalDeviceDiscardRectanglePropertiesEXT
Definition: vulkan_structs.hpp:54803

VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV::operator==
bool operator==(IndirectCommandsLayoutNV const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6583

VULKAN_HPP_NAMESPACE::Flags
Definition: vulkan.hpp:384

VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL::NativeType
VkPerformanceConfigurationINTEL NativeType
Definition: vulkan_handles.hpp:2164

VULKAN_HPP_NAMESPACE::StridedArrayProxy
Definition: vulkan.hpp:851

VULKAN_HPP_NAMESPACE::CommandBuffer
Definition: vulkan_handles.hpp:3348

VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorIndexingFeatures
Definition: vulkan_structs.hpp:53702

VULKAN_HPP_NAMESPACE::PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT
Definition: vulkan_structs.hpp:64917

VULKAN_HPP_NAMESPACE::Fence::objectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
Definition: vulkan_handles.hpp:2081

VULKAN_HPP_NAMESPACE::SubpassDescription2
Definition: vulkan_structs.hpp:87327

VULKAN_HPP_NAMESPACE::PhysicalDeviceBufferDeviceAddressFeatures
Definition: vulkan_structs.hpp:51146

VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionInfo
Definition: vulkan_structs.hpp:90957

VULKAN_HPP_NAMESPACE::Device::getRefreshCycleDurationGOOGLE
VULKAN_HPP_NODISCARD Result getRefreshCycleDurationGOOGLE(VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE *pDisplayTimingProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT
Definition: vulkan_structs.hpp:96758

VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV::NativeType
VkIndirectCommandsLayoutNV NativeType
Definition: vulkan_handles.hpp:6552

VULKAN_HPP_NAMESPACE::Device::destroyAccelerationStructureKHR
void destroyAccelerationStructureKHR(VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::MutableDescriptorTypeCreateInfoEXT
Definition: vulkan_structs.hpp:47920

VULKAN_HPP_NAMESPACE::DeviceMemoryOverallocationCreateInfoAMD
Definition: vulkan_structs.hpp:26729

VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT::operator==
bool operator==(DebugUtilsMessengerEXT const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:1773

VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT::operator=
DebugUtilsMessengerEXT & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:1764

VULKAN_HPP_NAMESPACE::PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV
Definition: vulkan_structs.hpp:52709

VULKAN_HPP_NAMESPACE::Buffer::Buffer
VULKAN_HPP_TYPESAFE_EXPLICIT Buffer(VkBuffer buffer) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2340

VULKAN_HPP_NAMESPACE::MicromapEXT::MicromapEXT
VULKAN_HPP_CONSTEXPR MicromapEXT(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3281

VULKAN_HPP_NAMESPACE::CommandBuffer::copyBufferToImage
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

VULKAN_HPP_NAMESPACE::CommandBuffer::setRasterizationSamplesEXT
void setRasterizationSamplesEXT(VULKAN_HPP_NAMESPACE::SampleCountFlagBits rasterizationSamples, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::AmigoProfilingSubmitInfoSEC
Definition: vulkan_structs.hpp:4296

VULKAN_HPP_NAMESPACE::Device::getImageDrmFormatModifierPropertiesEXT
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

VULKAN_HPP_NAMESPACE::PhysicalDevice::getDrmDisplayEXTUnique
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch > >::type getDrmDisplayEXTUnique(int32_t drmFd, uint32_t connectorId, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

VULKAN_HPP_NAMESPACE::Device::Device
VULKAN_HPP_CONSTEXPR Device()=default

VULKAN_HPP_NAMESPACE::DirectDriverLoadingInfoLUNARG
Definition: vulkan_structs.hpp:27253

VULKAN_HPP_NAMESPACE::Device::getGroupPeerMemoryFeaturesKHR
void getGroupPeerMemoryFeaturesKHR(uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags *pPeerMemoryFeatures, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Pipeline::objectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
Definition: vulkan_handles.hpp:2673

VULKAN_HPP_NAMESPACE::Device::getBufferAddress
DeviceAddress getBufferAddress(const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::CommandBuffer::setStencilCompareMask
void setStencilCompareMask(VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask, uint32_t compareMask, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Device::createSamplerYcbcrConversionUnique
VULKAN_HPP_NODISCARD 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

VULKAN_HPP_NAMESPACE::PhysicalDeviceLinearColorAttachmentFeaturesNV
Definition: vulkan_structs.hpp:61958

VULKAN_HPP_NAMESPACE::DescriptorSet::DescriptorSet
VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSet(VkDescriptorSet descriptorSet) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2510

VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV::objectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
Definition: vulkan_handles.hpp:6554

VULKAN_HPP_NAMESPACE::AccelerationStructureMatrixMotionInstanceNV
Definition: vulkan_structs.hpp:2641

VULKAN_HPP_NAMESPACE::Device::getRayTracingShaderGroupHandleNV
VULKAN_HPP_NODISCARD ResultValueType< DataType >::type getRayTracingShaderGroupHandleNV(VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

VULKAN_HPP_NAMESPACE::CuModuleNVX
Definition: vulkan_handles.hpp:6205

VULKAN_HPP_NAMESPACE::DeviceMemory::operator!=
bool operator!=(DeviceMemory const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:5564

VULKAN_HPP_NAMESPACE::Device::getBufferMemoryRequirements
void getBufferMemoryRequirements(VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::MemoryRequirements *pMemoryRequirements, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::OpaqueCaptureDescriptorDataCreateInfoEXT
Definition: vulkan_structs.hpp:48055

VULKAN_HPP_NAMESPACE::Fence::operator!=
bool operator!=(Fence const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2112

VULKAN_HPP_NAMESPACE::Device::getImageViewOpaqueCaptureDescriptorDataEXT
VULKAN_HPP_NODISCARD Result getImageViewOpaqueCaptureDescriptorDataEXT(const VULKAN_HPP_NAMESPACE::ImageViewCaptureDescriptorDataInfoEXT *pInfo, void *pData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Device::createBufferUnique
VULKAN_HPP_NODISCARD 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

VULKAN_HPP_NAMESPACE::QueryPool::QueryPool
VULKAN_HPP_CONSTEXPR QueryPool()=default

VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR
Definition: vulkan_structs.hpp:79563

VULKAN_HPP_NAMESPACE::DescriptorSet::DescriptorSet
VULKAN_HPP_CONSTEXPR DescriptorSet()=default

VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion
Definition: vulkan_handles.hpp:6880

VULKAN_HPP_NAMESPACE::Buffer::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2385

VULKAN_HPP_NAMESPACE::SurfaceCounterFlagBitsEXT
SurfaceCounterFlagBitsEXT
Definition: vulkan_enums.hpp:4858

VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryDecompressionPropertiesNV
Definition: vulkan_structs.hpp:62513

height
GLint GLsizei GLsizei height
Definition: glcorearb.h:103

VULKAN_HPP_NAMESPACE::Device::createGraphicsPipelineUnique
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

VULKAN_HPP_NAMESPACE::BufferView::operator!=
bool operator!=(BufferView const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:5902

VULKAN_HPP_NAMESPACE::DescriptorSet::objectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
Definition: vulkan_handles.hpp:2503

VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3068

VULKAN_HPP_NAMESPACE::Device::getPipelineExecutablePropertiesKHR
VULKAN_HPP_NODISCARD Result getPipelineExecutablePropertiesKHR(const VULKAN_HPP_NAMESPACE::PipelineInfoKHR *pPipelineInfo, uint32_t *pExecutableCount, VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR *pProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Queue::operator==
bool operator==(Queue const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7255

VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixFeaturesNV
Definition: vulkan_structs.hpp:51948

VULKAN_HPP_NAMESPACE::Device::destroyCuModuleNVX
void destroyCuModuleNVX(VULKAN_HPP_NAMESPACE::CuModuleNVX module, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL
Definition: vulkan_structs.hpp:49226

VULKAN_HPP_NAMESPACE::PhysicalDevice::operator==
bool operator==(PhysicalDevice const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:12429

VULKAN_HPP_NAMESPACE::PhysicalDeviceConservativeRasterizationPropertiesEXT
Definition: vulkan_structs.hpp:51812

VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceMemoryReportFeaturesEXT
Definition: vulkan_structs.hpp:54607

VULKAN_HPP_NAMESPACE::Pipeline::NativeType
VkPipeline NativeType
Definition: vulkan_handles.hpp:2671

VULKAN_HPP_NAMESPACE::CommandBuffer::drawMeshTasksIndirectCountEXT
void drawMeshTasksIndirectCountEXT(VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, VULKAN_HPP_NAMESPACE::Buffer countBuffer, VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::operator<
bool operator<(std::string const &lhs, ArrayWrapper1D< char, N > const &rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:330

VULKAN_HPP_NAMESPACE::PhysicalDeviceConditionalRenderingFeaturesEXT
Definition: vulkan_structs.hpp:51702

VULKAN_HPP_NAMESPACE::Queue::bindSparse
VULKAN_HPP_NODISCARD Result bindSparse(uint32_t bindInfoCount, const VULKAN_HPP_NAMESPACE::BindSparseInfo *pBindInfo, VULKAN_HPP_NAMESPACE::Fence fence, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::CommandBuffer::bindTransformFeedbackBuffersEXT
void bindTransformFeedbackBuffersEXT(uint32_t firstBinding, uint32_t bindingCount, const VULKAN_HPP_NAMESPACE::Buffer *pBuffers, const VULKAN_HPP_NAMESPACE::DeviceSize *pOffsets, const VULKAN_HPP_NAMESPACE::DeviceSize *pSizes, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::CommandBuffer::endTransformFeedbackEXT
void endTransformFeedbackEXT(uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VULKAN_HPP_NAMESPACE::Buffer *pCounterBuffers, const VULKAN_HPP_NAMESPACE::DeviceSize *pCounterBufferOffsets, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Device::createDeferredOperationKHRUnique
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< VULKAN_HPP_NAMESPACE::DeferredOperationKHR, Dispatch > >::type createDeferredOperationKHRUnique(Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

VULKAN_HPP_CONST_OR_CONSTEXPR
#define VULKAN_HPP_CONST_OR_CONSTEXPR
Definition: vulkan.hpp:193

VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR
AccelerationStructureCompatibilityKHR
Definition: vulkan_enums.hpp:5273

VULKAN_HPP_NAMESPACE::ObjectType::eQueue

VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState3PropertiesEXT
Definition: vulkan_structs.hpp:55906

VULKAN_HPP_NAMESPACE::PipelineTessellationDomainOriginStateCreateInfo
Definition: vulkan_structs.hpp:81879

VULKAN_HPP_NAMESPACE::CommandBuffer::setCoverageReductionModeNV
void setCoverageReductionModeNV(VULKAN_HPP_NAMESPACE::CoverageReductionModeNV coverageReductionMode, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Device::getImageSparseMemoryRequirements
void getImageSparseMemoryRequirements(VULKAN_HPP_NAMESPACE::Image image, uint32_t *pSparseMemoryRequirementCount, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements *pSparseMemoryRequirements, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesEXT
Definition: vulkan_structs.hpp:29748

VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryTrianglesDataKHR
Definition: vulkan_structs.hpp:179

VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2
Definition: vulkan_structs.hpp:93027

VULKAN_HPP_NAMESPACE::Device::createSampler
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

VULKAN_HPP_NAMESPACE::Device::createCuModuleNVX
VULKAN_HPP_NODISCARD Result createCuModuleNVX(const VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX *pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, VULKAN_HPP_NAMESPACE::CuModuleNVX *pModule, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::AccelerationStructureVersionInfoKHR
Definition: vulkan_structs.hpp:3830

VULKAN_HPP_NAMESPACE::CommandBuffer::setAlphaToOneEnableEXT
void setAlphaToOneEnableEXT(VULKAN_HPP_NAMESPACE::Bool32 alphaToOneEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

framebuffer
GLuint framebuffer
Definition: glcorearb.h:1287

VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL::operator!=
bool operator!=(PerformanceConfigurationINTEL const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2200

VULKAN_HPP_NAMESPACE::BufferView
Definition: vulkan_handles.hpp:5865

VULKAN_HPP_NAMESPACE::CommandBuffer::waitEvents2KHR
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

VULKAN_HPP_NAMESPACE::DescriptorSetLayout::operator!=
bool operator!=(DescriptorSetLayout const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6415

VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessingPropertiesQCOM
Definition: vulkan_structs.hpp:59962

VULKAN_HPP_NAMESPACE::Device::createRenderPass2KHR
VULKAN_HPP_NODISCARD Result createRenderPass2KHR(const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 *pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, VULKAN_HPP_NAMESPACE::RenderPass *pRenderPass, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Device::destroySemaphore
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

VULKAN_HPP_CONSTEXPR
#define VULKAN_HPP_CONSTEXPR
Definition: vulkan.hpp:191

VULKAN_HPP_NAMESPACE::PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT
Definition: vulkan_structs.hpp:66564

VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorFeaturesEXT
Definition: vulkan_structs.hpp:74741

VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT::operator<
bool operator<(DebugUtilsMessengerEXT const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:1783

VULKAN_HPP_NAMESPACE::Device::createPipelineLayout
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

VULKAN_HPP_NAMESPACE::Device::setLocalDimmingAMD
void setLocalDimmingAMD(VULKAN_HPP_NAMESPACE::SwapchainKHR swapChain, VULKAN_HPP_NAMESPACE::Bool32 localDimmingEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::BufferCopy
Definition: vulkan_structs.hpp:10887

VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerDotProductFeatures
Definition: vulkan_structs.hpp:71332

VULKAN_HPP_NAMESPACE::Device::getPipelinePropertiesEXT
VULKAN_HPP_NODISCARD Result getPipelinePropertiesEXT(const VULKAN_HPP_NAMESPACE::PipelineInfoEXT *pPipelineInfo, VULKAN_HPP_NAMESPACE::BaseOutStructure *pPipelineProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits
ExternalMemoryHandleTypeFlagBits
Definition: vulkan_enums.hpp:3300

offset
GLintptr offset
Definition: glcorearb.h:665

VULKAN_HPP_NAMESPACE::CommandBuffer::pushDescriptorSetKHR
void pushDescriptorSetKHR(VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, VULKAN_HPP_NAMESPACE::PipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VULKAN_HPP_NAMESPACE::WriteDescriptorSet *pDescriptorWrites, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::ShaderModule::operator==
bool operator==(ShaderModule const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7001

VULKAN_HPP_NAMESPACE::CommandBuffer::setDepthClipEnableEXT
void setDepthClipEnableEXT(VULKAN_HPP_NAMESPACE::Bool32 depthClipEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Device::getMicromapBuildSizesEXT
void getMicromapBuildSizesEXT(VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR buildType, const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT *pBuildInfo, VULKAN_HPP_NAMESPACE::MicromapBuildSizesInfoEXT *pSizeInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::DeviceGroupPresentInfoKHR
Definition: vulkan_structs.hpp:25662

VULKAN_HPP_NAMESPACE::DisplayModeKHR::operator<
bool operator<(DisplayModeKHR const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:12346

VULKAN_HPP_NAMESPACE::PhysicalDevice::getSparseImageFormatProperties
void getSparseImageFormatProperties(VULKAN_HPP_NAMESPACE::Format format, VULKAN_HPP_NAMESPACE::ImageType type, VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples, VULKAN_HPP_NAMESPACE::ImageUsageFlags usage, VULKAN_HPP_NAMESPACE::ImageTiling tiling, uint32_t *pPropertyCount, VULKAN_HPP_NAMESPACE::SparseImageFormatProperties *pProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM
Definition: vulkan_structs.hpp:63995

VULKAN_HPP_NAMESPACE::DisplayModeKHR::operator!=
bool operator!=(DisplayModeKHR const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:12341

VULKAN_HPP_NAMESPACE::DescriptorSet
Definition: vulkan_handles.hpp:2497

VULKAN_HPP_NAMESPACE::Device::unmapMemory
void unmapMemory(VULKAN_HPP_NAMESPACE::DeviceMemory memory, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Device::getShaderModuleCreateInfoIdentifierEXT
void getShaderModuleCreateInfoIdentifierEXT(const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo *pCreateInfo, VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT *pIdentifier, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

buffer
Definition: core.h:760

VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkanMemoryModelFeatures
Definition: vulkan_structs.hpp:77217

VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSMBuiltinsFeaturesNV
Definition: vulkan_structs.hpp:71989

VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassShadingFeaturesHUAWEI
Definition: vulkan_structs.hpp:73220

VULKAN_HPP_NAMESPACE::CommandBuffer::debugReportObjectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
Definition: vulkan_handles.hpp:3355

VULKAN_HPP_NAMESPACE::SurfaceKHR::debugReportObjectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
Definition: vulkan_handles.hpp:1572

VULKAN_HPP_NAMESPACE::ShaderStatisticsInfoAMD
Definition: vulkan_structs.hpp:92600

VULKAN_HPP_NAMESPACE::Device::getDescriptorSetLayoutBindingOffsetEXT
void getDescriptorSetLayoutBindingOffsetEXT(VULKAN_HPP_NAMESPACE::DescriptorSetLayout layout, uint32_t binding, VULKAN_HPP_NAMESPACE::DeviceSize *pOffset, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::RenderingAttachmentInfo
Definition: vulkan_structs.hpp:89269

VULKAN_HPP_NAMESPACE::PrivateDataSlot::objectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
Definition: vulkan_handles.hpp:6636

VULKAN_HPP_NAMESPACE::PipelineLayout::debugReportObjectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
Definition: vulkan_handles.hpp:2419

VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
#define VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
Definition: vulkan.hpp:225

VULKAN_HPP_NAMESPACE::Device::destroyDeferredOperationKHR
void destroyDeferredOperationKHR(VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderPropertiesNV
Definition: vulkan_structs.hpp:68062

VULKAN_HPP_NAMESPACE::GeometryAABBNV
Definition: vulkan_structs.hpp:1654

VULKAN_HPP_NAMESPACE::RectLayerKHR
Definition: vulkan_structs.hpp:83750

VULKAN_HPP_NAMESPACE::AccelerationStructureKHR::NativeType
VkAccelerationStructureKHR NativeType
Definition: vulkan_handles.hpp:3185

VULKAN_HPP_NAMESPACE::ImageView::operator!=
bool operator!=(ImageView const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2619

VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingMotionBlurFeaturesNV
Definition: vulkan_structs.hpp:68260

VULKAN_HPP_NAMESPACE::ImageViewCaptureDescriptorDataInfoEXT
Definition: vulkan_structs.hpp:40889

VULKAN_HPP_NAMESPACE::CommandBuffer::buildAccelerationStructureNV
void buildAccelerationStructureNV(const VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV *pInfo, VULKAN_HPP_NAMESPACE::Buffer instanceData, VULKAN_HPP_NAMESPACE::DeviceSize instanceOffset, VULKAN_HPP_NAMESPACE::Bool32 update, VULKAN_HPP_NAMESPACE::AccelerationStructureNV dst, VULKAN_HPP_NAMESPACE::AccelerationStructureNV src, VULKAN_HPP_NAMESPACE::Buffer scratch, VULKAN_HPP_NAMESPACE::DeviceSize scratchOffset, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR
Definition: vulkan_structs.hpp:79287

VULKAN_HPP_NAMESPACE::DirectDriverLoadingListLUNARG
Definition: vulkan_structs.hpp:27358

VULKAN_HPP_NAMESPACE::ImageCopy
Definition: vulkan_structs.hpp:38786

VULKAN_HPP_NAMESPACE::BufferImageCopy
Definition: vulkan_structs.hpp:11292

VULKAN_HPP_NAMESPACE::Pipeline::Pipeline
VULKAN_HPP_TYPESAFE_EXPLICIT Pipeline(VkPipeline pipeline) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2680

VULKAN_HPP_NAMESPACE::PhysicalDeviceSamplerYcbcrConversionFeatures
Definition: vulkan_structs.hpp:69281

VULKAN_HPP_NAMESPACE::Device::getImageMemoryRequirements2KHR
void getImageMemoryRequirements2KHR(const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 *pInfo, VULKAN_HPP_NAMESPACE::MemoryRequirements2 *pMemoryRequirements, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::DisplayPowerInfoEXT
Definition: vulkan_structs.hpp:28688

VULKAN_HPP_NAMESPACE::Instance::createDebugReportCallbackEXT
VULKAN_HPP_NODISCARD Result createDebugReportCallbackEXT(const VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT *pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT *pCallback, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Event::operator<
bool operator<(Event const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3138

VULKAN_HPP_NAMESPACE::DependencyInfo
Definition: vulkan_structs.hpp:20297

VULKAN_HPP_NAMESPACE::Device::operator<
bool operator<(Device const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7769

VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo
Definition: vulkan_structs.hpp:80069

VULKAN_HPP_NAMESPACE::MicromapEXT::operator<
bool operator<(MicromapEXT const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3311

VULKAN_HPP_NAMESPACE::MicromapBuildSizesInfoEXT
Definition: vulkan_structs.hpp:46875

VULKAN_HPP_NAMESPACE::PhysicalDeviceImageViewMinLodFeaturesEXT
Definition: vulkan_structs.hpp:60258

VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewFeatures
Definition: vulkan_structs.hpp:63787

VULKAN_HPP_NAMESPACE::CommandBuffer::operator==
bool operator==(CommandBuffer const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3378

VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessingFeaturesQCOM
Definition: vulkan_structs.hpp:59839

VULKAN_HPP_NAMESPACE::PhysicalDeviceGlobalPriorityQueryFeaturesKHR
Definition: vulkan_structs.hpp:58629

VULKAN_HPP_NAMESPACE::PhysicalDeviceTexelBufferAlignmentFeaturesEXT
Definition: vulkan_structs.hpp:73594

VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT::DebugUtilsMessengerEXT
VULKAN_HPP_CONSTEXPR DebugUtilsMessengerEXT(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:1750

VULKAN_HPP_NAMESPACE::Device::getSubpassShadingMaxWorkgroupSizeHUAWEI
VULKAN_HPP_NODISCARD Result getSubpassShadingMaxWorkgroupSizeHUAWEI(VULKAN_HPP_NAMESPACE::RenderPass renderpass, VULKAN_HPP_NAMESPACE::Extent2D *pMaxWorkgroupSize, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Instance::enumeratePhysicalDevices
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

VULKAN_HPP_NAMESPACE::RemoteAddressNV
void * RemoteAddressNV
Definition: vulkan.hpp:6076

VULKAN_HPP_NAMESPACE::Device::getRenderAreaGranularity
void getRenderAreaGranularity(VULKAN_HPP_NAMESPACE::RenderPass renderPass, VULKAN_HPP_NAMESPACE::Extent2D *pGranularity, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6941

VULKAN_HPP_NAMESPACE::Device::free
void() free(VULKAN_HPP_NAMESPACE::DeviceMemory memory, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Device::destroyBuffer
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

VULKAN_HPP_NAMESPACE::PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR
Definition: vulkan_structs.hpp:77342

VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL::PerformanceConfigurationINTEL
VULKAN_HPP_CONSTEXPR PerformanceConfigurationINTEL()=default

VULKAN_HPP_NAMESPACE::Instance::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:14416

VULKAN_HPP_NAMESPACE::CoarseSampleLocationNV
Definition: vulkan_structs.hpp:12861

VULKAN_HPP_NAMESPACE::PhysicalDevice::getMultisamplePropertiesEXT
void getMultisamplePropertiesEXT(VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples, VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT *pMultisampleProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::SubmitInfo
Definition: vulkan_structs.hpp:93328

VULKAN_HPP_NAMESPACE::DeferredOperationKHR::operator==
bool operator==(DeferredOperationKHR const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:5728

VULKAN_HPP_NAMESPACE::SamplerCreateInfo
Definition: vulkan_structs.hpp:90239

VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion::SamplerYcbcrConversion
VULKAN_HPP_TYPESAFE_EXPLICIT SamplerYcbcrConversion(VkSamplerYcbcrConversion samplerYcbcrConversion) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6893

VULKAN_HPP_NAMESPACE::BufferCopy2
Definition: vulkan_structs.hpp:10980

VULKAN_HPP_NAMESPACE::CommandBuffer::setStencilReference
void setStencilReference(VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask, uint32_t reference, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::CommandBuffer::setEvent
void setEvent(VULKAN_HPP_NAMESPACE::Event event, VULKAN_HPP_NAMESPACE::PipelineStageFlags stageMask, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::SurfaceKHR::NativeType
VkSurfaceKHR NativeType
Definition: vulkan_handles.hpp:1569

VULKAN_HPP_NAMESPACE::PipelineDiscardRectangleStateCreateInfoEXT
Definition: vulkan_structs.hpp:79023

VULKAN_HPP_NAMESPACE::CommandBuffer::setScissorWithCount
void setScissorWithCount(uint32_t scissorCount, const VULKAN_HPP_NAMESPACE::Rect2D *pScissors, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::PhysicalDevice::getDisplayPlanePropertiesKHR
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

VULKAN_HPP_NAMESPACE::Device::destroySamplerYcbcrConversionKHR
void destroySamplerYcbcrConversionKHR(VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Instance::Instance
Instance(VkInstance instance) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:13793

VULKAN_HPP_NAMESPACE::DeviceMemory::NativeType
VkDeviceMemory NativeType
Definition: vulkan_handles.hpp:5531

VULKAN_HPP_NAMESPACE::PresentRegionKHR
Definition: vulkan_structs.hpp:83844

VULKAN_HPP_NAMESPACE::CommandBuffer::drawIndexedIndirectCountKHR
void drawIndexedIndirectCountKHR(VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, VULKAN_HPP_NAMESPACE::Buffer countBuffer, VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Device::bindImageMemory2
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

VULKAN_HPP_NAMESPACE::QueryPoolPerformanceCreateInfoKHR
Definition: vulkan_structs.hpp:84595

VULKAN_HPP_NAMESPACE::PhysicalDevice::getExternalBufferProperties
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

VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements
Definition: vulkan_structs.hpp:92939

VULKAN_HPP_NAMESPACE::PhysicalDevice::getToolPropertiesEXT
VULKAN_HPP_NODISCARD Result getToolPropertiesEXT(uint32_t *pToolCount, VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties *pToolProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::PhysicalDevice::operator=
PhysicalDevice & operator=(VkPhysicalDevice physicalDevice) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:12414

VULKAN_HPP_NAMESPACE::PhysicalDevice::getQueueFamilyProperties2KHR
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector< StructureChain > getQueueFamilyProperties2KHR() const
Definition: vulkan_raii.hpp:14457

VULKAN_HPP_NAMESPACE::CommandBuffer::beginRenderingKHR
void beginRenderingKHR(const VULKAN_HPP_NAMESPACE::RenderingInfo *pRenderingInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::PhysicalDeviceProtectedMemoryProperties
Definition: vulkan_structs.hpp:67276

VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT::DebugReportCallbackEXT
VULKAN_HPP_TYPESAFE_EXPLICIT DebugReportCallbackEXT(VkDebugReportCallbackEXT debugReportCallbackEXT) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:1663

VULKAN_HPP_NAMESPACE::QueueFamilyProperties
Definition: vulkan_structs.hpp:85127

VULKAN_HPP_NAMESPACE::CommandBuffer::setLineWidth
void setLineWidth(float lineWidth, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::SwapchainKHR::SwapchainKHR
VULKAN_HPP_CONSTEXPR SwapchainKHR()=default

VULKAN_HPP_NAMESPACE
#define VULKAN_HPP_NAMESPACE
Definition: vulkan.hpp:229

VULKAN_HPP_NAMESPACE::Device::destroyPipelineCache
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

VULKAN_HPP_NAMESPACE::SubresourceLayout2EXT
Definition: vulkan_structs.hpp:94372

VULKAN_HPP_NAMESPACE::DeviceDiagnosticsConfigCreateInfoNV
Definition: vulkan_structs.hpp:24450

VULKAN_HPP_NAMESPACE::Device::trimCommandPool
void trimCommandPool(VULKAN_HPP_NAMESPACE::CommandPool commandPool, VULKAN_HPP_NAMESPACE::CommandPoolTrimFlags flags, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::ImageViewUsageCreateInfo
Definition: vulkan_structs.hpp:41472

VULKAN_HPP_NAMESPACE::Instance::destroyDebugReportCallbackEXT
void destroyDebugReportCallbackEXT(VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT callback, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Event::Event
VULKAN_HPP_TYPESAFE_EXPLICIT Event(VkEvent event) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3109

VULKAN_HPP_NAMESPACE::CommandBuffer::setDiscardRectangleEXT
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

VULKAN_HPP_NAMESPACE::PresentModeKHR
PresentModeKHR
Definition: vulkan_enums.hpp:3961

VULKAN_HPP_NAMESPACE::ObjectType::eDeviceMemory

VULKAN_HPP_NAMESPACE::ValidationCacheEXT::operator!=
bool operator!=(ValidationCacheEXT const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7093

VULKAN_HPP_NAMESPACE::PhysicalDeviceAccelerationStructurePropertiesKHR
Definition: vulkan_structs.hpp:50395

VULKAN_HPP_NAMESPACE::Instance::createDebugReportCallbackEXTUnique
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT, Dispatch > >::type createDebugReportCallbackEXTUnique(const VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT &createInfo, Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

VULKAN_HPP_NAMESPACE::CommandBuffer::copyMicromapToMemoryEXT
void copyMicromapToMemoryEXT(const VULKAN_HPP_NAMESPACE::CopyMicromapToMemoryInfoEXT *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::CommandBuffer::setDepthCompareOpEXT
void setDepthCompareOpEXT(VULKAN_HPP_NAMESPACE::CompareOp depthCompareOp, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT::operator!=
bool operator!=(DebugReportCallbackEXT const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:1690

VULKAN_HPP_NAMESPACE::AccelerationStructureTrianglesOpacityMicromapEXT
Definition: vulkan_structs.hpp:3620

PFN_vkVoidFunction
void(VKAPI_PTR * PFN_vkVoidFunction)(void)
Definition: vulkan_core.h:2918

VULKAN_HPP_NAMESPACE::Queue::objectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
Definition: vulkan_handles.hpp:7231

VULKAN_HPP_NAMESPACE::PipelineCache::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6093

VULKAN_HPP_NAMESPACE::Framebuffer::objectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
Definition: vulkan_handles.hpp:6469

VULKAN_HPP_NAMESPACE::PhysicalDevice::getExternalFenceProperties
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

VULKAN_HPP_NAMESPACE::PhysicalDeviceProtectedMemoryFeatures
Definition: vulkan_structs.hpp:67179

VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectPropertiesNV
Definition: vulkan_structs.hpp:52237

VULKAN_HPP_NAMESPACE::DisplayKHR
Definition: vulkan_handles.hpp:1820

VULKAN_HPP_NAMESPACE::Buffer::Buffer
VULKAN_HPP_CONSTEXPR Buffer()=default

VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferFeaturesEXT
Definition: vulkan_structs.hpp:53289

VULKAN_HPP_NAMESPACE::MicromapEXT::debugReportObjectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
Definition: vulkan_handles.hpp:3276

VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL
Definition: vulkan_handles.hpp:2160

VULKAN_HPP_NAMESPACE::AttachmentDescriptionStencilLayout
Definition: vulkan_structs.hpp:5545

VULKAN_HPP_NAMESPACE::SurfaceKHR::SurfaceKHR
VULKAN_HPP_CONSTEXPR SurfaceKHR(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:1577

VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcrImageArraysFeaturesEXT
Definition: vulkan_structs.hpp:77586

VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT
Definition: vulkan_structs.hpp:19261

VULKAN_HPP_NAMESPACE::PhysicalDeviceAmigoProfilingFeaturesSEC
Definition: vulkan_structs.hpp:50623

timeout
GLbitfield GLuint64 timeout
Definition: glcorearb.h:1599

VULKAN_HPP_NAMESPACE::ExternalMemoryProperties
Definition: vulkan_structs.hpp:31910

VULKAN_HPP_NAMESPACE::ResultValueType
Definition: vulkan.hpp:6589

VULKAN_HPP_NAMESPACE::Device::getBufferAddressEXT
DeviceAddress getBufferAddressEXT(const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::ImageViewCreateInfo
Definition: vulkan_structs.hpp:40986

VULKAN_HPP_NAMESPACE::PipelineCache::PipelineCache
VULKAN_HPP_CONSTEXPR PipelineCache()=default

VULKAN_HPP_NAMESPACE::PipelineViewportSwizzleStateCreateInfoNV
Definition: vulkan_structs.hpp:82938

VULKAN_HPP_NAMESPACE::Pipeline::operator=
Pipeline & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2690

VULKAN_HPP_NAMESPACE::PhysicalDevice::getSurfaceFormatsKHR
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

VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectFeaturesNV
Definition: vulkan_structs.hpp:52140

VULKAN_HPP_NAMESPACE::ObjectType::eFence

VULKAN_HPP_NAMESPACE::PhysicalDevicePrivateDataFeatures
Definition: vulkan_structs.hpp:66801

VULKAN_HPP_NAMESPACE::Framebuffer::operator<
bool operator<(Framebuffer const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6505

VULKAN_HPP_NAMESPACE::SwapchainKHR
Definition: vulkan_handles.hpp:1905

VULKAN_HPP_NAMESPACE::DisplayKHR::DisplayKHR
VULKAN_HPP_TYPESAFE_EXPLICIT DisplayKHR(VkDisplayKHR displayKHR) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:1833

VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT
DebugReportObjectTypeEXT
Definition: vulkan_enums.hpp:4203

VULKAN_HPP_NAMESPACE::Device::mapMemory
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

VULKAN_HPP_NAMESPACE::Device::createSemaphoreUnique
VULKAN_HPP_NODISCARD 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

VULKAN_HPP_NAMESPACE::Semaphore::debugReportObjectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
Definition: vulkan_handles.hpp:1997

VULKAN_HPP_NAMESPACE::ValidationFlagsEXT
Definition: vulkan_structs.hpp:97067

VULKAN_HPP_TYPESAFE_EXPLICIT
#define VULKAN_HPP_TYPESAFE_EXPLICIT
Definition: vulkan.hpp:179

VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV::operator=
OpticalFlowSessionNV & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2951

VULKAN_HPP_NAMESPACE::CommandBuffer::bindDescriptorBuffersEXT
void bindDescriptorBuffersEXT(uint32_t bufferCount, const VULKAN_HPP_NAMESPACE::DescriptorBufferBindingInfoEXT *pBindingInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::CommandBuffer::copyImage2
void copyImage2(const VULKAN_HPP_NAMESPACE::CopyImageInfo2 *pCopyImageInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryPriorityFeaturesEXT
Definition: vulkan_structs.hpp:62601

VULKAN_HPP_NAMESPACE::ObjectType::eCuModuleNVX

VULKAN_HPP_NAMESPACE::CommandBuffer::setColorWriteMaskEXT
void setColorWriteMaskEXT(uint32_t firstAttachment, uint32_t attachmentCount, const VULKAN_HPP_NAMESPACE::ColorComponentFlags *pColorWriteMasks, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2
Definition: vulkan_structs.hpp:15867

VULKAN_HPP_NAMESPACE::PhysicalDeviceComputeShaderDerivativesFeaturesNV
Definition: vulkan_structs.hpp:51592

VULKAN_HPP_NAMESPACE::Device::destroyPipelineLayout
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

VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT
#define VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT
Definition: vulkan.hpp:5885

VULKAN_HPP_NAMESPACE::UniqueHandleTraits
Definition: vulkan.hpp:1163

VULKAN_HPP_NAMESPACE::RenderPass
Definition: vulkan_handles.hpp:6710

VULKAN_HPP_NAMESPACE::GraphicsPipelineShaderGroupsCreateInfoNV
Definition: vulkan_structs.hpp:37376

VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan12Features
Definition: vulkan_structs.hpp:75532

VULKAN_HPP_NAMESPACE::AttachmentSampleLocationsEXT
Definition: vulkan_structs.hpp:6434

VULKAN_HPP_NAMESPACE::RenderPassAttachmentBeginInfo
Definition: vulkan_structs.hpp:86437

VULKAN_HPP_NAMESPACE::CuModuleNVX::operator<
bool operator<(CuModuleNVX const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6247

VULKAN_HPP_NAMESPACE::Optional
Definition: vulkan.hpp:892

VULKAN_HPP_NAMESPACE::Device::createRayTracingPipelineKHRUnique
VULKAN_HPP_NODISCARD ResultValue< UniqueHandle< VULKAN_HPP_NAMESPACE::Pipeline, Dispatch > > createRayTracingPipelineKHRUnique(VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR &createInfo, Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

VULKAN_HPP_NAMESPACE::PipelineCoverageToColorStateCreateInfoNV
Definition: vulkan_structs.hpp:78678

VULKAN_HPP_NAMESPACE::DescriptorSetLayout::operator=
DescriptorSetLayout & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6401

VULKAN_HPP_NAMESPACE::CommandBuffer::insertDebugUtilsLabelEXT
void insertDebugUtilsLabelEXT(const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT *pLabelInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Device::createRenderPass2Unique
VULKAN_HPP_NODISCARD 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

VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL::operator==
bool operator==(PerformanceConfigurationINTEL const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2195

VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT
Definition: vulkan_structs.hpp:39288

VULKAN_HPP_NAMESPACE::CommandBuffer::setFragmentShadingRateKHR
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

VULKAN_HPP_NAMESPACE::MicromapEXT
Definition: vulkan_handles.hpp:3269

VULKAN_HPP_NAMESPACE::ImportFenceFdInfoKHR
Definition: vulkan_structs.hpp:41667

VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderPropertiesNV
Definition: vulkan_structs.hpp:63353

VULKAN_HPP_NAMESPACE::Pipeline::Pipeline
VULKAN_HPP_CONSTEXPR Pipeline()=default

VULKAN_HPP_NAMESPACE::Device::destroyDescriptorSetLayout
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

VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo
Definition: vulkan_structs.hpp:56608

VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryHostPropertiesEXT
Definition: vulkan_structs.hpp:56426

VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate::debugReportObjectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
Definition: vulkan_handles.hpp:3014

VULKAN_HPP_NAMESPACE::CommandBuffer::setLineStippleEXT
void setLineStippleEXT(uint32_t lineStippleFactor, uint16_t lineStipplePattern, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Instance::operator==
bool operator==(Instance const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:13810

VULKAN_HPP_NAMESPACE::CommandBuffer::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:5500

VULKAN_HPP_NAMESPACE::Device::signalSemaphore
VULKAN_HPP_NODISCARD Result signalSemaphore(const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo *pSignalInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::MultiDrawInfoEXT
Definition: vulkan_structs.hpp:47428

VULKAN_HPP_NAMESPACE::PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT
Definition: vulkan_structs.hpp:63685

VULKAN_HPP_NAMESPACE::Device::createImageView
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

VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion::operator!=
bool operator!=(SamplerYcbcrConversion const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6920

VULKAN_HPP_NAMESPACE::Device::createGraphicsPipelines
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

VULKAN_HPP_NAMESPACE::CheckpointDataNV
Definition: vulkan_structs.hpp:12422

VULKAN_HPP_NAMESPACE::InputAttachmentAspectReference
Definition: vulkan_structs.hpp:44034

VULKAN_HPP_NAMESPACE::PipelineLayout::PipelineLayout
VULKAN_HPP_CONSTEXPR PipelineLayout(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2424

VULKAN_HPP_NAMESPACE::Device::displayPowerControlEXT
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

VULKAN_HPP_NAMESPACE::PipelineRasterizationLineStateCreateInfoEXT
Definition: vulkan_structs.hpp:80706

VULKAN_HPP_NAMESPACE::BufferView::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:5923

VULKAN_HPP_NAMESPACE::Device::getQueryPoolResult
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

VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCoreBuiltinsFeaturesARM
Definition: vulkan_structs.hpp:70282

VULKAN_HPP_NAMESPACE::PhysicalDeviceASTCDecodeFeaturesEXT
Definition: vulkan_structs.hpp:50141

VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderImageFootprintFeaturesNV
Definition: vulkan_structs.hpp:71235

VULKAN_HPP_NAMESPACE::Device::getFaultInfoEXT
VULKAN_HPP_NODISCARD Result getFaultInfoEXT(VULKAN_HPP_NAMESPACE::DeviceFaultCountsEXT *pFaultCounts, VULKAN_HPP_NAMESPACE::DeviceFaultInfoEXT *pFaultInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Device::createSharedSwapchainKHR
VULKAN_HPP_NODISCARD 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

format
GLint GLint GLsizei GLint GLenum format
Definition: glcorearb.h:108

VULKAN_HPP_NAMESPACE::Device::createDescriptorSetLayout
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

VULKAN_HPP_NAMESPACE::Device::operator!=
bool operator!=(Device const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7764

VULKAN_HPP_NAMESPACE::CopyMemoryIndirectCommandNV
Definition: vulkan_structs.hpp:16770

VULKAN_HPP_NAMESPACE::StructureChain
Definition: vulkan.hpp:975

VULKAN_HPP_NAMESPACE::SubpassResolvePerformanceQueryEXT
Definition: vulkan_structs.hpp:94204

VULKAN_HPP_NAMESPACE::DisplayPresentInfoKHR
Definition: vulkan_structs.hpp:28784

VULKAN_HPP_NAMESPACE::RenderPass::RenderPass
VULKAN_HPP_CONSTEXPR RenderPass()=default

VULKAN_HPP_NAMESPACE::Device::createDescriptorUpdateTemplateKHRUnique
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate, Dispatch > >::type createDescriptorUpdateTemplateKHRUnique(const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo &createInfo, Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

VULKAN_HPP_NAMESPACE::CopyImageInfo2
Definition: vulkan_structs.hpp:16428

VULKAN_HPP_NAMESPACE::WriteDescriptorSetAccelerationStructureNV
Definition: vulkan_structs.hpp:106721

VULKAN_HPP_NAMESPACE::DescriptorPool::objectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
Definition: vulkan_handles.hpp:6296

VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR
Definition: vulkan_structs.hpp:29098

VULKAN_HPP_NAMESPACE::PhysicalDevicePushDescriptorPropertiesKHR
Definition: vulkan_structs.hpp:67555

VULKAN_HPP_NAMESPACE::Device::getAccelerationStructureHandleNV
VULKAN_HPP_NODISCARD Result getAccelerationStructureHandleNV(VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure, size_t dataSize, void *pData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::QueryPool::operator!=
bool operator!=(QueryPool const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2279

VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPipelinePropertiesKHR
Definition: vulkan_structs.hpp:68523

VULKAN_HPP_NAMESPACE::ShaderModule::ShaderModule
VULKAN_HPP_CONSTEXPR ShaderModule()=default

VULKAN_HPP_NAMESPACE::CommandBuffer::reset
ResultValueType< void >::type reset(VULKAN_HPP_NAMESPACE::CommandBufferResetFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

VULKAN_HPP_NAMESPACE::BufferViewCreateInfo
Definition: vulkan_structs.hpp:12103

VULKAN_HPP_NAMESPACE::FormatProperties3
Definition: vulkan_structs.hpp:33467

VULKAN_HPP_NAMESPACE::PhysicalDeviceInlineUniformBlockFeatures
Definition: vulkan_structs.hpp:60649

VULKAN_HPP_NAMESPACE::ImageView::ImageView
VULKAN_HPP_TYPESAFE_EXPLICIT ImageView(VkImageView imageView) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2595

VULKAN_HPP_NAMESPACE::PipelineLayout::NativeType
VkPipelineLayout NativeType
Definition: vulkan_handles.hpp:2416

VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClampZeroOneFeaturesEXT
Definition: vulkan_structs.hpp:52810

VULKAN_HPP_NAMESPACE::Pipeline::operator==
bool operator==(Pipeline const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2699

VULKAN_HPP_NAMESPACE::Device::createSharedSwapchainsKHRUnique
VULKAN_HPP_NODISCARD 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

VULKAN_HPP_NAMESPACE::CommandBuffer::operator=
CommandBuffer & operator=(VkCommandBuffer commandBuffer) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3363

VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT
Definition: vulkan_structs.hpp:18326

VULKAN_HPP_NAMESPACE::Device::getDeferredOperationMaxConcurrencyKHR
uint32_t getDeferredOperationMaxConcurrencyKHR(VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::AccelerationStructureNV::NativeType
VkAccelerationStructureNV NativeType
Definition: vulkan_handles.hpp:2841

VULKAN_HPP_NAMESPACE::PipelineViewportWScalingStateCreateInfoNV
Definition: vulkan_structs.hpp:83163

VULKAN_HPP_NAMESPACE::DisplayModeKHR::NativeType
VkDisplayModeKHR NativeType
Definition: vulkan_handles.hpp:12308

VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV::debugReportObjectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
Definition: vulkan_handles.hpp:2932

VULKAN_HPP_NAMESPACE::DeviceOrHostAddressKHR
Definition: vulkan_structs.hpp:677

VULKAN_HPP_NAMESPACE::Device::debugReportObjectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
Definition: vulkan_handles.hpp:7736

VULKAN_HPP_NAMESPACE::PhysicalDeviceBufferDeviceAddressFeaturesEXT
Definition: vulkan_structs.hpp:51271

stride
GLint GLenum GLboolean GLsizei stride
Definition: glcorearb.h:872

VULKAN_HPP_NAMESPACE::Device::createComputePipelineUnique
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

VULKAN_HPP_NAMESPACE::ObjectType::eEvent

VULKAN_HPP_NAMESPACE::ImageView::ImageView
VULKAN_HPP_CONSTEXPR ImageView()=default

VULKAN_HPP_NAMESPACE::Device::createOpticalFlowSessionNVUnique
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV, Dispatch > >::type createOpticalFlowSessionNVUnique(const VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreateInfoNV &createInfo, Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR
Definition: vulkan_structs.hpp:85722

VULKAN_HPP_NAMESPACE::Device::freeMemory
void freeMemory(VULKAN_HPP_NAMESPACE::DeviceMemory memory, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::CommandBuffer::setViewportWithCountEXT
void setViewportWithCountEXT(uint32_t viewportCount, const VULKAN_HPP_NAMESPACE::Viewport *pViewports, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Device::getAccelerationStructureCompatibilityKHR
void getAccelerationStructureCompatibilityKHR(const VULKAN_HPP_NAMESPACE::AccelerationStructureVersionInfoKHR *pVersionInfo, VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR *pCompatibility, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

CType
Definition: typedesc.h:481

buffers
const GLuint * buffers
Definition: glcorearb.h:661

attachments
GLsizei const GLenum * attachments
Definition: glcorearb.h:2518

VULKAN_HPP_NAMESPACE::PrivateDataSlot::operator<
bool operator<(PrivateDataSlot const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6672

VULKAN_HPP_NAMESPACE::Device::getImageViewHandleNVX
uint32_t getImageViewHandleNVX(const VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::AccelerationStructureNV::AccelerationStructureNV
VULKAN_HPP_CONSTEXPR AccelerationStructureNV()=default

VULKAN_HPP_NAMESPACE::PhysicalDevice::operator<
bool operator<(PhysicalDevice const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:12439

VULKAN_HPP_NAMESPACE::PipelineCache::operator!=
bool operator!=(PipelineCache const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6072

VULKAN_HPP_NAMESPACE::CopyBufferInfo2
Definition: vulkan_structs.hpp:15720

VULKAN_HPP_NAMESPACE::CommandBuffer::executeCommands
void executeCommands(uint32_t commandBufferCount, const VULKAN_HPP_NAMESPACE::CommandBuffer *pCommandBuffers, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::SurfaceKHR::SurfaceKHR
VULKAN_HPP_CONSTEXPR SurfaceKHR()=default

VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT
Definition: vulkan_structs.hpp:53203

VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryKHR
Definition: vulkan_structs.hpp:574

VULKAN_HPP_NAMESPACE::BufferCaptureDescriptorDataInfoEXT
Definition: vulkan_structs.hpp:9703

VULKAN_HPP_NAMESPACE::CommandBuffer::setRasterizationStreamEXT
void setRasterizationStreamEXT(uint32_t rasterizationStream, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::CommandBuffer::resetQueryPool
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

VULKAN_HPP_NAMESPACE::Device::registerEventEXTUnique
VULKAN_HPP_NODISCARD 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

VULKAN_HPP_NAMESPACE::PhysicalDeviceDriverProperties
Definition: vulkan_structs.hpp:54885

VULKAN_HPP_NAMESPACE::DeferredOperationKHR::debugReportObjectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
Definition: vulkan_handles.hpp:5700

VULKAN_HPP_NAMESPACE::Device::bindAccelerationStructureMemoryNV
VULKAN_HPP_NODISCARD Result bindAccelerationStructureMemoryNV(uint32_t bindInfoCount, const VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV *pBindInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::SwapchainKHR::objectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
Definition: vulkan_handles.hpp:1911

VULKAN_HPP_NAMESPACE::HdrMetadataEXT
Definition: vulkan_structs.hpp:37624

VULKAN_HPP_NAMESPACE::CommandBuffer::setDepthBoundsTestEnable
void setDepthBoundsTestEnable(VULKAN_HPP_NAMESPACE::Bool32 depthBoundsTestEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo
Definition: vulkan_structs.hpp:56104

VULKAN_HPP_NAMESPACE::DescriptorDataEXT
Definition: vulkan_structs.hpp:21034

VULKAN_HPP_NAMESPACE::Device::createRayTracingPipelineNV
VULKAN_HPP_NODISCARD ResultValue< VULKAN_HPP_NAMESPACE::Pipeline > createRayTracingPipelineNV(VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV &createInfo, Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingFeatures
Definition: vulkan_structs.hpp:55091

VULKAN_HPP_NAMESPACE::CommandPool::operator!=
bool operator!=(CommandPool const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:5987

VULKAN_HPP_NAMESPACE::PipelineLayout::operator==
bool operator==(PipelineLayout const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2444

VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR
Definition: vulkan_structs.hpp:3926

VULKAN_HPP_NAMESPACE::Device::getBufferMemoryRequirements2
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

VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomBorderColorFeaturesEXT
Definition: vulkan_structs.hpp:52517

VULKAN_HPP_NAMESPACE::Device::importSemaphoreFdKHR
VULKAN_HPP_NODISCARD Result importSemaphoreFdKHR(const VULKAN_HPP_NAMESPACE::ImportSemaphoreFdInfoKHR *pImportSemaphoreFdInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::ObjectType::eInstance

VULKAN_HPP_NAMESPACE::Device::getAccelerationStructureAddressKHR
DeviceAddress getAccelerationStructureAddressKHR(const VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::PhysicalDeviceIndexTypeUint8FeaturesEXT
Definition: vulkan_structs.hpp:60453

VULKAN_HPP_NAMESPACE::CuModuleNVX::NativeType
VkCuModuleNVX NativeType
Definition: vulkan_handles.hpp:6209

VULKAN_HPP_NAMESPACE::PipelineRobustnessCreateInfoEXT
Definition: vulkan_structs.hpp:81423

VULKAN_HPP_NAMESPACE::CommandPool::operator<
bool operator<(CommandPool const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:5992

VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV
Definition: vulkan_structs.hpp:34373

VULKAN_HPP_NAMESPACE::Device::waitSemaphoresKHR
VULKAN_HPP_NODISCARD Result waitSemaphoresKHR(const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo *pWaitInfo, uint64_t timeout, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::CommandBuffer::end
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type end(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexInputDynamicStateFeaturesEXT
Definition: vulkan_structs.hpp:74935

VULKAN_HPP_NAMESPACE::DisplayNativeHdrSurfaceCapabilitiesAMD
Definition: vulkan_structs.hpp:28157

VULKAN_HPP_NAMESPACE::Device::getValidationCacheDataEXT
VULKAN_HPP_NODISCARD Result getValidationCacheDataEXT(VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache, size_t *pDataSize, void *pData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Device::createAccelerationStructureNV
VULKAN_HPP_NODISCARD Result createAccelerationStructureNV(const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV *pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, VULKAN_HPP_NAMESPACE::AccelerationStructureNV *pAccelerationStructure, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::CommandBuffer::resolveImage2KHR
void resolveImage2KHR(const VULKAN_HPP_NAMESPACE::ResolveImageInfo2 *pResolveImageInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineCreationCacheControlFeatures
Definition: vulkan_structs.hpp:65209

VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2PropertiesEXT
Definition: vulkan_structs.hpp:68997

VULKAN_HPP_NAMESPACE::CommandBuffer::writeTimestamp2KHR
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

VULKAN_HPP_NAMESPACE::DescriptorSet::operator<
bool operator<(DescriptorSet const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2539

VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT::DebugReportCallbackEXT
VULKAN_HPP_CONSTEXPR DebugReportCallbackEXT()=default

queue
*get result *(waiting if necessary)*A common idiom is to fire a bunch of sub tasks at the queue
Definition: thread.h:623

VULKAN_HPP_NAMESPACE::CommandPool::operator==
bool operator==(CommandPool const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:5982

VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierListCreateInfoEXT
Definition: vulkan_structs.hpp:39163

location
GLint location
Definition: glcorearb.h:805

VULKAN_HPP_NAMESPACE::CommandBuffer::drawIndirectCountKHR
void drawIndirectCountKHR(VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, VULKAN_HPP_NAMESPACE::Buffer countBuffer, VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan13Properties
Definition: vulkan_structs.hpp:76860

VULKAN_HPP_NAMESPACE::ObjectType::eIndirectCommandsLayoutNV

VULKAN_HPP_NAMESPACE::DeviceMemory::operator=
DeviceMemory & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:5550

handle
int handle
Definition: RV_OGLInteropTextureBase.h:36

VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo
Definition: vulkan_structs.hpp:90697

VULKAN_HPP_NAMESPACE::ObjectType::ePipelineCache

VULKAN_HPP_NAMESPACE::CommandBuffer::endRendering
void endRendering(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT::objectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
Definition: vulkan_handles.hpp:1656

VULKAN_HPP_NAMESPACE::ProtectedSubmitInfo
Definition: vulkan_structs.hpp:84370

VULKAN_HPP_NAMESPACE::OpticalFlowExecuteInfoNV
Definition: vulkan_structs.hpp:48153

VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2FeaturesEXT
Definition: vulkan_structs.hpp:68876

VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan11Features
Definition: vulkan_structs.hpp:75133

VULKAN_HPP_NAMESPACE::CommandBuffer::updateBuffer
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

VULKAN_HPP_NAMESPACE::Device::destroyPrivateDataSlot
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

VULKAN_HPP_NAMESPACE::DedicatedAllocationMemoryAllocateInfoNV
Definition: vulkan_structs.hpp:19744

VULKAN_HPP_NAMESPACE::Instance::submitDebugUtilsMessageEXT
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

VULKAN_HPP_NAMESPACE::Sampler::objectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
Definition: vulkan_handles.hpp:6801

VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicInt64Features
Definition: vulkan_structs.hpp:70064

VULKAN_HPP_NAMESPACE::Device::createGraphicsPipeline
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

VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM
Definition: vulkan_structs.hpp:57415

VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineProtectedAccessFeaturesEXT
Definition: vulkan_structs.hpp:65508

VULKAN_HPP_NAMESPACE::Device::getDescriptorEXT
void getDescriptorEXT(const VULKAN_HPP_NAMESPACE::DescriptorGetInfoEXT *pDescriptorInfo, size_t dataSize, void *pDescriptor, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::ImageSubresourceRange
Definition: vulkan_structs.hpp:19978

VULKAN_HPP_NAMESPACE::Device::resetQueryPoolEXT
void resetQueryPoolEXT(VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::PhysicalDevicePresentWaitFeaturesKHR
Definition: vulkan_structs.hpp:66468

VULKAN_HPP_NAMESPACE::Device::getFramebufferTilePropertiesQCOM
VULKAN_HPP_NODISCARD Result getFramebufferTilePropertiesQCOM(VULKAN_HPP_NAMESPACE::Framebuffer framebuffer, uint32_t *pPropertiesCount, VULKAN_HPP_NAMESPACE::TilePropertiesQCOM *pProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::CommandBuffer::setRayTracingPipelineStackSizeKHR
void setRayTracingPipelineStackSizeKHR(uint32_t pipelineStackSize, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::PhysicalDeviceUniformBufferStandardLayoutFeatures
Definition: vulkan_structs.hpp:74529

VULKAN_HPP_NAMESPACE::DescriptorAddressInfoEXT
Definition: vulkan_structs.hpp:20515

VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderPropertiesEXT
Definition: vulkan_structs.hpp:63115

VULKAN_HPP_NAMESPACE::DeviceFaultInfoEXT
Definition: vulkan_structs.hpp:24950

VULKAN_HPP_NAMESPACE::PhysicalDevice4444FormatsFeaturesEXT
Definition: vulkan_structs.hpp:49911

VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT
Definition: vulkan_structs.hpp:19123

VULKAN_HPP_NAMESPACE::Device::createPrivateDataSlotEXTUnique
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< VULKAN_HPP_NAMESPACE::PrivateDataSlot, Dispatch > >::type createPrivateDataSlotEXTUnique(const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo &createInfo, Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

VULKAN_HPP_NAMESPACE::RenderPassCreationControlEXT
Definition: vulkan_structs.hpp:88045

VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT
Definition: vulkan_structs.hpp:37802

VULKAN_HPP_NAMESPACE::PhysicalDevice::getFragmentShadingRatesKHR
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

VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiDrawFeaturesEXT
Definition: vulkan_structs.hpp:63507

VULKAN_HPP_NAMESPACE::Device::createRayTracingPipelineKHR
VULKAN_HPP_NODISCARD ResultValue< VULKAN_HPP_NAMESPACE::Pipeline > createRayTracingPipelineKHR(VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR &createInfo, Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

VULKAN_HPP_NAMESPACE::WriteDescriptorSetInlineUniformBlock
Definition: vulkan_structs.hpp:106852

VULKAN_HPP_NAMESPACE::CommandBuffer::copyImageToBuffer2
void copyImageToBuffer2(const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 *pCopyImageToBufferInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::LayerProperties
Definition: vulkan_structs.hpp:44348

VULKAN_HPP_NAMESPACE::CommandBuffer::nextSubpass
void nextSubpass(VULKAN_HPP_NAMESPACE::SubpassContents contents, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderTerminateInvocationFeatures
Definition: vulkan_structs.hpp:72374

VULKAN_HPP_NAMESPACE::DisplayKHR::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:1878

VULKAN_HPP_NAMESPACE::Queue::waitIdle
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type waitIdle(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

VULKAN_HPP_NAMESPACE::CommandBuffer::waitEvents2
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

VULKAN_HPP_NAMESPACE::QueueFamilyGlobalPriorityPropertiesKHR
Definition: vulkan_structs.hpp:84999

VULKAN_HPP_NAMESPACE::ImageMemoryBarrier2
Definition: vulkan_structs.hpp:20093

VULKAN_HPP_NAMESPACE::Device::getShaderInfoAMD
VULKAN_HPP_NODISCARD Result getShaderInfoAMD(VULKAN_HPP_NAMESPACE::Pipeline pipeline, VULKAN_HPP_NAMESPACE::ShaderStageFlagBits shaderStage, VULKAN_HPP_NAMESPACE::ShaderInfoTypeAMD infoType, size_t *pInfoSize, void *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance3Properties
Definition: vulkan_structs.hpp:62057

VULKAN_HPP_NAMESPACE::DescriptorSetBindingReferenceVALVE
Definition: vulkan_structs.hpp:21718

VULKAN_HPP_NAMESPACE::PhysicalDevice::getExternalSemaphoreProperties
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

VULKAN_HPP_NAMESPACE::CuModuleNVX::objectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
Definition: vulkan_handles.hpp:6211

VULKAN_HPP_NAMESPACE::ExternalBufferProperties
Definition: vulkan_structs.hpp:31990

VULKAN_HPP_NAMESPACE::ImageView::operator<
bool operator<(ImageView const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2624

VULKAN_HPP_NAMESPACE::AabbPositionsKHR
Definition: vulkan_structs.hpp:19

VULKAN_HPP_NAMESPACE::CommandBuffer::drawIndirectCountAMD
void drawIndirectCountAMD(VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, VULKAN_HPP_NAMESPACE::Buffer countBuffer, VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Instance::createHeadlessSurfaceEXT
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

VULKAN_HPP_NAMESPACE::SubpassShadingPipelineCreateInfoHUAWEI
Definition: vulkan_structs.hpp:94286

VULKAN_HPP_NAMESPACE::CommandBuffer::setStencilOpEXT
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

VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL::PerformanceConfigurationINTEL
VULKAN_HPP_TYPESAFE_EXPLICIT PerformanceConfigurationINTEL(VkPerformanceConfigurationINTEL performanceConfigurationINTEL) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2173

VULKAN_HPP_NAMESPACE::FrontFace
FrontFace
Definition: vulkan_enums.hpp:2445

VULKAN_HPP_NAMESPACE::FramebufferAttachmentsCreateInfo
Definition: vulkan_structs.hpp:33862

VULKAN_HPP_NAMESPACE::ExtensionProperties
Definition: vulkan_structs.hpp:31838

VULKAN_HPP_NAMESPACE::Image::Image
VULKAN_HPP_TYPESAFE_EXPLICIT Image(VkImage image) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2765

VULKAN_HPP_NAMESPACE::ObjectType::eFramebuffer

VULKAN_HPP_NAMESPACE::ObjectType::eCommandPool

VULKAN_HPP_NAMESPACE::Device::createRenderPass
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

VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryDataKHR
Definition: vulkan_structs.hpp:512

VULKAN_HPP_NODISCARD
#define VULKAN_HPP_NODISCARD
Definition: vulkan.hpp:224

VULKAN_HPP_NAMESPACE::DescriptorPool::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6348

VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures
Definition: vulkan_structs.hpp:23358

VULKAN_HPP_NAMESPACE::SRTDataNV
Definition: vulkan_structs.hpp:3009

name
GLuint const GLchar * name
Definition: glcorearb.h:786

VULKAN_HPP_NAMESPACE::Device::release
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type release(VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

VULKAN_HPP_NAMESPACE::CommandBuffer::debugMarkerBeginEXT
void debugMarkerBeginEXT(const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT *pMarkerInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::PrivateDataSlot::operator==
bool operator==(PrivateDataSlot const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6662

VULKAN_HPP_NAMESPACE::CuModuleNVX::CuModuleNVX
VULKAN_HPP_TYPESAFE_EXPLICIT CuModuleNVX(VkCuModuleNVX cuModuleNVX) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6218

VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR
Definition: vulkan_structs.hpp:95540

VULKAN_HPP_NAMESPACE::CopyMemoryToMicromapInfoEXT
Definition: vulkan_structs.hpp:17100

VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo
Definition: vulkan_structs.hpp:14968

VULKAN_HPP_NAMESPACE::ShaderModule::NativeType
VkShaderModule NativeType
Definition: vulkan_handles.hpp:6973

VULKAN_HPP_NAMESPACE::PhysicalDeviceInlineUniformBlockProperties
Definition: vulkan_structs.hpp:60759

VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2
Definition: vulkan_structs.hpp:39748

VULKAN_HPP_NAMESPACE::VertexInputBindingDivisorDescriptionEXT
Definition: vulkan_structs.hpp:81980

VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2
Definition: vulkan_structs.hpp:16603

VULKAN_HPP_NAMESPACE::Device::getCalibratedTimestampEXT
VULKAN_HPP_NODISCARD ResultValueType< std::pair< uint64_t, uint64_t > >::type getCalibratedTimestampEXT(const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT &timestampInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

VULKAN_HPP_NAMESPACE::Image
Definition: vulkan_handles.hpp:2752

VULKAN_HPP_NAMESPACE::ShaderModule
Definition: vulkan_handles.hpp:6969

VULKAN_HPP_NAMESPACE::GeometryNV
Definition: vulkan_structs.hpp:1865

VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapPropertiesEXT
Definition: vulkan_structs.hpp:57600

VULKAN_HPP_NAMESPACE::SubpassBeginInfo
Definition: vulkan_structs.hpp:93772

VULKAN_HPP_NAMESPACE::ExportMemoryAllocateInfoNV
Definition: vulkan_structs.hpp:30427

VULKAN_HPP_NAMESPACE::Device::getAccelerationStructureOpaqueCaptureDescriptorDataEXT
VULKAN_HPP_NODISCARD Result getAccelerationStructureOpaqueCaptureDescriptorDataEXT(const VULKAN_HPP_NAMESPACE::AccelerationStructureCaptureDescriptorDataInfoEXT *pInfo, void *pData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV::operator!=
bool operator!=(OpticalFlowSessionNV const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2965

VULKAN_HPP_NAMESPACE::CommandPool::CommandPool
VULKAN_HPP_TYPESAFE_EXPLICIT CommandPool(VkCommandPool commandPool) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:5963

VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX
Definition: vulkan_structs.hpp:40802

VULKAN_HPP_NAMESPACE::DescriptorSet::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2555

VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR
Definition: vulkan_structs.hpp:72272

VULKAN_HPP_NAMESPACE::PipelinePropertiesIdentifierEXT
Definition: vulkan_structs.hpp:80370

VULKAN_HPP_NAMESPACE::QueryPoolPerformanceQueryCreateInfoINTEL
Definition: vulkan_structs.hpp:84733

VULKAN_HPP_NAMESPACE::Device::createRayTracingPipelineNVUnique
VULKAN_HPP_NODISCARD ResultValue< UniqueHandle< VULKAN_HPP_NAMESPACE::Pipeline, Dispatch > > createRayTracingPipelineNVUnique(VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV &createInfo, Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

VULKAN_HPP_NAMESPACE::Semaphore::Semaphore
VULKAN_HPP_CONSTEXPR Semaphore(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2002

VULKAN_HPP_NAMESPACE::Device::createDescriptorPoolUnique
VULKAN_HPP_NODISCARD 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

VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR
Definition: vulkan_structs.hpp:45164

VULKAN_HPP_NAMESPACE::Device::mergePipelineCaches
VULKAN_HPP_NODISCARD Result mergePipelineCaches(VULKAN_HPP_NAMESPACE::PipelineCache dstCache, uint32_t srcCacheCount, const VULKAN_HPP_NAMESPACE::PipelineCache *pSrcCaches, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalImageFormatInfo
Definition: vulkan_structs.hpp:56326

VULKAN_HPP_NAMESPACE::Device::destroyOpticalFlowSessionNV
void destroyOpticalFlowSessionNV(VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV session, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::PhysicalDevice::getFormatProperties2KHR
void getFormatProperties2KHR(VULKAN_HPP_NAMESPACE::Format format, VULKAN_HPP_NAMESPACE::FormatProperties2 *pFormatProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::ShaderModule::operator<
bool operator<(ShaderModule const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7011

VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesPresentBarrierNV
Definition: vulkan_structs.hpp:94898

VULKAN_HPP_NAMESPACE::CommandBuffer::setFrontFaceEXT
void setFrontFaceEXT(VULKAN_HPP_NAMESPACE::FrontFace frontFace, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::DescriptorSetLayout::operator==
bool operator==(DescriptorSetLayout const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6410

VULKAN_HPP_NAMESPACE::Device::resetEvent
ResultValueType< void >::type resetEvent(VULKAN_HPP_NAMESPACE::Event event, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

VULKAN_HPP_NAMESPACE::BlitImageInfo2
Definition: vulkan_structs.hpp:9515

VULKAN_HPP_NAMESPACE::AccelerationStructureNV::operator<
bool operator<(AccelerationStructureNV const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2882

VULKAN_HPP_NAMESPACE::PhysicalDeviceBlendOperationAdvancedPropertiesEXT
Definition: vulkan_structs.hpp:50919

VULKAN_HPP_NAMESPACE::CommandBuffer::bindInvocationMaskHUAWEI
void bindInvocationMaskHUAWEI(VULKAN_HPP_NAMESPACE::ImageView imageView, VULKAN_HPP_NAMESPACE::ImageLayout imageLayout, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate::operator=
DescriptorUpdateTemplate & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3033

VULKAN_HPP_NAMESPACE::ObjectType::eDisplayKHR

VULKAN_HPP_NAMESPACE::SurfaceKHR::SurfaceKHR
VULKAN_HPP_TYPESAFE_EXPLICIT SurfaceKHR(VkSurfaceKHR surfaceKHR) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:1578

VULKAN_HPP_NAMESPACE::Device::invalidateMappedMemoryRanges
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

VULKAN_HPP_NAMESPACE::DeviceQueueGlobalPriorityCreateInfoKHR
Definition: vulkan_structs.hpp:27036

VULKAN_HPP_NAMESPACE::PipelineCache::operator<
bool operator<(PipelineCache const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6077

VULKAN_HPP_NAMESPACE::ValidationCacheEXT::operator=
ValidationCacheEXT & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7079

VULKAN_HPP_NAMESPACE::Device::createAccelerationStructureNVUnique
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< VULKAN_HPP_NAMESPACE::AccelerationStructureNV, Dispatch > >::type createAccelerationStructureNVUnique(const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV &createInfo, Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

VULKAN_HPP_NAMESPACE::CommandBuffer::beginRenderPass2KHR
void beginRenderPass2KHR(const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo *pRenderPassBegin, const VULKAN_HPP_NAMESPACE::SubpassBeginInfo *pSubpassBeginInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2986

VULKAN_HPP_NAMESPACE::CoverageReductionModeNV
CoverageReductionModeNV
Definition: vulkan_enums.hpp:5569

VULKAN_HPP_NAMESPACE::MicromapUsageEXT
Definition: vulkan_structs.hpp:3529

VULKAN_HPP_NAMESPACE::PipelineColorWriteCreateInfoEXT
Definition: vulkan_structs.hpp:78170

VULKAN_HPP_NAMESPACE::Pipeline::Pipeline
VULKAN_HPP_CONSTEXPR Pipeline(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2679

VULKAN_HPP_NAMESPACE::ImageCaptureDescriptorDataInfoEXT
Definition: vulkan_structs.hpp:38113

VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo
Definition: vulkan_structs.hpp:91176

VULKAN_HPP_NAMESPACE::Framebuffer::Framebuffer
VULKAN_HPP_CONSTEXPR Framebuffer()=default

VULKAN_HPP_NAMESPACE::Image::operator==
bool operator==(Image const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2784

VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMap2FeaturesEXT
Definition: vulkan_structs.hpp:57093

VULKAN_HPP_NAMESPACE::PhysicalDevice::debugReportObjectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
Definition: vulkan_handles.hpp:12406

VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:1799

VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomBorderColorPropertiesEXT
Definition: vulkan_structs.hpp:52626

VULKAN_HPP_NAMESPACE::AccelerationStructureKHR::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3242

VULKAN_HPP_NAMESPACE::PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT
Definition: vulkan_structs.hpp:67735

VULKAN_HPP_NAMESPACE::DeviceFaultVendorInfoEXT
Definition: vulkan_structs.hpp:24854

VULKAN_HPP_NAMESPACE::Device::createFramebufferUnique
VULKAN_HPP_NODISCARD 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

VULKAN_HPP_NAMESPACE::Fence::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2133

VULKAN_HPP_NAMESPACE::ImageType
ImageType
Definition: vulkan_enums.hpp:1565

VULKAN_HPP_NAMESPACE::CommandBuffer::resolveImage
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

VULKAN_HPP_NAMESPACE::DrawMeshTasksIndirectCommandNV
Definition: vulkan_structs.hpp:29585

VULKAN_HPP_NAMESPACE::Device::destroySamplerYcbcrConversion
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

VULKAN_HPP_NAMESPACE::BufferDeviceAddressCreateInfoEXT
Definition: vulkan_structs.hpp:11097

VULKAN_HPP_NAMESPACE::SparseImageFormatProperties
Definition: vulkan_structs.hpp:92779

VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV::operator=
IndirectCommandsLayoutNV & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6574

VULKAN_HPP_NAMESPACE::CuModuleNVX::operator=
CuModuleNVX & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6228

VULKAN_HPP_NAMESPACE::SamplerReductionModeCreateInfo
Definition: vulkan_structs.hpp:90598

VULKAN_HPP_NAMESPACE::Device::allocateCommandBuffers
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

VULKAN_HPP_NAMESPACE::PhysicalDevice
Definition: vulkan_handles.hpp:12399

VULKAN_HPP_NAMESPACE::CommandBuffer::pipelineBarrier2
void pipelineBarrier2(const VULKAN_HPP_NAMESPACE::DependencyInfo *pDependencyInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT
Definition: vulkan_structs.hpp:18489

VULKAN_HPP_NAMESPACE::ObjectType::eCommandBuffer

VULKAN_HPP_NAMESPACE::Sampler::NativeType
VkSampler NativeType
Definition: vulkan_handles.hpp:6799

VULKAN_HPP_NAMESPACE::Sampler::Sampler
VULKAN_HPP_CONSTEXPR Sampler()=default

VULKAN_HPP_NAMESPACE::enumerateInstanceExtensionProperties
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result enumerateInstanceExtensionProperties(const char *pLayerName, uint32_t *pPropertyCount, VULKAN_HPP_NAMESPACE::ExtensionProperties *pProperties, Dispatch const &d) VULKAN_HPP_NOEXCEPT
Definition: vulkan_funcs.hpp:455

VULKAN_HPP_NAMESPACE::PerformanceQuerySubmitInfoKHR
Definition: vulkan_structs.hpp:49442

VULKAN_HPP_NAMESPACE::Device::createPipelineCache
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

VULKAN_HPP_NAMESPACE::MicromapEXT::operator=
MicromapEXT & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3292

VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV::IndirectCommandsLayoutNV
VULKAN_HPP_TYPESAFE_EXPLICIT IndirectCommandsLayoutNV(VkIndirectCommandsLayoutNV indirectCommandsLayoutNV) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6561

VULKAN_HPP_NAMESPACE::ExternalImageFormatProperties
Definition: vulkan_structs.hpp:32267

samples
GLsizei samples
Definition: glcorearb.h:1298

VULKAN_HPP_NAMESPACE::ObjectType::eAccelerationStructureKHR

VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo
Definition: vulkan_structs.hpp:14478

VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT::DebugUtilsMessengerEXT
VULKAN_HPP_CONSTEXPR DebugUtilsMessengerEXT()=default

VULKAN_HPP_NAMESPACE::CommandBuffer::preprocessGeneratedCommandsNV
void preprocessGeneratedCommandsNV(const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV *pGeneratedCommandsInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2
Definition: vulkan_structs.hpp:62782

VULKAN_HPP_NAMESPACE::PhysicalDevice::PhysicalDevice
VULKAN_HPP_CONSTEXPR PhysicalDevice()=default

VULKAN_HPP_NAMESPACE::Instance::destroy
void destroy(const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::PipelineLayout::PipelineLayout
VULKAN_HPP_CONSTEXPR PipelineLayout()=default

VULKAN_HPP_NAMESPACE::Device::destroyImageView
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

VULKAN_HPP_NAMESPACE::Viewport
Definition: vulkan_structs.hpp:14131

VULKAN_HPP_NAMESPACE::DescriptorBufferBindingPushDescriptorBufferHandleEXT
Definition: vulkan_structs.hpp:20743

VULKAN_HPP_NAMESPACE::PhysicalDeviceAddressBindingReportFeaturesEXT
Definition: vulkan_structs.hpp:50524

VULKAN_HPP_NAMESPACE::CommandBuffer::operator<
bool operator<(CommandBuffer const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3388

VULKAN_HPP_NAMESPACE::TraceRaysIndirectCommandKHR
Definition: vulkan_structs.hpp:96659

mode
GLenum mode
Definition: glcorearb.h:99

VULKAN_HPP_NAMESPACE::SwapchainKHR::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:1963

VULKAN_HPP_NAMESPACE::DisplayModeKHR::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:12362

VULKAN_HPP_NAMESPACE::PhysicalDeviceTimelineSemaphoreProperties
Definition: vulkan_structs.hpp:74095

VULKAN_HPP_NAMESPACE::ObjectType::eOpticalFlowSessionNV

VULKAN_HPP_NAMESPACE::SurfaceKHR::operator=
SurfaceKHR & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:1588

depth
GLint GLint GLsizei GLsizei GLsizei depth
Definition: glcorearb.h:476

VULKAN_HPP_NAMESPACE::Device::allocateCommandBuffersUnique
VULKAN_HPP_NODISCARD 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

VULKAN_HPP_NAMESPACE::PhysicalDeviceBorderColorSwizzleFeaturesEXT
Definition: vulkan_structs.hpp:51037

VULKAN_HPP_NAMESPACE::PipelineViewportDepthClipControlCreateInfoEXT
Definition: vulkan_structs.hpp:82350

VULKAN_HPP_NAMESPACE::DescriptorSet::operator=
DescriptorSet & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2520

VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerDotProductProperties
Definition: vulkan_structs.hpp:71432

VULKAN_HPP_NAMESPACE::CommandBuffer::executeGeneratedCommandsNV
void executeGeneratedCommandsNV(VULKAN_HPP_NAMESPACE::Bool32 isPreprocessed, const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV *pGeneratedCommandsInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::DescriptorPool::NativeType
VkDescriptorPool NativeType
Definition: vulkan_handles.hpp:6294

SOP_VisibilityEnums::Viewport
Viewport
Definition: SOP_Visibility.proto.h:35

VULKAN_HPP_NAMESPACE::Filter
Filter
Definition: vulkan_enums.hpp:2738

VULKAN_HPP_NAMESPACE::CommandBuffer::copyImage2KHR
void copyImage2KHR(const VULKAN_HPP_NAMESPACE::CopyImageInfo2 *pCopyImageInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV::operator<
bool operator<(OpticalFlowSessionNV const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2970

VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV::operator!=
bool operator!=(IndirectCommandsLayoutNV const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6588

VULKAN_HPP_NAMESPACE::Device::getBufferMemoryRequirementsKHR
void getBufferMemoryRequirementsKHR(const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements *pInfo, VULKAN_HPP_NAMESPACE::MemoryRequirements2 *pMemoryRequirements, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::PresentTimeGOOGLE
Definition: vulkan_structs.hpp:84065

VULKAN_HPP_NAMESPACE::ExternalMemoryBufferCreateInfo
Definition: vulkan_structs.hpp:32522

VULKAN_HPP_NAMESPACE::Device::debugMarkerSetObjectTagEXT
VULKAN_HPP_NODISCARD Result debugMarkerSetObjectTagEXT(const VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT *pTagInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::PhysicalDeviceNonSeamlessCubeMapFeaturesEXT
Definition: vulkan_structs.hpp:64283

VULKAN_HPP_NAMESPACE::Device::createRayTracingPipelinesKHR
VULKAN_HPP_NODISCARD Result createRayTracingPipelinesKHR(VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, uint32_t createInfoCount, const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR *pCreateInfos, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, VULKAN_HPP_NAMESPACE::Pipeline *pPipelines, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::CommandPool::debugReportObjectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
Definition: vulkan_handles.hpp:5957

VULKAN_HPP_NAMESPACE::Device::getSemaphoreCounterValue
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

VULKAN_HPP_NAMESPACE::CommandBuffer::setDeviceMaskKHR
void setDeviceMaskKHR(uint32_t deviceMask, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::PipelineStageFlagBits
PipelineStageFlagBits
Definition: vulkan_enums.hpp:1763

VULKAN_HPP_NAMESPACE::ObjectType::ePipeline

VULKAN_HPP_NAMESPACE::Device::acquirePerformanceConfigurationINTELUnique
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL, Dispatch > >::type acquirePerformanceConfigurationINTELUnique(const VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL &acquireInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

VULKAN_HPP_NAMESPACE::CommandBuffer::setExtraPrimitiveOverestimationSizeEXT
void setExtraPrimitiveOverestimationSizeEXT(float extraPrimitiveOverestimationSize, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::CommandBuffer::setDepthWriteEnable
void setDepthWriteEnable(VULKAN_HPP_NAMESPACE::Bool32 depthWriteEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::CommandBuffer::copyBufferToImage2KHR
void copyBufferToImage2KHR(const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 *pCopyBufferToImageInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Queue::presentKHR
VULKAN_HPP_NODISCARD Result presentKHR(const VULKAN_HPP_NAMESPACE::PresentInfoKHR *pPresentInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::CommandBuffer::setStencilOp
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

VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderInterlockFeaturesEXT
Definition: vulkan_structs.hpp:57883

VULKAN_HPP_NAMESPACE::ShaderModule::operator=
ShaderModule & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6992

VULKAN_HPP_NAMESPACE::DescriptorPool::DescriptorPool
VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorPool(VkDescriptorPool descriptorPool) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6303

VULKAN_HPP_NAMESPACE::AccelerationStructureKHR
Definition: vulkan_handles.hpp:3181

VULKAN_HPP_NAMESPACE::ValidationCacheEXT::operator<
bool operator<(ValidationCacheEXT const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7098

VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierExplicitCreateInfoEXT
Definition: vulkan_structs.hpp:39018

VULKAN_HPP_NAMESPACE::DeviceMemory
Definition: vulkan_handles.hpp:5527

VULKAN_HPP_NAMESPACE::DeviceCreateInfo
Definition: vulkan_structs.hpp:24068

VULKAN_HPP_NAMESPACE::CommandBuffer::endRenderingKHR
void endRenderingKHR(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::PerformanceValueDataINTEL
Definition: vulkan_structs.hpp:49634

VULKAN_HPP_NAMESPACE::Device::createQueryPool
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

VULKAN_HPP_NAMESPACE::Device::createFenceUnique
VULKAN_HPP_NODISCARD 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

VULKAN_HPP_NAMESPACE::CommandBuffer::traceRaysKHR
void traceRaysKHR(const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR *pRaygenShaderBindingTable, const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR *pMissShaderBindingTable, const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR *pHitShaderBindingTable, const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR *pCallableShaderBindingTable, uint32_t width, uint32_t height, uint32_t depth, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::CommandPool::NativeType
VkCommandPool NativeType
Definition: vulkan_handles.hpp:5954

VULKAN_HPP_NAMESPACE::CuModuleNVX::CuModuleNVX
VULKAN_HPP_CONSTEXPR CuModuleNVX(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6217

VULKAN_HPP_NAMESPACE::CommandBuffer::setDepthClampEnableEXT
void setDepthClampEnableEXT(VULKAN_HPP_NAMESPACE::Bool32 depthClampEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::CommandBuffer::copyMemoryToMicromapEXT
void copyMemoryToMicromapEXT(const VULKAN_HPP_NAMESPACE::CopyMemoryToMicromapInfoEXT *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::CommandPool::operator=
CommandPool & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:5973

VULKAN_HPP_NAMESPACE::RenderPassBeginInfo
Definition: vulkan_structs.hpp:86562

VULKAN_HPP_NAMESPACE::SamplerBorderColorComponentMappingCreateInfoEXT
Definition: vulkan_structs.hpp:90032

VULKAN_HPP_NAMESPACE::ValidationCacheEXT::ValidationCacheEXT
VULKAN_HPP_TYPESAFE_EXPLICIT ValidationCacheEXT(VkValidationCacheEXT validationCacheEXT) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7067

VULKAN_HPP_NAMESPACE::Instance
Definition: vulkan_handles.hpp:13780

VULKAN_HPP_NAMESPACE::CommandBuffer::beginQuery
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

VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR
Definition: vulkan_structs.hpp:946

VULKAN_HPP_NAMESPACE::CommandBuffer::buildAccelerationStructuresIndirectKHR
void buildAccelerationStructuresIndirectKHR(uint32_t infoCount, const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR *pInfos, const VULKAN_HPP_NAMESPACE::DeviceAddress *pIndirectDeviceAddresses, const uint32_t *pIndirectStrides, const uint32_t *const *ppMaxPrimitiveCounts, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::PhysicalDevice::getFeatures2KHR
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain< X, Y, Z...> getFeatures2KHR() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:14334

VULKAN_HPP_NAMESPACE::Device::getSwapchainImagesKHR
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

VULKAN_HPP_NAMESPACE::CommandBufferInheritanceConditionalRenderingInfoEXT
Definition: vulkan_structs.hpp:13718

VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT::objectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
Definition: vulkan_handles.hpp:1744

VULKAN_HPP_NAMESPACE::ConservativeRasterizationModeEXT
ConservativeRasterizationModeEXT
Definition: vulkan_enums.hpp:4941

VULKAN_HPP_NAMESPACE::CommandBuffer::setStencilTestEnable
void setStencilTestEnable(VULKAN_HPP_NAMESPACE::Bool32 stencilTestEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::QueryPool::operator=
QueryPool & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2265

VULKAN_HPP_NAMESPACE::Device::getSemaphoreCounterValueKHR
VULKAN_HPP_NODISCARD Result getSemaphoreCounterValueKHR(VULKAN_HPP_NAMESPACE::Semaphore semaphore, uint64_t *pValue, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::AccelerationStructureKHR::operator!=
bool operator!=(AccelerationStructureKHR const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3221

VULKAN_HPP_NAMESPACE::Format
Format
Definition: vulkan_enums.hpp:1127

VULKAN_HPP_NAMESPACE::DecompressMemoryRegionNV
Definition: vulkan_structs.hpp:19428

VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR
Definition: vulkan_structs.hpp:79181

VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT
Definition: vulkan_structs.hpp:77487

VULKAN_HPP_NAMESPACE::CommandBuffer::setCoverageToColorEnableNV
void setCoverageToColorEnableNV(VULKAN_HPP_NAMESPACE::Bool32 coverageToColorEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::PhysicalDevice::enumerateDeviceExtensionProperties
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

VULKAN_HPP_NAMESPACE::Device::writeAccelerationStructuresPropertyKHR
VULKAN_HPP_NODISCARD ResultValueType< DataType >::type writeAccelerationStructuresPropertyKHR(VULKAN_HPP_NAMESPACE::ArrayProxy< const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR > const &accelerationStructures, VULKAN_HPP_NAMESPACE::QueryType queryType, size_t stride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

VULKAN_HPP_NAMESPACE::UniqueHandle
Definition: vulkan.hpp:1166

VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR
Definition: vulkan_structs.hpp:28001

VULKAN_HPP_NAMESPACE::ObjectType::eSamplerYcbcrConversion

VULKAN_HPP_NAMESPACE::PhysicalDevice::enumerateDeviceLayerProperties
VULKAN_HPP_NODISCARD Result enumerateDeviceLayerProperties(uint32_t *pPropertyCount, VULKAN_HPP_NAMESPACE::LayerProperties *pProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderFeaturesNV
Definition: vulkan_structs.hpp:63009

VULKAN_HPP_NAMESPACE::Image::Image
VULKAN_HPP_CONSTEXPR Image()=default

VULKAN_HPP_NAMESPACE::AttachmentReference2
Definition: vulkan_structs.hpp:5743

VULKAN_HPP_NAMESPACE::Device::getRayTracingShaderGroupHandlesKHR
VULKAN_HPP_NODISCARD Result getRayTracingShaderGroupHandlesKHR(VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::CommandBuffer::bindShadingRateImageNV
void bindShadingRateImageNV(VULKAN_HPP_NAMESPACE::ImageView imageView, VULKAN_HPP_NAMESPACE::ImageLayout imageLayout, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::ImageView
Definition: vulkan_handles.hpp:2582

VULKAN_HPP_NAMESPACE::ValidationCacheEXT::debugReportObjectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
Definition: vulkan_handles.hpp:7061

VULKAN_HPP_NAMESPACE::ImageBlit
Definition: vulkan_structs.hpp:38007

VULKAN_HPP_NAMESPACE::Device::getPipelineExecutableInternalRepresentationsKHR
VULKAN_HPP_NODISCARD Result getPipelineExecutableInternalRepresentationsKHR(const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR *pExecutableInfo, uint32_t *pInternalRepresentationCount, VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR *pInternalRepresentations, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Buffer::debugReportObjectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
Definition: vulkan_handles.hpp:2334

VULKAN_HPP_NAMESPACE::ImageLayout
ImageLayout
Definition: vulkan_enums.hpp:2134

size
GLsizeiptr size
Definition: glcorearb.h:664

VULKAN_HPP_NAMESPACE::DeferredOperationKHR::DeferredOperationKHR
VULKAN_HPP_TYPESAFE_EXPLICIT DeferredOperationKHR(VkDeferredOperationKHR deferredOperationKHR) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:5706

VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate::DescriptorUpdateTemplate
VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorUpdateTemplate(VkDescriptorUpdateTemplate descriptorUpdateTemplate) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3020

VULKAN_HPP_NAMESPACE::BufferView::BufferView
VULKAN_HPP_TYPESAFE_EXPLICIT BufferView(VkBufferView bufferView) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:5878

VULKAN_HPP_NAMESPACE::Instance::operator!=
bool operator!=(Instance const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:13815

VULKAN_HPP_NAMESPACE::ProvokingVertexModeEXT
ProvokingVertexModeEXT
Definition: vulkan_enums.hpp:5590

VULKAN_HPP_NAMESPACE::CommandBuffer::beginRendering
void beginRendering(const VULKAN_HPP_NAMESPACE::RenderingInfo *pRenderingInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::CommandBuffer::fillBuffer
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

VULKAN_HPP_NAMESPACE::Event::objectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
Definition: vulkan_handles.hpp:3102

VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate::DescriptorUpdateTemplate
VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplate(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3019

VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan12Properties
Definition: vulkan_structs.hpp:76207

VULKAN_HPP_NAMESPACE::Device::createBufferView
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

dst
GLenum GLenum dst
Definition: glcorearb.h:1793

VULKAN_HPP_NAMESPACE::CommandBuffer::setDepthWriteEnableEXT
void setDepthWriteEnableEXT(VULKAN_HPP_NAMESPACE::Bool32 depthWriteEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Device::bindBufferMemory2KHR
VULKAN_HPP_NODISCARD Result bindBufferMemory2KHR(uint32_t bindInfoCount, const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo *pBindInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::CuFunctionNVX::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6178

VULKAN_HPP_NAMESPACE::CommandBufferSubmitInfo
Definition: vulkan_structs.hpp:14371

VULKAN_HPP_NAMESPACE::Device::getMicromapCompatibilityEXT
void getMicromapCompatibilityEXT(const VULKAN_HPP_NAMESPACE::MicromapVersionInfoEXT *pVersionInfo, VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR *pCompatibility, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

shader
GLuint shader
Definition: glcorearb.h:785

VULKAN_HPP_NAMESPACE::DisplayModeKHR::DisplayModeKHR
VULKAN_HPP_TYPESAFE_EXPLICIT DisplayModeKHR(VkDisplayModeKHR displayModeKHR) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:12317

VULKAN_HPP_NAMESPACE::BufferImageCopy2
Definition: vulkan_structs.hpp:11418

VULKAN_HPP_NAMESPACE::Queue::operator<
bool operator<(Queue const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7265

VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR
Definition: vulkan_structs.hpp:15497

VULKAN_HPP_NAMESPACE::AccelerationStructureNV::debugReportObjectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
Definition: vulkan_handles.hpp:2844

VULKAN_HPP_NAMESPACE::PerformanceValueINTEL
Definition: vulkan_structs.hpp:49705

VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2
Definition: vulkan_structs.hpp:59698

VULKAN_HPP_NAMESPACE::AccelerationStructureNV::operator!=
bool operator!=(AccelerationStructureNV const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2877

VULKAN_HPP_NAMESPACE::ValidationCacheEXT
Definition: vulkan_handles.hpp:7054

VULKAN_HPP_NAMESPACE::Device::createImage
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

usage
GLsizeiptr const void GLenum usage
Definition: glcorearb.h:664

VULKAN_HPP_NAMESPACE::PhysicalDevicePresentBarrierFeaturesNV
Definition: vulkan_structs.hpp:66275

VULKAN_HPP_NAMESPACE::DisplayKHR::NativeType
VkDisplayKHR NativeType
Definition: vulkan_handles.hpp:1824

VULKAN_HPP_NAMESPACE::CommandBuffer::setCoarseSampleOrderNV
void setCoarseSampleOrderNV(VULKAN_HPP_NAMESPACE::CoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV *pCustomSampleOrders, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Device::getGroupPresentCapabilitiesKHR
VULKAN_HPP_NODISCARD Result getGroupPresentCapabilitiesKHR(VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR *pDeviceGroupPresentCapabilities, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Event::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3154

VULKAN_HPP_NAMESPACE::Device::bindImageMemory
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS 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

VULKAN_HPP_NAMESPACE::LineRasterizationModeEXT
LineRasterizationModeEXT
Definition: vulkan_enums.hpp:5625

VULKAN_HPP_NAMESPACE::CommandBuffer::setCoverageToColorLocationNV
void setCoverageToColorLocationNV(uint32_t coverageToColorLocation, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::ImageView::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2640

VULKAN_HPP_NAMESPACE::Device::createSharedSwapchainsKHR
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

VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements
Definition: vulkan_structs.hpp:26520

VULKAN_HPP_NAMESPACE::Device::acquireProfilingLockKHR
VULKAN_HPP_NODISCARD Result acquireProfilingLockKHR(const VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::PipelineBindPoint
PipelineBindPoint
Definition: vulkan_enums.hpp:2981

VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicStateFeaturesEXT
Definition: vulkan_structs.hpp:56005

VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL::debugReportObjectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
Definition: vulkan_handles.hpp:2167

VULKAN_HPP_NAMESPACE::CuFunctionNVX::debugReportObjectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
Definition: vulkan_handles.hpp:6127

VULKAN_HPP_NAMESPACE::PipelineRepresentativeFragmentTestStateCreateInfoNV
Definition: vulkan_structs.hpp:81323

VULKAN_HPP_NAMESPACE::operator!=
bool operator!=(std::string const &lhs, ArrayWrapper1D< char, N > const &rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:360

operator!
Usd_Term operator!(Usd_PrimFlags flag)
Definition: primFlags.h:130

VULKAN_HPP_NAMESPACE::CommandBuffer::writeBufferMarkerAMD
void writeBufferMarkerAMD(VULKAN_HPP_NAMESPACE::PipelineStageFlagBits pipelineStage, VULKAN_HPP_NAMESPACE::Buffer dstBuffer, VULKAN_HPP_NAMESPACE::DeviceSize dstOffset, uint32_t marker, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::MicromapEXT::MicromapEXT
VULKAN_HPP_CONSTEXPR MicromapEXT()=default

VULKAN_HPP_NAMESPACE::GraphicsPipelineLibraryCreateInfoEXT
Definition: vulkan_structs.hpp:37122

VULKAN_HPP_NAMESPACE::PhysicalDevice::getOpticalFlowImageFormatsNV
VULKAN_HPP_NODISCARD Result getOpticalFlowImageFormatsNV(const VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatInfoNV *pOpticalFlowImageFormatInfo, uint32_t *pFormatCount, VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV *pImageFormatProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::CommandBuffer::setDepthBias
void setDepthBias(float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutTokenNV
Definition: vulkan_structs.hpp:43444

VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo
Definition: vulkan_structs.hpp:92193

VULKAN_HPP_NAMESPACE::Device::destroyRenderPass
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

VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR
Definition: vulkan_structs.hpp:28240

VULKAN_HPP_NAMESPACE::TraceRaysIndirectCommand2KHR
Definition: vulkan_structs.hpp:96420

VULKAN_HPP_NAMESPACE::Instance::createDisplayPlaneSurfaceKHR
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

VULKAN_HPP_NAMESPACE::CommandBuffer::pipelineBarrier2KHR
void pipelineBarrier2KHR(const VULKAN_HPP_NAMESPACE::DependencyInfo *pDependencyInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::CuFunctionNVX::objectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
Definition: vulkan_handles.hpp:6126

VULKAN_HPP_NAMESPACE::ObjectType::eSwapchainKHR

VULKAN_HPP_NAMESPACE::QueryPool::objectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
Definition: vulkan_handles.hpp:2248

VULKAN_HPP_NAMESPACE::Device::bindOpticalFlowSessionImageNV
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type bindOpticalFlowSessionImageNV(VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV session, VULKAN_HPP_NAMESPACE::OpticalFlowSessionBindingPointNV bindingPoint, VULKAN_HPP_NAMESPACE::ImageView view, VULKAN_HPP_NAMESPACE::ImageLayout layout, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR
Definition: vulkan_structs.hpp:73400

VULKAN_HPP_NAMESPACE::SampleCountFlagBits
SampleCountFlagBits
Definition: vulkan_enums.hpp:1719

VULKAN_HPP_NAMESPACE::BufferView::BufferView
VULKAN_HPP_CONSTEXPR BufferView(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:5877

VULKAN_HPP_NAMESPACE::Instance::enumeratePhysicalDeviceGroupsKHR
VULKAN_HPP_NODISCARD Result enumeratePhysicalDeviceGroupsKHR(uint32_t *pPhysicalDeviceGroupCount, VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD
Definition: vulkan_structs.hpp:70916

VULKAN_HPP_NAMESPACE::CommandBuffer::setFrontFace
void setFrontFace(VULKAN_HPP_NAMESPACE::FrontFace frontFace, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::CommandBuffer::copyImageToBuffer
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

VULKAN_HPP_NAMESPACE::ValidationFeaturesEXT
Definition: vulkan_structs.hpp:96898

VULKAN_HPP_NAMESPACE::Instance::Instance
VULKAN_HPP_CONSTEXPR Instance(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:13792

VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT
Definition: vulkan_structs.hpp:47511

VULKAN_HPP_NAMESPACE::ObjectType::eAccelerationStructureNV

VULKAN_HPP_NAMESPACE::SwapchainKHR::operator!=
bool operator!=(SwapchainKHR const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:1942

VULKAN_HPP_NAMESPACE::Device::initializePerformanceApiINTEL
VULKAN_HPP_NODISCARD Result initializePerformanceApiINTEL(const VULKAN_HPP_NAMESPACE::InitializePerformanceApiInfoINTEL *pInitializeInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR
Definition: vulkan_structs.hpp:58357

VULKAN_HPP_NAMESPACE::MemoryBarrier2
Definition: vulkan_structs.hpp:19850

VULKAN_HPP_NAMESPACE::Device::getGroupSurfacePresentModesKHR
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

values
GLenum GLsizei GLsizei GLint * values
Definition: glcorearb.h:1602

VULKAN_HPP_NAMESPACE::Semaphore::Semaphore
VULKAN_HPP_TYPESAFE_EXPLICIT Semaphore(VkSemaphore semaphore) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2003

VULKAN_HPP_NAMESPACE::ObjectType::eImageView

VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV
Definition: vulkan_structs.hpp:15327

VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineRobustnessPropertiesEXT
Definition: vulkan_structs.hpp:65705

VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT
Definition: vulkan_structs.hpp:24547

VULKAN_HPP_NAMESPACE::Device::createMicromapEXTUnique
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< VULKAN_HPP_NAMESPACE::MicromapEXT, Dispatch > >::type createMicromapEXTUnique(const VULKAN_HPP_NAMESPACE::MicromapCreateInfoEXT &createInfo, Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

VULKAN_HPP_NAMESPACE::CuFunctionNVX::operator<
bool operator<(CuFunctionNVX const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6162

color
GLuint color
Definition: glcorearb.h:1261

VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo
Definition: vulkan_structs.hpp:36780

VULKAN_HPP_NAMESPACE::CheckpointData2NV
Definition: vulkan_structs.hpp:12340

VULKAN_HPP_NAMESPACE::CommandBuffer::copyAccelerationStructureKHR
void copyAccelerationStructureKHR(const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::PhysicalDeviceBlendOperationAdvancedFeaturesEXT
Definition: vulkan_structs.hpp:50820

VULKAN_HPP_NAMESPACE::PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT
Definition: vulkan_structs.hpp:58728

VULKAN_HPP_NAMESPACE::MemoryDedicatedAllocateInfo
Definition: vulkan_structs.hpp:44969

VULKAN_HPP_NAMESPACE::Device::releasePerformanceConfigurationINTEL
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type releasePerformanceConfigurationINTEL(VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

VULKAN_HPP_NAMESPACE::PhysicalDevice::getMemoryProperties2KHR
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain< X, Y, Z...> getMemoryProperties2KHR() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:14502

VULKAN_HPP_NAMESPACE::DisplayKHR::operator==
bool operator==(DisplayKHR const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:1852

VULKAN_HPP_NAMESPACE::CommandBuffer::bindPipeline
void bindPipeline(VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, VULKAN_HPP_NAMESPACE::Pipeline pipeline, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::PipelineShaderStageRequiredSubgroupSizeCreateInfo
Definition: vulkan_structs.hpp:81794

VULKAN_HPP_NAMESPACE::RenderingInfo
Definition: vulkan_structs.hpp:89654

VULKAN_HPP_NAMESPACE::Device::createSemaphore
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

VULKAN_HPP_NAMESPACE::AccelerationStructureCaptureDescriptorDataInfoEXT
Definition: vulkan_structs.hpp:1175

VULKAN_HPP_NAMESPACE::Device::copyMicromapToMemoryEXT
VULKAN_HPP_NODISCARD Result copyMicromapToMemoryEXT(VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, const VULKAN_HPP_NAMESPACE::CopyMicromapToMemoryInfoEXT *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Device::resetDescriptorPool
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

VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT::debugReportObjectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
Definition: vulkan_handles.hpp:1657

VULKAN_HPP_NAMESPACE::Buffer::operator!=
bool operator!=(Buffer const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2364

VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX
Definition: vulkan_structs.hpp:63910

VULKAN_HPP_NAMESPACE::CommandBuffer::copyBuffer2KHR
void copyBuffer2KHR(const VULKAN_HPP_NAMESPACE::CopyBufferInfo2 *pCopyBufferInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::CommandBufferInheritanceViewportScissorInfoNV
Definition: vulkan_structs.hpp:14248

VULKAN_HPP_NAMESPACE::Event::Event
VULKAN_HPP_CONSTEXPR Event(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3108

VULKAN_HPP_NAMESPACE::DedicatedAllocationImageCreateInfoNV
Definition: vulkan_structs.hpp:19646

VULKAN_HPP_NAMESPACE::PerformanceCounterKHR
Definition: vulkan_structs.hpp:49053

VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2
Definition: vulkan_structs.hpp:11909

VULKAN_HPP_NAMESPACE::Device::getSamplerOpaqueCaptureDescriptorDataEXT
VULKAN_HPP_NODISCARD Result getSamplerOpaqueCaptureDescriptorDataEXT(const VULKAN_HPP_NAMESPACE::SamplerCaptureDescriptorDataInfoEXT *pInfo, void *pData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::DeviceMemory::operator==
bool operator==(DeviceMemory const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:5559

VULKAN_HPP_NAMESPACE::Device::getPastPresentationTimingGOOGLE
VULKAN_HPP_NODISCARD Result getPastPresentationTimingGOOGLE(VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, uint32_t *pPresentationTimingCount, VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE *pPresentationTimings, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT
Definition: vulkan_structs.hpp:97192

VULKAN_HPP_NAMESPACE::Device::createFence
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

VULKAN_HPP_NAMESPACE::PhysicalDevice::getProperties2
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain< X, Y, Z...> getProperties2() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:12591

VULKAN_HPP_NAMESPACE::Image::NativeType
VkImage NativeType
Definition: vulkan_handles.hpp:2756

VULKAN_HPP_NAMESPACE::PhysicalDevice::createDisplayModeKHRUnique
VULKAN_HPP_NODISCARD 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

VULKAN_HPP_NAMESPACE::ValidationCacheEXT::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7114

VULKAN_HPP_NAMESPACE::CommandBuffer::setSampleLocationsEXT
void setSampleLocationsEXT(const VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT *pSampleLocationsInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::CommandBuffer::setScissor
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

VULKAN_HPP_NAMESPACE::Device::freeCommandBuffers
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

VULKAN_HPP_NAMESPACE::CommandBuffer::setSampleMaskEXT
void setSampleMaskEXT(VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples, const VULKAN_HPP_NAMESPACE::SampleMask *pSampleMask, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Device::getImageMemoryRequirements
void getImageMemoryRequirements(VULKAN_HPP_NAMESPACE::Image image, VULKAN_HPP_NAMESPACE::MemoryRequirements *pMemoryRequirements, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::CommandBuffer::nextSubpass2KHR
void nextSubpass2KHR(const VULKAN_HPP_NAMESPACE::SubpassBeginInfo *pSubpassBeginInfo, const VULKAN_HPP_NAMESPACE::SubpassEndInfo *pSubpassEndInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::DescriptorPool::debugReportObjectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
Definition: vulkan_handles.hpp:6297

VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR
Definition: vulkan_structs.hpp:15617

VULKAN_HPP_NAMESPACE::Framebuffer::Framebuffer
VULKAN_HPP_CONSTEXPR Framebuffer(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6475

VULKAN_HPP_NAMESPACE::PhysicalDeviceImagelessFramebufferFeatures
Definition: vulkan_structs.hpp:60354

VULKAN_HPP_NAMESPACE::CommandBuffer::clearAttachments
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

VULKAN_HPP_NAMESPACE::Device::destroyCuFunctionNVX
void destroyCuFunctionNVX(VULKAN_HPP_NAMESPACE::CuFunctionNVX function, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Device::getQueue2
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

VULKAN_HPP_NAMESPACE::PhysicalDevice::operator!=
bool operator!=(PhysicalDevice const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:12434

VULKAN_HPP_NAMESPACE::DeviceGroupRenderPassBeginInfo
Definition: vulkan_structs.hpp:25801

VULKAN_HPP_NAMESPACE::Device::destroyFence
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

VULKAN_HPP_NAMESPACE::PhysicalDeviceAccelerationStructureFeaturesKHR
Definition: vulkan_structs.hpp:50239

VULKAN_HPP_NAMESPACE::PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT
Definition: vulkan_structs.hpp:66675

VULKAN_HPP_NAMESPACE::SubpassDependency2
Definition: vulkan_structs.hpp:87622

VULKAN_HPP_NAMESPACE::PhysicalDeviceRepresentativeFragmentTestFeaturesNV
Definition: vulkan_structs.hpp:68776

VULKAN_HPP_NAMESPACE::PrivateDataSlot::NativeType
VkPrivateDataSlot NativeType
Definition: vulkan_handles.hpp:6634

VULKAN_HPP_NAMESPACE::RenderPassMultiviewCreateInfo
Definition: vulkan_structs.hpp:88538

VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPropertiesNV
Definition: vulkan_structs.hpp:68650

VULKAN_HPP_NAMESPACE::PhysicalDeviceCoherentMemoryFeaturesAMD
Definition: vulkan_structs.hpp:51396

VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV
Definition: vulkan_handles.hpp:2925

VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT
#define VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT
Definition: vulkan.hpp:5886

VULKAN_HPP_NAMESPACE::StencilOp
StencilOp
Definition: vulkan_enums.hpp:2617

VULKAN_HPP_NAMESPACE::createInstance
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result createInstance(const VULKAN_HPP_NAMESPACE::InstanceCreateInfo *pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, VULKAN_HPP_NAMESPACE::Instance *pInstance, Dispatch const &d) VULKAN_HPP_NOEXCEPT
Definition: vulkan_funcs.hpp:20

VULKAN_HPP_NAMESPACE::DisplayModeKHR::objectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
Definition: vulkan_handles.hpp:12310

VULKAN_HPP_NAMESPACE::Device::trimCommandPoolKHR
void trimCommandPoolKHR(VULKAN_HPP_NAMESPACE::CommandPool commandPool, VULKAN_HPP_NAMESPACE::CommandPoolTrimFlags flags, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT
#define VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT
Definition: vulkan.hpp:5884

index
GLuint index
Definition: glcorearb.h:786

VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreatePrivateDataInfoNV
Definition: vulkan_structs.hpp:48656

VULKAN_HPP_NAMESPACE::operator==
bool operator==(std::string const &lhs, ArrayWrapper1D< char, N > const &rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:354

VULKAN_HPP_NAMESPACE::CommandBufferInheritanceRenderPassTransformInfoQCOM
Definition: vulkan_structs.hpp:13818

VULKAN_HPP_NAMESPACE::DeviceGroupSubmitInfo
Definition: vulkan_structs.hpp:25942

VULKAN_HPP_NAMESPACE::Device::destroyValidationCacheEXT
void destroyValidationCacheEXT(VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::WriteDescriptorSetAccelerationStructureKHR
Definition: vulkan_structs.hpp:106590

VULKAN_HPP_NAMESPACE::CommandBuffer::setConservativeRasterizationModeEXT
void setConservativeRasterizationModeEXT(VULKAN_HPP_NAMESPACE::ConservativeRasterizationModeEXT conservativeRasterizationMode, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Device::createAccelerationStructureKHR
VULKAN_HPP_NODISCARD Result createAccelerationStructureKHR(const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR *pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, VULKAN_HPP_NAMESPACE::AccelerationStructureKHR *pAccelerationStructure, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::PhysicalDevice::NativeType
VkPhysicalDevice NativeType
Definition: vulkan_handles.hpp:12403

VULKAN_HPP_NAMESPACE::PhysicalDevice::getQueueFamilyProperties2
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector< StructureChain > getQueueFamilyProperties2() const
Definition: vulkan_raii.hpp:12670

VULKAN_HPP_NAMESPACE::Sampler::operator=
Sampler & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6818

VULKAN_HPP_NAMESPACE::Device::waitForFences
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

VULKAN_HPP_NAMESPACE::CommandBuffer::decompressMemoryIndirectCountNV
void decompressMemoryIndirectCountNV(VULKAN_HPP_NAMESPACE::DeviceAddress indirectCommandsAddress, VULKAN_HPP_NAMESPACE::DeviceAddress indirectCommandsCountAddress, uint32_t stride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::RenderPassCreationFeedbackInfoEXT
Definition: vulkan_structs.hpp:88141

VULKAN_HPP_NAMESPACE::ObjectType::eSampler

VULKAN_HPP_NAMESPACE::Device::registerDisplayEventEXT
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

VULKAN_HPP_NAMESPACE::PhysicalDevice::getSupportedFramebufferMixedSamplesCombinationsNV
VULKAN_HPP_NODISCARD Result getSupportedFramebufferMixedSamplesCombinationsNV(uint32_t *pCombinationCount, VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV *pCombinations, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Device::compileDeferredNV
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type compileDeferredNV(VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t shader, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

VULKAN_HPP_NAMESPACE::PhysicalDevice8BitStorageFeatures
Definition: vulkan_structs.hpp:50017

VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo
Definition: vulkan_structs.hpp:84272

VULKAN_HPP_NAMESPACE::Device::getSwapchainStatusKHR
VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result getSwapchainStatusKHR(VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

VULKAN_HPP_NAMESPACE::RenderPassInputAttachmentAspectCreateInfo
Definition: vulkan_structs.hpp:88407

VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2
Definition: vulkan_structs.hpp:56816

VULKAN_HPP_NAMESPACE::CommandBuffer::setColorWriteEnableEXT
void setColorWriteEnableEXT(uint32_t attachmentCount, const VULKAN_HPP_NAMESPACE::Bool32 *pColorWriteEnables, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::CompareOp
CompareOp
Definition: vulkan_enums.hpp:2328

VULKAN_HPP_NAMESPACE::AccelerationStructureKHR::AccelerationStructureKHR
VULKAN_HPP_CONSTEXPR AccelerationStructureKHR()=default

VULKAN_HPP_NAMESPACE::Buffer::operator==
bool operator==(Buffer const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2359

VULKAN_HPP_NAMESPACE::SetStateFlagsIndirectCommandNV
Definition: vulkan_structs.hpp:92118

VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo
Definition: vulkan_structs.hpp:22761

VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT
Definition: vulkan_structs.hpp:18716

VULKAN_HPP_NAMESPACE::CommandBuffer::setCoverageModulationTableEnableNV
void setCoverageModulationTableEnableNV(VULKAN_HPP_NAMESPACE::Bool32 coverageModulationTableEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::AccelerationStructureNV::objectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
Definition: vulkan_handles.hpp:2843

VULKAN_HPP_NAMESPACE::PipelineCoverageModulationStateCreateInfoNV
Definition: vulkan_structs.hpp:78393

VULKAN_HPP_NAMESPACE::CommandBuffer::copyMicromapEXT
void copyMicromapEXT(const VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::PhysicalDevice::getCooperativeMatrixPropertiesNV
VULKAN_HPP_NODISCARD Result getCooperativeMatrixPropertiesNV(uint32_t *pPropertyCount, VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV *pProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::PhysicalDevice::getMemoryProperties2
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain< X, Y, Z...> getMemoryProperties2() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:12709

VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV::objectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
Definition: vulkan_handles.hpp:2931

VULKAN_HPP_NAMESPACE::AccelerationStructureNV::AccelerationStructureNV
VULKAN_HPP_TYPESAFE_EXPLICIT AccelerationStructureNV(VkAccelerationStructureNV accelerationStructureNV) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2850

VULKAN_HPP_NAMESPACE::Device::createComputePipelines
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

VULKAN_HPP_NAMESPACE::PhysicalDevice::getExternalFencePropertiesKHR
void getExternalFencePropertiesKHR(const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo *pExternalFenceInfo, VULKAN_HPP_NAMESPACE::ExternalFenceProperties *pExternalFenceProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Device::setDebugUtilsObjectTagEXT
VULKAN_HPP_NODISCARD Result setDebugUtilsObjectTagEXT(const VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT *pTagInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::MicromapEXT::NativeType
VkMicromapEXT NativeType
Definition: vulkan_handles.hpp:3273

VULKAN_HPP_NAMESPACE::CommandBuffer::setDepthTestEnableEXT
void setDepthTestEnableEXT(VULKAN_HPP_NAMESPACE::Bool32 depthTestEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures
Definition: vulkan_structs.hpp:77684

VULKAN_HPP_NAMESPACE::DescriptorPool::operator<
bool operator<(DescriptorPool const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6332

VULKAN_HPP_NAMESPACE::CommandBuffer::setPerformanceMarkerINTEL
VULKAN_HPP_NODISCARD Result setPerformanceMarkerINTEL(const VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL *pMarkerInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorUpdateTemplate

VULKAN_HPP_NAMESPACE::Device::createRenderPass2
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

VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackCreateInfo
Definition: vulkan_structs.hpp:78874

VULKAN_HPP_NAMESPACE::PhysicalDevice::createDeviceUnique
VULKAN_HPP_NODISCARD 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

VULKAN_HPP_NAMESPACE::PhysicalDevice::getSparseImageFormatProperties2KHR
void getSparseImageFormatProperties2KHR(const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 *pFormatInfo, uint32_t *pPropertyCount, VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2 *pProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Device::destroyImage
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

VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticValueKHR
Definition: vulkan_structs.hpp:79500

VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX
Definition: vulkan_structs.hpp:41136

VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR
Definition: vulkan_structs.hpp:4066

VULKAN_HPP_NAMESPACE::PhysicalDevice::PhysicalDevice
VULKAN_HPP_CONSTEXPR PhysicalDevice(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:12411

VULKAN_HPP_NAMESPACE::CommandBuffer::setColorBlendEquationEXT
void setColorBlendEquationEXT(uint32_t firstAttachment, uint32_t attachmentCount, const VULKAN_HPP_NAMESPACE::ColorBlendEquationEXT *pColorBlendEquations, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Device::writeAccelerationStructuresPropertiesKHR
VULKAN_HPP_NODISCARD Result writeAccelerationStructuresPropertiesKHR(uint32_t accelerationStructureCount, const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR *pAccelerationStructures, VULKAN_HPP_NAMESPACE::QueryType queryType, size_t dataSize, void *pData, size_t stride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Instance::debugReportObjectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
Definition: vulkan_handles.hpp:13787

VULKAN_HPP_NAMESPACE::Device::getImageSparseMemoryRequirementsKHR
void getImageSparseMemoryRequirementsKHR(const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements *pInfo, uint32_t *pSparseMemoryRequirementCount, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 *pSparseMemoryRequirements, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT
Definition: vulkan_structs.hpp:50720

VULKAN_HPP_NAMESPACE::ResultValueType::type
T type
Definition: vulkan.hpp:6594

VULKAN_HPP_NAMESPACE::PipelineCreationFeedback
Definition: vulkan_structs.hpp:78800

VULKAN_HPP_NAMESPACE::DeferredOperationKHR::operator!=
bool operator!=(DeferredOperationKHR const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:5733

VULKAN_HPP_NAMESPACE::CommandBuffer::drawMeshTasksIndirectNV
void drawMeshTasksIndirectNV(VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::PhysicalDevicePCIBusInfoPropertiesEXT
Definition: vulkan_structs.hpp:64827

VULKAN_HPP_NAMESPACE::CuModuleNVX::debugReportObjectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
Definition: vulkan_handles.hpp:6212

VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV
Definition: vulkan_structs.hpp:34655

VULKAN_HPP_NAMESPACE::Instance::destroySurfaceKHR
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

VULKAN_HPP_NAMESPACE::Device::resetCommandPool
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

VULKAN_HPP_NAMESPACE::MemoryRequirements2
Definition: vulkan_structs.hpp:46206

VULKAN_HPP_NAMESPACE::Device::getMemoryRemoteAddressNV
VULKAN_HPP_NODISCARD Result getMemoryRemoteAddressNV(const VULKAN_HPP_NAMESPACE::MemoryGetRemoteAddressInfoNV *pMemoryGetRemoteAddressInfo, VULKAN_HPP_NAMESPACE::RemoteAddressNV *pAddress, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Device::getDescriptorSetLayoutSizeEXT
void getDescriptorSetLayoutSizeEXT(VULKAN_HPP_NAMESPACE::DescriptorSetLayout layout, VULKAN_HPP_NAMESPACE::DeviceSize *pLayoutSizeInBytes, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::PhysicalDeviceInheritedViewportScissorFeaturesNV
Definition: vulkan_structs.hpp:60550

VULKAN_HPP_NAMESPACE::SubmitInfo2
Definition: vulkan_structs.hpp:93554

VULKAN_HPP_NAMESPACE::PolygonMode
PolygonMode
Definition: vulkan_enums.hpp:2551

VULKAN_HPP_NAMESPACE::Device::getRayTracingShaderGroupStackSizeKHR
DeviceSize getRayTracingShaderGroupStackSizeKHR(VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t group, VULKAN_HPP_NAMESPACE::ShaderGroupShaderKHR groupShader, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::AccelerationStructureNV::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2898

VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV::IndirectCommandsLayoutNV
VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutNV()=default

VULKAN_HPP_NAMESPACE::CommandBuffer::drawIndexedIndirect
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

VULKAN_HPP_NAMESPACE::ShaderModule::objectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
Definition: vulkan_handles.hpp:6975

VULKAN_HPP_NAMESPACE::BaseOutStructure
Definition: vulkan_structs.hpp:6600

VULKAN_HPP_NAMESPACE::DescriptorSet::debugReportObjectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
Definition: vulkan_handles.hpp:2504

VULKAN_HPP_NAMESPACE::PhysicalDevice::getSurfaceCapabilities2EXT
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

VULKAN_HPP_NAMESPACE::Device::createDescriptorUpdateTemplate
VULKAN_HPP_NODISCARD Result createDescriptorUpdateTemplate(const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo *pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate *pDescriptorUpdateTemplate, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::TextureLODGatherFormatPropertiesAMD
Definition: vulkan_structs.hpp:96056

VULKAN_HPP_NAMESPACE::PipelineCache::operator=
PipelineCache & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6058

VULKAN_HPP_NAMESPACE::PrimitiveTopology
PrimitiveTopology
Definition: vulkan_enums.hpp:2559

VULKAN_HPP_NAMESPACE::PhysicalDeviceScalarBlockLayoutFeatures
Definition: vulkan_structs.hpp:69380

VULKAN_HPP_NAMESPACE::Device::operator=
Device & operator=(VkDevice device) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7744

VULKAN_HPP_NAMESPACE::ImageStencilUsageCreateInfo
Definition: vulkan_structs.hpp:40415

VULKAN_HPP_DEFAULT_DISPATCHER_TYPE
#define VULKAN_HPP_DEFAULT_DISPATCHER_TYPE
Definition: vulkan.hpp:5875

VULKAN_HPP_NAMESPACE::Device::createSwapchainKHRUnique
VULKAN_HPP_NODISCARD 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

VULKAN_HPP_NAMESPACE::Device::createCuFunctionNVX
VULKAN_HPP_NODISCARD Result createCuFunctionNVX(const VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX *pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, VULKAN_HPP_NAMESPACE::CuFunctionNVX *pFunction, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::PhysicalDevicePresentIdFeaturesKHR
Definition: vulkan_structs.hpp:66372

VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRatePropertiesKHR
Definition: vulkan_structs.hpp:58444

VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX
Definition: vulkan_structs.hpp:17534

VULKAN_HPP_NAMESPACE::WriteDescriptorSet
Definition: vulkan_structs.hpp:106359

VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan13Features
Definition: vulkan_structs.hpp:76590

VULKAN_HPP_NAMESPACE::CommandBuffer::clearDepthStencilImage
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

VULKAN_HPP_NAMESPACE::Sampler::operator!=
bool operator!=(Sampler const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6832

VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo
Definition: vulkan_structs.hpp:26631

VULKAN_HPP_NAMESPACE::RenderingFragmentShadingRateAttachmentInfoKHR
Definition: vulkan_structs.hpp:89531

VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataEXT
Definition: vulkan_structs.hpp:18844

VULKAN_HPP_NAMESPACE::Device::createRayTracingPipelinesKHRUnique
VULKAN_HPP_NODISCARD ResultValue< std::vector< UniqueHandle< VULKAN_HPP_NAMESPACE::Pipeline, Dispatch >, PipelineAllocator > > createRayTracingPipelinesKHRUnique(VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, VULKAN_HPP_NAMESPACE::ArrayProxy< const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR > const &createInfos, Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

VULKAN_HPP_NAMESPACE::PhysicalDeviceImageCompressionControlFeaturesEXT
Definition: vulkan_structs.hpp:59342

VULKAN_HPP_NAMESPACE::PerformanceOverrideInfoINTEL
Definition: vulkan_structs.hpp:49322

VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT
Definition: vulkan_structs.hpp:18194

VULKAN_HPP_NAMESPACE::PhysicalDeviceSamplerFilterMinmaxProperties
Definition: vulkan_structs.hpp:69193

VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV::IndirectCommandsLayoutNV
VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutNV(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6560

VULKAN_HPP_NAMESPACE::Device::createCommandPool
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

VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV::debugReportObjectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
Definition: vulkan_handles.hpp:6555

VULKAN_HPP_NAMESPACE::CommandBuffer::setCullModeEXT
void setCullModeEXT(VULKAN_HPP_NAMESPACE::CullModeFlags cullMode, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Device::destroyDescriptorUpdateTemplate
void destroyDescriptorUpdateTemplate(VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::PhysicalDevice::getSurfaceFormats2KHR
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

VULKAN_HPP_NAMESPACE::MicromapEXT::MicromapEXT
VULKAN_HPP_TYPESAFE_EXPLICIT MicromapEXT(VkMicromapEXT micromapEXT) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3282

VULKAN_HPP_NAMESPACE::CommandBuffer::setDepthBiasEnable
void setDepthBiasEnable(VULKAN_HPP_NAMESPACE::Bool32 depthBiasEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Device::getQueryPoolResults
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

VULKAN_HPP_NAMESPACE::SurfaceKHR::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:1623

width
GLint GLsizei width
Definition: glcorearb.h:103

VULKAN_HPP_NAMESPACE::PhysicalDeviceOpticalFlowFeaturesNV
Definition: vulkan_structs.hpp:64590

VULKAN_HPP_NAMESPACE::CommandBuffer::CommandBuffer
VULKAN_HPP_CONSTEXPR CommandBuffer()=default

VULKAN_HPP_NAMESPACE::ValidationCacheEXT::operator==
bool operator==(ValidationCacheEXT const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7088

VULKAN_HPP_NAMESPACE::Device::createOpticalFlowSessionNV
VULKAN_HPP_NODISCARD Result createOpticalFlowSessionNV(const VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreateInfoNV *pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV *pSession, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE
Definition: vulkan_structs.hpp:86370

VULKAN_HPP_NAMESPACE::Device::destroy
void destroy(const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Device::destroyEvent
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

VULKAN_HPP_NAMESPACE::Device::getSemaphoreFdKHR
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

VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR
Definition: vulkan_structs.hpp:94596

VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate
Definition: vulkan_handles.hpp:3007

VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV::operator==
bool operator==(OpticalFlowSessionNV const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2960

VULKAN_HPP_NAMESPACE::CommandBuffer::NativeType
VkCommandBuffer NativeType
Definition: vulkan_handles.hpp:3352

VULKAN_HPP_NAMESPACE::DeferredOperationKHR::DeferredOperationKHR
VULKAN_HPP_CONSTEXPR DeferredOperationKHR(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:5705

VULKAN_HPP_NAMESPACE::SubpassEndInfo
Definition: vulkan_structs.hpp:93992

VULKAN_HPP_NAMESPACE::ImageCreateInfo
Definition: vulkan_structs.hpp:26245

VULKAN_HPP_NAMESPACE::Device::getImageViewAddressNVX
VULKAN_HPP_NODISCARD Result getImageViewAddressNVX(VULKAN_HPP_NAMESPACE::ImageView imageView, VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX *pProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::CommandPool::objectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
Definition: vulkan_handles.hpp:5956

view
Definition: core.h:982

VULKAN_HPP_NAMESPACE::Buffer::operator<
bool operator<(Buffer const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2369

VULKAN_HPP_NAMESPACE::PhysicalDevice::getSurfaceSupportKHR
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

VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV
Definition: vulkan_structs.hpp:32438

VULKAN_HPP_NAMESPACE::DescriptorSetLayout::DescriptorSetLayout
VULKAN_HPP_CONSTEXPR DescriptorSetLayout()=default

VULKAN_HPP_NAMESPACE::DescriptorGetInfoEXT
Definition: vulkan_structs.hpp:21155

VULKAN_HPP_NAMESPACE::PhysicalDevice::getProperties
void getProperties(VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties *pProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::MemoryOpaqueCaptureAddressAllocateInfo
Definition: vulkan_structs.hpp:45940

VULKAN_HPP_NAMESPACE::Framebuffer::NativeType
VkFramebuffer NativeType
Definition: vulkan_handles.hpp:6467

VULKAN_HPP_NAMESPACE::PhysicalDevice::acquireDrmDisplayEXT
ResultValueType< void >::type acquireDrmDisplayEXT(int32_t drmFd, VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

VULKAN_HPP_NAMESPACE::CommandBuffer::endDebugUtilsLabelEXT
void endDebugUtilsLabelEXT(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::SamplerCustomBorderColorCreateInfoEXT
Definition: vulkan_structs.hpp:90506

VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorIndexingProperties
Definition: vulkan_structs.hpp:54053

VULKAN_HPP_NAMESPACE::CommandBuffer::copyBuffer
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

VULKAN_HPP_NAMESPACE::ShaderModule::ShaderModule
VULKAN_HPP_CONSTEXPR ShaderModule(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6981

VULKAN_HPP_NAMESPACE::Device::getDescriptorSetLayoutSupportKHR
void getDescriptorSetLayoutSupportKHR(const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo *pCreateInfo, VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport *pSupport, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::PhysicalDeviceHostQueryResetFeatures
Definition: vulkan_structs.hpp:59035

VULKAN_HPP_NAMESPACE::PhysicalDevice::getImageFormatProperties
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

VULKAN_HPP_NAMESPACE::CommandBuffer::nextSubpass2
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

VULKAN_HPP_NAMESPACE::CommandBuffer::dispatchIndirect
void dispatchIndirect(VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Device::createRenderPassUnique
VULKAN_HPP_NODISCARD 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

VULKAN_HPP_NAMESPACE::Device::createValidationCacheEXT
VULKAN_HPP_NODISCARD Result createValidationCacheEXT(const VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT *pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, VULKAN_HPP_NAMESPACE::ValidationCacheEXT *pValidationCache, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::PhysicalDeviceTilePropertiesFeaturesQCOM
Definition: vulkan_structs.hpp:73899

VULKAN_HPP_NAMESPACE::Device::createImageViewUnique
VULKAN_HPP_NODISCARD 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

VULKAN_HPP_NAMESPACE::Sampler
Definition: vulkan_handles.hpp:6795

VULKAN_HPP_NAMESPACE::Fence::operator<
bool operator<(Fence const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2117

VULKAN_HPP_NAMESPACE::BufferView::operator=
BufferView & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:5888

VULKAN_HPP_NAMESPACE::Device::createEvent
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

VULKAN_HPP_NAMESPACE::CommandBuffer::drawMeshTasksIndirectCountNV
void drawMeshTasksIndirectCountNV(VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, VULKAN_HPP_NAMESPACE::Buffer countBuffer, VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::DescriptorSetLayout::debugReportObjectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
Definition: vulkan_handles.hpp:6382

VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR
Definition: vulkan_structs.hpp:94715

VULKAN_HPP_NAMESPACE::CommandBuffer::setShadingRateImageEnableNV
void setShadingRateImageEnableNV(VULKAN_HPP_NAMESPACE::Bool32 shadingRateImageEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::AttachmentSampleCountInfoAMD
Definition: vulkan_structs.hpp:5962

VULKAN_HPP_NAMESPACE::DisplayKHR::debugReportObjectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
Definition: vulkan_handles.hpp:1827

VULKAN_HPP_NAMESPACE::AccelerationStructureKHR::objectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
Definition: vulkan_handles.hpp:3187

VULKAN_HPP_NAMESPACE::CommandBuffer::setDeviceMask
void setDeviceMask(uint32_t deviceMask, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::DescriptorSetVariableDescriptorCountAllocateInfo
Definition: vulkan_structs.hpp:22423

VULKAN_HPP_NAMESPACE::DisplayKHR::operator<
bool operator<(DisplayKHR const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:1862

VULKAN_HPP_NAMESPACE::Device::operator=
Device & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7750

VULKAN_HPP_NAMESPACE::CommandBuffer::copyImageToBuffer2KHR
void copyImageToBuffer2KHR(const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 *pCopyImageToBufferInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR
Definition: vulkan_structs.hpp:48955

VULKAN_HPP_NAMESPACE::Device::createCuModuleNVXUnique
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< VULKAN_HPP_NAMESPACE::CuModuleNVX, Dispatch > >::type createCuModuleNVXUnique(const VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX &createInfo, Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

VULKAN_HPP_NAMESPACE::ObjectType::eImage

VULKAN_HPP_NAMESPACE::ImportMemoryHostPointerInfoEXT
Definition: vulkan_structs.hpp:42157

VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT::operator=
DebugReportCallbackEXT & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:1676

VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties
Definition: vulkan_structs.hpp:66991

VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMap2PropertiesEXT
Definition: vulkan_structs.hpp:57191

value
Definition: core.h:1131

VULKAN_HPP_NAMESPACE::PipelineCache::debugReportObjectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
Definition: vulkan_handles.hpp:6042

VULKAN_HPP_NAMESPACE::PhysicalDevice::getDisplayProperties2KHR
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

VULKAN_HPP_NAMESPACE::Device::destroyIndirectCommandsLayoutNV
void destroyIndirectCommandsLayoutNV(VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV indirectCommandsLayout, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::CommandBuffer::endQueryIndexedEXT
void endQueryIndexedEXT(VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query, uint32_t index, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate::NativeType
VkDescriptorUpdateTemplate NativeType
Definition: vulkan_handles.hpp:3011

VULKAN_HPP_NAMESPACE::PhysicalDeviceOpticalFlowPropertiesNV
Definition: vulkan_structs.hpp:64686

VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderClockFeaturesKHR
Definition: vulkan_structs.hpp:70174

VULKAN_HPP_NAMESPACE::ResultValue
Definition: vulkan.hpp:6513

VULKAN_HPP_NAMESPACE::GeometryTrianglesNV
Definition: vulkan_structs.hpp:1441

VULKAN_HPP_NAMESPACE::DedicatedAllocationBufferCreateInfoNV
Definition: vulkan_structs.hpp:19548

VULKAN_HPP_NAMESPACE::MicromapVersionInfoEXT
Definition: vulkan_structs.hpp:47238

VULKAN_HPP_NAMESPACE::DeviceMemoryReportCallbackDataEXT
Definition: vulkan_structs.hpp:26828

VULKAN_HPP_NAMESPACE::ConformanceVersion
Definition: vulkan_structs.hpp:15227

VULKAN_HPP_NAMESPACE::Device::getImageSparseMemoryRequirements2KHR
void getImageSparseMemoryRequirements2KHR(const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 *pInfo, uint32_t *pSparseMemoryRequirementCount, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 *pSparseMemoryRequirements, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::DisplayModeKHR::operator==
bool operator==(DisplayModeKHR const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:12336

VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV
Definition: vulkan_handles.hpp:6548

VULKAN_HPP_NAMESPACE::PhysicalDevice::getExternalImageFormatPropertiesNV
VULKAN_HPP_NODISCARD Result getExternalImageFormatPropertiesNV(VULKAN_HPP_NAMESPACE::Format format, VULKAN_HPP_NAMESPACE::ImageType type, VULKAN_HPP_NAMESPACE::ImageTiling tiling, VULKAN_HPP_NAMESPACE::ImageUsageFlags usage, VULKAN_HPP_NAMESPACE::ImageCreateFlags flags, VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV externalHandleType, VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV *pExternalImageFormatProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL::objectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
Definition: vulkan_handles.hpp:2166

VULKAN_HPP_NAMESPACE::PhysicalDevice::getDisplayModePropertiesKHR
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

VULKAN_HPP_NAMESPACE::CommandBuffer::setDescriptorBufferOffsetsEXT
void setDescriptorBufferOffsetsEXT(VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, VULKAN_HPP_NAMESPACE::PipelineLayout layout, uint32_t firstSet, uint32_t setCount, const uint32_t *pBufferIndices, const VULKAN_HPP_NAMESPACE::DeviceSize *pOffsets, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::CommandPool::CommandPool
VULKAN_HPP_CONSTEXPR CommandPool()=default

VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT
Definition: vulkan_structs.hpp:18079

VULKAN_HPP_NAMESPACE::ImageFormatListCreateInfo
Definition: vulkan_structs.hpp:39370

VULKAN_HPP_NAMESPACE::DescriptorPool::operator==
bool operator==(DescriptorPool const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6322

VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo
Definition: vulkan_structs.hpp:13608

VULKAN_HPP_NAMESPACE::CuModuleNVX::CuModuleNVX
VULKAN_HPP_CONSTEXPR CuModuleNVX()=default

VULKAN_HPP_NAMESPACE::DescriptorType
DescriptorType
Definition: vulkan_enums.hpp:2824

VULKAN_HPP_NAMESPACE::CuModuleNVX::operator==
bool operator==(CuModuleNVX const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6237

VULKAN_HPP_NAMESPACE::TimeDomainEXT
TimeDomainEXT
Definition: vulkan_enums.hpp:5398

VULKAN_HPP_NAMESPACE::ViewportWScalingNV
Definition: vulkan_structs.hpp:83080

VULKAN_HPP_NAMESPACE::CommandPool
Definition: vulkan_handles.hpp:5950

VULKAN_HPP_NAMESPACE::CommandBuffer::copyMemoryToAccelerationStructureKHR
void copyMemoryToAccelerationStructureKHR(const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::CommandBuffer::drawIndexedIndirectCountAMD
void drawIndexedIndirectCountAMD(VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, VULKAN_HPP_NAMESPACE::Buffer countBuffer, VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties
Definition: vulkan_structs.hpp:74179

VULKAN_HPP_NAMESPACE::ImageSubresource2EXT
Definition: vulkan_structs.hpp:40513

VULKAN_HPP_NAMESPACE::CopyMicromapToMemoryInfoEXT
Definition: vulkan_structs.hpp:17319

VULKAN_HPP_NAMESPACE::MemoryRequirements
Definition: vulkan_structs.hpp:46133

VULKAN_HPP_NAMESPACE::QueryType
QueryType
Definition: vulkan_enums.hpp:1995

VULKAN_HPP_NAMESPACE::InstanceCreateInfo
Definition: vulkan_structs.hpp:44131

const
#define const
Definition: zconf.h:214

VULKAN_HPP_NAMESPACE::XYColorEXT
Definition: vulkan_structs.hpp:37541

VULKAN_HPP_NAMESPACE::CommandBuffer::drawIndexed
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

VULKAN_HPP_NAMESPACE::RenderPassFragmentDensityMapCreateInfoEXT
Definition: vulkan_structs.hpp:88309

VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV::OpticalFlowSessionNV
VULKAN_HPP_TYPESAFE_EXPLICIT OpticalFlowSessionNV(VkOpticalFlowSessionNV opticalFlowSessionNV) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2938

VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCorePropertiesAMD
Definition: vulkan_structs.hpp:70558

VULKAN_HPP_NAMESPACE::CommandBuffer::setLogicOpEnableEXT
void setLogicOpEnableEXT(VULKAN_HPP_NAMESPACE::Bool32 logicOpEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::PipelineLayout::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2470

VULKAN_HPP_NAMESPACE::Device::copyAccelerationStructureKHR
VULKAN_HPP_NODISCARD Result copyAccelerationStructureKHR(VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::DescriptorPool::operator=
DescriptorPool & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6313

VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV
Definition: vulkan_structs.hpp:34187

VULKAN_HPP_NAMESPACE::PhysicalDevice::getImageFormatProperties2KHR
VULKAN_HPP_NODISCARD Result getImageFormatProperties2KHR(const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 *pImageFormatInfo, VULKAN_HPP_NAMESPACE::ImageFormatProperties2 *pImageFormatProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::ObjectType::eDevice

VULKAN_HPP_NAMESPACE::CommandBuffer::setRepresentativeFragmentTestEnableNV
void setRepresentativeFragmentTestEnableNV(VULKAN_HPP_NAMESPACE::Bool32 representativeFragmentTestEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Semaphore::objectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
Definition: vulkan_handles.hpp:1996

VULKAN_HPP_NAMESPACE::CuFunctionNVX
Definition: vulkan_handles.hpp:6120

VULKAN_HPP_NAMESPACE::CuFunctionNVX::operator==
bool operator==(CuFunctionNVX const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6152

VULKAN_HPP_NAMESPACE::DeviceDeviceMemoryReportCreateInfoEXT
Definition: vulkan_structs.hpp:24333

VULKAN_HPP_NAMESPACE::MicromapEXT::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3327

VULKAN_HPP_NAMESPACE::PipelineRasterizationStateStreamCreateInfoEXT
Definition: vulkan_structs.hpp:81042

VULKAN_HPP_NAMESPACE::ExportFenceCreateInfo
Definition: vulkan_structs.hpp:30114

VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderFeaturesEXT
Definition: vulkan_structs.hpp:62866

VULKAN_HPP_NAMESPACE::Device::NativeType
VkDevice NativeType
Definition: vulkan_handles.hpp:7733

VULKAN_HPP_NAMESPACE::Device::getImageMemoryRequirementsKHR
void getImageMemoryRequirementsKHR(const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements *pInfo, VULKAN_HPP_NAMESPACE::MemoryRequirements2 *pMemoryRequirements, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::CommandBuffer::bindVertexBuffers2
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

VULKAN_HPP_NAMESPACE::Device::createShaderModuleUnique
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< VULKAN_HPP_NAMESPACE::ShaderModule, Dispatch > >::type createShaderModuleUnique(const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo &createInfo, Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

VULKAN_HPP_NAMESPACE::ObjectType::eShaderModule

VULKAN_HPP_NAMESPACE::PipelineCache
Definition: vulkan_handles.hpp:6035

VULKAN_HPP_NAMESPACE::SubpassDescriptionDepthStencilResolve
Definition: vulkan_structs.hpp:93867

VULKAN_HPP_NAMESPACE::CommandBuffer::setLineRasterizationModeEXT
void setLineRasterizationModeEXT(VULKAN_HPP_NAMESPACE::LineRasterizationModeEXT lineRasterizationMode, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassMergeFeedbackFeaturesEXT
Definition: vulkan_structs.hpp:73121

VULKAN_HPP_NAMESPACE::Queue::NativeType
VkQueue NativeType
Definition: vulkan_handles.hpp:7229

VULKAN_HPP_NAMESPACE::CppType
Definition: vulkan_enums.hpp:14

VULKAN_HPP_NAMESPACE::CoarseSampleOrderTypeNV
CoarseSampleOrderTypeNV
Definition: vulkan_enums.hpp:5364

VULKAN_HPP_NAMESPACE::CommandBuffer::setBlendConstants
void setBlendConstants(const float blendConstants[4], Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Queue::getCheckpointData2NV
void getCheckpointData2NV(uint32_t *pCheckpointDataCount, VULKAN_HPP_NAMESPACE::CheckpointData2NV *pCheckpointData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFloat16Int8Features
Definition: vulkan_structs.hpp:71017

VULKAN_HPP_NAMESPACE::RayTracingShaderGroupCreateInfoKHR
Definition: vulkan_structs.hpp:85461

VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion::objectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
Definition: vulkan_handles.hpp:6886

VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT
Definition: vulkan_structs.hpp:94454

VULKAN_HPP_NAMESPACE::ObjectType::ePerformanceConfigurationINTEL

VULKAN_HPP_NAMESPACE::Device::createValidationCacheEXTUnique
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< VULKAN_HPP_NAMESPACE::ValidationCacheEXT, Dispatch > >::type createValidationCacheEXTUnique(const VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT &createInfo, Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo
Definition: vulkan_structs.hpp:21579

VULKAN_HPP_NAMESPACE::Semaphore::operator=
Semaphore & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2013

VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT
Definition: vulkan_handles.hpp:1738

VULKAN_HPP_NAMESPACE::ValidationCacheEXT::objectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
Definition: vulkan_handles.hpp:7060

VULKAN_HPP_NAMESPACE::PipelineInfoKHR
Definition: vulkan_structs.hpp:79883

VULKAN_HPP_NAMESPACE::SharedPresentSurfaceCapabilitiesKHR
Definition: vulkan_structs.hpp:92696

VULKAN_HPP_NAMESPACE::CommandBuffer::setStencilWriteMask
void setStencilWriteMask(VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask, uint32_t writeMask, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::AccelerationStructureNV::AccelerationStructureNV
VULKAN_HPP_CONSTEXPR AccelerationStructureNV(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2849

VULKAN_HPP_NAMESPACE::OpticalFlowSessionBindingPointNV
OpticalFlowSessionBindingPointNV
Definition: vulkan_enums.hpp:6388

VULKAN_HPP_NAMESPACE::Device::bindImageMemory2KHR
VULKAN_HPP_NODISCARD Result bindImageMemory2KHR(uint32_t bindInfoCount, const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo *pBindInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Device::getImageSparseMemoryRequirements2
void getImageSparseMemoryRequirements2(const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 *pInfo, uint32_t *pSparseMemoryRequirementCount, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 *pSparseMemoryRequirements, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::CommandBuffer::setDepthTestEnable
void setDepthTestEnable(VULKAN_HPP_NAMESPACE::Bool32 depthTestEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT::DebugUtilsMessengerEXT
VULKAN_HPP_TYPESAFE_EXPLICIT DebugUtilsMessengerEXT(VkDebugUtilsMessengerEXT debugUtilsMessengerEXT) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:1751

VULKAN_HPP_NAMESPACE::Device::setPrivateDataEXT
ResultValueType< void >::type setPrivateDataEXT(VULKAN_HPP_NAMESPACE::ObjectType objectType, uint64_t objectHandle, VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, uint64_t data, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

VULKAN_HPP_NAMESPACE::DescriptorSetLayout::NativeType
VkDescriptorSetLayout NativeType
Definition: vulkan_handles.hpp:6379

VULKAN_HPP_NAMESPACE::CommandPool::CommandPool
VULKAN_HPP_CONSTEXPR CommandPool(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:5962

VULKAN_HPP_NAMESPACE::SampleLocationEXT
Definition: vulkan_structs.hpp:6192

VULKAN_HPP_NAMESPACE::ClearColorValue
Definition: vulkan_structs.hpp:12505

VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX
Definition: vulkan_structs.hpp:17420

VULKAN_HPP_NAMESPACE::Buffer::objectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
Definition: vulkan_handles.hpp:2333

VULKAN_HPP_NAMESPACE::PerformanceCounterResultKHR
Definition: vulkan_structs.hpp:49152

VULKAN_HPP_NAMESPACE::BindImageMemoryInfo
Definition: vulkan_structs.hpp:7420

VULKAN_HPP_NAMESPACE::AccelerationStructureKHR::operator==
bool operator==(AccelerationStructureKHR const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3216

VULKAN_HPP_NAMESPACE::DisplayModeKHR::operator=
DisplayModeKHR & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:12327

VULKAN_HPP_NAMESPACE::CommandBuffer::setTessellationDomainOriginEXT
void setTessellationDomainOriginEXT(VULKAN_HPP_NAMESPACE::TessellationDomainOrigin domainOrigin, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::DeferredOperationKHR::operator<
bool operator<(DeferredOperationKHR const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:5738

VULKAN_HPP_NAMESPACE::Queue::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7430

VULKAN_HPP_NAMESPACE::ClearRect
Definition: vulkan_structs.hpp:12770

VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreateInfoNV
Definition: vulkan_structs.hpp:48471

VULKAN_HPP_NAMESPACE::FragmentShadingRateNV
FragmentShadingRateNV
Definition: vulkan_enums.hpp:5923

VULKAN_HPP_NAMESPACE::DescriptorBufferBindingInfoEXT
Definition: vulkan_structs.hpp:20634

VULKAN_HPP_NAMESPACE::TimelineSemaphoreSubmitInfo
Definition: vulkan_structs.hpp:96255

VULKAN_HPP_NAMESPACE::Fence
Definition: vulkan_handles.hpp:2075

VULKAN_HPP_NAMESPACE::PipelineShaderStageModuleIdentifierCreateInfoEXT
Definition: vulkan_structs.hpp:81669

VULKAN_HPP_NAMESPACE::PhysicalDevice::getDrmDisplayEXT
VULKAN_HPP_NODISCARD Result getDrmDisplayEXT(int32_t drmFd, uint32_t connectorId, VULKAN_HPP_NAMESPACE::DisplayKHR *display, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo
Definition: vulkan_structs.hpp:6969

VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR
Definition: vulkan_structs.hpp:28605

VULKAN_HPP_NAMESPACE::Device::createEventUnique
VULKAN_HPP_NODISCARD 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

VULKAN_HPP_NAMESPACE::Device::createImageUnique
VULKAN_HPP_NODISCARD 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

VULKAN_HPP_NAMESPACE::Semaphore::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2048

VULKAN_HPP_NAMESPACE::CommandBuffer::setAlphaToCoverageEnableEXT
void setAlphaToCoverageEnableEXT(VULKAN_HPP_NAMESPACE::Bool32 alphaToCoverageEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::CuModuleNVX::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6263

onnxruntime::logging::DataType
DataType
Definition: logging.h:65

VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsPropertiesNV
Definition: vulkan_structs.hpp:54471

VULKAN_HPP_NAMESPACE::QueryPool::debugReportObjectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
Definition: vulkan_handles.hpp:2249

VULKAN_HPP_NAMESPACE::PipelineCache::PipelineCache
VULKAN_HPP_TYPESAFE_EXPLICIT PipelineCache(VkPipelineCache pipelineCache) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6048

VULKAN_HPP_NAMESPACE::BufferCreateInfo
Definition: vulkan_structs.hpp:10589

VULKAN_HPP_NAMESPACE::DeviceMemory::objectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
Definition: vulkan_handles.hpp:5533

VULKAN_HPP_NAMESPACE::Device::getAccelerationStructureBuildSizesKHR
void getAccelerationStructureBuildSizesKHR(VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR buildType, const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR *pBuildInfo, const uint32_t *pMaxPrimitiveCounts, VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR *pSizeInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInstanceNV
Definition: vulkan_structs.hpp:3445

type
type
Definition: core.h:1059

VULKAN_HPP_NAMESPACE::CommandBuffer::beginRenderPass
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

VULKAN_HPP_NAMESPACE::BufferOpaqueCaptureAddressCreateInfo
Definition: vulkan_structs.hpp:12006

VULKAN_HPP_NAMESPACE::CommandBuffer::drawIndirectByteCountEXT
void drawIndirectByteCountEXT(uint32_t instanceCount, uint32_t firstInstance, VULKAN_HPP_NAMESPACE::Buffer counterBuffer, VULKAN_HPP_NAMESPACE::DeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::PipelineFragmentShadingRateStateCreateInfoKHR
Definition: vulkan_structs.hpp:79769

VULKAN_HPP_NAMESPACE::PipelineRasterizationProvokingVertexStateCreateInfoEXT
Definition: vulkan_structs.hpp:80840

VULKAN_HPP_NAMESPACE::PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR
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

VULKAN_HPP_NAMESPACE::FramebufferAttachmentImageInfo
Definition: vulkan_structs.hpp:33671

VULKAN_HPP_NAMESPACE::Device::createPipelineLayoutUnique
VULKAN_HPP_NODISCARD 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

VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR
Definition: vulkan_structs.hpp:28344

VULKAN_HPP_NAMESPACE::ImageTiling
ImageTiling
Definition: vulkan_enums.hpp:1558

VULKAN_HPP_NAMESPACE::Device::allocateMemory
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

VULKAN_HPP_NAMESPACE::Device::createRayTracingPipelinesNVUnique
VULKAN_HPP_NODISCARD ResultValue< std::vector< UniqueHandle< VULKAN_HPP_NAMESPACE::Pipeline, Dispatch >, PipelineAllocator > > createRayTracingPipelinesNVUnique(VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, VULKAN_HPP_NAMESPACE::ArrayProxy< const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV > const &createInfos, Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

VULKAN_HPP_NAMESPACE::SwapchainKHR::operator==
bool operator==(SwapchainKHR const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:1937

VULKAN_HPP_NAMESPACE::QueryPool::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2300

VULKAN_HPP_NAMESPACE::PipelineLayout::operator=
PipelineLayout & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2435

VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV
Definition: vulkan_structs.hpp:12955

VULKAN_HPP_NAMESPACE::Instance::debugReportMessageEXT
void debugReportMessageEXT(VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT flags, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char *pLayerPrefix, const char *pMessage, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Device::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:12277

VULKAN_HPP_NAMESPACE::ValidationCacheEXT::NativeType
VkValidationCacheEXT NativeType
Definition: vulkan_handles.hpp:7058

VULKAN_HPP_NAMESPACE::PipelineLayout::objectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
Definition: vulkan_handles.hpp:2418

VULKAN_HPP_NAMESPACE::Device::createShaderModule
VULKAN_HPP_NODISCARD Result createShaderModule(const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo *pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, VULKAN_HPP_NAMESPACE::ShaderModule *pShaderModule, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::CommandBuffer::setCullMode
void setCullMode(VULKAN_HPP_NAMESPACE::CullModeFlags cullMode, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX
Definition: vulkan_structs.hpp:17791

VULKAN_HPP_NAMESPACE::Instance::createHeadlessSurfaceEXTUnique
VULKAN_HPP_NODISCARD 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

VULKAN_HPP_NAMESPACE::PhysicalDeviceShadingRateImagePropertiesNV
Definition: vulkan_structs.hpp:72582

VULKAN_HPP_NAMESPACE::CommandBuffer::setCheckpointNV
void setCheckpointNV(const void *pCheckpointMarker, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Device::getProcAddr
PFN_vkVoidFunction getProcAddr(const char *pName, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Pipeline::operator!=
bool operator!=(Pipeline const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2704

VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloat2FeaturesEXT
Definition: vulkan_structs.hpp:69580

VULKAN_HPP_NAMESPACE::DeviceMemory::operator<
bool operator<(DeviceMemory const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:5569

VULKAN_HPP_NAMESPACE::Device::signalSemaphoreKHR
VULKAN_HPP_NODISCARD Result signalSemaphoreKHR(const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo *pSignalInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Semaphore::Semaphore
VULKAN_HPP_CONSTEXPR Semaphore()=default

VULKAN_HPP_NAMESPACE::SemaphoreSubmitInfo
Definition: vulkan_structs.hpp:91712

VULKAN_HPP_NAMESPACE::ImportMemoryFdInfoKHR
Definition: vulkan_structs.hpp:42050

VULKAN_HPP_NAMESPACE::CommandBuffer::traceRaysIndirectKHR
void traceRaysIndirectKHR(const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR *pRaygenShaderBindingTable, const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR *pMissShaderBindingTable, const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR *pHitShaderBindingTable, const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR *pCallableShaderBindingTable, VULKAN_HPP_NAMESPACE::DeviceAddress indirectDeviceAddress, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::PipelineRasterizationStateRasterizationOrderAMD
Definition: vulkan_structs.hpp:80942

VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationPropertiesEXT
Definition: vulkan_structs.hpp:61876

VULKAN_HPP_NAMESPACE::Device::debugMarkerSetObjectNameEXT
VULKAN_HPP_NODISCARD Result debugMarkerSetObjectNameEXT(const VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT *pNameInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::PrivateDataSlot::PrivateDataSlot
VULKAN_HPP_CONSTEXPR PrivateDataSlot(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6642

VULKAN_HPP_NAMESPACE::CommandBuffer::buildMicromapsEXT
void buildMicromapsEXT(uint32_t infoCount, const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT *pInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Queue::insertDebugUtilsLabelEXT
void insertDebugUtilsLabelEXT(const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT *pLabelInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::DescriptorSetLayout::objectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
Definition: vulkan_handles.hpp:6381

VULKAN_HPP_NAMESPACE::Device::uninitializePerformanceApiINTEL
void uninitializePerformanceApiINTEL(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Device::buildAccelerationStructuresKHR
VULKAN_HPP_NODISCARD Result buildAccelerationStructuresKHR(VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, uint32_t infoCount, const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR *pInfos, const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR *const *ppBuildRangeInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Image::operator!=
bool operator!=(Image const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2789

VULKAN_HPP_NAMESPACE::Device::createComputePipeline
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

VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2
Definition: vulkan_structs.hpp:72672

VULKAN_HPP_NAMESPACE::Instance::operator=
Instance & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:13801

VULKAN_HPP_NAMESPACE::ImageResolve
Definition: vulkan_structs.hpp:40064

VULKAN_HPP_NAMESPACE::DeferredOperationKHR::NativeType
VkDeferredOperationKHR NativeType
Definition: vulkan_handles.hpp:5697

VULKAN_HPP_NAMESPACE::CommandBuffer::copyMemoryToImageIndirectNV
void copyMemoryToImageIndirectNV(VULKAN_HPP_NAMESPACE::DeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride, VULKAN_HPP_NAMESPACE::Image dstImage, VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, const VULKAN_HPP_NAMESPACE::ImageSubresourceLayers *pImageSubresources, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::SampleMask
uint32_t SampleMask
Definition: vulkan.hpp:6077

VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV
Definition: vulkan_structs.hpp:48388

VULKAN_HPP_NAMESPACE::Device::getMemoryHostPointerPropertiesEXT
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

VULKAN_HPP_NAMESPACE::PhysicalDevice::getQueueFamilyProperties
void getQueueFamilyProperties(uint32_t *pQueueFamilyPropertyCount, VULKAN_HPP_NAMESPACE::QueueFamilyProperties *pQueueFamilyProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::SwapchainKHR::SwapchainKHR
VULKAN_HPP_CONSTEXPR SwapchainKHR(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:1917

VULKAN_HPP_NAMESPACE::Queue::submit2KHR
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

VULKAN_HPP_NAMESPACE::PhysicalDevice::operator=
PhysicalDevice & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:12420

VULKAN_HPP_NAMESPACE::Device::getBufferOpaqueCaptureAddress
uint64_t getBufferOpaqueCaptureAddress(const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Device::getRayTracingCaptureReplayShaderGroupHandlesKHR
VULKAN_HPP_NODISCARD Result getRayTracingCaptureReplayShaderGroupHandlesKHR(VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:1711

VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT
Definition: vulkan_structs.hpp:17201

VULKAN_HPP_NAMESPACE::DeviceMemory::debugReportObjectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
Definition: vulkan_handles.hpp:5534

VULKAN_HPP_NAMESPACE::ImageFormatProperties
Definition: vulkan_structs.hpp:32351

VULKAN_HPP_NAMESPACE::DeferredOperationKHR::DeferredOperationKHR
VULKAN_HPP_CONSTEXPR DeferredOperationKHR()=default

VULKAN_HPP_NAMESPACE::MicromapTriangleEXT
Definition: vulkan_structs.hpp:47145

VULKAN_HPP_NAMESPACE::FragmentShadingRateAttachmentInfoKHR
Definition: vulkan_structs.hpp:33559

VULKAN_HPP_NAMESPACE::TransformMatrixKHR
Definition: vulkan_structs.hpp:2436

VULKAN_HPP_NAMESPACE::InitializePerformanceApiInfoINTEL
Definition: vulkan_structs.hpp:43938

VULKAN_HPP_NAMESPACE::LogicOp
LogicOp
Definition: vulkan_enums.hpp:2451

VULKAN_HPP_NAMESPACE::Fence::Fence
VULKAN_HPP_CONSTEXPR Fence()=default

VULKAN_HPP_NAMESPACE::SwapchainPresentBarrierCreateInfoNV
Definition: vulkan_structs.hpp:95958

VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR
FragmentShadingRateCombinerOpKHR
Definition: vulkan_enums.hpp:5495

VULKAN_HPP_NAMESPACE::Sampler::operator<
bool operator<(Sampler const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6837

VULKAN_HPP_NAMESPACE::Queue::Queue
VULKAN_HPP_CONSTEXPR Queue(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7237

fd
GLuint64 GLenum GLint fd
Definition: RE_OGL.h:262

VULKAN_HPP_NAMESPACE::RayTracingShaderGroupCreateInfoNV
Definition: vulkan_structs.hpp:86002

VULKAN_HPP_NAMESPACE::CommandBuffer::writeTimestamp2
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

VULKAN_HPP_NAMESPACE::AllocationCallbacks
Definition: vulkan_structs.hpp:4172

VULKAN_HPP_NAMESPACE::Queue::setPerformanceConfigurationINTEL
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type setPerformanceConfigurationINTEL(VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

VULKAN_HPP_NAMESPACE::SubpassContents
SubpassContents
Definition: vulkan_enums.hpp:3141

VULKAN_HPP_NAMESPACE::RenderPass::operator=
RenderPass & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6733

VULKAN_HPP_NAMESPACE::Pipeline::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2725

VULKAN_HPP_NAMESPACE::Device::destroyAccelerationStructureNV
void destroyAccelerationStructureNV(VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::CommandBuffer::CommandBuffer
CommandBuffer(VkCommandBuffer commandBuffer) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3361

VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR
Definition: vulkan_structs.hpp:1289

VULKAN_HPP_NAMESPACE::CommandBuffer::operator=
CommandBuffer & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3369

VULKAN_HPP_NAMESPACE::Instance::destroyDebugUtilsMessengerEXT
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

VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR
Definition: vulkan_structs.hpp:28074

VULKAN_HPP_NAMESPACE::ImageView::operator==
bool operator==(ImageView const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2614

VULKAN_HPP_NAMESPACE::CuFunctionNVX::operator=
CuFunctionNVX & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6143

VULKAN_HPP_NAMESPACE::Device::freeDescriptorSets
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

VULKAN_HPP_NAMESPACE::PipelineRasterizationDepthClipStateCreateInfoEXT
Definition: vulkan_structs.hpp:80594

VULKAN_HPP_NAMESPACE::CommandBuffer::bindPipelineShaderGroupNV
void bindPipelineShaderGroupNV(VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t groupIndex, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderModuleIdentifierPropertiesEXT
Definition: vulkan_structs.hpp:71903

VULKAN_HPP_NAMESPACE::PipelineViewportCoarseSampleOrderStateCreateInfoNV
Definition: vulkan_structs.hpp:82201

VULKAN_HPP_NAMESPACE::Device::createDeferredOperationKHR
VULKAN_HPP_NODISCARD Result createDeferredOperationKHR(const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, VULKAN_HPP_NAMESPACE::DeferredOperationKHR *pDeferredOperation, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::ObjectFree
Definition: vulkan.hpp:5964

VULKAN_HPP_NAMESPACE::PipelineLayout::PipelineLayout
VULKAN_HPP_TYPESAFE_EXPLICIT PipelineLayout(VkPipelineLayout pipelineLayout) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2425

VULKAN_HPP_NAMESPACE::Device::bindBufferMemory2
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

VULKAN_HPP_NAMESPACE::Device::writeMicromapsPropertyEXT
VULKAN_HPP_NODISCARD ResultValueType< DataType >::type writeMicromapsPropertyEXT(VULKAN_HPP_NAMESPACE::ArrayProxy< const VULKAN_HPP_NAMESPACE::MicromapEXT > const &micromaps, VULKAN_HPP_NAMESPACE::QueryType queryType, size_t stride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

VULKAN_HPP_NAMESPACE::isVulkanHandleType
Definition: vulkan_handles.hpp:1560

VULKAN_HPP_NAMESPACE::PerformanceParameterTypeINTEL
PerformanceParameterTypeINTEL
Definition: vulkan_enums.hpp:5444

VULKAN_HPP_NAMESPACE::CopyDescriptorSet
Definition: vulkan_structs.hpp:16132

VULKAN_HPP_NAMESPACE::CommandBuffer::pushDescriptorSetWithTemplateKHR
void pushDescriptorSetWithTemplateKHR(VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, VULKAN_HPP_NAMESPACE::PipelineLayout layout, uint32_t set, const void *pData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

data
Definition: format.h:895

VULKAN_HPP_NAMESPACE::PhysicalDeviceColorWriteEnableFeaturesEXT
Definition: vulkan_structs.hpp:51494

VULKAN_HPP_NAMESPACE::CommandBuffer::endQuery
void endQuery(VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::Device::getFenceFdKHR
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

VULKAN_HPP_NAMESPACE::PhysicalDeviceProvokingVertexPropertiesEXT
Definition: vulkan_structs.hpp:67468

VULKAN_HPP_NAMESPACE::CommandBuffer::setSampleLocationsEnableEXT
void setSampleLocationsEnableEXT(VULKAN_HPP_NAMESPACE::Bool32 sampleLocationsEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo
Definition: vulkan_structs.hpp:91607

VULKAN_HPP_NAMESPACE::PhysicalDeviceInvocationMaskFeaturesHUAWEI
Definition: vulkan_structs.hpp:60871

VULKAN_HPP_NAMESPACE::ObjectType::eMicromapEXT

VULKAN_HPP_NAMESPACE::RayTracingPipelineInterfaceCreateInfoKHR
Definition: vulkan_structs.hpp:85614

VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2
Definition: vulkan_structs.hpp:87791

VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR
Definition: vulkan_structs.hpp:93232

VULKAN_HPP_NAMESPACE::CopyCommandTransformInfoQCOM
Definition: vulkan_structs.hpp:16034

VULKAN_HPP_NAMESPACE::CommandBuffer::waitEvents
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

VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR
Definition: vulkan_structs.hpp:1052

VULKAN_HPP_NAMESPACE::CommandBuffer::setViewportWithCount
void setViewportWithCount(uint32_t viewportCount, const VULKAN_HPP_NAMESPACE::Viewport *pViewports, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::DisplayModeKHR
Definition: vulkan_handles.hpp:12304

VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV
Definition: vulkan_structs.hpp:1981

VULKAN_HPP_NAMESPACE::Framebuffer::operator!=
bool operator!=(Framebuffer const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6500

VULKAN_HPP_NAMESPACE::PipelineRenderingCreateInfo
Definition: vulkan_structs.hpp:81153

VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionImageFormatProperties
Definition: vulkan_structs.hpp:90873

VULKAN_HPP_NAMESPACE::CommandBuffer::drawIndirectCount
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

VULKAN_HPP_NAMESPACE::CommandBuffer::setScissorWithCountEXT
void setScissorWithCountEXT(uint32_t scissorCount, const VULKAN_HPP_NAMESPACE::Rect2D *pScissors, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::CommandBuffer::resetEvent2
void resetEvent2(VULKAN_HPP_NAMESPACE::Event event, VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stageMask, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV::operator<
bool operator<(IndirectCommandsLayoutNV const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6593

VULKAN_HPP_NAMESPACE::Buffer::NativeType
VkBuffer NativeType
Definition: vulkan_handles.hpp:2331

VULKAN_HPP_NAMESPACE::Device::objectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
Definition: vulkan_handles.hpp:7735

VULKAN_HPP_NAMESPACE::CommandBuffer::copyImage
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

VULKAN_HPP_NAMESPACE::SurfaceKHR::operator!=
bool operator!=(SurfaceKHR const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:1602

strides
GLsizei const GLuint const GLintptr const GLsizei * strides
Definition: glcorearb.h:2625

VULKAN_HPP_NAMESPACE::Event::Event
VULKAN_HPP_CONSTEXPR Event()=default

VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryRDMAFeaturesNV
Definition: vulkan_structs.hpp:56510

VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceQueryFeaturesKHR
Definition: vulkan_structs.hpp:65017

VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateEnumsFeaturesNV
Definition: vulkan_structs.hpp:58008

VULKAN_HPP_NAMESPACE::DescriptorSet::operator!=
bool operator!=(DescriptorSet const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2534

VULKAN_HPP_NAMESPACE::Device::createPrivateDataSlotEXT
VULKAN_HPP_NODISCARD Result createPrivateDataSlotEXT(const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo *pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, VULKAN_HPP_NAMESPACE::PrivateDataSlot *pPrivateDataSlot, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR
Definition: vulkan_structs.hpp:27892

VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateEnumsPropertiesNV
Definition: vulkan_structs.hpp:58133

VULKAN_HPP_NAMESPACE::CommandBuffer::setPatchControlPointsEXT
void setPatchControlPointsEXT(uint32_t patchControlPoints, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV
Definition: vulkan_structs.hpp:2147

VULKAN_HPP_NAMESPACE::MultiviewPerViewAttributesInfoNVX
Definition: vulkan_structs.hpp:47706

VULKAN_HPP_NAMESPACE::Image::debugReportObjectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
Definition: vulkan_handles.hpp:2759

VULKAN_HPP_NAMESPACE::ObjectType::eBufferView

VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryAabbsDataKHR
Definition: vulkan_structs.hpp:326

VULKAN_HPP_NAMESPACE::Device::releaseProfilingLockKHR
void releaseProfilingLockKHR(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::DisplayKHR::objectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
Definition: vulkan_handles.hpp:1826

VULKAN_HPP_NAMESPACE::DescriptorPoolInlineUniformBlockCreateInfo
Definition: vulkan_structs.hpp:21480

VULKAN_HPP_NAMESPACE::enumerateInstanceLayerProperties
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result enumerateInstanceLayerProperties(uint32_t *pPropertyCount, VULKAN_HPP_NAMESPACE::LayerProperties *pProperties, Dispatch const &d) VULKAN_HPP_NOEXCEPT
Definition: vulkan_funcs.hpp:603

VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupSizeControlProperties
Definition: vulkan_structs.hpp:73022

VULKAN_HPP_NAMESPACE::ObjectDestroy
Definition: vulkan.hpp:5893

VULKAN_HPP_NAMESPACE::FenceCreateInfo
Definition: vulkan_structs.hpp:32913

VULKAN_HPP_NAMESPACE::PresentTimesInfoGOOGLE
Definition: vulkan_structs.hpp:84148

VULKAN_HPP_NAMESPACE::Device::getMemoryOpaqueCaptureAddress
uint64_t getMemoryOpaqueCaptureAddress(const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::ImageCompressionControlEXT
Definition: vulkan_structs.hpp:38209

VULKAN_HPP_NAMESPACE::DeviceFaultCountsEXT
Definition: vulkan_structs.hpp:24738

VULKAN_HPP_NAMESPACE::Device::Device
VULKAN_HPP_CONSTEXPR Device(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7741

VULKAN_HPP_NAMESPACE::CommandBuffer::CommandBuffer
VULKAN_HPP_CONSTEXPR CommandBuffer(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3360

VULKAN_HPP_NAMESPACE::createInstanceUnique
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValueType< UniqueHandle< VULKAN_HPP_NAMESPACE::Instance, Dispatch > >::type createInstanceUnique(const VULKAN_HPP_NAMESPACE::InstanceCreateInfo &createInfo, Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator, Dispatch const &d)
Definition: vulkan_funcs.hpp:50

VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorPool

VULKAN_HPP_NAMESPACE::RenderPass::RenderPass
VULKAN_HPP_TYPESAFE_EXPLICIT RenderPass(VkRenderPass renderPass) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6723

VULKAN_HPP_NAMESPACE::Device::destroySwapchainKHR
void destroySwapchainKHR(VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL::operator=
PerformanceConfigurationINTEL & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2186

VULKAN_HPP_NAMESPACE::Device::createCommandPoolUnique
VULKAN_HPP_NODISCARD 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

VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorSetLayout

VULKAN_HPP_NAMESPACE::Device::destroyMicromapEXT
void destroyMicromapEXT(VULKAN_HPP_NAMESPACE::MicromapEXT micromap, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::PhysicalDevice::getFeatures
void getFeatures(VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures *pFeatures, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

filter
GLint GLint GLint GLint GLint GLint GLint GLbitfield GLenum filter
Definition: glcorearb.h:1297

src
GLenum src
Definition: glcorearb.h:1793

VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR
Definition: vulkan_structs.hpp:720

VULKAN_HPP_NAMESPACE::DeferredOperationKHR::objectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
Definition: vulkan_handles.hpp:5699

VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewProperties
Definition: vulkan_structs.hpp:64095

VULKAN_HPP_NAMESPACE::CommandBuffer::setDepthClipNegativeOneToOneEXT
void setDepthClipNegativeOneToOneEXT(VULKAN_HPP_NAMESPACE::Bool32 negativeOneToOne, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::DebugUtilsMessageSeverityFlagBitsEXT
DebugUtilsMessageSeverityFlagBitsEXT
Definition: vulkan_enums.hpp:5078

VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloatFeaturesEXT
Definition: vulkan_structs.hpp:69824

VULKAN_HPP_NAMESPACE::PipelineCache::operator==
bool operator==(PipelineCache const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6067

VULKAN_HPP_NAMESPACE::ObjectType::eBuffer

VULKAN_HPP_NAMESPACE::ObjectType::eValidationCacheEXT

VULKAN_HPP_NAMESPACE::PrivateDataSlot::PrivateDataSlot
VULKAN_HPP_CONSTEXPR PrivateDataSlot()=default

VULKAN_HPP_NAMESPACE::PhysicalDeviceImageViewImageFormatInfoEXT
Definition: vulkan_structs.hpp:60159

VULKAN_HPP_NAMESPACE::CommandBuffer::setEvent2
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

VULKAN_HPP_NAMESPACE::Device::setDebugUtilsObjectNameEXT
VULKAN_HPP_NODISCARD Result setDebugUtilsObjectNameEXT(const VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT *pNameInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion::operator==
bool operator==(SamplerYcbcrConversion const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6915

VULKAN_HPP_NAMESPACE::ArrayProxy
Definition: vulkan.hpp:585

VULKAN_HPP_NAMESPACE::ObjectType::eQueryPool