// 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 QueueFamilyQueryResultStatusProperties2KHR; struct VideoQueueFamilyProperties2KHR; struct VideoProfileKHR; struct VideoProfilesKHR; struct VideoCapabilitiesKHR; struct PhysicalDeviceVideoFormatInfoKHR; struct VideoFormatPropertiesKHR; struct VideoPictureResourceKHR; struct VideoReferenceSlotKHR; struct VideoGetMemoryPropertiesKHR; struct VideoBindMemoryKHR; 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 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 VideoEncodeH264ReferenceListsEXT; struct VideoEncodeH264EmitPictureParametersEXT; struct VideoEncodeH264DpbSlotInfoEXT; struct VideoEncodeH264NaluSliceEXT; struct VideoEncodeH264ProfileEXT; 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 VideoEncodeH265EmitPictureParametersEXT; struct VideoEncodeH265DpbSlotInfoEXT; struct VideoEncodeH265NaluSliceSegmentEXT; struct VideoEncodeH265ProfileEXT; struct VideoEncodeH265ReferenceListsEXT; 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 VideoDecodeH264ProfileEXT; struct VideoDecodeH264CapabilitiesEXT; struct VideoDecodeH264SessionParametersCreateInfoEXT; struct VideoDecodeH264SessionParametersAddInfoEXT; struct VideoDecodeH264PictureInfoEXT; struct VideoDecodeH264MvcEXT; 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; #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 VideoDecodeH265ProfileEXT; 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_fragment_shader_barycentric === struct PhysicalDeviceFragmentShaderBarycentricFeaturesNV; //=== 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; 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_KHR_present_id === struct PresentIdKHR; struct PhysicalDevicePresentIdFeaturesKHR; #if defined(VK_ENABLE_BETA_EXTENSIONS) //=== VK_KHR_video_encode_queue === struct VideoEncodeInfoKHR; struct VideoEncodeCapabilitiesKHR; struct VideoEncodeRateControlInfoKHR; struct VideoEncodeRateControlLayerInfoKHR; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ //=== VK_NV_device_diagnostics_config === struct PhysicalDeviceDiagnosticsConfigFeaturesNV; struct DeviceDiagnosticsConfigCreateInfoNV; //=== VK_KHR_synchronization2 === struct QueueFamilyCheckpointProperties2NV; struct CheckpointData2NV; //=== VK_EXT_graphics_pipeline_library === struct PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT; struct PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT; struct GraphicsPipelineLibraryCreateInfoEXT; //=== 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_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_4444_formats === struct PhysicalDevice4444FormatsFeaturesEXT; //=== VK_ARM_rasterization_order_attachment_access === struct PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM; //=== 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_VALVE_mutable_descriptor_type === struct PhysicalDeviceMutableDescriptorTypeFeaturesVALVE; struct MutableDescriptorTypeListVALVE; struct MutableDescriptorTypeCreateInfoVALVE; //=== VK_EXT_vertex_input_dynamic_state === struct PhysicalDeviceVertexInputDynamicStateFeaturesEXT; struct VertexInputBindingDescription2EXT; struct VertexInputAttributeDescription2EXT; //=== VK_EXT_physical_device_drm === struct PhysicalDeviceDrmPropertiesEXT; //=== 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_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_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_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_QCOM_fragment_density_map_offset === struct PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM; struct PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM; struct SubpassFragmentDensityMapOffsetEndInfoQCOM; //=== VK_NV_linear_color_attachment === struct PhysicalDeviceLinearColorAttachmentFeaturesNV; //=============== //=== HANDLEs === //=============== 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 = {}; }; VULKAN_HPP_STATIC_ASSERT(sizeof(VULKAN_HPP_NAMESPACE::SurfaceKHR) == sizeof(VkSurfaceKHR), "handle and wrapper have different size!"); VULKAN_HPP_STATIC_ASSERT(std::is_nothrow_move_constructible::value, "SurfaceKHR is not nothrow_move_constructible!"); template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::SurfaceKHR; }; template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::SurfaceKHR; }; template<> struct isVulkanHandleType { 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 = {}; }; VULKAN_HPP_STATIC_ASSERT(sizeof(VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT) == sizeof(VkDebugReportCallbackEXT), "handle and wrapper have different size!"); VULKAN_HPP_STATIC_ASSERT(std::is_nothrow_move_constructible::value, "DebugReportCallbackEXT is not nothrow_move_constructible!"); template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT; }; template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT; }; template<> struct isVulkanHandleType { 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 = {}; }; VULKAN_HPP_STATIC_ASSERT(sizeof(VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT) == sizeof(VkDebugUtilsMessengerEXT), "handle and wrapper have different size!"); VULKAN_HPP_STATIC_ASSERT(std::is_nothrow_move_constructible::value, "DebugUtilsMessengerEXT is not nothrow_move_constructible!"); template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT; }; template<> struct isVulkanHandleType { 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 = {}; }; VULKAN_HPP_STATIC_ASSERT(sizeof(VULKAN_HPP_NAMESPACE::DisplayKHR) == sizeof(VkDisplayKHR), "handle and wrapper have different size!"); VULKAN_HPP_STATIC_ASSERT(std::is_nothrow_move_constructible::value, "DisplayKHR is not nothrow_move_constructible!"); template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::DisplayKHR; }; template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::DisplayKHR; }; template<> struct isVulkanHandleType { 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 = {}; }; VULKAN_HPP_STATIC_ASSERT(sizeof(VULKAN_HPP_NAMESPACE::SwapchainKHR) == sizeof(VkSwapchainKHR), "handle and wrapper have different size!"); VULKAN_HPP_STATIC_ASSERT(std::is_nothrow_move_constructible::value, "SwapchainKHR is not nothrow_move_constructible!"); template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::SwapchainKHR; }; template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::SwapchainKHR; }; template<> struct isVulkanHandleType { 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 = {}; }; VULKAN_HPP_STATIC_ASSERT(sizeof(VULKAN_HPP_NAMESPACE::Semaphore) == sizeof(VkSemaphore), "handle and wrapper have different size!"); VULKAN_HPP_STATIC_ASSERT(std::is_nothrow_move_constructible::value, "Semaphore is not nothrow_move_constructible!"); template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::Semaphore; }; template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::Semaphore; }; template<> struct isVulkanHandleType { 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 = {}; }; VULKAN_HPP_STATIC_ASSERT(sizeof(VULKAN_HPP_NAMESPACE::Fence) == sizeof(VkFence), "handle and wrapper have different size!"); VULKAN_HPP_STATIC_ASSERT(std::is_nothrow_move_constructible::value, "Fence is not nothrow_move_constructible!"); template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::Fence; }; template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::Fence; }; template<> struct isVulkanHandleType { 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 = {}; }; VULKAN_HPP_STATIC_ASSERT(sizeof(VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL) == sizeof(VkPerformanceConfigurationINTEL), "handle and wrapper have different size!"); VULKAN_HPP_STATIC_ASSERT(std::is_nothrow_move_constructible::value, "PerformanceConfigurationINTEL is not nothrow_move_constructible!"); template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL; }; template<> struct isVulkanHandleType { 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 = {}; }; VULKAN_HPP_STATIC_ASSERT(sizeof(VULKAN_HPP_NAMESPACE::QueryPool) == sizeof(VkQueryPool), "handle and wrapper have different size!"); VULKAN_HPP_STATIC_ASSERT(std::is_nothrow_move_constructible::value, "QueryPool is not nothrow_move_constructible!"); template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::QueryPool; }; template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::QueryPool; }; template<> struct isVulkanHandleType { 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 = {}; }; VULKAN_HPP_STATIC_ASSERT(sizeof(VULKAN_HPP_NAMESPACE::Buffer) == sizeof(VkBuffer), "handle and wrapper have different size!"); VULKAN_HPP_STATIC_ASSERT(std::is_nothrow_move_constructible::value, "Buffer is not nothrow_move_constructible!"); template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::Buffer; }; template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::Buffer; }; template<> struct isVulkanHandleType { 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 = {}; }; VULKAN_HPP_STATIC_ASSERT(sizeof(VULKAN_HPP_NAMESPACE::PipelineLayout) == sizeof(VkPipelineLayout), "handle and wrapper have different size!"); VULKAN_HPP_STATIC_ASSERT(std::is_nothrow_move_constructible::value, "PipelineLayout is not nothrow_move_constructible!"); template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::PipelineLayout; }; template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::PipelineLayout; }; template<> struct isVulkanHandleType { 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 = {}; }; VULKAN_HPP_STATIC_ASSERT(sizeof(VULKAN_HPP_NAMESPACE::DescriptorSet) == sizeof(VkDescriptorSet), "handle and wrapper have different size!"); VULKAN_HPP_STATIC_ASSERT(std::is_nothrow_move_constructible::value, "DescriptorSet is not nothrow_move_constructible!"); template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::DescriptorSet; }; template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::DescriptorSet; }; template<> struct isVulkanHandleType { 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 = {}; }; VULKAN_HPP_STATIC_ASSERT(sizeof(VULKAN_HPP_NAMESPACE::ImageView) == sizeof(VkImageView), "handle and wrapper have different size!"); VULKAN_HPP_STATIC_ASSERT(std::is_nothrow_move_constructible::value, "ImageView is not nothrow_move_constructible!"); template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::ImageView; }; template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::ImageView; }; template<> struct isVulkanHandleType { 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 = {}; }; VULKAN_HPP_STATIC_ASSERT(sizeof(VULKAN_HPP_NAMESPACE::Pipeline) == sizeof(VkPipeline), "handle and wrapper have different size!"); VULKAN_HPP_STATIC_ASSERT(std::is_nothrow_move_constructible::value, "Pipeline is not nothrow_move_constructible!"); template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::Pipeline; }; template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::Pipeline; }; template<> struct isVulkanHandleType { 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 = {}; }; VULKAN_HPP_STATIC_ASSERT(sizeof(VULKAN_HPP_NAMESPACE::Image) == sizeof(VkImage), "handle and wrapper have different size!"); VULKAN_HPP_STATIC_ASSERT(std::is_nothrow_move_constructible::value, "Image is not nothrow_move_constructible!"); template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::Image; }; template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::Image; }; template<> struct isVulkanHandleType { 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 = {}; }; VULKAN_HPP_STATIC_ASSERT(sizeof(VULKAN_HPP_NAMESPACE::AccelerationStructureNV) == sizeof(VkAccelerationStructureNV), "handle and wrapper have different size!"); VULKAN_HPP_STATIC_ASSERT(std::is_nothrow_move_constructible::value, "AccelerationStructureNV is not nothrow_move_constructible!"); template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::AccelerationStructureNV; }; template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::AccelerationStructureNV; }; template<> struct isVulkanHandleType { 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 = {}; }; VULKAN_HPP_STATIC_ASSERT(sizeof(VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate) == sizeof(VkDescriptorUpdateTemplate), "handle and wrapper have different size!"); VULKAN_HPP_STATIC_ASSERT(std::is_nothrow_move_constructible::value, "DescriptorUpdateTemplate is not nothrow_move_constructible!"); template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate; }; template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate; }; template<> struct isVulkanHandleType { 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 = {}; }; VULKAN_HPP_STATIC_ASSERT(sizeof(VULKAN_HPP_NAMESPACE::Event) == sizeof(VkEvent), "handle and wrapper have different size!"); VULKAN_HPP_STATIC_ASSERT(std::is_nothrow_move_constructible::value, "Event is not nothrow_move_constructible!"); template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::Event; }; template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::Event; }; template<> struct isVulkanHandleType { 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 = {}; }; VULKAN_HPP_STATIC_ASSERT(sizeof(VULKAN_HPP_NAMESPACE::AccelerationStructureKHR) == sizeof(VkAccelerationStructureKHR), "handle and wrapper have different size!"); VULKAN_HPP_STATIC_ASSERT(std::is_nothrow_move_constructible::value, "AccelerationStructureKHR is not nothrow_move_constructible!"); template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::AccelerationStructureKHR; }; template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::AccelerationStructureKHR; }; template<> struct isVulkanHandleType { 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 {} VULKAN_HPP_TYPESAFE_EXPLICIT CommandBuffer(VkCommandBuffer commandBuffer) VULKAN_HPP_NOEXCEPT : m_commandBuffer(commandBuffer) {} #if defined(VULKAN_HPP_TYPESAFE_CONVERSION) CommandBuffer &operator=(VkCommandBuffer commandBuffer) VULKAN_HPP_NOEXCEPT { m_commandBuffer = commandBuffer; return *this; } #endif 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 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 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::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 VULKAN_HPP_NODISCARD Result end(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; #else template VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type end(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE template 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 ResultValueType::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 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 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 void setViewport(uint32_t firstViewport, ArrayProxy const &viewports, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 void setScissor(uint32_t firstScissor, ArrayProxy const &scissors, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template void setLineWidth(float lineWidth, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; template void setDepthBias(float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; template void setBlendConstants(const float blendConstants[4], Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; template void setDepthBounds(float minDepthBounds, float maxDepthBounds, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; template void setStencilCompareMask(VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask, uint32_t compareMask, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; template void setStencilWriteMask(VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask, uint32_t writeMask, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; template void setStencilReference(VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask, uint32_t reference, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; template 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 void bindDescriptorSets(VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, VULKAN_HPP_NAMESPACE::PipelineLayout layout, uint32_t firstSet, ArrayProxy const &descriptorSets, ArrayProxy const &dynamicOffsets, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 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 void bindVertexBuffers(uint32_t firstBinding, ArrayProxy const &buffers, ArrayProxy const &offsets, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 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 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 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 void dispatch(uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; template 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 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 void copyBuffer(VULKAN_HPP_NAMESPACE::Buffer srcBuffer, VULKAN_HPP_NAMESPACE::Buffer dstBuffer, ArrayProxy const ®ions, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 void copyImage(VULKAN_HPP_NAMESPACE::Image srcImage, VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout, VULKAN_HPP_NAMESPACE::Image dstImage, VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, ArrayProxy const ®ions, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 void blitImage(VULKAN_HPP_NAMESPACE::Image srcImage, VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout, VULKAN_HPP_NAMESPACE::Image dstImage, VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, ArrayProxy const ®ions, VULKAN_HPP_NAMESPACE::Filter filter, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 void copyBufferToImage(VULKAN_HPP_NAMESPACE::Buffer srcBuffer, VULKAN_HPP_NAMESPACE::Image dstImage, VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, ArrayProxy const ®ions, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 void copyImageToBuffer(VULKAN_HPP_NAMESPACE::Image srcImage, VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout, VULKAN_HPP_NAMESPACE::Buffer dstBuffer, ArrayProxy const ®ions, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 void updateBuffer(VULKAN_HPP_NAMESPACE::Buffer dstBuffer, VULKAN_HPP_NAMESPACE::DeviceSize dstOffset, ArrayProxy const &data, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 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 void clearColorImage(VULKAN_HPP_NAMESPACE::Image image, VULKAN_HPP_NAMESPACE::ImageLayout imageLayout, const VULKAN_HPP_NAMESPACE::ClearColorValue &color, ArrayProxy const &ranges, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 void clearDepthStencilImage(VULKAN_HPP_NAMESPACE::Image image, VULKAN_HPP_NAMESPACE::ImageLayout imageLayout, const VULKAN_HPP_NAMESPACE::ClearDepthStencilValue &depthStencil, ArrayProxy const &ranges, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 void clearAttachments(ArrayProxy const &attachments, ArrayProxy const &rects, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 void resolveImage(VULKAN_HPP_NAMESPACE::Image srcImage, VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout, VULKAN_HPP_NAMESPACE::Image dstImage, VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, ArrayProxy const ®ions, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 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 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 void waitEvents(ArrayProxy const &events, VULKAN_HPP_NAMESPACE::PipelineStageFlags srcStageMask, VULKAN_HPP_NAMESPACE::PipelineStageFlags dstStageMask, ArrayProxy const &memoryBarriers, ArrayProxy const &bufferMemoryBarriers, ArrayProxy const &imageMemoryBarriers, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 void pipelineBarrier(VULKAN_HPP_NAMESPACE::PipelineStageFlags srcStageMask, VULKAN_HPP_NAMESPACE::PipelineStageFlags dstStageMask, VULKAN_HPP_NAMESPACE::DependencyFlags dependencyFlags, ArrayProxy const &memoryBarriers, ArrayProxy const &bufferMemoryBarriers, ArrayProxy const &imageMemoryBarriers, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 void endQuery(VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; template 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 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 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 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 void pushConstants(VULKAN_HPP_NAMESPACE::PipelineLayout layout, VULKAN_HPP_NAMESPACE::ShaderStageFlags stageFlags, uint32_t offset, ArrayProxy const &values, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 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 void nextSubpass(VULKAN_HPP_NAMESPACE::SubpassContents contents, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; template void endRenderPass(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; template 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 void executeCommands(ArrayProxy 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 void setDeviceMask(uint32_t deviceMask, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; template 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 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 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 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 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 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 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 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 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 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 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 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 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 void waitEvents2(ArrayProxy const &events, ArrayProxy const &dependencyInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 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 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 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 void copyBuffer2(const VULKAN_HPP_NAMESPACE::CopyBufferInfo2 ©BufferInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 void copyImage2(const VULKAN_HPP_NAMESPACE::CopyImageInfo2 ©ImageInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 void copyBufferToImage2(const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 ©BufferToImageInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 void copyImageToBuffer2(const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 ©ImageToBufferInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 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 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 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 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 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 void endRendering(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; template void setCullMode(VULKAN_HPP_NAMESPACE::CullModeFlags cullMode, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; template void setFrontFace(VULKAN_HPP_NAMESPACE::FrontFace frontFace, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; template void setPrimitiveTopology(VULKAN_HPP_NAMESPACE::PrimitiveTopology primitiveTopology, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; template 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 void setViewportWithCount(ArrayProxy const &viewports, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 void setScissorWithCount(ArrayProxy const &scissors, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 void bindVertexBuffers2(uint32_t firstBinding, ArrayProxy const &buffers, ArrayProxy const &offsets, ArrayProxy const &sizes VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, ArrayProxy 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 void setDepthTestEnable(VULKAN_HPP_NAMESPACE::Bool32 depthTestEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; template void setDepthWriteEnable(VULKAN_HPP_NAMESPACE::Bool32 depthWriteEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; template void setDepthCompareOp(VULKAN_HPP_NAMESPACE::CompareOp depthCompareOp, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; template void setDepthBoundsTestEnable(VULKAN_HPP_NAMESPACE::Bool32 depthBoundsTestEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; template void setStencilTestEnable(VULKAN_HPP_NAMESPACE::Bool32 stencilTestEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; template 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 void setRasterizerDiscardEnable(VULKAN_HPP_NAMESPACE::Bool32 rasterizerDiscardEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; template void setDepthBiasEnable(VULKAN_HPP_NAMESPACE::Bool32 depthBiasEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; template void setPrimitiveRestartEnable(VULKAN_HPP_NAMESPACE::Bool32 primitiveRestartEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; //=== VK_EXT_debug_marker === template 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 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 void debugMarkerEndEXT(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; template 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 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 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 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 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 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 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 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 void decodeVideoKHR(const VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR *pFrameInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template void decodeVideoKHR(const VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR &frameInfo, 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 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 void bindTransformFeedbackBuffersEXT(uint32_t firstBinding, ArrayProxy const &buffers, ArrayProxy const &offsets, ArrayProxy 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 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 void beginTransformFeedbackEXT(uint32_t firstCounterBuffer, ArrayProxy const &counterBuffers, ArrayProxy 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 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 void endTransformFeedbackEXT(uint32_t firstCounterBuffer, ArrayProxy const &counterBuffers, ArrayProxy 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 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 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 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 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 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 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 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 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 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 void endRenderingKHR(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; //=== VK_KHR_device_group === template void setDeviceMaskKHR(uint32_t deviceMask, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; template 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 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 void pushDescriptorSetKHR(VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, VULKAN_HPP_NAMESPACE::PipelineLayout layout, uint32_t set, ArrayProxy const &descriptorWrites, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 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 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 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 void endConditionalRenderingEXT(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; //=== VK_NV_clip_space_w_scaling === template 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 void setViewportWScalingNV(uint32_t firstViewport, ArrayProxy 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 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 void setDiscardRectangleEXT(uint32_t firstDiscardRectangle, ArrayProxy 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 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 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 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 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 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 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 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 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 void endDebugUtilsLabelEXT(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; template 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 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 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 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 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 void buildAccelerationStructuresKHR(ArrayProxy const &infos, ArrayProxy const &pBuildRangeInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 void buildAccelerationStructuresIndirectKHR(ArrayProxy const &infos, ArrayProxy const &indirectDeviceAddresses, ArrayProxy const &indirectStrides, ArrayProxy const &pMaxPrimitiveCounts, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 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 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 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 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 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 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 void writeAccelerationStructuresPropertiesKHR(ArrayProxy 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 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 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 void setViewportShadingRatePaletteNV(uint32_t firstViewport, ArrayProxy const &shadingRatePalettes, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 void setCoarseSampleOrderNV(VULKAN_HPP_NAMESPACE::CoarseSampleOrderTypeNV sampleOrderType, ArrayProxy 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 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 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 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 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 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 void writeAccelerationStructuresPropertiesNV(ArrayProxy 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 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 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 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 void drawMeshTasksNV(uint32_t taskCount, uint32_t firstTask, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; template 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 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 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 void setExclusiveScissorNV(uint32_t firstExclusiveScissor, ArrayProxy 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 void setCheckpointNV(const void *pCheckpointMarker, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template 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 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 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type setPerformanceMarkerINTEL(const VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL &markerInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type setPerformanceStreamMarkerINTEL(const VULKAN_HPP_NAMESPACE::PerformanceStreamMarkerInfoINTEL &markerInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::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 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 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 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 void setCullModeEXT(VULKAN_HPP_NAMESPACE::CullModeFlags cullMode, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; template void setFrontFaceEXT(VULKAN_HPP_NAMESPACE::FrontFace frontFace, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; template void setPrimitiveTopologyEXT(VULKAN_HPP_NAMESPACE::PrimitiveTopology primitiveTopology, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; template 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 void setViewportWithCountEXT(ArrayProxy const &viewports, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 void setScissorWithCountEXT(ArrayProxy const &scissors, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 void bindVertexBuffers2EXT(uint32_t firstBinding, ArrayProxy const &buffers, ArrayProxy const &offsets, ArrayProxy const &sizes VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, ArrayProxy 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 void setDepthTestEnableEXT(VULKAN_HPP_NAMESPACE::Bool32 depthTestEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; template void setDepthWriteEnableEXT(VULKAN_HPP_NAMESPACE::Bool32 depthWriteEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; template void setDepthCompareOpEXT(VULKAN_HPP_NAMESPACE::CompareOp depthCompareOp, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; template void setDepthBoundsTestEnableEXT(VULKAN_HPP_NAMESPACE::Bool32 depthBoundsTestEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; template void setStencilTestEnableEXT(VULKAN_HPP_NAMESPACE::Bool32 stencilTestEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; template 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 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 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 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 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 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 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 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 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 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 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 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 void waitEvents2KHR(ArrayProxy const &events, ArrayProxy const &dependencyInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 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 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 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_NV_fragment_shading_rate_enums === template 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_KHR_copy_commands2 === template 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 void copyBuffer2KHR(const VULKAN_HPP_NAMESPACE::CopyBufferInfo2 ©BufferInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 void copyImage2KHR(const VULKAN_HPP_NAMESPACE::CopyImageInfo2 ©ImageInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 void copyBufferToImage2KHR(const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 ©BufferToImageInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 void copyImageToBuffer2KHR(const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 ©ImageToBufferInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 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 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 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 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 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 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 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 void setRayTracingPipelineStackSizeKHR(uint32_t pipelineStackSize, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; //=== VK_EXT_vertex_input_dynamic_state === template 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 void setVertexInputEXT(ArrayProxy const &vertexBindingDescriptions, ArrayProxy 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 void subpassShadingHUAWEI(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; //=== VK_HUAWEI_invocation_mask === template 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 void setPatchControlPointsEXT(uint32_t patchControlPoints, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; template void setRasterizerDiscardEnableEXT(VULKAN_HPP_NAMESPACE::Bool32 rasterizerDiscardEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; template void setDepthBiasEnableEXT(VULKAN_HPP_NAMESPACE::Bool32 depthBiasEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; template void setLogicOpEXT(VULKAN_HPP_NAMESPACE::LogicOp logicOp, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; template 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 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 void setColorWriteEnableEXT(ArrayProxy const &colorWriteEnables, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ //=== VK_EXT_multi_draw === template 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 void drawMultiEXT(ArrayProxy const &vertexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 void drawMultiIndexedEXT(ArrayProxy const &indexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride, Optional 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*/ VULKAN_HPP_TYPESAFE_EXPLICIT 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 = {}; }; VULKAN_HPP_STATIC_ASSERT(sizeof(VULKAN_HPP_NAMESPACE::CommandBuffer) == sizeof(VkCommandBuffer), "handle and wrapper have different size!"); VULKAN_HPP_STATIC_ASSERT(std::is_nothrow_move_constructible::value, "CommandBuffer is not nothrow_move_constructible!"); template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::CommandBuffer; }; template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::CommandBuffer; }; template<> struct isVulkanHandleType { 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 = {}; }; VULKAN_HPP_STATIC_ASSERT(sizeof(VULKAN_HPP_NAMESPACE::DeviceMemory) == sizeof(VkDeviceMemory), "handle and wrapper have different size!"); VULKAN_HPP_STATIC_ASSERT(std::is_nothrow_move_constructible::value, "DeviceMemory is not nothrow_move_constructible!"); template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::DeviceMemory; }; template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::DeviceMemory; }; template<> struct isVulkanHandleType { 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 = {}; }; VULKAN_HPP_STATIC_ASSERT(sizeof(VULKAN_HPP_NAMESPACE::VideoSessionKHR) == sizeof(VkVideoSessionKHR), "handle and wrapper have different size!"); VULKAN_HPP_STATIC_ASSERT(std::is_nothrow_move_constructible::value, "VideoSessionKHR is not nothrow_move_constructible!"); template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::VideoSessionKHR; }; template<> struct isVulkanHandleType { 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 = {}; }; VULKAN_HPP_STATIC_ASSERT(sizeof(VULKAN_HPP_NAMESPACE::DeferredOperationKHR) == sizeof(VkDeferredOperationKHR), "handle and wrapper have different size!"); VULKAN_HPP_STATIC_ASSERT(std::is_nothrow_move_constructible::value, "DeferredOperationKHR is not nothrow_move_constructible!"); template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::DeferredOperationKHR; }; template<> struct isVulkanHandleType { 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 = {}; }; VULKAN_HPP_STATIC_ASSERT(sizeof(VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA) == sizeof(VkBufferCollectionFUCHSIA), "handle and wrapper have different size!"); VULKAN_HPP_STATIC_ASSERT(std::is_nothrow_move_constructible::value, "BufferCollectionFUCHSIA is not nothrow_move_constructible!"); template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA; }; template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA; }; template<> struct isVulkanHandleType { 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 = {}; }; VULKAN_HPP_STATIC_ASSERT(sizeof(VULKAN_HPP_NAMESPACE::BufferView) == sizeof(VkBufferView), "handle and wrapper have different size!"); VULKAN_HPP_STATIC_ASSERT(std::is_nothrow_move_constructible::value, "BufferView is not nothrow_move_constructible!"); template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::BufferView; }; template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::BufferView; }; template<> struct isVulkanHandleType { 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 = {}; }; VULKAN_HPP_STATIC_ASSERT(sizeof(VULKAN_HPP_NAMESPACE::CommandPool) == sizeof(VkCommandPool), "handle and wrapper have different size!"); VULKAN_HPP_STATIC_ASSERT(std::is_nothrow_move_constructible::value, "CommandPool is not nothrow_move_constructible!"); template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::CommandPool; }; template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::CommandPool; }; template<> struct isVulkanHandleType { 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 = {}; }; VULKAN_HPP_STATIC_ASSERT(sizeof(VULKAN_HPP_NAMESPACE::PipelineCache) == sizeof(VkPipelineCache), "handle and wrapper have different size!"); VULKAN_HPP_STATIC_ASSERT(std::is_nothrow_move_constructible::value, "PipelineCache is not nothrow_move_constructible!"); template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::PipelineCache; }; template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::PipelineCache; }; template<> struct isVulkanHandleType { 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 = {}; }; VULKAN_HPP_STATIC_ASSERT(sizeof(VULKAN_HPP_NAMESPACE::CuFunctionNVX) == sizeof(VkCuFunctionNVX), "handle and wrapper have different size!"); VULKAN_HPP_STATIC_ASSERT(std::is_nothrow_move_constructible::value, "CuFunctionNVX is not nothrow_move_constructible!"); template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::CuFunctionNVX; }; template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::CuFunctionNVX; }; template<> struct isVulkanHandleType { 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 = {}; }; VULKAN_HPP_STATIC_ASSERT(sizeof(VULKAN_HPP_NAMESPACE::CuModuleNVX) == sizeof(VkCuModuleNVX), "handle and wrapper have different size!"); VULKAN_HPP_STATIC_ASSERT(std::is_nothrow_move_constructible::value, "CuModuleNVX is not nothrow_move_constructible!"); template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::CuModuleNVX; }; template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::CuModuleNVX; }; template<> struct isVulkanHandleType { 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 = {}; }; VULKAN_HPP_STATIC_ASSERT(sizeof(VULKAN_HPP_NAMESPACE::DescriptorPool) == sizeof(VkDescriptorPool), "handle and wrapper have different size!"); VULKAN_HPP_STATIC_ASSERT(std::is_nothrow_move_constructible::value, "DescriptorPool is not nothrow_move_constructible!"); template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::DescriptorPool; }; template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::DescriptorPool; }; template<> struct isVulkanHandleType { 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 = {}; }; VULKAN_HPP_STATIC_ASSERT(sizeof(VULKAN_HPP_NAMESPACE::DescriptorSetLayout) == sizeof(VkDescriptorSetLayout), "handle and wrapper have different size!"); VULKAN_HPP_STATIC_ASSERT(std::is_nothrow_move_constructible::value, "DescriptorSetLayout is not nothrow_move_constructible!"); template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::DescriptorSetLayout; }; template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::DescriptorSetLayout; }; template<> struct isVulkanHandleType { 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 = {}; }; VULKAN_HPP_STATIC_ASSERT(sizeof(VULKAN_HPP_NAMESPACE::Framebuffer) == sizeof(VkFramebuffer), "handle and wrapper have different size!"); VULKAN_HPP_STATIC_ASSERT(std::is_nothrow_move_constructible::value, "Framebuffer is not nothrow_move_constructible!"); template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::Framebuffer; }; template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::Framebuffer; }; template<> struct isVulkanHandleType { 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 = {}; }; VULKAN_HPP_STATIC_ASSERT(sizeof(VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV) == sizeof(VkIndirectCommandsLayoutNV), "handle and wrapper have different size!"); VULKAN_HPP_STATIC_ASSERT(std::is_nothrow_move_constructible::value, "IndirectCommandsLayoutNV is not nothrow_move_constructible!"); template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV; }; template<> struct isVulkanHandleType { 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 = {}; }; VULKAN_HPP_STATIC_ASSERT(sizeof(VULKAN_HPP_NAMESPACE::PrivateDataSlot) == sizeof(VkPrivateDataSlot), "handle and wrapper have different size!"); VULKAN_HPP_STATIC_ASSERT(std::is_nothrow_move_constructible::value, "PrivateDataSlot is not nothrow_move_constructible!"); template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::PrivateDataSlot; }; template<> struct isVulkanHandleType { 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 = {}; }; VULKAN_HPP_STATIC_ASSERT(sizeof(VULKAN_HPP_NAMESPACE::RenderPass) == sizeof(VkRenderPass), "handle and wrapper have different size!"); VULKAN_HPP_STATIC_ASSERT(std::is_nothrow_move_constructible::value, "RenderPass is not nothrow_move_constructible!"); template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::RenderPass; }; template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::RenderPass; }; template<> struct isVulkanHandleType { 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 = {}; }; VULKAN_HPP_STATIC_ASSERT(sizeof(VULKAN_HPP_NAMESPACE::Sampler) == sizeof(VkSampler), "handle and wrapper have different size!"); VULKAN_HPP_STATIC_ASSERT(std::is_nothrow_move_constructible::value, "Sampler is not nothrow_move_constructible!"); template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::Sampler; }; template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::Sampler; }; template<> struct isVulkanHandleType { 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 = {}; }; VULKAN_HPP_STATIC_ASSERT(sizeof(VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion) == sizeof(VkSamplerYcbcrConversion), "handle and wrapper have different size!"); VULKAN_HPP_STATIC_ASSERT(std::is_nothrow_move_constructible::value, "SamplerYcbcrConversion is not nothrow_move_constructible!"); template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion; }; template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion; }; template<> struct isVulkanHandleType { 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 = {}; }; VULKAN_HPP_STATIC_ASSERT(sizeof(VULKAN_HPP_NAMESPACE::ShaderModule) == sizeof(VkShaderModule), "handle and wrapper have different size!"); VULKAN_HPP_STATIC_ASSERT(std::is_nothrow_move_constructible::value, "ShaderModule is not nothrow_move_constructible!"); template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::ShaderModule; }; template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::ShaderModule; }; template<> struct isVulkanHandleType { 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 = {}; }; VULKAN_HPP_STATIC_ASSERT(sizeof(VULKAN_HPP_NAMESPACE::ValidationCacheEXT) == sizeof(VkValidationCacheEXT), "handle and wrapper have different size!"); VULKAN_HPP_STATIC_ASSERT(std::is_nothrow_move_constructible::value, "ValidationCacheEXT is not nothrow_move_constructible!"); template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::ValidationCacheEXT; }; template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::ValidationCacheEXT; }; template<> struct isVulkanHandleType { 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 = {}; }; VULKAN_HPP_STATIC_ASSERT(sizeof(VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR) == sizeof(VkVideoSessionParametersKHR), "handle and wrapper have different size!"); VULKAN_HPP_STATIC_ASSERT(std::is_nothrow_move_constructible::value, "VideoSessionParametersKHR is not nothrow_move_constructible!"); template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR; }; template<> struct isVulkanHandleType { 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 {} VULKAN_HPP_TYPESAFE_EXPLICIT Queue(VkQueue queue) VULKAN_HPP_NOEXCEPT : m_queue(queue) {} #if defined(VULKAN_HPP_TYPESAFE_CONVERSION) Queue &operator=(VkQueue queue) VULKAN_HPP_NOEXCEPT { m_queue = queue; return *this; } #endif 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 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 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type submit(ArrayProxy 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 VULKAN_HPP_NODISCARD Result waitIdle(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; #else template VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type waitIdle(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type bindSparse(ArrayProxy 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 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 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type submit2(ArrayProxy 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 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 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 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 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 void endDebugUtilsLabelEXT(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; template 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 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 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 Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> VULKAN_HPP_NODISCARD std::vector getCheckpointDataNV(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; template, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B = CheckpointDataNVAllocator, typename std::enable_if::value, int>::type = 0> VULKAN_HPP_NODISCARD std::vector 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 VULKAN_HPP_NODISCARD Result setPerformanceConfigurationINTEL(VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; #else template VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::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 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 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type submit2KHR(ArrayProxy 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 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 Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> VULKAN_HPP_NODISCARD std::vector getCheckpointData2NV(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; template, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B = CheckpointData2NVAllocator, typename std::enable_if::value, int>::type = 0> VULKAN_HPP_NODISCARD std::vector getCheckpointData2NV(CheckpointData2NVAllocator &checkpointData2NVAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ VULKAN_HPP_TYPESAFE_EXPLICIT 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 = {}; }; VULKAN_HPP_STATIC_ASSERT(sizeof(VULKAN_HPP_NAMESPACE::Queue) == sizeof(VkQueue), "handle and wrapper have different size!"); VULKAN_HPP_STATIC_ASSERT(std::is_nothrow_move_constructible::value, "Queue is not nothrow_move_constructible!"); template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::Queue; }; template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::Queue; }; template<> struct isVulkanHandleType { static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; }; #ifndef VULKAN_HPP_NO_SMART_HANDLE class Device; template class UniqueHandleTraits { public: using deleter = ObjectDestroy; }; using UniqueAccelerationStructureKHR = UniqueHandle; template class UniqueHandleTraits { public: using deleter = ObjectDestroy; }; using UniqueAccelerationStructureNV = UniqueHandle; template class UniqueHandleTraits { public: using deleter = ObjectDestroy; }; using UniqueBuffer = UniqueHandle; # if defined(VK_USE_PLATFORM_FUCHSIA) template class UniqueHandleTraits { public: using deleter = ObjectDestroy; }; using UniqueBufferCollectionFUCHSIA = UniqueHandle; # endif /*VK_USE_PLATFORM_FUCHSIA*/ template class UniqueHandleTraits { public: using deleter = ObjectDestroy; }; using UniqueBufferView = UniqueHandle; template class UniqueHandleTraits { public: using deleter = PoolFree; }; using UniqueCommandBuffer = UniqueHandle; template class UniqueHandleTraits { public: using deleter = ObjectDestroy; }; using UniqueCommandPool = UniqueHandle; template class UniqueHandleTraits { public: using deleter = ObjectDestroy; }; using UniqueCuFunctionNVX = UniqueHandle; template class UniqueHandleTraits { public: using deleter = ObjectDestroy; }; using UniqueCuModuleNVX = UniqueHandle; template class UniqueHandleTraits { public: using deleter = ObjectDestroy; }; using UniqueDeferredOperationKHR = UniqueHandle; template class UniqueHandleTraits { public: using deleter = ObjectDestroy; }; using UniqueDescriptorPool = UniqueHandle; template class UniqueHandleTraits { public: using deleter = PoolFree; }; using UniqueDescriptorSet = UniqueHandle; template class UniqueHandleTraits { public: using deleter = ObjectDestroy; }; using UniqueDescriptorSetLayout = UniqueHandle; template class UniqueHandleTraits { public: using deleter = ObjectDestroy; }; using UniqueDescriptorUpdateTemplate = UniqueHandle; using UniqueDescriptorUpdateTemplateKHR = UniqueHandle; template class UniqueHandleTraits { public: using deleter = ObjectFree; }; using UniqueDeviceMemory = UniqueHandle; template class UniqueHandleTraits { public: using deleter = ObjectDestroy; }; using UniqueEvent = UniqueHandle; template class UniqueHandleTraits { public: using deleter = ObjectDestroy; }; using UniqueFence = UniqueHandle; template class UniqueHandleTraits { public: using deleter = ObjectDestroy; }; using UniqueFramebuffer = UniqueHandle; template class UniqueHandleTraits { public: using deleter = ObjectDestroy; }; using UniqueImage = UniqueHandle; template class UniqueHandleTraits { public: using deleter = ObjectDestroy; }; using UniqueImageView = UniqueHandle; template class UniqueHandleTraits { public: using deleter = ObjectDestroy; }; using UniqueIndirectCommandsLayoutNV = UniqueHandle; template class UniqueHandleTraits { public: using deleter = ObjectDestroy; }; using UniquePipeline = UniqueHandle; template class UniqueHandleTraits { public: using deleter = ObjectDestroy; }; using UniquePipelineCache = UniqueHandle; template class UniqueHandleTraits { public: using deleter = ObjectDestroy; }; using UniquePipelineLayout = UniqueHandle; template class UniqueHandleTraits { public: using deleter = ObjectDestroy; }; using UniquePrivateDataSlot = UniqueHandle; using UniquePrivateDataSlotEXT = UniqueHandle; template class UniqueHandleTraits { public: using deleter = ObjectDestroy; }; using UniqueQueryPool = UniqueHandle; template class UniqueHandleTraits { public: using deleter = ObjectDestroy; }; using UniqueRenderPass = UniqueHandle; template class UniqueHandleTraits { public: using deleter = ObjectDestroy; }; using UniqueSampler = UniqueHandle; template class UniqueHandleTraits { public: using deleter = ObjectDestroy; }; using UniqueSamplerYcbcrConversion = UniqueHandle; using UniqueSamplerYcbcrConversionKHR = UniqueHandle; template class UniqueHandleTraits { public: using deleter = ObjectDestroy; }; using UniqueSemaphore = UniqueHandle; template class UniqueHandleTraits { public: using deleter = ObjectDestroy; }; using UniqueShaderModule = UniqueHandle; template class UniqueHandleTraits { public: using deleter = ObjectDestroy; }; using UniqueSwapchainKHR = UniqueHandle; template class UniqueHandleTraits { public: using deleter = ObjectDestroy; }; using UniqueValidationCacheEXT = UniqueHandle; # if defined(VK_ENABLE_BETA_EXTENSIONS) template class UniqueHandleTraits { public: using deleter = ObjectDestroy; }; using UniqueVideoSessionKHR = UniqueHandle; # endif /*VK_ENABLE_BETA_EXTENSIONS*/ # if defined(VK_ENABLE_BETA_EXTENSIONS) template class UniqueHandleTraits { public: using deleter = ObjectDestroy; }; using UniqueVideoSessionParametersKHR = UniqueHandle; # 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 {} VULKAN_HPP_TYPESAFE_EXPLICIT Device(VkDevice device) VULKAN_HPP_NOEXCEPT : m_device(device) {} #if defined(VULKAN_HPP_TYPESAFE_CONVERSION) Device &operator=(VkDevice device) VULKAN_HPP_NOEXCEPT { m_device = device; return *this; } #endif 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 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 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 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 void destroy(Optional 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 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 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 VULKAN_HPP_NODISCARD Result waitIdle(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; #else template VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type waitIdle(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 VULKAN_HPP_NODISCARD typename ResultValueType::type allocateMemory(const VULKAN_HPP_NAMESPACE::MemoryAllocateInfo &allocateInfo, Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; # ifndef VULKAN_HPP_NO_SMART_HANDLE template VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type allocateMemoryUnique(const VULKAN_HPP_NAMESPACE::MemoryAllocateInfo &allocateInfo, Optional 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 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 void freeMemory(VULKAN_HPP_NAMESPACE::DeviceMemory memory VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional 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 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 void(free)(VULKAN_HPP_NAMESPACE::DeviceMemory memory, Optional 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 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 VULKAN_HPP_NODISCARD typename ResultValueType::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 void unmapMemory(VULKAN_HPP_NAMESPACE::DeviceMemory memory, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; template 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 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type flushMappedMemoryRanges(ArrayProxy const &memoryRanges, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type invalidateMappedMemoryRanges(ArrayProxy const &memoryRanges, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 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 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 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::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 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 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::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 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 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 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 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 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 Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> VULKAN_HPP_NODISCARD std::vector getImageSparseMemoryRequirements(VULKAN_HPP_NAMESPACE::Image image, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; template, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B = SparseImageMemoryRequirementsAllocator, typename std::enable_if::value, int>::type = 0> VULKAN_HPP_NODISCARD std::vector getImageSparseMemoryRequirements(VULKAN_HPP_NAMESPACE::Image image, SparseImageMemoryRequirementsAllocator &sparseImageMemoryRequirementsAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 VULKAN_HPP_NODISCARD typename ResultValueType::type createFence(const VULKAN_HPP_NAMESPACE::FenceCreateInfo &createInfo, Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; # ifndef VULKAN_HPP_NO_SMART_HANDLE template VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type createFenceUnique(const VULKAN_HPP_NAMESPACE::FenceCreateInfo &createInfo, Optional 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 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 void destroyFence(VULKAN_HPP_NAMESPACE::Fence fence VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional 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 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 void destroy(VULKAN_HPP_NAMESPACE::Fence fence, Optional 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 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 ResultValueType::type resetFences(ArrayProxy const &fences, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE template VULKAN_HPP_NODISCARD Result getFenceStatus(VULKAN_HPP_NAMESPACE::Fence fence, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; #else template 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 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 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result waitForFences(ArrayProxy 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 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 VULKAN_HPP_NODISCARD typename ResultValueType::type createSemaphore(const VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo &createInfo, Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; # ifndef VULKAN_HPP_NO_SMART_HANDLE template VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type createSemaphoreUnique(const VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo &createInfo, Optional 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 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 void destroySemaphore(VULKAN_HPP_NAMESPACE::Semaphore semaphore VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional 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 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 void destroy(VULKAN_HPP_NAMESPACE::Semaphore semaphore, Optional 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 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 VULKAN_HPP_NODISCARD typename ResultValueType::type createEvent(const VULKAN_HPP_NAMESPACE::EventCreateInfo &createInfo, Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; # ifndef VULKAN_HPP_NO_SMART_HANDLE template VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type createEventUnique(const VULKAN_HPP_NAMESPACE::EventCreateInfo &createInfo, Optional 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 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 void destroyEvent(VULKAN_HPP_NAMESPACE::Event event VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional 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 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 void destroy(VULKAN_HPP_NAMESPACE::Event event, Optional 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 VULKAN_HPP_NODISCARD Result getEventStatus(VULKAN_HPP_NAMESPACE::Event event, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; #else template 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 VULKAN_HPP_NODISCARD Result setEvent(VULKAN_HPP_NAMESPACE::Event event, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; #else template VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::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 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 ResultValueType::type resetEvent(VULKAN_HPP_NAMESPACE::Event event, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 VULKAN_HPP_NODISCARD typename ResultValueType::type createQueryPool(const VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo &createInfo, Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; # ifndef VULKAN_HPP_NO_SMART_HANDLE template VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type createQueryPoolUnique(const VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo &createInfo, Optional 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 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 void destroyQueryPool(VULKAN_HPP_NAMESPACE::QueryPool queryPool VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional 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 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 void destroy(VULKAN_HPP_NAMESPACE::QueryPool queryPool, Optional 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 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 Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> VULKAN_HPP_NODISCARD ResultValue> 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 VULKAN_HPP_NODISCARD ResultValue 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 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 VULKAN_HPP_NODISCARD typename ResultValueType::type createBuffer(const VULKAN_HPP_NAMESPACE::BufferCreateInfo &createInfo, Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; # ifndef VULKAN_HPP_NO_SMART_HANDLE template VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type createBufferUnique(const VULKAN_HPP_NAMESPACE::BufferCreateInfo &createInfo, Optional 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 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 void destroyBuffer(VULKAN_HPP_NAMESPACE::Buffer buffer VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional 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 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 void destroy(VULKAN_HPP_NAMESPACE::Buffer buffer, Optional 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 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 VULKAN_HPP_NODISCARD typename ResultValueType::type createBufferView(const VULKAN_HPP_NAMESPACE::BufferViewCreateInfo &createInfo, Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; # ifndef VULKAN_HPP_NO_SMART_HANDLE template VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type createBufferViewUnique(const VULKAN_HPP_NAMESPACE::BufferViewCreateInfo &createInfo, Optional 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 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 void destroyBufferView(VULKAN_HPP_NAMESPACE::BufferView bufferView VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional 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 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 void destroy(VULKAN_HPP_NAMESPACE::BufferView bufferView, Optional 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 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 VULKAN_HPP_NODISCARD typename ResultValueType::type createImage(const VULKAN_HPP_NAMESPACE::ImageCreateInfo &createInfo, Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; # ifndef VULKAN_HPP_NO_SMART_HANDLE template VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type createImageUnique(const VULKAN_HPP_NAMESPACE::ImageCreateInfo &createInfo, Optional 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 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 void destroyImage(VULKAN_HPP_NAMESPACE::Image image VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional 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 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 void destroy(VULKAN_HPP_NAMESPACE::Image image, Optional 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 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 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 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 VULKAN_HPP_NODISCARD typename ResultValueType::type createImageView(const VULKAN_HPP_NAMESPACE::ImageViewCreateInfo &createInfo, Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; # ifndef VULKAN_HPP_NO_SMART_HANDLE template VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type createImageViewUnique(const VULKAN_HPP_NAMESPACE::ImageViewCreateInfo &createInfo, Optional 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 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 void destroyImageView(VULKAN_HPP_NAMESPACE::ImageView imageView VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional 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 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 void destroy(VULKAN_HPP_NAMESPACE::ImageView imageView, Optional 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 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 VULKAN_HPP_NODISCARD typename ResultValueType::type createShaderModule(const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo &createInfo, Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; # ifndef VULKAN_HPP_NO_SMART_HANDLE template VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type createShaderModuleUnique(const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo &createInfo, Optional 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 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 void destroyShaderModule(VULKAN_HPP_NAMESPACE::ShaderModule shaderModule VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional 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 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 void destroy(VULKAN_HPP_NAMESPACE::ShaderModule shaderModule, Optional 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 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 VULKAN_HPP_NODISCARD typename ResultValueType::type createPipelineCache(const VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo &createInfo, Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; # ifndef VULKAN_HPP_NO_SMART_HANDLE template VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type createPipelineCacheUnique(const VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo &createInfo, Optional 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 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 void destroyPipelineCache(VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional 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 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 void destroy(VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, Optional 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 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 Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> VULKAN_HPP_NODISCARD typename ResultValueType>::type getPipelineCacheData(VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; template, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B = Uint8_tAllocator, typename std::enable_if::value, int>::type = 0> VULKAN_HPP_NODISCARD typename ResultValueType>::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 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 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type mergePipelineCaches(VULKAN_HPP_NAMESPACE::PipelineCache dstCache, ArrayProxy const &srcCaches, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> VULKAN_HPP_NODISCARD ResultValue> createGraphicsPipelines(VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, ArrayProxy const &createInfos, Optional 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 B = PipelineAllocator, typename std::enable_if::value, int>::type = 0> VULKAN_HPP_NODISCARD ResultValue> createGraphicsPipelines(VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, ArrayProxy const &createInfos, Optional allocator, PipelineAllocator &pipelineAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; template VULKAN_HPP_NODISCARD ResultValue createGraphicsPipeline(VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo &createInfo, Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; # ifndef VULKAN_HPP_NO_SMART_HANDLE template>> VULKAN_HPP_NODISCARD ResultValue, PipelineAllocator>> createGraphicsPipelinesUnique(VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, ArrayProxy const &createInfos, Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; template>, typename B = PipelineAllocator, typename std::enable_if>::value, int>::type = 0> VULKAN_HPP_NODISCARD ResultValue, PipelineAllocator>> createGraphicsPipelinesUnique(VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, ArrayProxy const &createInfos, Optional allocator, PipelineAllocator &pipelineAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; template VULKAN_HPP_NODISCARD ResultValue> createGraphicsPipelineUnique(VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo &createInfo, Optional 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 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 Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> VULKAN_HPP_NODISCARD ResultValue> createComputePipelines(VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, ArrayProxy const &createInfos, Optional 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 B = PipelineAllocator, typename std::enable_if::value, int>::type = 0> VULKAN_HPP_NODISCARD ResultValue> createComputePipelines(VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, ArrayProxy const &createInfos, Optional allocator, PipelineAllocator &pipelineAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; template VULKAN_HPP_NODISCARD ResultValue createComputePipeline(VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo &createInfo, Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; # ifndef VULKAN_HPP_NO_SMART_HANDLE template>> VULKAN_HPP_NODISCARD ResultValue, PipelineAllocator>> createComputePipelinesUnique(VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, ArrayProxy const &createInfos, Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; template>, typename B = PipelineAllocator, typename std::enable_if>::value, int>::type = 0> VULKAN_HPP_NODISCARD ResultValue, PipelineAllocator>> createComputePipelinesUnique(VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, ArrayProxy const &createInfos, Optional allocator, PipelineAllocator &pipelineAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; template VULKAN_HPP_NODISCARD ResultValue> createComputePipelineUnique(VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo &createInfo, Optional 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 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 void destroyPipeline(VULKAN_HPP_NAMESPACE::Pipeline pipeline VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional 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 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 void destroy(VULKAN_HPP_NAMESPACE::Pipeline pipeline, Optional 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 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 VULKAN_HPP_NODISCARD typename ResultValueType::type createPipelineLayout(const VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo &createInfo, Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; # ifndef VULKAN_HPP_NO_SMART_HANDLE template VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type createPipelineLayoutUnique(const VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo &createInfo, Optional 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 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 void destroyPipelineLayout(VULKAN_HPP_NAMESPACE::PipelineLayout pipelineLayout VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional 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 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 void destroy(VULKAN_HPP_NAMESPACE::PipelineLayout pipelineLayout, Optional 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 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 VULKAN_HPP_NODISCARD typename ResultValueType::type createSampler(const VULKAN_HPP_NAMESPACE::SamplerCreateInfo &createInfo, Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; # ifndef VULKAN_HPP_NO_SMART_HANDLE template VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type createSamplerUnique(const VULKAN_HPP_NAMESPACE::SamplerCreateInfo &createInfo, Optional 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 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 void destroySampler(VULKAN_HPP_NAMESPACE::Sampler sampler VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional 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 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 void destroy(VULKAN_HPP_NAMESPACE::Sampler sampler, Optional 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 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 VULKAN_HPP_NODISCARD typename ResultValueType::type createDescriptorSetLayout(const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo &createInfo, Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; # ifndef VULKAN_HPP_NO_SMART_HANDLE template VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type createDescriptorSetLayoutUnique(const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo &createInfo, Optional 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 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 void destroyDescriptorSetLayout(VULKAN_HPP_NAMESPACE::DescriptorSetLayout descriptorSetLayout VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional 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 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 void destroy(VULKAN_HPP_NAMESPACE::DescriptorSetLayout descriptorSetLayout, Optional 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 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 VULKAN_HPP_NODISCARD typename ResultValueType::type createDescriptorPool(const VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo &createInfo, Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; # ifndef VULKAN_HPP_NO_SMART_HANDLE template VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type createDescriptorPoolUnique(const VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo &createInfo, Optional 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 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 void destroyDescriptorPool(VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional 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 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 void destroy(VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool, Optional 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 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 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 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 Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> VULKAN_HPP_NODISCARD typename ResultValueType>::type allocateDescriptorSets(const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo &allocateInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; template, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B = DescriptorSetAllocator, typename std::enable_if::value, int>::type = 0> VULKAN_HPP_NODISCARD typename ResultValueType>::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>> VULKAN_HPP_NODISCARD typename ResultValueType, DescriptorSetAllocator>>::type allocateDescriptorSetsUnique(const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo &allocateInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; template>, typename B = DescriptorSetAllocator, typename std::enable_if>::value, int>::type = 0> VULKAN_HPP_NODISCARD typename ResultValueType, 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 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 void freeDescriptorSets(VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool, ArrayProxy const &descriptorSets, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 void(free)(VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool, ArrayProxy const &descriptorSets, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 void updateDescriptorSets(ArrayProxy const &descriptorWrites, ArrayProxy const &descriptorCopies, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 VULKAN_HPP_NODISCARD typename ResultValueType::type createFramebuffer(const VULKAN_HPP_NAMESPACE::FramebufferCreateInfo &createInfo, Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; # ifndef VULKAN_HPP_NO_SMART_HANDLE template VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type createFramebufferUnique(const VULKAN_HPP_NAMESPACE::FramebufferCreateInfo &createInfo, Optional 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 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 void destroyFramebuffer(VULKAN_HPP_NAMESPACE::Framebuffer framebuffer VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional 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 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 void destroy(VULKAN_HPP_NAMESPACE::Framebuffer framebuffer, Optional 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 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 VULKAN_HPP_NODISCARD typename ResultValueType::type createRenderPass(const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo &createInfo, Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; # ifndef VULKAN_HPP_NO_SMART_HANDLE template VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type createRenderPassUnique(const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo &createInfo, Optional 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 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 void destroyRenderPass(VULKAN_HPP_NAMESPACE::RenderPass renderPass VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional 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 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 void destroy(VULKAN_HPP_NAMESPACE::RenderPass renderPass, Optional 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 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 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 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 VULKAN_HPP_NODISCARD typename ResultValueType::type createCommandPool(const VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo &createInfo, Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; # ifndef VULKAN_HPP_NO_SMART_HANDLE template VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type createCommandPoolUnique(const VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo &createInfo, Optional 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 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 void destroyCommandPool(VULKAN_HPP_NAMESPACE::CommandPool commandPool VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional 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 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 void destroy(VULKAN_HPP_NAMESPACE::CommandPool commandPool, Optional 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 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 ResultValueType::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 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 Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> VULKAN_HPP_NODISCARD typename ResultValueType>::type allocateCommandBuffers(const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo &allocateInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; template, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B = CommandBufferAllocator, typename std::enable_if::value, int>::type = 0> VULKAN_HPP_NODISCARD typename ResultValueType>::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>> VULKAN_HPP_NODISCARD typename ResultValueType, CommandBufferAllocator>>::type allocateCommandBuffersUnique(const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo &allocateInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; template>, typename B = CommandBufferAllocator, typename std::enable_if>::value, int>::type = 0> VULKAN_HPP_NODISCARD typename ResultValueType, 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 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 void freeCommandBuffers(VULKAN_HPP_NAMESPACE::CommandPool commandPool, ArrayProxy const &commandBuffers, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 void(free)(VULKAN_HPP_NAMESPACE::CommandPool commandPool, ArrayProxy 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 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 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type bindBufferMemory2(ArrayProxy const &bindInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type bindImageMemory2(ArrayProxy const &bindInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 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 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 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 VULKAN_HPP_NODISCARD StructureChain 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 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 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 VULKAN_HPP_NODISCARD StructureChain 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 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 Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> VULKAN_HPP_NODISCARD std::vector getImageSparseMemoryRequirements2(const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; template, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B = SparseImageMemoryRequirements2Allocator, typename std::enable_if::value, int>::type = 0> VULKAN_HPP_NODISCARD std::vector 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 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 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 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 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 VULKAN_HPP_NODISCARD typename ResultValueType::type createSamplerYcbcrConversion(const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo &createInfo, Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; # ifndef VULKAN_HPP_NO_SMART_HANDLE template VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type createSamplerYcbcrConversionUnique(const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo &createInfo, Optional 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 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 void destroySamplerYcbcrConversion(VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional 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 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 void destroy(VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion, Optional 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 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 VULKAN_HPP_NODISCARD typename ResultValueType::type createDescriptorUpdateTemplate(const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo &createInfo, Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; # ifndef VULKAN_HPP_NO_SMART_HANDLE template VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type createDescriptorUpdateTemplateUnique(const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo &createInfo, Optional 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 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 void destroyDescriptorUpdateTemplate(VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional 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 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 void destroy(VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, Optional 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 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 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 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 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 VULKAN_HPP_NODISCARD StructureChain 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 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 VULKAN_HPP_NODISCARD typename ResultValueType::type createRenderPass2(const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 &createInfo, Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; # ifndef VULKAN_HPP_NO_SMART_HANDLE template VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type createRenderPass2Unique(const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 &createInfo, Optional 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 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 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 VULKAN_HPP_NODISCARD typename ResultValueType::type getSemaphoreCounterValue(VULKAN_HPP_NAMESPACE::Semaphore semaphore, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 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 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 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type signalSemaphore(const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo &signalInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 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 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 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 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 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 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 VULKAN_HPP_NODISCARD typename ResultValueType::type createPrivateDataSlot(const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo &createInfo, Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; # ifndef VULKAN_HPP_NO_SMART_HANDLE template VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type createPrivateDataSlotUnique(const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo &createInfo, Optional 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 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 void destroyPrivateDataSlot(VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional 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 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 void destroy(VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, Optional 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 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 ResultValueType::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 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 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 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 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 VULKAN_HPP_NODISCARD StructureChain 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 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 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 VULKAN_HPP_NODISCARD StructureChain 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 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 Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> VULKAN_HPP_NODISCARD std::vector getImageSparseMemoryRequirements(const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; template, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B = SparseImageMemoryRequirements2Allocator, typename std::enable_if::value, int>::type = 0> VULKAN_HPP_NODISCARD std::vector 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 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 VULKAN_HPP_NODISCARD typename ResultValueType::type createSwapchainKHR(const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR &createInfo, Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; # ifndef VULKAN_HPP_NO_SMART_HANDLE template VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type createSwapchainKHRUnique(const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR &createInfo, Optional 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 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 void destroySwapchainKHR(VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional 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 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 void destroy(VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Optional 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 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 Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> VULKAN_HPP_NODISCARD typename ResultValueType>::type getSwapchainImagesKHR(VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; template, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B = ImageAllocator, typename std::enable_if::value, int>::type = 0> VULKAN_HPP_NODISCARD typename ResultValueType>::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 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 VULKAN_HPP_NODISCARD ResultValue 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 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 VULKAN_HPP_NODISCARD typename ResultValueType::type getGroupPresentCapabilitiesKHR(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 VULKAN_HPP_NODISCARD typename ResultValueType::type getGroupSurfacePresentModesKHR(VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 VULKAN_HPP_NODISCARD ResultValue 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 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 Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> VULKAN_HPP_NODISCARD typename ResultValueType>::type createSharedSwapchainsKHR(ArrayProxy const &createInfos, Optional 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 B = SwapchainKHRAllocator, typename std::enable_if::value, int>::type = 0> VULKAN_HPP_NODISCARD typename ResultValueType>::type createSharedSwapchainsKHR(ArrayProxy const &createInfos, Optional allocator, SwapchainKHRAllocator &swapchainKHRAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; template VULKAN_HPP_NODISCARD typename ResultValueType::type createSharedSwapchainKHR(const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR &createInfo, Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; # ifndef VULKAN_HPP_NO_SMART_HANDLE template>> VULKAN_HPP_NODISCARD typename ResultValueType, SwapchainKHRAllocator>>::type createSharedSwapchainsKHRUnique(ArrayProxy const &createInfos, Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; template>, typename B = SwapchainKHRAllocator, typename std::enable_if>::value, int>::type = 0> VULKAN_HPP_NODISCARD typename ResultValueType, SwapchainKHRAllocator>>::type createSharedSwapchainsKHRUnique(ArrayProxy const &createInfos, Optional allocator, SwapchainKHRAllocator &swapchainKHRAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; template VULKAN_HPP_NODISCARD typename ResultValueType>::type createSharedSwapchainKHRUnique(const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR &createInfo, Optional 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 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 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type debugMarkerSetObjectTagEXT(const VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT &tagInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::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 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 VULKAN_HPP_NODISCARD typename ResultValueType::type createVideoSessionKHR(const VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR &createInfo, Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; # ifndef VULKAN_HPP_NO_SMART_HANDLE template VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type createVideoSessionKHRUnique(const VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR &createInfo, Optional 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 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 void destroyVideoSessionKHR(VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession, Optional 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 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 void destroy(VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession, Optional 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 VULKAN_HPP_NODISCARD Result getVideoSessionMemoryRequirementsKHR(VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession, uint32_t *pVideoSessionMemoryRequirementsCount, VULKAN_HPP_NAMESPACE::VideoGetMemoryPropertiesKHR *pVideoSessionMemoryRequirements, Dispatch const &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>::type getVideoSessionMemoryRequirementsKHR(VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; template, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B = VideoGetMemoryPropertiesKHRAllocator, typename std::enable_if::value, int>::type = 0> VULKAN_HPP_NODISCARD typename ResultValueType>::type getVideoSessionMemoryRequirementsKHR(VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession, VideoGetMemoryPropertiesKHRAllocator &videoGetMemoryPropertiesKHRAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template VULKAN_HPP_NODISCARD Result bindVideoSessionMemoryKHR(VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession, uint32_t videoSessionBindMemoryCount, const VULKAN_HPP_NAMESPACE::VideoBindMemoryKHR *pVideoSessionBindMemories, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type bindVideoSessionMemoryKHR(VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession, ArrayProxy const &videoSessionBindMemories, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 VULKAN_HPP_NODISCARD typename ResultValueType::type createVideoSessionParametersKHR(const VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR &createInfo, Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; # ifndef VULKAN_HPP_NO_SMART_HANDLE template VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type createVideoSessionParametersKHRUnique(const VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR &createInfo, Optional 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 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 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::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 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 void destroyVideoSessionParametersKHR(VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters, Optional 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 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 void destroy(VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters, Optional 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 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 VULKAN_HPP_NODISCARD typename ResultValueType::type createCuModuleNVX(const VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX &createInfo, Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; # ifndef VULKAN_HPP_NO_SMART_HANDLE template VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type createCuModuleNVXUnique(const VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX &createInfo, Optional 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 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 VULKAN_HPP_NODISCARD typename ResultValueType::type createCuFunctionNVX(const VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX &createInfo, Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; # ifndef VULKAN_HPP_NO_SMART_HANDLE template VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type createCuFunctionNVXUnique(const VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX &createInfo, Optional 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 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 void destroyCuModuleNVX(VULKAN_HPP_NAMESPACE::CuModuleNVX module, Optional 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 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 void destroy(VULKAN_HPP_NAMESPACE::CuModuleNVX module, Optional 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 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 void destroyCuFunctionNVX(VULKAN_HPP_NAMESPACE::CuFunctionNVX function, Optional 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 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 void destroy(VULKAN_HPP_NAMESPACE::CuFunctionNVX function, Optional 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 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 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 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 VULKAN_HPP_NODISCARD typename ResultValueType::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 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 Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> VULKAN_HPP_NODISCARD typename ResultValueType>::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 Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B = Uint8_tAllocator, typename std::enable_if::value, int>::type = 0> VULKAN_HPP_NODISCARD typename ResultValueType>::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 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 VULKAN_HPP_NODISCARD typename ResultValueType::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 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 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 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 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 VULKAN_HPP_NODISCARD typename ResultValueType::type getMemoryWin32HandleKHR(const VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR &getWin32HandleInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 VULKAN_HPP_NODISCARD typename ResultValueType::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 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 VULKAN_HPP_NODISCARD typename ResultValueType::type getMemoryFdKHR(const VULKAN_HPP_NAMESPACE::MemoryGetFdInfoKHR &getFdInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 VULKAN_HPP_NODISCARD typename ResultValueType::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 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 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type importSemaphoreWin32HandleKHR(const VULKAN_HPP_NAMESPACE::ImportSemaphoreWin32HandleInfoKHR &importSemaphoreWin32HandleInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 VULKAN_HPP_NODISCARD typename ResultValueType::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 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 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type importSemaphoreFdKHR(const VULKAN_HPP_NAMESPACE::ImportSemaphoreFdInfoKHR &importSemaphoreFdInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 VULKAN_HPP_NODISCARD typename ResultValueType::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 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 VULKAN_HPP_NODISCARD typename ResultValueType::type createDescriptorUpdateTemplateKHR(const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo &createInfo, Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; # ifndef VULKAN_HPP_NO_SMART_HANDLE template VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type createDescriptorUpdateTemplateKHRUnique(const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo &createInfo, Optional 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 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 void destroyDescriptorUpdateTemplateKHR(VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional 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 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 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 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 ResultValueType::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 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 VULKAN_HPP_NODISCARD typename ResultValueType::type registerEventEXT(const VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT &deviceEventInfo, Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; # ifndef VULKAN_HPP_NO_SMART_HANDLE template VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type registerEventEXTUnique(const VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT &deviceEventInfo, Optional 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 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 VULKAN_HPP_NODISCARD typename ResultValueType::type registerDisplayEventEXT(VULKAN_HPP_NAMESPACE::DisplayKHR display, const VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT &displayEventInfo, Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; # ifndef VULKAN_HPP_NO_SMART_HANDLE template VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type registerDisplayEventEXTUnique(VULKAN_HPP_NAMESPACE::DisplayKHR display, const VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT &displayEventInfo, Optional 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 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 VULKAN_HPP_NODISCARD typename ResultValueType::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 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 VULKAN_HPP_NODISCARD typename ResultValueType::type getRefreshCycleDurationGOOGLE(VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> VULKAN_HPP_NODISCARD typename ResultValueType>::type getPastPresentationTimingGOOGLE(VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; template, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B = PastPresentationTimingGOOGLEAllocator, typename std::enable_if::value, int>::type = 0> VULKAN_HPP_NODISCARD typename ResultValueType>::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 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 void setHdrMetadataEXT(ArrayProxy const &swapchains, ArrayProxy 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 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 VULKAN_HPP_NODISCARD typename ResultValueType::type createRenderPass2KHR(const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 &createInfo, Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; # ifndef VULKAN_HPP_NO_SMART_HANDLE template VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type createRenderPass2KHRUnique(const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 &createInfo, Optional 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 VULKAN_HPP_NODISCARD Result getSwapchainStatusKHR(VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; #else template 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 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 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type importFenceWin32HandleKHR(const VULKAN_HPP_NAMESPACE::ImportFenceWin32HandleInfoKHR &importFenceWin32HandleInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 VULKAN_HPP_NODISCARD typename ResultValueType::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 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 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type importFenceFdKHR(const VULKAN_HPP_NAMESPACE::ImportFenceFdInfoKHR &importFenceFdInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 VULKAN_HPP_NODISCARD typename ResultValueType::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 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 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type acquireProfilingLockKHR(const VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template void releaseProfilingLockKHR(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; //=== VK_EXT_debug_utils === template 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 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type setDebugUtilsObjectNameEXT(const VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT &nameInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::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 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 VULKAN_HPP_NODISCARD typename ResultValueType::type getAndroidHardwareBufferPropertiesANDROID(const struct AHardwareBuffer &buffer, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; template VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType>::type getAndroidHardwareBufferPropertiesANDROID(const struct AHardwareBuffer &buffer, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 VULKAN_HPP_NODISCARD typename ResultValueType::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 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 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 VULKAN_HPP_NODISCARD StructureChain 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 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 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 VULKAN_HPP_NODISCARD StructureChain 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 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 Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> VULKAN_HPP_NODISCARD std::vector getImageSparseMemoryRequirements2KHR(const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; template, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B = SparseImageMemoryRequirements2Allocator, typename std::enable_if::value, int>::type = 0> VULKAN_HPP_NODISCARD std::vector 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 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 VULKAN_HPP_NODISCARD typename ResultValueType::type createAccelerationStructureKHR(const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR &createInfo, Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; # ifndef VULKAN_HPP_NO_SMART_HANDLE template VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type createAccelerationStructureKHRUnique(const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR &createInfo, Optional 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 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 void destroyAccelerationStructureKHR(VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional 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 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 void destroy(VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure, Optional 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 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 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result buildAccelerationStructuresKHR(VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, ArrayProxy const &infos, ArrayProxy const &pBuildRangeInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 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 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 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 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 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 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 Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> VULKAN_HPP_NODISCARD typename ResultValueType>::type writeAccelerationStructuresPropertiesKHR(ArrayProxy const &accelerationStructures, VULKAN_HPP_NAMESPACE::QueryType queryType, size_t dataSize, size_t stride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; template VULKAN_HPP_NODISCARD typename ResultValueType::type writeAccelerationStructuresPropertyKHR(ArrayProxy 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 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 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 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 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 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 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR getAccelerationStructureBuildSizesKHR(VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR buildType, const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR &buildInfo, ArrayProxy 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 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 VULKAN_HPP_NODISCARD typename ResultValueType::type createSamplerYcbcrConversionKHR(const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo &createInfo, Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; # ifndef VULKAN_HPP_NO_SMART_HANDLE template VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type createSamplerYcbcrConversionKHRUnique(const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo &createInfo, Optional 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 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 void destroySamplerYcbcrConversionKHR(VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional 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 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 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type bindBufferMemory2KHR(ArrayProxy const &bindInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type bindImageMemory2KHR(ArrayProxy const &bindInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ //=== VK_EXT_image_drm_format_modifier === template 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 VULKAN_HPP_NODISCARD typename ResultValueType::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 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 VULKAN_HPP_NODISCARD typename ResultValueType::type createValidationCacheEXT(const VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT &createInfo, Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; # ifndef VULKAN_HPP_NO_SMART_HANDLE template VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type createValidationCacheEXTUnique(const VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT &createInfo, Optional 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 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 void destroyValidationCacheEXT(VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional 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 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 void destroy(VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache, Optional 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 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 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type mergeValidationCachesEXT(VULKAN_HPP_NAMESPACE::ValidationCacheEXT dstCache, ArrayProxy const &srcCaches, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> VULKAN_HPP_NODISCARD typename ResultValueType>::type getValidationCacheDataEXT(VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; template, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B = Uint8_tAllocator, typename std::enable_if::value, int>::type = 0> VULKAN_HPP_NODISCARD typename ResultValueType>::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 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 VULKAN_HPP_NODISCARD typename ResultValueType::type createAccelerationStructureNV(const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV &createInfo, Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; # ifndef VULKAN_HPP_NO_SMART_HANDLE template VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type createAccelerationStructureNVUnique(const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV &createInfo, Optional 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 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 void destroyAccelerationStructureNV(VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional 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 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 void destroy(VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure, Optional 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 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 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 VULKAN_HPP_NODISCARD StructureChain 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 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 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type bindAccelerationStructureMemoryNV(ArrayProxy const &bindInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> VULKAN_HPP_NODISCARD ResultValue> createRayTracingPipelinesNV(VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, ArrayProxy const &createInfos, Optional 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 B = PipelineAllocator, typename std::enable_if::value, int>::type = 0> VULKAN_HPP_NODISCARD ResultValue> createRayTracingPipelinesNV(VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, ArrayProxy const &createInfos, Optional allocator, PipelineAllocator &pipelineAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; template VULKAN_HPP_NODISCARD ResultValue createRayTracingPipelineNV(VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV &createInfo, Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; # ifndef VULKAN_HPP_NO_SMART_HANDLE template>> VULKAN_HPP_NODISCARD ResultValue, PipelineAllocator>> createRayTracingPipelinesNVUnique(VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, ArrayProxy const &createInfos, Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; template>, typename B = PipelineAllocator, typename std::enable_if>::value, int>::type = 0> VULKAN_HPP_NODISCARD ResultValue, PipelineAllocator>> createRayTracingPipelinesNVUnique(VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, ArrayProxy const &createInfos, Optional allocator, PipelineAllocator &pipelineAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; template VULKAN_HPP_NODISCARD ResultValue> createRayTracingPipelineNVUnique(VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV &createInfo, Optional 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 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 Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> VULKAN_HPP_NODISCARD typename ResultValueType>::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 VULKAN_HPP_NODISCARD typename ResultValueType::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 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 Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> VULKAN_HPP_NODISCARD typename ResultValueType>::type getAccelerationStructureHandleNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure, size_t dataSize, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; template VULKAN_HPP_NODISCARD typename ResultValueType::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 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 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::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 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 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 VULKAN_HPP_NODISCARD StructureChain 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 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 VULKAN_HPP_NODISCARD typename ResultValueType::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 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 Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> VULKAN_HPP_NODISCARD typename ResultValueType, uint64_t>>::type getCalibratedTimestampsEXT(ArrayProxy const ×tampInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; template, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B = Uint64_tAllocator, typename std::enable_if::value, int>::type = 0> VULKAN_HPP_NODISCARD typename ResultValueType, uint64_t>>::type getCalibratedTimestampsEXT(ArrayProxy const ×tampInfos, Uint64_tAllocator &uint64_tAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; template VULKAN_HPP_NODISCARD typename ResultValueType>::type getCalibratedTimestampEXT(const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT ×tampInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ //=== VK_KHR_timeline_semaphore === template 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 VULKAN_HPP_NODISCARD typename ResultValueType::type getSemaphoreCounterValueKHR(VULKAN_HPP_NAMESPACE::Semaphore semaphore, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 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 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 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::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 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 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type initializePerformanceApiINTEL(const VULKAN_HPP_NAMESPACE::InitializePerformanceApiInfoINTEL &initializeInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template void uninitializePerformanceApiINTEL(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; template 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 VULKAN_HPP_NODISCARD typename ResultValueType::type acquirePerformanceConfigurationINTEL(const VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL &acquireInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; # ifndef VULKAN_HPP_NO_SMART_HANDLE template VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::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 VULKAN_HPP_NODISCARD Result releasePerformanceConfigurationINTEL(VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; #else template VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::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 VULKAN_HPP_NODISCARD Result release(VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; #else template VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type release(VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 VULKAN_HPP_NODISCARD typename ResultValueType::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 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 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 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 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 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 VULKAN_HPP_NODISCARD Result acquireFullScreenExclusiveModeEXT(VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; # else template VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::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 VULKAN_HPP_NODISCARD Result releaseFullScreenExclusiveModeEXT(VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; # else template VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type releaseFullScreenExclusiveModeEXT(VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 VULKAN_HPP_NODISCARD typename ResultValueType::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 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 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 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 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 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 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 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 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 VULKAN_HPP_NODISCARD typename ResultValueType::type createDeferredOperationKHR(Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; # ifndef VULKAN_HPP_NO_SMART_HANDLE template VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type createDeferredOperationKHRUnique(Optional 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 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 void destroyDeferredOperationKHR(VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional 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 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 void destroy(VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation, Optional 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 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 VULKAN_HPP_NODISCARD Result getDeferredOperationResultKHR(VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; #else template 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 VULKAN_HPP_NODISCARD Result deferredOperationJoinKHR(VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; #else template 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 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 Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> VULKAN_HPP_NODISCARD typename ResultValueType>::type getPipelineExecutablePropertiesKHR(const VULKAN_HPP_NAMESPACE::PipelineInfoKHR &pipelineInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; template, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B = PipelineExecutablePropertiesKHRAllocator, typename std::enable_if::value, int>::type = 0> VULKAN_HPP_NODISCARD typename ResultValueType>::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 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 Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> VULKAN_HPP_NODISCARD typename ResultValueType>::type getPipelineExecutableStatisticsKHR(const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR &executableInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; template, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B = PipelineExecutableStatisticKHRAllocator, typename std::enable_if::value, int>::type = 0> VULKAN_HPP_NODISCARD typename ResultValueType>::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 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 Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> VULKAN_HPP_NODISCARD typename ResultValueType>::type getPipelineExecutableInternalRepresentationsKHR(const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR &executableInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; template, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B = PipelineExecutableInternalRepresentationKHRAllocator, typename std::enable_if::value, int>::type = 0> VULKAN_HPP_NODISCARD typename ResultValueType>::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 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 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 VULKAN_HPP_NODISCARD StructureChain 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 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 VULKAN_HPP_NODISCARD typename ResultValueType::type createIndirectCommandsLayoutNV(const VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV &createInfo, Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; # ifndef VULKAN_HPP_NO_SMART_HANDLE template VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type createIndirectCommandsLayoutNVUnique(const VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV &createInfo, Optional 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 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 void destroyIndirectCommandsLayoutNV(VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV indirectCommandsLayout VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional 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 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 void destroy(VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV indirectCommandsLayout, Optional 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 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 VULKAN_HPP_NODISCARD typename ResultValueType::type createPrivateDataSlotEXT(const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo &createInfo, Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; # ifndef VULKAN_HPP_NO_SMART_HANDLE template VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type createPrivateDataSlotEXTUnique(const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo &createInfo, Optional 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 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 void destroyPrivateDataSlotEXT(VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional 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 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 ResultValueType::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 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 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*/ //=== VK_KHR_ray_tracing_pipeline === template 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 Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> VULKAN_HPP_NODISCARD ResultValue> createRayTracingPipelinesKHR(VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, ArrayProxy const &createInfos, Optional 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 B = PipelineAllocator, typename std::enable_if::value, int>::type = 0> VULKAN_HPP_NODISCARD ResultValue> createRayTracingPipelinesKHR(VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, ArrayProxy const &createInfos, Optional allocator, PipelineAllocator &pipelineAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; template VULKAN_HPP_NODISCARD ResultValue createRayTracingPipelineKHR(VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR &createInfo, Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; # ifndef VULKAN_HPP_NO_SMART_HANDLE template>> VULKAN_HPP_NODISCARD ResultValue, PipelineAllocator>> createRayTracingPipelinesKHRUnique(VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, ArrayProxy const &createInfos, Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; template>, typename B = PipelineAllocator, typename std::enable_if>::value, int>::type = 0> VULKAN_HPP_NODISCARD ResultValue, PipelineAllocator>> createRayTracingPipelinesKHRUnique(VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, ArrayProxy const &createInfos, Optional allocator, PipelineAllocator &pipelineAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; template VULKAN_HPP_NODISCARD ResultValue> createRayTracingPipelineKHRUnique(VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR &createInfo, Optional 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 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 Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> VULKAN_HPP_NODISCARD typename ResultValueType>::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 VULKAN_HPP_NODISCARD typename ResultValueType::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 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 Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> VULKAN_HPP_NODISCARD typename ResultValueType>::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 VULKAN_HPP_NODISCARD typename ResultValueType::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 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 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 VULKAN_HPP_NODISCARD typename ResultValueType::type getMemoryZirconHandleFUCHSIA(const VULKAN_HPP_NAMESPACE::MemoryGetZirconHandleInfoFUCHSIA &getZirconHandleInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 VULKAN_HPP_NODISCARD typename ResultValueType::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 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 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type importSemaphoreZirconHandleFUCHSIA(const VULKAN_HPP_NAMESPACE::ImportSemaphoreZirconHandleInfoFUCHSIA &importSemaphoreZirconHandleInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 VULKAN_HPP_NODISCARD typename ResultValueType::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 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 VULKAN_HPP_NODISCARD typename ResultValueType::type createBufferCollectionFUCHSIA(const VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA &createInfo, Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; # ifndef VULKAN_HPP_NO_SMART_HANDLE template VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type createBufferCollectionFUCHSIAUnique(const VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA &createInfo, Optional 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 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 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::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 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 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::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 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 void destroyBufferCollectionFUCHSIA(VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection, Optional 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 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 void destroy(VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection, Optional 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 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 VULKAN_HPP_NODISCARD typename ResultValueType::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 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 VULKAN_HPP_NODISCARD ResultValue 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 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 VULKAN_HPP_NODISCARD typename ResultValueType::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_pageable_device_local_memory === template 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 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 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 VULKAN_HPP_NODISCARD StructureChain 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 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 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 VULKAN_HPP_NODISCARD StructureChain 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 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 Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> VULKAN_HPP_NODISCARD std::vector getImageSparseMemoryRequirementsKHR(const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; template, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B = SparseImageMemoryRequirements2Allocator, typename std::enable_if::value, int>::type = 0> VULKAN_HPP_NODISCARD std::vector 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 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 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 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 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*/ VULKAN_HPP_TYPESAFE_EXPLICIT 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 = {}; }; VULKAN_HPP_STATIC_ASSERT(sizeof(VULKAN_HPP_NAMESPACE::Device) == sizeof(VkDevice), "handle and wrapper have different size!"); VULKAN_HPP_STATIC_ASSERT(std::is_nothrow_move_constructible::value, "Device is not nothrow_move_constructible!"); template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::Device; }; template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::Device; }; template<> struct isVulkanHandleType { 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 = {}; }; VULKAN_HPP_STATIC_ASSERT(sizeof(VULKAN_HPP_NAMESPACE::DisplayModeKHR) == sizeof(VkDisplayModeKHR), "handle and wrapper have different size!"); VULKAN_HPP_STATIC_ASSERT(std::is_nothrow_move_constructible::value, "DisplayModeKHR is not nothrow_move_constructible!"); template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::DisplayModeKHR; }; template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::DisplayModeKHR; }; template<> struct isVulkanHandleType { static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; }; #ifndef VULKAN_HPP_NO_SMART_HANDLE template class UniqueHandleTraits { public: using deleter = ObjectDestroy; }; using UniqueDevice = UniqueHandle; #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 {} VULKAN_HPP_TYPESAFE_EXPLICIT PhysicalDevice(VkPhysicalDevice physicalDevice) VULKAN_HPP_NOEXCEPT : m_physicalDevice(physicalDevice) {} #if defined(VULKAN_HPP_TYPESAFE_CONVERSION) PhysicalDevice &operator=(VkPhysicalDevice physicalDevice) VULKAN_HPP_NOEXCEPT { m_physicalDevice = physicalDevice; return *this; } #endif 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 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 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 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 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 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 VULKAN_HPP_NODISCARD typename ResultValueType::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 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 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 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 Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> VULKAN_HPP_NODISCARD std::vector getQueueFamilyProperties(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; template, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B = QueueFamilyPropertiesAllocator, typename std::enable_if::value, int>::type = 0> VULKAN_HPP_NODISCARD std::vector getQueueFamilyProperties(QueueFamilyPropertiesAllocator &queueFamilyPropertiesAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 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 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 VULKAN_HPP_NODISCARD typename ResultValueType::type createDevice(const VULKAN_HPP_NAMESPACE::DeviceCreateInfo &createInfo, Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; # ifndef VULKAN_HPP_NO_SMART_HANDLE template VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type createDeviceUnique(const VULKAN_HPP_NAMESPACE::DeviceCreateInfo &createInfo, Optional 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 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 Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> VULKAN_HPP_NODISCARD typename ResultValueType>::type enumerateDeviceExtensionProperties(Optional layerName VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; template, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B = ExtensionPropertiesAllocator, typename std::enable_if::value, int>::type = 0> VULKAN_HPP_NODISCARD typename ResultValueType>::type enumerateDeviceExtensionProperties(Optional layerName, ExtensionPropertiesAllocator &extensionPropertiesAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> VULKAN_HPP_NODISCARD typename ResultValueType>::type enumerateDeviceLayerProperties(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; template, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B = LayerPropertiesAllocator, typename std::enable_if::value, int>::type = 0> VULKAN_HPP_NODISCARD typename ResultValueType>::type enumerateDeviceLayerProperties(LayerPropertiesAllocator &layerPropertiesAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> VULKAN_HPP_NODISCARD std::vector 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 Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B = SparseImageFormatPropertiesAllocator, typename std::enable_if::value, int>::type = 0> VULKAN_HPP_NODISCARD std::vector 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 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 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 getFeatures2(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; template VULKAN_HPP_NODISCARD StructureChain getFeatures2(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 getProperties2(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; template VULKAN_HPP_NODISCARD StructureChain getProperties2(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 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 VULKAN_HPP_NODISCARD StructureChain 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 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 VULKAN_HPP_NODISCARD typename ResultValueType::type getImageFormatProperties2(const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 &imageFormatInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; template VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType>::type getImageFormatProperties2(const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 &imageFormatInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> VULKAN_HPP_NODISCARD std::vector getQueueFamilyProperties2(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; template, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B = QueueFamilyProperties2Allocator, typename std::enable_if::value, int>::type = 0> VULKAN_HPP_NODISCARD std::vector getQueueFamilyProperties2(QueueFamilyProperties2Allocator &queueFamilyProperties2Allocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; template, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> VULKAN_HPP_NODISCARD std::vector getQueueFamilyProperties2(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; template, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B = StructureChainAllocator, typename std::enable_if::value, int>::type = 0> VULKAN_HPP_NODISCARD std::vector getQueueFamilyProperties2(StructureChainAllocator &structureChainAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 getMemoryProperties2(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; template VULKAN_HPP_NODISCARD StructureChain getMemoryProperties2(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> VULKAN_HPP_NODISCARD std::vector getSparseImageFormatProperties2(const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 &formatInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; template, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B = SparseImageFormatProperties2Allocator, typename std::enable_if::value, int>::type = 0> VULKAN_HPP_NODISCARD std::vector 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 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 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 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 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 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 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 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 Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> VULKAN_HPP_NODISCARD typename ResultValueType>::type getToolProperties(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; template, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B = PhysicalDeviceToolPropertiesAllocator, typename std::enable_if::value, int>::type = 0> VULKAN_HPP_NODISCARD typename ResultValueType>::type getToolProperties(PhysicalDeviceToolPropertiesAllocator &physicalDeviceToolPropertiesAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ //=== VK_KHR_surface === template 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 VULKAN_HPP_NODISCARD typename ResultValueType::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 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 VULKAN_HPP_NODISCARD typename ResultValueType::type getSurfaceCapabilitiesKHR(VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> VULKAN_HPP_NODISCARD typename ResultValueType>::type getSurfaceFormatsKHR(VULKAN_HPP_NAMESPACE::SurfaceKHR surface VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; template, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B = SurfaceFormatKHRAllocator, typename std::enable_if::value, int>::type = 0> VULKAN_HPP_NODISCARD typename ResultValueType>::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 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 Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> VULKAN_HPP_NODISCARD typename ResultValueType>::type getSurfacePresentModesKHR(VULKAN_HPP_NAMESPACE::SurfaceKHR surface VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; template, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B = PresentModeKHRAllocator, typename std::enable_if::value, int>::type = 0> VULKAN_HPP_NODISCARD typename ResultValueType>::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 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 Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> VULKAN_HPP_NODISCARD typename ResultValueType>::type getPresentRectanglesKHR(VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; template, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B = Rect2DAllocator, typename std::enable_if::value, int>::type = 0> VULKAN_HPP_NODISCARD typename ResultValueType>::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 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 Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> VULKAN_HPP_NODISCARD typename ResultValueType>::type getDisplayPropertiesKHR(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; template, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B = DisplayPropertiesKHRAllocator, typename std::enable_if::value, int>::type = 0> VULKAN_HPP_NODISCARD typename ResultValueType>::type getDisplayPropertiesKHR(DisplayPropertiesKHRAllocator &displayPropertiesKHRAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> VULKAN_HPP_NODISCARD typename ResultValueType>::type getDisplayPlanePropertiesKHR(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; template, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B = DisplayPlanePropertiesKHRAllocator, typename std::enable_if::value, int>::type = 0> VULKAN_HPP_NODISCARD typename ResultValueType>::type getDisplayPlanePropertiesKHR(DisplayPlanePropertiesKHRAllocator &displayPlanePropertiesKHRAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> VULKAN_HPP_NODISCARD typename ResultValueType>::type getDisplayPlaneSupportedDisplaysKHR(uint32_t planeIndex, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; template, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B = DisplayKHRAllocator, typename std::enable_if::value, int>::type = 0> VULKAN_HPP_NODISCARD typename ResultValueType>::type getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, DisplayKHRAllocator &displayKHRAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> VULKAN_HPP_NODISCARD typename ResultValueType>::type getDisplayModePropertiesKHR(VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; template, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B = DisplayModePropertiesKHRAllocator, typename std::enable_if::value, int>::type = 0> VULKAN_HPP_NODISCARD typename ResultValueType>::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 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 VULKAN_HPP_NODISCARD typename ResultValueType::type createDisplayModeKHR(VULKAN_HPP_NAMESPACE::DisplayKHR display, const VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR &createInfo, Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; # ifndef VULKAN_HPP_NO_SMART_HANDLE template VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type createDisplayModeKHRUnique(VULKAN_HPP_NAMESPACE::DisplayKHR display, const VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR &createInfo, Optional 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 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 VULKAN_HPP_NODISCARD typename ResultValueType::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 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 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 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 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 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 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 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 VULKAN_HPP_NODISCARD Result getVideoCapabilitiesKHR(const VULKAN_HPP_NAMESPACE::VideoProfileKHR *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 VULKAN_HPP_NODISCARD typename ResultValueType::type getVideoCapabilitiesKHR(const VULKAN_HPP_NAMESPACE::VideoProfileKHR &videoProfile, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; template VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType>::type getVideoCapabilitiesKHR(const VULKAN_HPP_NAMESPACE::VideoProfileKHR &videoProfile, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> VULKAN_HPP_NODISCARD typename ResultValueType>::type getVideoFormatPropertiesKHR(const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR &videoFormatInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; template, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B = VideoFormatPropertiesKHRAllocator, typename std::enable_if::value, int>::type = 0> VULKAN_HPP_NODISCARD typename ResultValueType>::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 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 VULKAN_HPP_NODISCARD typename ResultValueType::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 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 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 getFeatures2KHR(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; template VULKAN_HPP_NODISCARD StructureChain getFeatures2KHR(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 getProperties2KHR(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; template VULKAN_HPP_NODISCARD StructureChain getProperties2KHR(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 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 VULKAN_HPP_NODISCARD StructureChain 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 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 VULKAN_HPP_NODISCARD typename ResultValueType::type getImageFormatProperties2KHR(const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 &imageFormatInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; template VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType>::type getImageFormatProperties2KHR(const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 &imageFormatInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> VULKAN_HPP_NODISCARD std::vector getQueueFamilyProperties2KHR(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; template, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B = QueueFamilyProperties2Allocator, typename std::enable_if::value, int>::type = 0> VULKAN_HPP_NODISCARD std::vector getQueueFamilyProperties2KHR(QueueFamilyProperties2Allocator &queueFamilyProperties2Allocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; template, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> VULKAN_HPP_NODISCARD std::vector getQueueFamilyProperties2KHR(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; template, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B = StructureChainAllocator, typename std::enable_if::value, int>::type = 0> VULKAN_HPP_NODISCARD std::vector getQueueFamilyProperties2KHR(StructureChainAllocator &structureChainAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 getMemoryProperties2KHR(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; template VULKAN_HPP_NODISCARD StructureChain getMemoryProperties2KHR(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> VULKAN_HPP_NODISCARD std::vector getSparseImageFormatProperties2KHR(const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 &formatInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; template, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B = SparseImageFormatProperties2Allocator, typename std::enable_if::value, int>::type = 0> VULKAN_HPP_NODISCARD std::vector 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 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 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 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 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 Result releaseDisplayEXT(VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; #else template 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 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 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::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 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 VULKAN_HPP_NODISCARD typename ResultValueType::type getRandROutputDisplayEXT(Display &dpy, RROutput rrOutput, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; # ifndef VULKAN_HPP_NO_SMART_HANDLE template VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::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 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 VULKAN_HPP_NODISCARD typename ResultValueType::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 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 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 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 PerformanceCounterDescriptionKHRAllocator = std::allocator, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> VULKAN_HPP_NODISCARD typename ResultValueType, std::vector>>::type enumerateQueueFamilyPerformanceQueryCountersKHR(uint32_t queueFamilyIndex, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; template, typename PerformanceCounterDescriptionKHRAllocator = std::allocator, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = PerformanceCounterKHRAllocator, typename B2 = PerformanceCounterDescriptionKHRAllocator, typename std::enable_if::value && std::is_same::value, int>::type = 0> VULKAN_HPP_NODISCARD typename ResultValueType, std::vector>>::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 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 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 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 VULKAN_HPP_NODISCARD typename ResultValueType::type getSurfaceCapabilities2KHR(const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR &surfaceInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; template VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType>::type getSurfaceCapabilities2KHR(const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR &surfaceInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> VULKAN_HPP_NODISCARD typename ResultValueType>::type getSurfaceFormats2KHR(const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR &surfaceInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; template, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B = SurfaceFormat2KHRAllocator, typename std::enable_if::value, int>::type = 0> VULKAN_HPP_NODISCARD typename ResultValueType>::type getSurfaceFormats2KHR(const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR &surfaceInfo, SurfaceFormat2KHRAllocator &surfaceFormat2KHRAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ //=== VK_KHR_get_display_properties2 === template 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 Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> VULKAN_HPP_NODISCARD typename ResultValueType>::type getDisplayProperties2KHR(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; template, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B = DisplayProperties2KHRAllocator, typename std::enable_if::value, int>::type = 0> VULKAN_HPP_NODISCARD typename ResultValueType>::type getDisplayProperties2KHR(DisplayProperties2KHRAllocator &displayProperties2KHRAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> VULKAN_HPP_NODISCARD typename ResultValueType>::type getDisplayPlaneProperties2KHR(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; template, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B = DisplayPlaneProperties2KHRAllocator, typename std::enable_if::value, int>::type = 0> VULKAN_HPP_NODISCARD typename ResultValueType>::type getDisplayPlaneProperties2KHR(DisplayPlaneProperties2KHRAllocator &displayPlaneProperties2KHRAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> VULKAN_HPP_NODISCARD typename ResultValueType>::type getDisplayModeProperties2KHR(VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; template, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B = DisplayModeProperties2KHRAllocator, typename std::enable_if::value, int>::type = 0> VULKAN_HPP_NODISCARD typename ResultValueType>::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 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 VULKAN_HPP_NODISCARD typename ResultValueType::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 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 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 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 Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> VULKAN_HPP_NODISCARD typename ResultValueType>::type getCalibrateableTimeDomainsEXT(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; template, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B = TimeDomainEXTAllocator, typename std::enable_if::value, int>::type = 0> VULKAN_HPP_NODISCARD typename ResultValueType>::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 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 Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> VULKAN_HPP_NODISCARD typename ResultValueType>::type getFragmentShadingRatesKHR(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; template, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B = PhysicalDeviceFragmentShadingRateKHRAllocator, typename std::enable_if::value, int>::type = 0> VULKAN_HPP_NODISCARD typename ResultValueType>::type getFragmentShadingRatesKHR(PhysicalDeviceFragmentShadingRateKHRAllocator &physicalDeviceFragmentShadingRateKHRAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ //=== VK_EXT_tooling_info === template 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 Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> VULKAN_HPP_NODISCARD typename ResultValueType>::type getToolPropertiesEXT(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; template, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B = PhysicalDeviceToolPropertiesAllocator, typename std::enable_if::value, int>::type = 0> VULKAN_HPP_NODISCARD typename ResultValueType>::type getToolPropertiesEXT(PhysicalDeviceToolPropertiesAllocator &physicalDeviceToolPropertiesAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ //=== VK_NV_cooperative_matrix === template 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 Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> VULKAN_HPP_NODISCARD typename ResultValueType>::type getCooperativeMatrixPropertiesNV(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; template, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B = CooperativeMatrixPropertiesNVAllocator, typename std::enable_if::value, int>::type = 0> VULKAN_HPP_NODISCARD typename ResultValueType>::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 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 Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> VULKAN_HPP_NODISCARD typename ResultValueType>::type getSupportedFramebufferMixedSamplesCombinationsNV(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; template, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B = FramebufferMixedSamplesCombinationNVAllocator, typename std::enable_if::value, int>::type = 0> VULKAN_HPP_NODISCARD typename ResultValueType>::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 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 Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> VULKAN_HPP_NODISCARD typename ResultValueType>::type getSurfacePresentModes2EXT(const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR &surfaceInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; template, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B = PresentModeKHRAllocator, typename std::enable_if::value, int>::type = 0> VULKAN_HPP_NODISCARD typename ResultValueType>::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 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 ResultValueType::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 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 VULKAN_HPP_NODISCARD typename ResultValueType::type getDrmDisplayEXT(int32_t drmFd, uint32_t connectorId, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; # ifndef VULKAN_HPP_NO_SMART_HANDLE template VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::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 VULKAN_HPP_NODISCARD Result acquireWinrtDisplayNV(VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; # else template VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type acquireWinrtDisplayNV(VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 VULKAN_HPP_NODISCARD typename ResultValueType::type getWinrtDisplayNV(uint32_t deviceRelativeId, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; # ifndef VULKAN_HPP_NO_SMART_HANDLE template VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::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 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 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 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 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*/ VULKAN_HPP_TYPESAFE_EXPLICIT 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 = {}; }; VULKAN_HPP_STATIC_ASSERT(sizeof(VULKAN_HPP_NAMESPACE::PhysicalDevice) == sizeof(VkPhysicalDevice), "handle and wrapper have different size!"); VULKAN_HPP_STATIC_ASSERT(std::is_nothrow_move_constructible::value, "PhysicalDevice is not nothrow_move_constructible!"); template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::PhysicalDevice; }; template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::PhysicalDevice; }; template<> struct isVulkanHandleType { static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; }; #ifndef VULKAN_HPP_NO_SMART_HANDLE class Instance; template class UniqueHandleTraits { public: using deleter = ObjectDestroy; }; using UniqueDebugReportCallbackEXT = UniqueHandle; template class UniqueHandleTraits { public: using deleter = ObjectDestroy; }; using UniqueDebugUtilsMessengerEXT = UniqueHandle; template class UniqueHandleTraits { public: using deleter = ObjectDestroy; }; using UniqueSurfaceKHR = UniqueHandle; #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 {} VULKAN_HPP_TYPESAFE_EXPLICIT Instance(VkInstance instance) VULKAN_HPP_NOEXCEPT : m_instance(instance) {} #if defined(VULKAN_HPP_TYPESAFE_CONVERSION) Instance &operator=(VkInstance instance) VULKAN_HPP_NOEXCEPT { m_instance = instance; return *this; } #endif 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 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 void destroy(Optional 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 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 Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> VULKAN_HPP_NODISCARD typename ResultValueType>::type enumeratePhysicalDevices(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; template, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B = PhysicalDeviceAllocator, typename std::enable_if::value, int>::type = 0> VULKAN_HPP_NODISCARD typename ResultValueType>::type enumeratePhysicalDevices(PhysicalDeviceAllocator &physicalDeviceAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 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 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 Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> VULKAN_HPP_NODISCARD typename ResultValueType>::type enumeratePhysicalDeviceGroups(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; template, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B = PhysicalDeviceGroupPropertiesAllocator, typename std::enable_if::value, int>::type = 0> VULKAN_HPP_NODISCARD typename ResultValueType>::type enumeratePhysicalDeviceGroups(PhysicalDeviceGroupPropertiesAllocator &physicalDeviceGroupPropertiesAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ //=== VK_KHR_surface === template 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 void destroySurfaceKHR(VULKAN_HPP_NAMESPACE::SurfaceKHR surface VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional 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 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 void destroy(VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Optional 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 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 VULKAN_HPP_NODISCARD typename ResultValueType::type createDisplayPlaneSurfaceKHR(const VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR &createInfo, Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; # ifndef VULKAN_HPP_NO_SMART_HANDLE template VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type createDisplayPlaneSurfaceKHRUnique(const VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR &createInfo, Optional 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 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 VULKAN_HPP_NODISCARD typename ResultValueType::type createXlibSurfaceKHR(const VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR &createInfo, Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; # ifndef VULKAN_HPP_NO_SMART_HANDLE template VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type createXlibSurfaceKHRUnique(const VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR &createInfo, Optional 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 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 VULKAN_HPP_NODISCARD typename ResultValueType::type createXcbSurfaceKHR(const VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR &createInfo, Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; # ifndef VULKAN_HPP_NO_SMART_HANDLE template VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type createXcbSurfaceKHRUnique(const VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR &createInfo, Optional 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 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 VULKAN_HPP_NODISCARD typename ResultValueType::type createWaylandSurfaceKHR(const VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR &createInfo, Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; # ifndef VULKAN_HPP_NO_SMART_HANDLE template VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type createWaylandSurfaceKHRUnique(const VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR &createInfo, Optional 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 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 VULKAN_HPP_NODISCARD typename ResultValueType::type createAndroidSurfaceKHR(const VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR &createInfo, Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; # ifndef VULKAN_HPP_NO_SMART_HANDLE template VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type createAndroidSurfaceKHRUnique(const VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR &createInfo, Optional 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 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 VULKAN_HPP_NODISCARD typename ResultValueType::type createWin32SurfaceKHR(const VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR &createInfo, Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; # ifndef VULKAN_HPP_NO_SMART_HANDLE template VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type createWin32SurfaceKHRUnique(const VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR &createInfo, Optional 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 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 VULKAN_HPP_NODISCARD typename ResultValueType::type createDebugReportCallbackEXT(const VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT &createInfo, Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; # ifndef VULKAN_HPP_NO_SMART_HANDLE template VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type createDebugReportCallbackEXTUnique(const VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT &createInfo, Optional 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 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 void destroyDebugReportCallbackEXT(VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT callback VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional 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 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 void destroy(VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT callback, Optional 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 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 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 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 VULKAN_HPP_NODISCARD typename ResultValueType::type createStreamDescriptorSurfaceGGP(const VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP &createInfo, Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; # ifndef VULKAN_HPP_NO_SMART_HANDLE template VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type createStreamDescriptorSurfaceGGPUnique(const VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP &createInfo, Optional 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 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 VULKAN_HPP_NODISCARD typename ResultValueType::type createViSurfaceNN(const VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN &createInfo, Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; # ifndef VULKAN_HPP_NO_SMART_HANDLE template VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type createViSurfaceNNUnique(const VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN &createInfo, Optional 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 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 Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> VULKAN_HPP_NODISCARD typename ResultValueType>::type enumeratePhysicalDeviceGroupsKHR(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; template, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B = PhysicalDeviceGroupPropertiesAllocator, typename std::enable_if::value, int>::type = 0> VULKAN_HPP_NODISCARD typename ResultValueType>::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 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 VULKAN_HPP_NODISCARD typename ResultValueType::type createIOSSurfaceMVK(const VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK &createInfo, Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; # ifndef VULKAN_HPP_NO_SMART_HANDLE template VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type createIOSSurfaceMVKUnique(const VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK &createInfo, Optional 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 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 VULKAN_HPP_NODISCARD typename ResultValueType::type createMacOSSurfaceMVK(const VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK &createInfo, Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; # ifndef VULKAN_HPP_NO_SMART_HANDLE template VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type createMacOSSurfaceMVKUnique(const VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK &createInfo, Optional 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 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 VULKAN_HPP_NODISCARD typename ResultValueType::type createDebugUtilsMessengerEXT(const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT &createInfo, Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; # ifndef VULKAN_HPP_NO_SMART_HANDLE template VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type createDebugUtilsMessengerEXTUnique(const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT &createInfo, Optional 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 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 void destroyDebugUtilsMessengerEXT(VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT messenger VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional 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 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 void destroy(VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT messenger, Optional 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 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 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 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 VULKAN_HPP_NODISCARD typename ResultValueType::type createImagePipeSurfaceFUCHSIA(const VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA &createInfo, Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; # ifndef VULKAN_HPP_NO_SMART_HANDLE template VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type createImagePipeSurfaceFUCHSIAUnique(const VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA &createInfo, Optional 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 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 VULKAN_HPP_NODISCARD typename ResultValueType::type createMetalSurfaceEXT(const VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT &createInfo, Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; # ifndef VULKAN_HPP_NO_SMART_HANDLE template VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type createMetalSurfaceEXTUnique(const VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT &createInfo, Optional 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 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 VULKAN_HPP_NODISCARD typename ResultValueType::type createHeadlessSurfaceEXT(const VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT &createInfo, Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; # ifndef VULKAN_HPP_NO_SMART_HANDLE template VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type createHeadlessSurfaceEXTUnique(const VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT &createInfo, Optional 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 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 VULKAN_HPP_NODISCARD typename ResultValueType::type createDirectFBSurfaceEXT(const VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT &createInfo, Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; # ifndef VULKAN_HPP_NO_SMART_HANDLE template VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type createDirectFBSurfaceEXTUnique(const VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT &createInfo, Optional 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 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 VULKAN_HPP_NODISCARD typename ResultValueType::type createScreenSurfaceQNX(const VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX &createInfo, Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const; # ifndef VULKAN_HPP_NO_SMART_HANDLE template VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type createScreenSurfaceQNXUnique(const VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX &createInfo, Optional 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*/ VULKAN_HPP_TYPESAFE_EXPLICIT 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 = {}; }; VULKAN_HPP_STATIC_ASSERT(sizeof(VULKAN_HPP_NAMESPACE::Instance) == sizeof(VkInstance), "handle and wrapper have different size!"); VULKAN_HPP_STATIC_ASSERT(std::is_nothrow_move_constructible::value, "Instance is not nothrow_move_constructible!"); template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::Instance; }; template<> struct CppType { using Type = VULKAN_HPP_NAMESPACE::Instance; }; template<> struct isVulkanHandleType { static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; }; //=== VK_VERSION_1_0 === #ifndef VULKAN_HPP_NO_SMART_HANDLE template class UniqueHandleTraits { public: using deleter = ObjectDestroy; }; using UniqueInstance = UniqueHandle; #endif /*VULKAN_HPP_NO_SMART_HANDLE*/ template 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 VULKAN_HPP_NODISCARD typename ResultValueType::type createInstance(const VULKAN_HPP_NAMESPACE::InstanceCreateInfo &createInfo, Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT); # ifndef VULKAN_HPP_NO_SMART_HANDLE template VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type createInstanceUnique(const VULKAN_HPP_NAMESPACE::InstanceCreateInfo &createInfo, Optional 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 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 Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> VULKAN_HPP_NODISCARD typename ResultValueType>::type enumerateInstanceExtensionProperties(Optional layerName VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT); template, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B = ExtensionPropertiesAllocator, typename std::enable_if::value, int>::type = 0> VULKAN_HPP_NODISCARD typename ResultValueType>::type enumerateInstanceExtensionProperties(Optional layerName, ExtensionPropertiesAllocator &extensionPropertiesAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT); #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template 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 Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> VULKAN_HPP_NODISCARD typename ResultValueType>::type enumerateInstanceLayerProperties(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT); template, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B = LayerPropertiesAllocator, typename std::enable_if::value, int>::type = 0> VULKAN_HPP_NODISCARD typename ResultValueType>::type enumerateInstanceLayerProperties(LayerPropertiesAllocator &layerPropertiesAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT); #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ //=== VK_VERSION_1_1 === template 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 VULKAN_HPP_NODISCARD typename ResultValueType::type enumerateInstanceVersion(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT); #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ } // namespace VULKAN_HPP_NAMESPACE #endif