Update Vulkan headers to version 1.3.266
https://github.com/KhronosGroup/Vulkan-Headers
revision 7e691380166fb1cd9b193ac9db896bc23a4ea9ad
tag v1.3.266
This also includes a file that was missed in previous rolls:
include/vulkan/vulkan.cppm (introduced in 1.3.256)
Bug: b/223456677
Change-Id: I7ff7d971c1aad2ff813d674f231582ff98413bdd
Reviewed-on: https://swiftshader-review.googlesource.com/c/SwiftShader/+/72448
Reviewed-by: Shahbaz Youssefi <syoussefi@google.com>
Commit-Queue: Shahbaz Youssefi <syoussefi@google.com>
Kokoro-Result: kokoro <noreply+kokoro@google.com>
Tested-by: Shahbaz Youssefi <syoussefi@google.com>
diff --git a/include/vulkan/vulkan.cppm b/include/vulkan/vulkan.cppm
new file mode 100644
index 0000000..cdcd1be
--- /dev/null
+++ b/include/vulkan/vulkan.cppm
@@ -0,0 +1,3191 @@
+// Copyright 2015-2023 The Khronos Group Inc.
+//
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+//
+
+// This header is generated from the Khronos Vulkan XML API Registry.
+
+// Note: This module is still in an experimental state.
+// Any feedback is welcome on https://github.com/KhronosGroup/Vulkan-Hpp/issues.
+
+module;
+
+#include <vulkan/vulkan.hpp>
+#include <vulkan/vulkan_extension_inspection.hpp>
+#include <vulkan/vulkan_format_traits.hpp>
+#include <vulkan/vulkan_hash.hpp>
+#include <vulkan/vulkan_raii.hpp>
+#include <vulkan/vulkan_shared.hpp>
+
+export module vulkan_hpp;
+
+export namespace VULKAN_HPP_NAMESPACE
+{
+ //=====================================
+ //=== HARDCODED TYPEs AND FUNCTIONs ===
+ //=====================================
+ using VULKAN_HPP_NAMESPACE::ArrayWrapper1D;
+ using VULKAN_HPP_NAMESPACE::ArrayWrapper2D;
+ using VULKAN_HPP_NAMESPACE::DispatchLoaderBase;
+ using VULKAN_HPP_NAMESPACE::DispatchLoaderDynamic;
+ using VULKAN_HPP_NAMESPACE::Flags;
+ using VULKAN_HPP_NAMESPACE::FlagTraits;
+
+#if !defined( VK_NO_PROTOTYPES )
+ using VULKAN_HPP_NAMESPACE::DispatchLoaderStatic;
+#endif /*VK_NO_PROTOTYPES*/
+
+ using VULKAN_HPP_NAMESPACE::operator&;
+ using VULKAN_HPP_NAMESPACE::operator|;
+ using VULKAN_HPP_NAMESPACE::operator^;
+ using VULKAN_HPP_NAMESPACE::operator~;
+ using VULKAN_HPP_DEFAULT_DISPATCHER_TYPE;
+
+#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+ using VULKAN_HPP_NAMESPACE::ArrayProxy;
+ using VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries;
+ using VULKAN_HPP_NAMESPACE::Optional;
+ using VULKAN_HPP_NAMESPACE::SharedHandle;
+ using VULKAN_HPP_NAMESPACE::StridedArrayProxy;
+ using VULKAN_HPP_NAMESPACE::StructureChain;
+ using VULKAN_HPP_NAMESPACE::UniqueHandle;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#if !defined( VULKAN_HPP_NO_SMART_HANDLE )
+ using VULKAN_HPP_NAMESPACE::ObjectDestroy;
+ using VULKAN_HPP_NAMESPACE::ObjectDestroyShared;
+ using VULKAN_HPP_NAMESPACE::ObjectFree;
+ using VULKAN_HPP_NAMESPACE::ObjectFreeShared;
+ using VULKAN_HPP_NAMESPACE::ObjectRelease;
+ using VULKAN_HPP_NAMESPACE::ObjectReleaseShared;
+ using VULKAN_HPP_NAMESPACE::PoolFree;
+ using VULKAN_HPP_NAMESPACE::PoolFreeShared;
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+
+ //==================
+ //=== BASE TYPEs ===
+ //==================
+ using VULKAN_HPP_NAMESPACE::Bool32;
+ using VULKAN_HPP_NAMESPACE::DeviceAddress;
+ using VULKAN_HPP_NAMESPACE::DeviceSize;
+ using VULKAN_HPP_NAMESPACE::RemoteAddressNV;
+ using VULKAN_HPP_NAMESPACE::SampleMask;
+
+ //=============
+ //=== ENUMs ===
+ //=============
+ using VULKAN_HPP_NAMESPACE::CppType;
+
+ //=== VK_VERSION_1_0 ===
+ using VULKAN_HPP_NAMESPACE::AccessFlagBits;
+ using VULKAN_HPP_NAMESPACE::AccessFlags;
+ using VULKAN_HPP_NAMESPACE::AttachmentDescriptionFlagBits;
+ using VULKAN_HPP_NAMESPACE::AttachmentDescriptionFlags;
+ using VULKAN_HPP_NAMESPACE::AttachmentLoadOp;
+ using VULKAN_HPP_NAMESPACE::AttachmentStoreOp;
+ using VULKAN_HPP_NAMESPACE::BlendFactor;
+ using VULKAN_HPP_NAMESPACE::BlendOp;
+ using VULKAN_HPP_NAMESPACE::BorderColor;
+ using VULKAN_HPP_NAMESPACE::BufferCreateFlagBits;
+ using VULKAN_HPP_NAMESPACE::BufferCreateFlags;
+ using VULKAN_HPP_NAMESPACE::BufferUsageFlagBits;
+ using VULKAN_HPP_NAMESPACE::BufferUsageFlags;
+ using VULKAN_HPP_NAMESPACE::BufferViewCreateFlagBits;
+ using VULKAN_HPP_NAMESPACE::BufferViewCreateFlags;
+ using VULKAN_HPP_NAMESPACE::ColorComponentFlagBits;
+ using VULKAN_HPP_NAMESPACE::ColorComponentFlags;
+ using VULKAN_HPP_NAMESPACE::CommandBufferLevel;
+ using VULKAN_HPP_NAMESPACE::CommandBufferResetFlagBits;
+ using VULKAN_HPP_NAMESPACE::CommandBufferResetFlags;
+ using VULKAN_HPP_NAMESPACE::CommandBufferUsageFlagBits;
+ using VULKAN_HPP_NAMESPACE::CommandBufferUsageFlags;
+ using VULKAN_HPP_NAMESPACE::CommandPoolCreateFlagBits;
+ using VULKAN_HPP_NAMESPACE::CommandPoolCreateFlags;
+ using VULKAN_HPP_NAMESPACE::CommandPoolResetFlagBits;
+ using VULKAN_HPP_NAMESPACE::CommandPoolResetFlags;
+ using VULKAN_HPP_NAMESPACE::CompareOp;
+ using VULKAN_HPP_NAMESPACE::ComponentSwizzle;
+ using VULKAN_HPP_NAMESPACE::CullModeFlagBits;
+ using VULKAN_HPP_NAMESPACE::CullModeFlags;
+ using VULKAN_HPP_NAMESPACE::DependencyFlagBits;
+ using VULKAN_HPP_NAMESPACE::DependencyFlags;
+ using VULKAN_HPP_NAMESPACE::DescriptorPoolCreateFlagBits;
+ using VULKAN_HPP_NAMESPACE::DescriptorPoolCreateFlags;
+ using VULKAN_HPP_NAMESPACE::DescriptorPoolResetFlagBits;
+ using VULKAN_HPP_NAMESPACE::DescriptorPoolResetFlags;
+ using VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateFlagBits;
+ using VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateFlags;
+ using VULKAN_HPP_NAMESPACE::DescriptorType;
+ using VULKAN_HPP_NAMESPACE::DeviceCreateFlagBits;
+ using VULKAN_HPP_NAMESPACE::DeviceCreateFlags;
+ using VULKAN_HPP_NAMESPACE::DynamicState;
+ using VULKAN_HPP_NAMESPACE::EventCreateFlagBits;
+ using VULKAN_HPP_NAMESPACE::EventCreateFlags;
+ using VULKAN_HPP_NAMESPACE::FenceCreateFlagBits;
+ using VULKAN_HPP_NAMESPACE::FenceCreateFlags;
+ using VULKAN_HPP_NAMESPACE::Filter;
+ using VULKAN_HPP_NAMESPACE::Format;
+ using VULKAN_HPP_NAMESPACE::FormatFeatureFlagBits;
+ using VULKAN_HPP_NAMESPACE::FormatFeatureFlags;
+ using VULKAN_HPP_NAMESPACE::FramebufferCreateFlagBits;
+ using VULKAN_HPP_NAMESPACE::FramebufferCreateFlags;
+ using VULKAN_HPP_NAMESPACE::FrontFace;
+ using VULKAN_HPP_NAMESPACE::ImageAspectFlagBits;
+ using VULKAN_HPP_NAMESPACE::ImageAspectFlags;
+ using VULKAN_HPP_NAMESPACE::ImageCreateFlagBits;
+ using VULKAN_HPP_NAMESPACE::ImageCreateFlags;
+ using VULKAN_HPP_NAMESPACE::ImageLayout;
+ using VULKAN_HPP_NAMESPACE::ImageTiling;
+ using VULKAN_HPP_NAMESPACE::ImageType;
+ using VULKAN_HPP_NAMESPACE::ImageUsageFlagBits;
+ using VULKAN_HPP_NAMESPACE::ImageUsageFlags;
+ using VULKAN_HPP_NAMESPACE::ImageViewCreateFlagBits;
+ using VULKAN_HPP_NAMESPACE::ImageViewCreateFlags;
+ using VULKAN_HPP_NAMESPACE::ImageViewType;
+ using VULKAN_HPP_NAMESPACE::IndexType;
+ using VULKAN_HPP_NAMESPACE::InstanceCreateFlagBits;
+ using VULKAN_HPP_NAMESPACE::InstanceCreateFlags;
+ using VULKAN_HPP_NAMESPACE::InternalAllocationType;
+ using VULKAN_HPP_NAMESPACE::LogicOp;
+ using VULKAN_HPP_NAMESPACE::MemoryHeapFlagBits;
+ using VULKAN_HPP_NAMESPACE::MemoryHeapFlags;
+ using VULKAN_HPP_NAMESPACE::MemoryMapFlagBits;
+ using VULKAN_HPP_NAMESPACE::MemoryMapFlags;
+ using VULKAN_HPP_NAMESPACE::MemoryPropertyFlagBits;
+ using VULKAN_HPP_NAMESPACE::MemoryPropertyFlags;
+ using VULKAN_HPP_NAMESPACE::ObjectType;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceType;
+ using VULKAN_HPP_NAMESPACE::PipelineBindPoint;
+ using VULKAN_HPP_NAMESPACE::PipelineCacheHeaderVersion;
+ using VULKAN_HPP_NAMESPACE::PipelineCreateFlagBits;
+ using VULKAN_HPP_NAMESPACE::PipelineCreateFlags;
+ using VULKAN_HPP_NAMESPACE::PipelineDynamicStateCreateFlagBits;
+ using VULKAN_HPP_NAMESPACE::PipelineDynamicStateCreateFlags;
+ using VULKAN_HPP_NAMESPACE::PipelineInputAssemblyStateCreateFlagBits;
+ using VULKAN_HPP_NAMESPACE::PipelineInputAssemblyStateCreateFlags;
+ using VULKAN_HPP_NAMESPACE::PipelineMultisampleStateCreateFlagBits;
+ using VULKAN_HPP_NAMESPACE::PipelineMultisampleStateCreateFlags;
+ using VULKAN_HPP_NAMESPACE::PipelineRasterizationStateCreateFlagBits;
+ using VULKAN_HPP_NAMESPACE::PipelineRasterizationStateCreateFlags;
+ using VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateFlagBits;
+ using VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateFlags;
+ using VULKAN_HPP_NAMESPACE::PipelineStageFlagBits;
+ using VULKAN_HPP_NAMESPACE::PipelineStageFlags;
+ using VULKAN_HPP_NAMESPACE::PipelineTessellationStateCreateFlagBits;
+ using VULKAN_HPP_NAMESPACE::PipelineTessellationStateCreateFlags;
+ using VULKAN_HPP_NAMESPACE::PipelineVertexInputStateCreateFlagBits;
+ using VULKAN_HPP_NAMESPACE::PipelineVertexInputStateCreateFlags;
+ using VULKAN_HPP_NAMESPACE::PipelineViewportStateCreateFlagBits;
+ using VULKAN_HPP_NAMESPACE::PipelineViewportStateCreateFlags;
+ using VULKAN_HPP_NAMESPACE::PolygonMode;
+ using VULKAN_HPP_NAMESPACE::PrimitiveTopology;
+ using VULKAN_HPP_NAMESPACE::QueryControlFlagBits;
+ using VULKAN_HPP_NAMESPACE::QueryControlFlags;
+ using VULKAN_HPP_NAMESPACE::QueryPipelineStatisticFlagBits;
+ using VULKAN_HPP_NAMESPACE::QueryPipelineStatisticFlags;
+ using VULKAN_HPP_NAMESPACE::QueryPoolCreateFlagBits;
+ using VULKAN_HPP_NAMESPACE::QueryPoolCreateFlags;
+ using VULKAN_HPP_NAMESPACE::QueryResultFlagBits;
+ using VULKAN_HPP_NAMESPACE::QueryResultFlags;
+ using VULKAN_HPP_NAMESPACE::QueryType;
+ using VULKAN_HPP_NAMESPACE::QueueFlagBits;
+ using VULKAN_HPP_NAMESPACE::QueueFlags;
+ using VULKAN_HPP_NAMESPACE::RenderPassCreateFlagBits;
+ using VULKAN_HPP_NAMESPACE::RenderPassCreateFlags;
+ using VULKAN_HPP_NAMESPACE::Result;
+ using VULKAN_HPP_NAMESPACE::SampleCountFlagBits;
+ using VULKAN_HPP_NAMESPACE::SampleCountFlags;
+ using VULKAN_HPP_NAMESPACE::SamplerAddressMode;
+ using VULKAN_HPP_NAMESPACE::SamplerCreateFlagBits;
+ using VULKAN_HPP_NAMESPACE::SamplerCreateFlags;
+ using VULKAN_HPP_NAMESPACE::SamplerMipmapMode;
+ using VULKAN_HPP_NAMESPACE::SemaphoreCreateFlagBits;
+ using VULKAN_HPP_NAMESPACE::SemaphoreCreateFlags;
+ using VULKAN_HPP_NAMESPACE::ShaderModuleCreateFlagBits;
+ using VULKAN_HPP_NAMESPACE::ShaderModuleCreateFlags;
+ using VULKAN_HPP_NAMESPACE::ShaderStageFlagBits;
+ using VULKAN_HPP_NAMESPACE::ShaderStageFlags;
+ using VULKAN_HPP_NAMESPACE::SharingMode;
+ using VULKAN_HPP_NAMESPACE::SparseImageFormatFlagBits;
+ using VULKAN_HPP_NAMESPACE::SparseImageFormatFlags;
+ using VULKAN_HPP_NAMESPACE::SparseMemoryBindFlagBits;
+ using VULKAN_HPP_NAMESPACE::SparseMemoryBindFlags;
+ using VULKAN_HPP_NAMESPACE::StencilFaceFlagBits;
+ using VULKAN_HPP_NAMESPACE::StencilFaceFlags;
+ using VULKAN_HPP_NAMESPACE::StencilOp;
+ using VULKAN_HPP_NAMESPACE::StructureType;
+ using VULKAN_HPP_NAMESPACE::SubpassContents;
+ using VULKAN_HPP_NAMESPACE::SubpassDescriptionFlagBits;
+ using VULKAN_HPP_NAMESPACE::SubpassDescriptionFlags;
+ using VULKAN_HPP_NAMESPACE::SystemAllocationScope;
+ using VULKAN_HPP_NAMESPACE::VendorId;
+ using VULKAN_HPP_NAMESPACE::VertexInputRate;
+
+ //=== VK_VERSION_1_1 ===
+ using VULKAN_HPP_NAMESPACE::ChromaLocation;
+ using VULKAN_HPP_NAMESPACE::ChromaLocationKHR;
+ using VULKAN_HPP_NAMESPACE::CommandPoolTrimFlagBits;
+ using VULKAN_HPP_NAMESPACE::CommandPoolTrimFlags;
+ using VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateFlagBits;
+ using VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateFlags;
+ using VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateType;
+ using VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateTypeKHR;
+ using VULKAN_HPP_NAMESPACE::DeviceQueueCreateFlagBits;
+ using VULKAN_HPP_NAMESPACE::DeviceQueueCreateFlags;
+ using VULKAN_HPP_NAMESPACE::ExternalFenceFeatureFlagBits;
+ using VULKAN_HPP_NAMESPACE::ExternalFenceFeatureFlagBitsKHR;
+ using VULKAN_HPP_NAMESPACE::ExternalFenceFeatureFlags;
+ using VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits;
+ using VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBitsKHR;
+ using VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlags;
+ using VULKAN_HPP_NAMESPACE::ExternalMemoryFeatureFlagBits;
+ using VULKAN_HPP_NAMESPACE::ExternalMemoryFeatureFlagBitsKHR;
+ using VULKAN_HPP_NAMESPACE::ExternalMemoryFeatureFlags;
+ using VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits;
+ using VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBitsKHR;
+ using VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlags;
+ using VULKAN_HPP_NAMESPACE::ExternalSemaphoreFeatureFlagBits;
+ using VULKAN_HPP_NAMESPACE::ExternalSemaphoreFeatureFlagBitsKHR;
+ using VULKAN_HPP_NAMESPACE::ExternalSemaphoreFeatureFlags;
+ using VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits;
+ using VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBitsKHR;
+ using VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlags;
+ using VULKAN_HPP_NAMESPACE::FenceImportFlagBits;
+ using VULKAN_HPP_NAMESPACE::FenceImportFlagBitsKHR;
+ using VULKAN_HPP_NAMESPACE::FenceImportFlags;
+ using VULKAN_HPP_NAMESPACE::MemoryAllocateFlagBits;
+ using VULKAN_HPP_NAMESPACE::MemoryAllocateFlagBitsKHR;
+ using VULKAN_HPP_NAMESPACE::MemoryAllocateFlags;
+ using VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlagBits;
+ using VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlagBitsKHR;
+ using VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags;
+ using VULKAN_HPP_NAMESPACE::PointClippingBehavior;
+ using VULKAN_HPP_NAMESPACE::PointClippingBehaviorKHR;
+ using VULKAN_HPP_NAMESPACE::SamplerYcbcrModelConversion;
+ using VULKAN_HPP_NAMESPACE::SamplerYcbcrModelConversionKHR;
+ using VULKAN_HPP_NAMESPACE::SamplerYcbcrRange;
+ using VULKAN_HPP_NAMESPACE::SamplerYcbcrRangeKHR;
+ using VULKAN_HPP_NAMESPACE::SemaphoreImportFlagBits;
+ using VULKAN_HPP_NAMESPACE::SemaphoreImportFlagBitsKHR;
+ using VULKAN_HPP_NAMESPACE::SemaphoreImportFlags;
+ using VULKAN_HPP_NAMESPACE::SubgroupFeatureFlagBits;
+ using VULKAN_HPP_NAMESPACE::SubgroupFeatureFlags;
+ using VULKAN_HPP_NAMESPACE::TessellationDomainOrigin;
+ using VULKAN_HPP_NAMESPACE::TessellationDomainOriginKHR;
+
+ //=== VK_VERSION_1_2 ===
+ using VULKAN_HPP_NAMESPACE::DescriptorBindingFlagBits;
+ using VULKAN_HPP_NAMESPACE::DescriptorBindingFlagBitsEXT;
+ using VULKAN_HPP_NAMESPACE::DescriptorBindingFlags;
+ using VULKAN_HPP_NAMESPACE::DriverId;
+ using VULKAN_HPP_NAMESPACE::DriverIdKHR;
+ using VULKAN_HPP_NAMESPACE::ResolveModeFlagBits;
+ using VULKAN_HPP_NAMESPACE::ResolveModeFlagBitsKHR;
+ using VULKAN_HPP_NAMESPACE::ResolveModeFlags;
+ using VULKAN_HPP_NAMESPACE::SamplerReductionMode;
+ using VULKAN_HPP_NAMESPACE::SamplerReductionModeEXT;
+ using VULKAN_HPP_NAMESPACE::SemaphoreType;
+ using VULKAN_HPP_NAMESPACE::SemaphoreTypeKHR;
+ using VULKAN_HPP_NAMESPACE::SemaphoreWaitFlagBits;
+ using VULKAN_HPP_NAMESPACE::SemaphoreWaitFlagBitsKHR;
+ using VULKAN_HPP_NAMESPACE::SemaphoreWaitFlags;
+ using VULKAN_HPP_NAMESPACE::ShaderFloatControlsIndependence;
+ using VULKAN_HPP_NAMESPACE::ShaderFloatControlsIndependenceKHR;
+
+ //=== VK_VERSION_1_3 ===
+ using VULKAN_HPP_NAMESPACE::AccessFlagBits2;
+ using VULKAN_HPP_NAMESPACE::AccessFlagBits2KHR;
+ using VULKAN_HPP_NAMESPACE::AccessFlags2;
+ using VULKAN_HPP_NAMESPACE::FormatFeatureFlagBits2;
+ using VULKAN_HPP_NAMESPACE::FormatFeatureFlagBits2KHR;
+ using VULKAN_HPP_NAMESPACE::FormatFeatureFlags2;
+ using VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackFlagBits;
+ using VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackFlagBitsEXT;
+ using VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackFlags;
+ using VULKAN_HPP_NAMESPACE::PipelineStageFlagBits2;
+ using VULKAN_HPP_NAMESPACE::PipelineStageFlagBits2KHR;
+ using VULKAN_HPP_NAMESPACE::PipelineStageFlags2;
+ using VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateFlagBits;
+ using VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateFlagBitsEXT;
+ using VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateFlags;
+ using VULKAN_HPP_NAMESPACE::RenderingFlagBits;
+ using VULKAN_HPP_NAMESPACE::RenderingFlagBitsKHR;
+ using VULKAN_HPP_NAMESPACE::RenderingFlags;
+ using VULKAN_HPP_NAMESPACE::SubmitFlagBits;
+ using VULKAN_HPP_NAMESPACE::SubmitFlagBitsKHR;
+ using VULKAN_HPP_NAMESPACE::SubmitFlags;
+ using VULKAN_HPP_NAMESPACE::ToolPurposeFlagBits;
+ using VULKAN_HPP_NAMESPACE::ToolPurposeFlagBitsEXT;
+ using VULKAN_HPP_NAMESPACE::ToolPurposeFlags;
+
+ //=== VK_KHR_surface ===
+ using VULKAN_HPP_NAMESPACE::ColorSpaceKHR;
+ using VULKAN_HPP_NAMESPACE::CompositeAlphaFlagBitsKHR;
+ using VULKAN_HPP_NAMESPACE::CompositeAlphaFlagsKHR;
+ using VULKAN_HPP_NAMESPACE::PresentModeKHR;
+ using VULKAN_HPP_NAMESPACE::SurfaceTransformFlagBitsKHR;
+ using VULKAN_HPP_NAMESPACE::SurfaceTransformFlagsKHR;
+
+ //=== VK_KHR_swapchain ===
+ using VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagBitsKHR;
+ using VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR;
+ using VULKAN_HPP_NAMESPACE::SwapchainCreateFlagBitsKHR;
+ using VULKAN_HPP_NAMESPACE::SwapchainCreateFlagsKHR;
+
+ //=== VK_KHR_display ===
+ using VULKAN_HPP_NAMESPACE::DisplayModeCreateFlagBitsKHR;
+ using VULKAN_HPP_NAMESPACE::DisplayModeCreateFlagsKHR;
+ using VULKAN_HPP_NAMESPACE::DisplayPlaneAlphaFlagBitsKHR;
+ using VULKAN_HPP_NAMESPACE::DisplayPlaneAlphaFlagsKHR;
+ using VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateFlagBitsKHR;
+ using VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateFlagsKHR;
+
+#if defined( VK_USE_PLATFORM_XLIB_KHR )
+ //=== VK_KHR_xlib_surface ===
+ using VULKAN_HPP_NAMESPACE::XlibSurfaceCreateFlagBitsKHR;
+ using VULKAN_HPP_NAMESPACE::XlibSurfaceCreateFlagsKHR;
+#endif /*VK_USE_PLATFORM_XLIB_KHR*/
+
+#if defined( VK_USE_PLATFORM_XCB_KHR )
+ //=== VK_KHR_xcb_surface ===
+ using VULKAN_HPP_NAMESPACE::XcbSurfaceCreateFlagBitsKHR;
+ using VULKAN_HPP_NAMESPACE::XcbSurfaceCreateFlagsKHR;
+#endif /*VK_USE_PLATFORM_XCB_KHR*/
+
+#if defined( VK_USE_PLATFORM_WAYLAND_KHR )
+ //=== VK_KHR_wayland_surface ===
+ using VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateFlagBitsKHR;
+ using VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateFlagsKHR;
+#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
+
+#if defined( VK_USE_PLATFORM_ANDROID_KHR )
+ //=== VK_KHR_android_surface ===
+ using VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateFlagBitsKHR;
+ using VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateFlagsKHR;
+#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
+
+#if defined( VK_USE_PLATFORM_WIN32_KHR )
+ //=== VK_KHR_win32_surface ===
+ using VULKAN_HPP_NAMESPACE::Win32SurfaceCreateFlagBitsKHR;
+ using VULKAN_HPP_NAMESPACE::Win32SurfaceCreateFlagsKHR;
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+ //=== VK_EXT_debug_report ===
+ using VULKAN_HPP_NAMESPACE::DebugReportFlagBitsEXT;
+ using VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT;
+ using VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT;
+
+ //=== VK_AMD_rasterization_order ===
+ using VULKAN_HPP_NAMESPACE::RasterizationOrderAMD;
+
+ //=== VK_KHR_video_queue ===
+ using VULKAN_HPP_NAMESPACE::QueryResultStatusKHR;
+ using VULKAN_HPP_NAMESPACE::VideoBeginCodingFlagBitsKHR;
+ using VULKAN_HPP_NAMESPACE::VideoBeginCodingFlagsKHR;
+ using VULKAN_HPP_NAMESPACE::VideoCapabilityFlagBitsKHR;
+ using VULKAN_HPP_NAMESPACE::VideoCapabilityFlagsKHR;
+ using VULKAN_HPP_NAMESPACE::VideoChromaSubsamplingFlagBitsKHR;
+ using VULKAN_HPP_NAMESPACE::VideoChromaSubsamplingFlagsKHR;
+ using VULKAN_HPP_NAMESPACE::VideoCodecOperationFlagBitsKHR;
+ using VULKAN_HPP_NAMESPACE::VideoCodecOperationFlagsKHR;
+ using VULKAN_HPP_NAMESPACE::VideoCodingControlFlagBitsKHR;
+ using VULKAN_HPP_NAMESPACE::VideoCodingControlFlagsKHR;
+ using VULKAN_HPP_NAMESPACE::VideoComponentBitDepthFlagBitsKHR;
+ using VULKAN_HPP_NAMESPACE::VideoComponentBitDepthFlagsKHR;
+ using VULKAN_HPP_NAMESPACE::VideoEndCodingFlagBitsKHR;
+ using VULKAN_HPP_NAMESPACE::VideoEndCodingFlagsKHR;
+ using VULKAN_HPP_NAMESPACE::VideoSessionCreateFlagBitsKHR;
+ using VULKAN_HPP_NAMESPACE::VideoSessionCreateFlagsKHR;
+ using VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateFlagBitsKHR;
+ using VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateFlagsKHR;
+
+ //=== VK_KHR_video_decode_queue ===
+ using VULKAN_HPP_NAMESPACE::VideoDecodeCapabilityFlagBitsKHR;
+ using VULKAN_HPP_NAMESPACE::VideoDecodeCapabilityFlagsKHR;
+ using VULKAN_HPP_NAMESPACE::VideoDecodeFlagBitsKHR;
+ using VULKAN_HPP_NAMESPACE::VideoDecodeFlagsKHR;
+ using VULKAN_HPP_NAMESPACE::VideoDecodeUsageFlagBitsKHR;
+ using VULKAN_HPP_NAMESPACE::VideoDecodeUsageFlagsKHR;
+
+ //=== VK_EXT_transform_feedback ===
+ using VULKAN_HPP_NAMESPACE::PipelineRasterizationStateStreamCreateFlagBitsEXT;
+ using VULKAN_HPP_NAMESPACE::PipelineRasterizationStateStreamCreateFlagsEXT;
+
+#if defined( VK_ENABLE_BETA_EXTENSIONS )
+ //=== VK_EXT_video_encode_h264 ===
+ using VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilityFlagBitsEXT;
+ using VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilityFlagsEXT;
+ using VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlFlagBitsEXT;
+ using VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlFlagsEXT;
+ using VULKAN_HPP_NAMESPACE::VideoEncodeH264StdFlagBitsEXT;
+ using VULKAN_HPP_NAMESPACE::VideoEncodeH264StdFlagsEXT;
+#endif /*VK_ENABLE_BETA_EXTENSIONS*/
+
+#if defined( VK_ENABLE_BETA_EXTENSIONS )
+ //=== VK_EXT_video_encode_h265 ===
+ using VULKAN_HPP_NAMESPACE::VideoEncodeH265CapabilityFlagBitsEXT;
+ using VULKAN_HPP_NAMESPACE::VideoEncodeH265CapabilityFlagsEXT;
+ using VULKAN_HPP_NAMESPACE::VideoEncodeH265CtbSizeFlagBitsEXT;
+ using VULKAN_HPP_NAMESPACE::VideoEncodeH265CtbSizeFlagsEXT;
+ using VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlFlagBitsEXT;
+ using VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlFlagsEXT;
+ using VULKAN_HPP_NAMESPACE::VideoEncodeH265StdFlagBitsEXT;
+ using VULKAN_HPP_NAMESPACE::VideoEncodeH265StdFlagsEXT;
+ using VULKAN_HPP_NAMESPACE::VideoEncodeH265TransformBlockSizeFlagBitsEXT;
+ using VULKAN_HPP_NAMESPACE::VideoEncodeH265TransformBlockSizeFlagsEXT;
+#endif /*VK_ENABLE_BETA_EXTENSIONS*/
+
+ //=== VK_KHR_video_decode_h264 ===
+ using VULKAN_HPP_NAMESPACE::VideoDecodeH264PictureLayoutFlagBitsKHR;
+ using VULKAN_HPP_NAMESPACE::VideoDecodeH264PictureLayoutFlagsKHR;
+
+ //=== VK_AMD_shader_info ===
+ using VULKAN_HPP_NAMESPACE::ShaderInfoTypeAMD;
+
+#if defined( VK_USE_PLATFORM_GGP )
+ //=== VK_GGP_stream_descriptor_surface ===
+ using VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateFlagBitsGGP;
+ using VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateFlagsGGP;
+#endif /*VK_USE_PLATFORM_GGP*/
+
+ //=== VK_NV_external_memory_capabilities ===
+ using VULKAN_HPP_NAMESPACE::ExternalMemoryFeatureFlagBitsNV;
+ using VULKAN_HPP_NAMESPACE::ExternalMemoryFeatureFlagsNV;
+ using VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBitsNV;
+ using VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV;
+
+ //=== VK_EXT_validation_flags ===
+ using VULKAN_HPP_NAMESPACE::ValidationCheckEXT;
+
+#if defined( VK_USE_PLATFORM_VI_NN )
+ //=== VK_NN_vi_surface ===
+ using VULKAN_HPP_NAMESPACE::ViSurfaceCreateFlagBitsNN;
+ using VULKAN_HPP_NAMESPACE::ViSurfaceCreateFlagsNN;
+#endif /*VK_USE_PLATFORM_VI_NN*/
+
+ //=== VK_EXT_pipeline_robustness ===
+ using VULKAN_HPP_NAMESPACE::PipelineRobustnessBufferBehaviorEXT;
+ using VULKAN_HPP_NAMESPACE::PipelineRobustnessImageBehaviorEXT;
+
+ //=== VK_EXT_conditional_rendering ===
+ using VULKAN_HPP_NAMESPACE::ConditionalRenderingFlagBitsEXT;
+ using VULKAN_HPP_NAMESPACE::ConditionalRenderingFlagsEXT;
+
+ //=== VK_EXT_display_surface_counter ===
+ using VULKAN_HPP_NAMESPACE::SurfaceCounterFlagBitsEXT;
+ using VULKAN_HPP_NAMESPACE::SurfaceCounterFlagsEXT;
+
+ //=== VK_EXT_display_control ===
+ using VULKAN_HPP_NAMESPACE::DeviceEventTypeEXT;
+ using VULKAN_HPP_NAMESPACE::DisplayEventTypeEXT;
+ using VULKAN_HPP_NAMESPACE::DisplayPowerStateEXT;
+
+ //=== VK_NV_viewport_swizzle ===
+ using VULKAN_HPP_NAMESPACE::PipelineViewportSwizzleStateCreateFlagBitsNV;
+ using VULKAN_HPP_NAMESPACE::PipelineViewportSwizzleStateCreateFlagsNV;
+ using VULKAN_HPP_NAMESPACE::ViewportCoordinateSwizzleNV;
+
+ //=== VK_EXT_discard_rectangles ===
+ using VULKAN_HPP_NAMESPACE::DiscardRectangleModeEXT;
+ using VULKAN_HPP_NAMESPACE::PipelineDiscardRectangleStateCreateFlagBitsEXT;
+ using VULKAN_HPP_NAMESPACE::PipelineDiscardRectangleStateCreateFlagsEXT;
+
+ //=== VK_EXT_conservative_rasterization ===
+ using VULKAN_HPP_NAMESPACE::ConservativeRasterizationModeEXT;
+ using VULKAN_HPP_NAMESPACE::PipelineRasterizationConservativeStateCreateFlagBitsEXT;
+ using VULKAN_HPP_NAMESPACE::PipelineRasterizationConservativeStateCreateFlagsEXT;
+
+ //=== VK_EXT_depth_clip_enable ===
+ using VULKAN_HPP_NAMESPACE::PipelineRasterizationDepthClipStateCreateFlagBitsEXT;
+ using VULKAN_HPP_NAMESPACE::PipelineRasterizationDepthClipStateCreateFlagsEXT;
+
+ //=== VK_KHR_performance_query ===
+ using VULKAN_HPP_NAMESPACE::AcquireProfilingLockFlagBitsKHR;
+ using VULKAN_HPP_NAMESPACE::AcquireProfilingLockFlagsKHR;
+ using VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionFlagBitsKHR;
+ using VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionFlagsKHR;
+ using VULKAN_HPP_NAMESPACE::PerformanceCounterScopeKHR;
+ using VULKAN_HPP_NAMESPACE::PerformanceCounterStorageKHR;
+ using VULKAN_HPP_NAMESPACE::PerformanceCounterUnitKHR;
+
+#if defined( VK_USE_PLATFORM_IOS_MVK )
+ //=== VK_MVK_ios_surface ===
+ using VULKAN_HPP_NAMESPACE::IOSSurfaceCreateFlagBitsMVK;
+ using VULKAN_HPP_NAMESPACE::IOSSurfaceCreateFlagsMVK;
+#endif /*VK_USE_PLATFORM_IOS_MVK*/
+
+#if defined( VK_USE_PLATFORM_MACOS_MVK )
+ //=== VK_MVK_macos_surface ===
+ using VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateFlagBitsMVK;
+ using VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateFlagsMVK;
+#endif /*VK_USE_PLATFORM_MACOS_MVK*/
+
+ //=== VK_EXT_debug_utils ===
+ using VULKAN_HPP_NAMESPACE::DebugUtilsMessageSeverityFlagBitsEXT;
+ using VULKAN_HPP_NAMESPACE::DebugUtilsMessageSeverityFlagsEXT;
+ using VULKAN_HPP_NAMESPACE::DebugUtilsMessageTypeFlagBitsEXT;
+ using VULKAN_HPP_NAMESPACE::DebugUtilsMessageTypeFlagsEXT;
+ using VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataFlagBitsEXT;
+ using VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataFlagsEXT;
+ using VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateFlagBitsEXT;
+ using VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateFlagsEXT;
+
+ //=== VK_EXT_blend_operation_advanced ===
+ using VULKAN_HPP_NAMESPACE::BlendOverlapEXT;
+
+ //=== VK_NV_fragment_coverage_to_color ===
+ using VULKAN_HPP_NAMESPACE::PipelineCoverageToColorStateCreateFlagBitsNV;
+ using VULKAN_HPP_NAMESPACE::PipelineCoverageToColorStateCreateFlagsNV;
+
+ //=== VK_KHR_acceleration_structure ===
+ using VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR;
+ using VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR;
+ using VULKAN_HPP_NAMESPACE::AccelerationStructureCreateFlagBitsKHR;
+ using VULKAN_HPP_NAMESPACE::AccelerationStructureCreateFlagsKHR;
+ using VULKAN_HPP_NAMESPACE::AccelerationStructureTypeKHR;
+ using VULKAN_HPP_NAMESPACE::AccelerationStructureTypeNV;
+ using VULKAN_HPP_NAMESPACE::BuildAccelerationStructureFlagBitsKHR;
+ using VULKAN_HPP_NAMESPACE::BuildAccelerationStructureFlagBitsNV;
+ using VULKAN_HPP_NAMESPACE::BuildAccelerationStructureFlagsKHR;
+ using VULKAN_HPP_NAMESPACE::BuildAccelerationStructureModeKHR;
+ using VULKAN_HPP_NAMESPACE::CopyAccelerationStructureModeKHR;
+ using VULKAN_HPP_NAMESPACE::CopyAccelerationStructureModeNV;
+ using VULKAN_HPP_NAMESPACE::GeometryFlagBitsKHR;
+ using VULKAN_HPP_NAMESPACE::GeometryFlagBitsNV;
+ using VULKAN_HPP_NAMESPACE::GeometryFlagsKHR;
+ using VULKAN_HPP_NAMESPACE::GeometryInstanceFlagBitsKHR;
+ using VULKAN_HPP_NAMESPACE::GeometryInstanceFlagBitsNV;
+ using VULKAN_HPP_NAMESPACE::GeometryInstanceFlagsKHR;
+ using VULKAN_HPP_NAMESPACE::GeometryTypeKHR;
+ using VULKAN_HPP_NAMESPACE::GeometryTypeNV;
+
+ //=== VK_KHR_ray_tracing_pipeline ===
+ using VULKAN_HPP_NAMESPACE::RayTracingShaderGroupTypeKHR;
+ using VULKAN_HPP_NAMESPACE::RayTracingShaderGroupTypeNV;
+ using VULKAN_HPP_NAMESPACE::ShaderGroupShaderKHR;
+
+ //=== VK_NV_framebuffer_mixed_samples ===
+ using VULKAN_HPP_NAMESPACE::CoverageModulationModeNV;
+ using VULKAN_HPP_NAMESPACE::PipelineCoverageModulationStateCreateFlagBitsNV;
+ using VULKAN_HPP_NAMESPACE::PipelineCoverageModulationStateCreateFlagsNV;
+
+ //=== VK_EXT_validation_cache ===
+ using VULKAN_HPP_NAMESPACE::ValidationCacheCreateFlagBitsEXT;
+ using VULKAN_HPP_NAMESPACE::ValidationCacheCreateFlagsEXT;
+ using VULKAN_HPP_NAMESPACE::ValidationCacheHeaderVersionEXT;
+
+ //=== VK_NV_shading_rate_image ===
+ using VULKAN_HPP_NAMESPACE::CoarseSampleOrderTypeNV;
+ using VULKAN_HPP_NAMESPACE::ShadingRatePaletteEntryNV;
+
+ //=== VK_NV_ray_tracing ===
+ using VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsTypeNV;
+
+ //=== VK_AMD_pipeline_compiler_control ===
+ using VULKAN_HPP_NAMESPACE::PipelineCompilerControlFlagBitsAMD;
+ using VULKAN_HPP_NAMESPACE::PipelineCompilerControlFlagsAMD;
+
+ //=== VK_EXT_calibrated_timestamps ===
+ using VULKAN_HPP_NAMESPACE::TimeDomainEXT;
+
+ //=== VK_KHR_global_priority ===
+ using VULKAN_HPP_NAMESPACE::QueueGlobalPriorityEXT;
+ using VULKAN_HPP_NAMESPACE::QueueGlobalPriorityKHR;
+
+ //=== VK_AMD_memory_overallocation_behavior ===
+ using VULKAN_HPP_NAMESPACE::MemoryOverallocationBehaviorAMD;
+
+ //=== VK_INTEL_performance_query ===
+ using VULKAN_HPP_NAMESPACE::PerformanceConfigurationTypeINTEL;
+ using VULKAN_HPP_NAMESPACE::PerformanceOverrideTypeINTEL;
+ using VULKAN_HPP_NAMESPACE::PerformanceParameterTypeINTEL;
+ using VULKAN_HPP_NAMESPACE::PerformanceValueTypeINTEL;
+ using VULKAN_HPP_NAMESPACE::QueryPoolSamplingModeINTEL;
+
+#if defined( VK_USE_PLATFORM_FUCHSIA )
+ //=== VK_FUCHSIA_imagepipe_surface ===
+ using VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateFlagBitsFUCHSIA;
+ using VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateFlagsFUCHSIA;
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
+
+#if defined( VK_USE_PLATFORM_METAL_EXT )
+ //=== VK_EXT_metal_surface ===
+ using VULKAN_HPP_NAMESPACE::MetalSurfaceCreateFlagBitsEXT;
+ using VULKAN_HPP_NAMESPACE::MetalSurfaceCreateFlagsEXT;
+#endif /*VK_USE_PLATFORM_METAL_EXT*/
+
+ //=== VK_KHR_fragment_shading_rate ===
+ using VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR;
+
+ //=== VK_AMD_shader_core_properties2 ===
+ using VULKAN_HPP_NAMESPACE::ShaderCorePropertiesFlagBitsAMD;
+ using VULKAN_HPP_NAMESPACE::ShaderCorePropertiesFlagsAMD;
+
+ //=== VK_EXT_validation_features ===
+ using VULKAN_HPP_NAMESPACE::ValidationFeatureDisableEXT;
+ using VULKAN_HPP_NAMESPACE::ValidationFeatureEnableEXT;
+
+ //=== VK_NV_coverage_reduction_mode ===
+ using VULKAN_HPP_NAMESPACE::CoverageReductionModeNV;
+ using VULKAN_HPP_NAMESPACE::PipelineCoverageReductionStateCreateFlagBitsNV;
+ using VULKAN_HPP_NAMESPACE::PipelineCoverageReductionStateCreateFlagsNV;
+
+ //=== VK_EXT_provoking_vertex ===
+ using VULKAN_HPP_NAMESPACE::ProvokingVertexModeEXT;
+
+#if defined( VK_USE_PLATFORM_WIN32_KHR )
+ //=== VK_EXT_full_screen_exclusive ===
+ using VULKAN_HPP_NAMESPACE::FullScreenExclusiveEXT;
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+ //=== VK_EXT_headless_surface ===
+ using VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateFlagBitsEXT;
+ using VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateFlagsEXT;
+
+ //=== VK_EXT_line_rasterization ===
+ using VULKAN_HPP_NAMESPACE::LineRasterizationModeEXT;
+
+ //=== VK_KHR_pipeline_executable_properties ===
+ using VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticFormatKHR;
+
+ //=== VK_EXT_host_image_copy ===
+ using VULKAN_HPP_NAMESPACE::HostImageCopyFlagBitsEXT;
+ using VULKAN_HPP_NAMESPACE::HostImageCopyFlagsEXT;
+
+ //=== VK_KHR_map_memory2 ===
+ using VULKAN_HPP_NAMESPACE::MemoryUnmapFlagBitsKHR;
+ using VULKAN_HPP_NAMESPACE::MemoryUnmapFlagsKHR;
+
+ //=== VK_EXT_surface_maintenance1 ===
+ using VULKAN_HPP_NAMESPACE::PresentGravityFlagBitsEXT;
+ using VULKAN_HPP_NAMESPACE::PresentGravityFlagsEXT;
+ using VULKAN_HPP_NAMESPACE::PresentScalingFlagBitsEXT;
+ using VULKAN_HPP_NAMESPACE::PresentScalingFlagsEXT;
+
+ //=== VK_NV_device_generated_commands ===
+ using VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutUsageFlagBitsNV;
+ using VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutUsageFlagsNV;
+ using VULKAN_HPP_NAMESPACE::IndirectCommandsTokenTypeNV;
+ using VULKAN_HPP_NAMESPACE::IndirectStateFlagBitsNV;
+ using VULKAN_HPP_NAMESPACE::IndirectStateFlagsNV;
+
+ //=== VK_EXT_depth_bias_control ===
+ using VULKAN_HPP_NAMESPACE::DepthBiasRepresentationEXT;
+
+ //=== VK_EXT_device_memory_report ===
+ using VULKAN_HPP_NAMESPACE::DeviceMemoryReportEventTypeEXT;
+ using VULKAN_HPP_NAMESPACE::DeviceMemoryReportFlagBitsEXT;
+ using VULKAN_HPP_NAMESPACE::DeviceMemoryReportFlagsEXT;
+
+ //=== VK_EXT_pipeline_creation_cache_control ===
+ using VULKAN_HPP_NAMESPACE::PipelineCacheCreateFlagBits;
+ using VULKAN_HPP_NAMESPACE::PipelineCacheCreateFlags;
+
+#if defined( VK_ENABLE_BETA_EXTENSIONS )
+ //=== VK_KHR_video_encode_queue ===
+ using VULKAN_HPP_NAMESPACE::VideoEncodeCapabilityFlagBitsKHR;
+ using VULKAN_HPP_NAMESPACE::VideoEncodeCapabilityFlagsKHR;
+ using VULKAN_HPP_NAMESPACE::VideoEncodeContentFlagBitsKHR;
+ using VULKAN_HPP_NAMESPACE::VideoEncodeContentFlagsKHR;
+ using VULKAN_HPP_NAMESPACE::VideoEncodeFeedbackFlagBitsKHR;
+ using VULKAN_HPP_NAMESPACE::VideoEncodeFeedbackFlagsKHR;
+ using VULKAN_HPP_NAMESPACE::VideoEncodeFlagBitsKHR;
+ using VULKAN_HPP_NAMESPACE::VideoEncodeFlagsKHR;
+ using VULKAN_HPP_NAMESPACE::VideoEncodeRateControlFlagBitsKHR;
+ using VULKAN_HPP_NAMESPACE::VideoEncodeRateControlFlagsKHR;
+ using VULKAN_HPP_NAMESPACE::VideoEncodeRateControlModeFlagBitsKHR;
+ using VULKAN_HPP_NAMESPACE::VideoEncodeRateControlModeFlagsKHR;
+ using VULKAN_HPP_NAMESPACE::VideoEncodeTuningModeKHR;
+ using VULKAN_HPP_NAMESPACE::VideoEncodeUsageFlagBitsKHR;
+ using VULKAN_HPP_NAMESPACE::VideoEncodeUsageFlagsKHR;
+#endif /*VK_ENABLE_BETA_EXTENSIONS*/
+
+ //=== VK_NV_device_diagnostics_config ===
+ using VULKAN_HPP_NAMESPACE::DeviceDiagnosticsConfigFlagBitsNV;
+ using VULKAN_HPP_NAMESPACE::DeviceDiagnosticsConfigFlagsNV;
+
+#if defined( VK_USE_PLATFORM_METAL_EXT )
+ //=== VK_EXT_metal_objects ===
+ using VULKAN_HPP_NAMESPACE::ExportMetalObjectTypeFlagBitsEXT;
+ using VULKAN_HPP_NAMESPACE::ExportMetalObjectTypeFlagsEXT;
+#endif /*VK_USE_PLATFORM_METAL_EXT*/
+
+ //=== VK_EXT_graphics_pipeline_library ===
+ using VULKAN_HPP_NAMESPACE::GraphicsPipelineLibraryFlagBitsEXT;
+ using VULKAN_HPP_NAMESPACE::GraphicsPipelineLibraryFlagsEXT;
+ using VULKAN_HPP_NAMESPACE::PipelineLayoutCreateFlagBits;
+ using VULKAN_HPP_NAMESPACE::PipelineLayoutCreateFlags;
+
+ //=== VK_NV_fragment_shading_rate_enums ===
+ using VULKAN_HPP_NAMESPACE::FragmentShadingRateNV;
+ using VULKAN_HPP_NAMESPACE::FragmentShadingRateTypeNV;
+
+ //=== VK_NV_ray_tracing_motion_blur ===
+ using VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInfoFlagBitsNV;
+ using VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInfoFlagsNV;
+ using VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInstanceFlagBitsNV;
+ using VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInstanceFlagsNV;
+ using VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInstanceTypeNV;
+
+ //=== VK_EXT_image_compression_control ===
+ using VULKAN_HPP_NAMESPACE::ImageCompressionFixedRateFlagBitsEXT;
+ using VULKAN_HPP_NAMESPACE::ImageCompressionFixedRateFlagsEXT;
+ using VULKAN_HPP_NAMESPACE::ImageCompressionFlagBitsEXT;
+ using VULKAN_HPP_NAMESPACE::ImageCompressionFlagsEXT;
+
+ //=== VK_EXT_device_fault ===
+ using VULKAN_HPP_NAMESPACE::DeviceFaultAddressTypeEXT;
+ using VULKAN_HPP_NAMESPACE::DeviceFaultVendorBinaryHeaderVersionEXT;
+
+#if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
+ //=== VK_EXT_directfb_surface ===
+ using VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateFlagBitsEXT;
+ using VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateFlagsEXT;
+#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
+
+ //=== VK_EXT_device_address_binding_report ===
+ using VULKAN_HPP_NAMESPACE::DeviceAddressBindingFlagBitsEXT;
+ using VULKAN_HPP_NAMESPACE::DeviceAddressBindingFlagsEXT;
+ using VULKAN_HPP_NAMESPACE::DeviceAddressBindingTypeEXT;
+
+#if defined( VK_USE_PLATFORM_FUCHSIA )
+ //=== VK_FUCHSIA_buffer_collection ===
+ using VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFlagBitsFUCHSIA;
+ using VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFlagsFUCHSIA;
+ using VULKAN_HPP_NAMESPACE::ImageFormatConstraintsFlagBitsFUCHSIA;
+ using VULKAN_HPP_NAMESPACE::ImageFormatConstraintsFlagsFUCHSIA;
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
+
+ //=== VK_EXT_frame_boundary ===
+ using VULKAN_HPP_NAMESPACE::FrameBoundaryFlagBitsEXT;
+ using VULKAN_HPP_NAMESPACE::FrameBoundaryFlagsEXT;
+
+#if defined( VK_USE_PLATFORM_SCREEN_QNX )
+ //=== VK_QNX_screen_surface ===
+ using VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateFlagBitsQNX;
+ using VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateFlagsQNX;
+#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
+
+ //=== VK_EXT_opacity_micromap ===
+ using VULKAN_HPP_NAMESPACE::BuildMicromapFlagBitsEXT;
+ using VULKAN_HPP_NAMESPACE::BuildMicromapFlagsEXT;
+ using VULKAN_HPP_NAMESPACE::BuildMicromapModeEXT;
+ using VULKAN_HPP_NAMESPACE::CopyMicromapModeEXT;
+ using VULKAN_HPP_NAMESPACE::MicromapCreateFlagBitsEXT;
+ using VULKAN_HPP_NAMESPACE::MicromapCreateFlagsEXT;
+ using VULKAN_HPP_NAMESPACE::MicromapTypeEXT;
+ using VULKAN_HPP_NAMESPACE::OpacityMicromapFormatEXT;
+ using VULKAN_HPP_NAMESPACE::OpacityMicromapSpecialIndexEXT;
+
+#if defined( VK_ENABLE_BETA_EXTENSIONS )
+ //=== VK_NV_displacement_micromap ===
+ using VULKAN_HPP_NAMESPACE::DisplacementMicromapFormatNV;
+#endif /*VK_ENABLE_BETA_EXTENSIONS*/
+
+ //=== VK_NV_memory_decompression ===
+ using VULKAN_HPP_NAMESPACE::MemoryDecompressionMethodFlagBitsNV;
+ using VULKAN_HPP_NAMESPACE::MemoryDecompressionMethodFlagsNV;
+
+ //=== VK_EXT_subpass_merge_feedback ===
+ using VULKAN_HPP_NAMESPACE::SubpassMergeStatusEXT;
+
+ //=== VK_LUNARG_direct_driver_loading ===
+ using VULKAN_HPP_NAMESPACE::DirectDriverLoadingFlagBitsLUNARG;
+ using VULKAN_HPP_NAMESPACE::DirectDriverLoadingFlagsLUNARG;
+ using VULKAN_HPP_NAMESPACE::DirectDriverLoadingModeLUNARG;
+
+ //=== VK_EXT_rasterization_order_attachment_access ===
+ using VULKAN_HPP_NAMESPACE::PipelineColorBlendStateCreateFlagBits;
+ using VULKAN_HPP_NAMESPACE::PipelineColorBlendStateCreateFlags;
+ using VULKAN_HPP_NAMESPACE::PipelineDepthStencilStateCreateFlagBits;
+ using VULKAN_HPP_NAMESPACE::PipelineDepthStencilStateCreateFlags;
+
+ //=== VK_NV_optical_flow ===
+ using VULKAN_HPP_NAMESPACE::OpticalFlowExecuteFlagBitsNV;
+ using VULKAN_HPP_NAMESPACE::OpticalFlowExecuteFlagsNV;
+ using VULKAN_HPP_NAMESPACE::OpticalFlowGridSizeFlagBitsNV;
+ using VULKAN_HPP_NAMESPACE::OpticalFlowGridSizeFlagsNV;
+ using VULKAN_HPP_NAMESPACE::OpticalFlowPerformanceLevelNV;
+ using VULKAN_HPP_NAMESPACE::OpticalFlowSessionBindingPointNV;
+ using VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreateFlagBitsNV;
+ using VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreateFlagsNV;
+ using VULKAN_HPP_NAMESPACE::OpticalFlowUsageFlagBitsNV;
+ using VULKAN_HPP_NAMESPACE::OpticalFlowUsageFlagsNV;
+
+ //=== VK_KHR_maintenance5 ===
+ using VULKAN_HPP_NAMESPACE::BufferUsageFlagBits2KHR;
+ using VULKAN_HPP_NAMESPACE::BufferUsageFlags2KHR;
+ using VULKAN_HPP_NAMESPACE::PipelineCreateFlagBits2KHR;
+ using VULKAN_HPP_NAMESPACE::PipelineCreateFlags2KHR;
+
+ //=== VK_EXT_shader_object ===
+ using VULKAN_HPP_NAMESPACE::ShaderCodeTypeEXT;
+ using VULKAN_HPP_NAMESPACE::ShaderCreateFlagBitsEXT;
+ using VULKAN_HPP_NAMESPACE::ShaderCreateFlagsEXT;
+
+ //=== VK_NV_ray_tracing_invocation_reorder ===
+ using VULKAN_HPP_NAMESPACE::RayTracingInvocationReorderModeNV;
+
+ //=== VK_NV_low_latency2 ===
+ using VULKAN_HPP_NAMESPACE::LatencyMarkerNV;
+ using VULKAN_HPP_NAMESPACE::OutOfBandQueueTypeNV;
+
+ //=== VK_KHR_cooperative_matrix ===
+ using VULKAN_HPP_NAMESPACE::ComponentTypeKHR;
+ using VULKAN_HPP_NAMESPACE::ComponentTypeNV;
+ using VULKAN_HPP_NAMESPACE::ScopeKHR;
+ using VULKAN_HPP_NAMESPACE::ScopeNV;
+
+ //=== VK_QCOM_image_processing2 ===
+ using VULKAN_HPP_NAMESPACE::BlockMatchWindowCompareModeQCOM;
+
+ //=== VK_QCOM_filter_cubic_weights ===
+ using VULKAN_HPP_NAMESPACE::CubicFilterWeightsQCOM;
+
+ //=== VK_MSFT_layered_driver ===
+ using VULKAN_HPP_NAMESPACE::LayeredDriverUnderlyingApiMSFT;
+
+ //=========================
+ //=== Index Type Traits ===
+ //=========================
+ using VULKAN_HPP_NAMESPACE::IndexTypeValue;
+
+ //======================
+ //=== ENUM to_string ===
+ //======================
+#if !defined( VULKAN_HPP_NO_TO_STRING )
+ using VULKAN_HPP_NAMESPACE::to_string;
+ using VULKAN_HPP_NAMESPACE::toHexString;
+#endif /*VULKAN_HPP_NO_TO_STRING*/
+
+ //=============================
+ //=== EXCEPTIONs AND ERRORs ===
+ //=============================
+#if !defined( VULKAN_HPP_NO_EXCEPTIONS )
+ using VULKAN_HPP_NAMESPACE::DeviceLostError;
+ using VULKAN_HPP_NAMESPACE::Error;
+ using VULKAN_HPP_NAMESPACE::errorCategory;
+ using VULKAN_HPP_NAMESPACE::ErrorCategoryImpl;
+ using VULKAN_HPP_NAMESPACE::ExtensionNotPresentError;
+ using VULKAN_HPP_NAMESPACE::FeatureNotPresentError;
+ using VULKAN_HPP_NAMESPACE::FormatNotSupportedError;
+ using VULKAN_HPP_NAMESPACE::FragmentationError;
+ using VULKAN_HPP_NAMESPACE::FragmentedPoolError;
+ using VULKAN_HPP_NAMESPACE::ImageUsageNotSupportedKHRError;
+ using VULKAN_HPP_NAMESPACE::IncompatibleDisplayKHRError;
+ using VULKAN_HPP_NAMESPACE::IncompatibleDriverError;
+ using VULKAN_HPP_NAMESPACE::InitializationFailedError;
+ using VULKAN_HPP_NAMESPACE::InvalidDrmFormatModifierPlaneLayoutEXTError;
+ using VULKAN_HPP_NAMESPACE::InvalidExternalHandleError;
+ using VULKAN_HPP_NAMESPACE::InvalidOpaqueCaptureAddressError;
+ using VULKAN_HPP_NAMESPACE::InvalidShaderNVError;
+ using VULKAN_HPP_NAMESPACE::LayerNotPresentError;
+ using VULKAN_HPP_NAMESPACE::LogicError;
+ using VULKAN_HPP_NAMESPACE::make_error_code;
+ using VULKAN_HPP_NAMESPACE::make_error_condition;
+ using VULKAN_HPP_NAMESPACE::MemoryMapFailedError;
+ using VULKAN_HPP_NAMESPACE::NativeWindowInUseKHRError;
+ using VULKAN_HPP_NAMESPACE::NotPermittedKHRError;
+ using VULKAN_HPP_NAMESPACE::OutOfDateKHRError;
+ using VULKAN_HPP_NAMESPACE::OutOfDeviceMemoryError;
+ using VULKAN_HPP_NAMESPACE::OutOfHostMemoryError;
+ using VULKAN_HPP_NAMESPACE::OutOfPoolMemoryError;
+ using VULKAN_HPP_NAMESPACE::SurfaceLostKHRError;
+ using VULKAN_HPP_NAMESPACE::SystemError;
+ using VULKAN_HPP_NAMESPACE::TooManyObjectsError;
+ using VULKAN_HPP_NAMESPACE::UnknownError;
+ using VULKAN_HPP_NAMESPACE::ValidationFailedEXTError;
+ using VULKAN_HPP_NAMESPACE::VideoPictureLayoutNotSupportedKHRError;
+ using VULKAN_HPP_NAMESPACE::VideoProfileCodecNotSupportedKHRError;
+ using VULKAN_HPP_NAMESPACE::VideoProfileFormatNotSupportedKHRError;
+ using VULKAN_HPP_NAMESPACE::VideoProfileOperationNotSupportedKHRError;
+ using VULKAN_HPP_NAMESPACE::VideoStdVersionNotSupportedKHRError;
+
+# if defined( VK_USE_PLATFORM_WIN32_KHR )
+ using VULKAN_HPP_NAMESPACE::FullScreenExclusiveModeLostEXTError;
+# endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+# if defined( VK_ENABLE_BETA_EXTENSIONS )
+ using VULKAN_HPP_NAMESPACE::InvalidVideoStdParametersKHRError;
+# endif /*VK_ENABLE_BETA_EXTENSIONS*/
+
+ using VULKAN_HPP_NAMESPACE::CompressionExhaustedEXTError;
+ using VULKAN_HPP_NAMESPACE::IncompatibleShaderBinaryEXTError;
+#endif /*VULKAN_HPP_NO_EXCEPTIONS*/
+
+ using VULKAN_HPP_NAMESPACE::createResultValueType;
+ using VULKAN_HPP_NAMESPACE::ignore;
+ using VULKAN_HPP_NAMESPACE::resultCheck;
+ using VULKAN_HPP_NAMESPACE::ResultValue;
+ using VULKAN_HPP_NAMESPACE::ResultValueType;
+
+ //===========================
+ //=== CONSTEXPR CONSTANTs ===
+ //===========================
+
+ //=== VK_VERSION_1_0 ===
+ using VULKAN_HPP_NAMESPACE::AttachmentUnused;
+ using VULKAN_HPP_NAMESPACE::False;
+ using VULKAN_HPP_NAMESPACE::LodClampNone;
+ using VULKAN_HPP_NAMESPACE::MaxDescriptionSize;
+ using VULKAN_HPP_NAMESPACE::MaxExtensionNameSize;
+ using VULKAN_HPP_NAMESPACE::MaxMemoryHeaps;
+ using VULKAN_HPP_NAMESPACE::MaxMemoryTypes;
+ using VULKAN_HPP_NAMESPACE::MaxPhysicalDeviceNameSize;
+ using VULKAN_HPP_NAMESPACE::QueueFamilyIgnored;
+ using VULKAN_HPP_NAMESPACE::RemainingArrayLayers;
+ using VULKAN_HPP_NAMESPACE::RemainingMipLevels;
+ using VULKAN_HPP_NAMESPACE::SubpassExternal;
+ using VULKAN_HPP_NAMESPACE::True;
+ using VULKAN_HPP_NAMESPACE::UuidSize;
+ using VULKAN_HPP_NAMESPACE::WholeSize;
+
+ //=== VK_VERSION_1_1 ===
+ using VULKAN_HPP_NAMESPACE::LuidSize;
+ using VULKAN_HPP_NAMESPACE::MaxDeviceGroupSize;
+ using VULKAN_HPP_NAMESPACE::QueueFamilyExternal;
+
+ //=== VK_VERSION_1_2 ===
+ using VULKAN_HPP_NAMESPACE::MaxDriverInfoSize;
+ using VULKAN_HPP_NAMESPACE::MaxDriverNameSize;
+
+ //=== VK_KHR_device_group_creation ===
+ using VULKAN_HPP_NAMESPACE::MaxDeviceGroupSizeKHR;
+
+ //=== VK_KHR_external_memory_capabilities ===
+ using VULKAN_HPP_NAMESPACE::LuidSizeKHR;
+
+ //=== VK_KHR_external_memory ===
+ using VULKAN_HPP_NAMESPACE::QueueFamilyExternalKHR;
+
+#if defined( VK_ENABLE_BETA_EXTENSIONS )
+ //=== VK_AMDX_shader_enqueue ===
+ using VULKAN_HPP_NAMESPACE::ShaderIndexUnusedAMDX;
+#endif /*VK_ENABLE_BETA_EXTENSIONS*/
+
+ //=== VK_KHR_ray_tracing_pipeline ===
+ using VULKAN_HPP_NAMESPACE::ShaderUnusedKHR;
+
+ //=== VK_NV_ray_tracing ===
+ using VULKAN_HPP_NAMESPACE::ShaderUnusedNV;
+
+ //=== VK_KHR_global_priority ===
+ using VULKAN_HPP_NAMESPACE::MaxGlobalPrioritySizeKHR;
+
+ //=== VK_KHR_driver_properties ===
+ using VULKAN_HPP_NAMESPACE::MaxDriverInfoSizeKHR;
+ using VULKAN_HPP_NAMESPACE::MaxDriverNameSizeKHR;
+
+ //=== VK_EXT_global_priority_query ===
+ using VULKAN_HPP_NAMESPACE::MaxGlobalPrioritySizeEXT;
+
+ //=== VK_EXT_image_sliced_view_of_3d ===
+ using VULKAN_HPP_NAMESPACE::Remaining3DSlicesEXT;
+
+ //=== VK_EXT_shader_module_identifier ===
+ using VULKAN_HPP_NAMESPACE::MaxShaderModuleIdentifierSizeEXT;
+
+ //========================
+ //=== CONSTEXPR VALUEs ===
+ //========================
+ using VULKAN_HPP_NAMESPACE::HeaderVersion;
+
+ //=========================
+ //=== CONSTEXPR CALLEEs ===
+ //=========================
+ using VULKAN_HPP_NAMESPACE::apiVersionMajor;
+ using VULKAN_HPP_NAMESPACE::apiVersionMinor;
+ using VULKAN_HPP_NAMESPACE::apiVersionPatch;
+ using VULKAN_HPP_NAMESPACE::apiVersionVariant;
+ using VULKAN_HPP_NAMESPACE::makeApiVersion;
+ using VULKAN_HPP_NAMESPACE::makeVersion;
+ using VULKAN_HPP_NAMESPACE::versionMajor;
+ using VULKAN_HPP_NAMESPACE::versionMinor;
+ using VULKAN_HPP_NAMESPACE::versionPatch;
+
+ //==========================
+ //=== CONSTEXPR CALLERSs ===
+ //==========================
+ using VULKAN_HPP_NAMESPACE::ApiVersion;
+ using VULKAN_HPP_NAMESPACE::ApiVersion10;
+ using VULKAN_HPP_NAMESPACE::ApiVersion11;
+ using VULKAN_HPP_NAMESPACE::ApiVersion12;
+ using VULKAN_HPP_NAMESPACE::ApiVersion13;
+ using VULKAN_HPP_NAMESPACE::HeaderVersionComplete;
+
+ //===============
+ //=== STRUCTs ===
+ //===============
+
+ //=== VK_VERSION_1_0 ===
+ using VULKAN_HPP_NAMESPACE::AllocationCallbacks;
+ using VULKAN_HPP_NAMESPACE::ApplicationInfo;
+ using VULKAN_HPP_NAMESPACE::AttachmentDescription;
+ using VULKAN_HPP_NAMESPACE::AttachmentReference;
+ using VULKAN_HPP_NAMESPACE::BaseInStructure;
+ using VULKAN_HPP_NAMESPACE::BaseOutStructure;
+ using VULKAN_HPP_NAMESPACE::BindSparseInfo;
+ using VULKAN_HPP_NAMESPACE::BufferCopy;
+ using VULKAN_HPP_NAMESPACE::BufferCreateInfo;
+ using VULKAN_HPP_NAMESPACE::BufferImageCopy;
+ using VULKAN_HPP_NAMESPACE::BufferMemoryBarrier;
+ using VULKAN_HPP_NAMESPACE::BufferViewCreateInfo;
+ using VULKAN_HPP_NAMESPACE::ClearAttachment;
+ using VULKAN_HPP_NAMESPACE::ClearColorValue;
+ using VULKAN_HPP_NAMESPACE::ClearDepthStencilValue;
+ using VULKAN_HPP_NAMESPACE::ClearRect;
+ using VULKAN_HPP_NAMESPACE::ClearValue;
+ using VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo;
+ using VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo;
+ using VULKAN_HPP_NAMESPACE::CommandBufferInheritanceInfo;
+ using VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo;
+ using VULKAN_HPP_NAMESPACE::ComponentMapping;
+ using VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo;
+ using VULKAN_HPP_NAMESPACE::CopyDescriptorSet;
+ using VULKAN_HPP_NAMESPACE::DescriptorBufferInfo;
+ using VULKAN_HPP_NAMESPACE::DescriptorImageInfo;
+ using VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo;
+ using VULKAN_HPP_NAMESPACE::DescriptorPoolSize;
+ using VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo;
+ using VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBinding;
+ using VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo;
+ using VULKAN_HPP_NAMESPACE::DeviceCreateInfo;
+ using VULKAN_HPP_NAMESPACE::DeviceQueueCreateInfo;
+ using VULKAN_HPP_NAMESPACE::DispatchIndirectCommand;
+ using VULKAN_HPP_NAMESPACE::DrawIndexedIndirectCommand;
+ using VULKAN_HPP_NAMESPACE::DrawIndirectCommand;
+ using VULKAN_HPP_NAMESPACE::EventCreateInfo;
+ using VULKAN_HPP_NAMESPACE::ExtensionProperties;
+ using VULKAN_HPP_NAMESPACE::Extent2D;
+ using VULKAN_HPP_NAMESPACE::Extent3D;
+ using VULKAN_HPP_NAMESPACE::FenceCreateInfo;
+ using VULKAN_HPP_NAMESPACE::FormatProperties;
+ using VULKAN_HPP_NAMESPACE::FramebufferCreateInfo;
+ using VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo;
+ using VULKAN_HPP_NAMESPACE::ImageBlit;
+ using VULKAN_HPP_NAMESPACE::ImageCopy;
+ using VULKAN_HPP_NAMESPACE::ImageCreateInfo;
+ using VULKAN_HPP_NAMESPACE::ImageFormatProperties;
+ using VULKAN_HPP_NAMESPACE::ImageMemoryBarrier;
+ using VULKAN_HPP_NAMESPACE::ImageResolve;
+ using VULKAN_HPP_NAMESPACE::ImageSubresource;
+ using VULKAN_HPP_NAMESPACE::ImageSubresourceLayers;
+ using VULKAN_HPP_NAMESPACE::ImageSubresourceRange;
+ using VULKAN_HPP_NAMESPACE::ImageViewCreateInfo;
+ using VULKAN_HPP_NAMESPACE::InstanceCreateInfo;
+ using VULKAN_HPP_NAMESPACE::LayerProperties;
+ using VULKAN_HPP_NAMESPACE::MappedMemoryRange;
+ using VULKAN_HPP_NAMESPACE::MemoryAllocateInfo;
+ using VULKAN_HPP_NAMESPACE::MemoryBarrier;
+ using VULKAN_HPP_NAMESPACE::MemoryHeap;
+ using VULKAN_HPP_NAMESPACE::MemoryRequirements;
+ using VULKAN_HPP_NAMESPACE::MemoryType;
+ using VULKAN_HPP_NAMESPACE::Offset2D;
+ using VULKAN_HPP_NAMESPACE::Offset3D;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceLimits;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseProperties;
+ using VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo;
+ using VULKAN_HPP_NAMESPACE::PipelineCacheHeaderVersionOne;
+ using VULKAN_HPP_NAMESPACE::PipelineColorBlendAttachmentState;
+ using VULKAN_HPP_NAMESPACE::PipelineColorBlendStateCreateInfo;
+ using VULKAN_HPP_NAMESPACE::PipelineDepthStencilStateCreateInfo;
+ using VULKAN_HPP_NAMESPACE::PipelineDynamicStateCreateInfo;
+ using VULKAN_HPP_NAMESPACE::PipelineInputAssemblyStateCreateInfo;
+ using VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo;
+ using VULKAN_HPP_NAMESPACE::PipelineMultisampleStateCreateInfo;
+ using VULKAN_HPP_NAMESPACE::PipelineRasterizationStateCreateInfo;
+ using VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo;
+ using VULKAN_HPP_NAMESPACE::PipelineTessellationStateCreateInfo;
+ using VULKAN_HPP_NAMESPACE::PipelineVertexInputStateCreateInfo;
+ using VULKAN_HPP_NAMESPACE::PipelineViewportStateCreateInfo;
+ using VULKAN_HPP_NAMESPACE::PushConstantRange;
+ using VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo;
+ using VULKAN_HPP_NAMESPACE::QueueFamilyProperties;
+ using VULKAN_HPP_NAMESPACE::Rect2D;
+ using VULKAN_HPP_NAMESPACE::RenderPassBeginInfo;
+ using VULKAN_HPP_NAMESPACE::RenderPassCreateInfo;
+ using VULKAN_HPP_NAMESPACE::SamplerCreateInfo;
+ using VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo;
+ using VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo;
+ using VULKAN_HPP_NAMESPACE::SparseBufferMemoryBindInfo;
+ using VULKAN_HPP_NAMESPACE::SparseImageFormatProperties;
+ using VULKAN_HPP_NAMESPACE::SparseImageMemoryBind;
+ using VULKAN_HPP_NAMESPACE::SparseImageMemoryBindInfo;
+ using VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements;
+ using VULKAN_HPP_NAMESPACE::SparseImageOpaqueMemoryBindInfo;
+ using VULKAN_HPP_NAMESPACE::SparseMemoryBind;
+ using VULKAN_HPP_NAMESPACE::SpecializationInfo;
+ using VULKAN_HPP_NAMESPACE::SpecializationMapEntry;
+ using VULKAN_HPP_NAMESPACE::StencilOpState;
+ using VULKAN_HPP_NAMESPACE::SubmitInfo;
+ using VULKAN_HPP_NAMESPACE::SubpassDependency;
+ using VULKAN_HPP_NAMESPACE::SubpassDescription;
+ using VULKAN_HPP_NAMESPACE::SubresourceLayout;
+ using VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription;
+ using VULKAN_HPP_NAMESPACE::VertexInputBindingDescription;
+ using VULKAN_HPP_NAMESPACE::Viewport;
+ using VULKAN_HPP_NAMESPACE::WriteDescriptorSet;
+
+ //=== VK_VERSION_1_1 ===
+ using VULKAN_HPP_NAMESPACE::BindBufferMemoryDeviceGroupInfo;
+ using VULKAN_HPP_NAMESPACE::BindBufferMemoryDeviceGroupInfoKHR;
+ using VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo;
+ using VULKAN_HPP_NAMESPACE::BindBufferMemoryInfoKHR;
+ using VULKAN_HPP_NAMESPACE::BindImageMemoryDeviceGroupInfo;
+ using VULKAN_HPP_NAMESPACE::BindImageMemoryDeviceGroupInfoKHR;
+ using VULKAN_HPP_NAMESPACE::BindImageMemoryInfo;
+ using VULKAN_HPP_NAMESPACE::BindImageMemoryInfoKHR;
+ using VULKAN_HPP_NAMESPACE::BindImagePlaneMemoryInfo;
+ using VULKAN_HPP_NAMESPACE::BindImagePlaneMemoryInfoKHR;
+ using VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2;
+ using VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2KHR;
+ using VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport;
+ using VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupportKHR;
+ using VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo;
+ using VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfoKHR;
+ using VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateEntry;
+ using VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateEntryKHR;
+ using VULKAN_HPP_NAMESPACE::DeviceGroupBindSparseInfo;
+ using VULKAN_HPP_NAMESPACE::DeviceGroupBindSparseInfoKHR;
+ using VULKAN_HPP_NAMESPACE::DeviceGroupCommandBufferBeginInfo;
+ using VULKAN_HPP_NAMESPACE::DeviceGroupCommandBufferBeginInfoKHR;
+ using VULKAN_HPP_NAMESPACE::DeviceGroupDeviceCreateInfo;
+ using VULKAN_HPP_NAMESPACE::DeviceGroupDeviceCreateInfoKHR;
+ using VULKAN_HPP_NAMESPACE::DeviceGroupRenderPassBeginInfo;
+ using VULKAN_HPP_NAMESPACE::DeviceGroupRenderPassBeginInfoKHR;
+ using VULKAN_HPP_NAMESPACE::DeviceGroupSubmitInfo;
+ using VULKAN_HPP_NAMESPACE::DeviceGroupSubmitInfoKHR;
+ using VULKAN_HPP_NAMESPACE::DeviceQueueInfo2;
+ using VULKAN_HPP_NAMESPACE::ExportFenceCreateInfo;
+ using VULKAN_HPP_NAMESPACE::ExportFenceCreateInfoKHR;
+ using VULKAN_HPP_NAMESPACE::ExportMemoryAllocateInfo;
+ using VULKAN_HPP_NAMESPACE::ExportMemoryAllocateInfoKHR;
+ using VULKAN_HPP_NAMESPACE::ExportSemaphoreCreateInfo;
+ using VULKAN_HPP_NAMESPACE::ExportSemaphoreCreateInfoKHR;
+ using VULKAN_HPP_NAMESPACE::ExternalBufferProperties;
+ using VULKAN_HPP_NAMESPACE::ExternalBufferPropertiesKHR;
+ using VULKAN_HPP_NAMESPACE::ExternalFenceProperties;
+ using VULKAN_HPP_NAMESPACE::ExternalFencePropertiesKHR;
+ using VULKAN_HPP_NAMESPACE::ExternalImageFormatProperties;
+ using VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesKHR;
+ using VULKAN_HPP_NAMESPACE::ExternalMemoryBufferCreateInfo;
+ using VULKAN_HPP_NAMESPACE::ExternalMemoryBufferCreateInfoKHR;
+ using VULKAN_HPP_NAMESPACE::ExternalMemoryImageCreateInfo;
+ using VULKAN_HPP_NAMESPACE::ExternalMemoryImageCreateInfoKHR;
+ using VULKAN_HPP_NAMESPACE::ExternalMemoryProperties;
+ using VULKAN_HPP_NAMESPACE::ExternalMemoryPropertiesKHR;
+ using VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties;
+ using VULKAN_HPP_NAMESPACE::ExternalSemaphorePropertiesKHR;
+ using VULKAN_HPP_NAMESPACE::FormatProperties2;
+ using VULKAN_HPP_NAMESPACE::FormatProperties2KHR;
+ using VULKAN_HPP_NAMESPACE::ImageFormatProperties2;
+ using VULKAN_HPP_NAMESPACE::ImageFormatProperties2KHR;
+ using VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2;
+ using VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2KHR;
+ using VULKAN_HPP_NAMESPACE::ImagePlaneMemoryRequirementsInfo;
+ using VULKAN_HPP_NAMESPACE::ImagePlaneMemoryRequirementsInfoKHR;
+ using VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2;
+ using VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2KHR;
+ using VULKAN_HPP_NAMESPACE::ImageViewUsageCreateInfo;
+ using VULKAN_HPP_NAMESPACE::ImageViewUsageCreateInfoKHR;
+ using VULKAN_HPP_NAMESPACE::InputAttachmentAspectReference;
+ using VULKAN_HPP_NAMESPACE::InputAttachmentAspectReferenceKHR;
+ using VULKAN_HPP_NAMESPACE::MemoryAllocateFlagsInfo;
+ using VULKAN_HPP_NAMESPACE::MemoryAllocateFlagsInfoKHR;
+ using VULKAN_HPP_NAMESPACE::MemoryDedicatedAllocateInfo;
+ using VULKAN_HPP_NAMESPACE::MemoryDedicatedAllocateInfoKHR;
+ using VULKAN_HPP_NAMESPACE::MemoryDedicatedRequirements;
+ using VULKAN_HPP_NAMESPACE::MemoryDedicatedRequirementsKHR;
+ using VULKAN_HPP_NAMESPACE::MemoryRequirements2;
+ using VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR;
+ using VULKAN_HPP_NAMESPACE::PhysicalDevice16BitStorageFeatures;
+ using VULKAN_HPP_NAMESPACE::PhysicalDevice16BitStorageFeaturesKHR;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfoKHR;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfoKHR;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalImageFormatInfo;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalImageFormatInfoKHR;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfoKHR;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2KHR;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupPropertiesKHR;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceIDProperties;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceIDPropertiesKHR;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2KHR;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance3Properties;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance3PropertiesKHR;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2KHR;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewFeatures;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewFeaturesKHR;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewProperties;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPropertiesKHR;
+ using VULKAN_HPP_NAMESPACE::PhysicalDevicePointClippingProperties;
+ using VULKAN_HPP_NAMESPACE::PhysicalDevicePointClippingPropertiesKHR;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2KHR;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceProtectedMemoryFeatures;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceProtectedMemoryProperties;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceSamplerYcbcrConversionFeatures;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceSamplerYcbcrConversionFeaturesKHR;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderDrawParameterFeatures;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderDrawParametersFeatures;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2KHR;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupProperties;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceVariablePointerFeatures;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceVariablePointerFeaturesKHR;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceVariablePointersFeatures;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceVariablePointersFeaturesKHR;
+ using VULKAN_HPP_NAMESPACE::PipelineTessellationDomainOriginStateCreateInfo;
+ using VULKAN_HPP_NAMESPACE::PipelineTessellationDomainOriginStateCreateInfoKHR;
+ using VULKAN_HPP_NAMESPACE::ProtectedSubmitInfo;
+ using VULKAN_HPP_NAMESPACE::QueueFamilyProperties2;
+ using VULKAN_HPP_NAMESPACE::QueueFamilyProperties2KHR;
+ using VULKAN_HPP_NAMESPACE::RenderPassInputAttachmentAspectCreateInfo;
+ using VULKAN_HPP_NAMESPACE::RenderPassInputAttachmentAspectCreateInfoKHR;
+ using VULKAN_HPP_NAMESPACE::RenderPassMultiviewCreateInfo;
+ using VULKAN_HPP_NAMESPACE::RenderPassMultiviewCreateInfoKHR;
+ using VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo;
+ using VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfoKHR;
+ using VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionImageFormatProperties;
+ using VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionImageFormatPropertiesKHR;
+ using VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionInfo;
+ using VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionInfoKHR;
+ using VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2;
+ using VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2KHR;
+ using VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2;
+ using VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2KHR;
+
+ //=== VK_VERSION_1_2 ===
+ using VULKAN_HPP_NAMESPACE::AttachmentDescription2;
+ using VULKAN_HPP_NAMESPACE::AttachmentDescription2KHR;
+ using VULKAN_HPP_NAMESPACE::AttachmentDescriptionStencilLayout;
+ using VULKAN_HPP_NAMESPACE::AttachmentDescriptionStencilLayoutKHR;
+ using VULKAN_HPP_NAMESPACE::AttachmentReference2;
+ using VULKAN_HPP_NAMESPACE::AttachmentReference2KHR;
+ using VULKAN_HPP_NAMESPACE::AttachmentReferenceStencilLayout;
+ using VULKAN_HPP_NAMESPACE::AttachmentReferenceStencilLayoutKHR;
+ using VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo;
+ using VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfoEXT;
+ using VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfoKHR;
+ using VULKAN_HPP_NAMESPACE::BufferOpaqueCaptureAddressCreateInfo;
+ using VULKAN_HPP_NAMESPACE::BufferOpaqueCaptureAddressCreateInfoKHR;
+ using VULKAN_HPP_NAMESPACE::ConformanceVersion;
+ using VULKAN_HPP_NAMESPACE::ConformanceVersionKHR;
+ using VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBindingFlagsCreateInfo;
+ using VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBindingFlagsCreateInfoEXT;
+ using VULKAN_HPP_NAMESPACE::DescriptorSetVariableDescriptorCountAllocateInfo;
+ using VULKAN_HPP_NAMESPACE::DescriptorSetVariableDescriptorCountAllocateInfoEXT;
+ using VULKAN_HPP_NAMESPACE::DescriptorSetVariableDescriptorCountLayoutSupport;
+ using VULKAN_HPP_NAMESPACE::DescriptorSetVariableDescriptorCountLayoutSupportEXT;
+ using VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo;
+ using VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfoKHR;
+ using VULKAN_HPP_NAMESPACE::FramebufferAttachmentImageInfo;
+ using VULKAN_HPP_NAMESPACE::FramebufferAttachmentImageInfoKHR;
+ using VULKAN_HPP_NAMESPACE::FramebufferAttachmentsCreateInfo;
+ using VULKAN_HPP_NAMESPACE::FramebufferAttachmentsCreateInfoKHR;
+ using VULKAN_HPP_NAMESPACE::ImageFormatListCreateInfo;
+ using VULKAN_HPP_NAMESPACE::ImageFormatListCreateInfoKHR;
+ using VULKAN_HPP_NAMESPACE::ImageStencilUsageCreateInfo;
+ using VULKAN_HPP_NAMESPACE::ImageStencilUsageCreateInfoEXT;
+ using VULKAN_HPP_NAMESPACE::MemoryOpaqueCaptureAddressAllocateInfo;
+ using VULKAN_HPP_NAMESPACE::MemoryOpaqueCaptureAddressAllocateInfoKHR;
+ using VULKAN_HPP_NAMESPACE::PhysicalDevice8BitStorageFeatures;
+ using VULKAN_HPP_NAMESPACE::PhysicalDevice8BitStorageFeaturesKHR;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceBufferDeviceAddressFeatures;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceBufferDeviceAddressFeaturesKHR;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthStencilResolveProperties;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthStencilResolvePropertiesKHR;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorIndexingFeatures;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorIndexingFeaturesEXT;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorIndexingProperties;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorIndexingPropertiesEXT;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceDriverProperties;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceDriverPropertiesKHR;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceFloat16Int8FeaturesKHR;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceFloatControlsProperties;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceFloatControlsPropertiesKHR;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceHostQueryResetFeatures;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceHostQueryResetFeaturesEXT;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceImagelessFramebufferFeatures;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceImagelessFramebufferFeaturesKHR;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceSamplerFilterMinmaxProperties;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceSamplerFilterMinmaxPropertiesEXT;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceScalarBlockLayoutFeatures;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceScalarBlockLayoutFeaturesEXT;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceSeparateDepthStencilLayoutsFeatures;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicInt64Features;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicInt64FeaturesKHR;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFloat16Int8Features;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFloat16Int8FeaturesKHR;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupExtendedTypesFeatures;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceTimelineSemaphoreFeatures;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceTimelineSemaphoreFeaturesKHR;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceTimelineSemaphoreProperties;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceTimelineSemaphorePropertiesKHR;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceUniformBufferStandardLayoutFeatures;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan11Features;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan11Properties;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan12Features;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan12Properties;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkanMemoryModelFeatures;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkanMemoryModelFeaturesKHR;
+ using VULKAN_HPP_NAMESPACE::RenderPassAttachmentBeginInfo;
+ using VULKAN_HPP_NAMESPACE::RenderPassAttachmentBeginInfoKHR;
+ using VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2;
+ using VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2KHR;
+ using VULKAN_HPP_NAMESPACE::SamplerReductionModeCreateInfo;
+ using VULKAN_HPP_NAMESPACE::SamplerReductionModeCreateInfoEXT;
+ using VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo;
+ using VULKAN_HPP_NAMESPACE::SemaphoreSignalInfoKHR;
+ using VULKAN_HPP_NAMESPACE::SemaphoreTypeCreateInfo;
+ using VULKAN_HPP_NAMESPACE::SemaphoreTypeCreateInfoKHR;
+ using VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo;
+ using VULKAN_HPP_NAMESPACE::SemaphoreWaitInfoKHR;
+ using VULKAN_HPP_NAMESPACE::SubpassBeginInfo;
+ using VULKAN_HPP_NAMESPACE::SubpassBeginInfoKHR;
+ using VULKAN_HPP_NAMESPACE::SubpassDependency2;
+ using VULKAN_HPP_NAMESPACE::SubpassDependency2KHR;
+ using VULKAN_HPP_NAMESPACE::SubpassDescription2;
+ using VULKAN_HPP_NAMESPACE::SubpassDescription2KHR;
+ using VULKAN_HPP_NAMESPACE::SubpassDescriptionDepthStencilResolve;
+ using VULKAN_HPP_NAMESPACE::SubpassDescriptionDepthStencilResolveKHR;
+ using VULKAN_HPP_NAMESPACE::SubpassEndInfo;
+ using VULKAN_HPP_NAMESPACE::SubpassEndInfoKHR;
+ using VULKAN_HPP_NAMESPACE::TimelineSemaphoreSubmitInfo;
+ using VULKAN_HPP_NAMESPACE::TimelineSemaphoreSubmitInfoKHR;
+
+ //=== VK_VERSION_1_3 ===
+ using VULKAN_HPP_NAMESPACE::BlitImageInfo2;
+ using VULKAN_HPP_NAMESPACE::BlitImageInfo2KHR;
+ using VULKAN_HPP_NAMESPACE::BufferCopy2;
+ using VULKAN_HPP_NAMESPACE::BufferCopy2KHR;
+ using VULKAN_HPP_NAMESPACE::BufferImageCopy2;
+ using VULKAN_HPP_NAMESPACE::BufferImageCopy2KHR;
+ using VULKAN_HPP_NAMESPACE::BufferMemoryBarrier2;
+ using VULKAN_HPP_NAMESPACE::BufferMemoryBarrier2KHR;
+ using VULKAN_HPP_NAMESPACE::CommandBufferInheritanceRenderingInfo;
+ using VULKAN_HPP_NAMESPACE::CommandBufferInheritanceRenderingInfoKHR;
+ using VULKAN_HPP_NAMESPACE::CommandBufferSubmitInfo;
+ using VULKAN_HPP_NAMESPACE::CommandBufferSubmitInfoKHR;
+ using VULKAN_HPP_NAMESPACE::CopyBufferInfo2;
+ using VULKAN_HPP_NAMESPACE::CopyBufferInfo2KHR;
+ using VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2;
+ using VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2KHR;
+ using VULKAN_HPP_NAMESPACE::CopyImageInfo2;
+ using VULKAN_HPP_NAMESPACE::CopyImageInfo2KHR;
+ using VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2;
+ using VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2KHR;
+ using VULKAN_HPP_NAMESPACE::DependencyInfo;
+ using VULKAN_HPP_NAMESPACE::DependencyInfoKHR;
+ using VULKAN_HPP_NAMESPACE::DescriptorPoolInlineUniformBlockCreateInfo;
+ using VULKAN_HPP_NAMESPACE::DescriptorPoolInlineUniformBlockCreateInfoEXT;
+ using VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements;
+ using VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirementsKHR;
+ using VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements;
+ using VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirementsKHR;
+ using VULKAN_HPP_NAMESPACE::DevicePrivateDataCreateInfo;
+ using VULKAN_HPP_NAMESPACE::DevicePrivateDataCreateInfoEXT;
+ using VULKAN_HPP_NAMESPACE::FormatProperties3;
+ using VULKAN_HPP_NAMESPACE::FormatProperties3KHR;
+ using VULKAN_HPP_NAMESPACE::ImageBlit2;
+ using VULKAN_HPP_NAMESPACE::ImageBlit2KHR;
+ using VULKAN_HPP_NAMESPACE::ImageCopy2;
+ using VULKAN_HPP_NAMESPACE::ImageCopy2KHR;
+ using VULKAN_HPP_NAMESPACE::ImageMemoryBarrier2;
+ using VULKAN_HPP_NAMESPACE::ImageMemoryBarrier2KHR;
+ using VULKAN_HPP_NAMESPACE::ImageResolve2;
+ using VULKAN_HPP_NAMESPACE::ImageResolve2KHR;
+ using VULKAN_HPP_NAMESPACE::MemoryBarrier2;
+ using VULKAN_HPP_NAMESPACE::MemoryBarrier2KHR;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingFeatures;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingFeaturesKHR;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceImageRobustnessFeatures;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceImageRobustnessFeaturesEXT;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceInlineUniformBlockFeatures;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceInlineUniformBlockFeaturesEXT;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceInlineUniformBlockProperties;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceInlineUniformBlockPropertiesEXT;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance4Features;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance4FeaturesKHR;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance4Properties;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance4PropertiesKHR;
+ using VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineCreationCacheControlFeatures;
+ using VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineCreationCacheControlFeaturesEXT;
+ using VULKAN_HPP_NAMESPACE::PhysicalDevicePrivateDataFeatures;
+ using VULKAN_HPP_NAMESPACE::PhysicalDevicePrivateDataFeaturesEXT;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderDemoteToHelperInvocationFeatures;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerDotProductFeatures;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerDotProductFeaturesKHR;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerDotProductProperties;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerDotProductPropertiesKHR;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderTerminateInvocationFeatures;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderTerminateInvocationFeaturesKHR;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupSizeControlFeatures;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupSizeControlFeaturesEXT;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupSizeControlProperties;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupSizeControlPropertiesEXT;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceSynchronization2Features;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceSynchronization2FeaturesKHR;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceTexelBufferAlignmentProperties;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceTexelBufferAlignmentPropertiesEXT;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceTextureCompressionASTCHDRFeatures;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceToolPropertiesEXT;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan13Features;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan13Properties;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR;
+ using VULKAN_HPP_NAMESPACE::PipelineCreationFeedback;
+ using VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackCreateInfo;
+ using VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackCreateInfoEXT;
+ using VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackEXT;
+ using VULKAN_HPP_NAMESPACE::PipelineRenderingCreateInfo;
+ using VULKAN_HPP_NAMESPACE::PipelineRenderingCreateInfoKHR;
+ using VULKAN_HPP_NAMESPACE::PipelineShaderStageRequiredSubgroupSizeCreateInfo;
+ using VULKAN_HPP_NAMESPACE::PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT;
+ using VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo;
+ using VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfoEXT;
+ using VULKAN_HPP_NAMESPACE::RenderingAttachmentInfo;
+ using VULKAN_HPP_NAMESPACE::RenderingAttachmentInfoKHR;
+ using VULKAN_HPP_NAMESPACE::RenderingInfo;
+ using VULKAN_HPP_NAMESPACE::RenderingInfoKHR;
+ using VULKAN_HPP_NAMESPACE::ResolveImageInfo2;
+ using VULKAN_HPP_NAMESPACE::ResolveImageInfo2KHR;
+ using VULKAN_HPP_NAMESPACE::SemaphoreSubmitInfo;
+ using VULKAN_HPP_NAMESPACE::SemaphoreSubmitInfoKHR;
+ using VULKAN_HPP_NAMESPACE::ShaderRequiredSubgroupSizeCreateInfoEXT;
+ using VULKAN_HPP_NAMESPACE::SubmitInfo2;
+ using VULKAN_HPP_NAMESPACE::SubmitInfo2KHR;
+ using VULKAN_HPP_NAMESPACE::WriteDescriptorSetInlineUniformBlock;
+ using VULKAN_HPP_NAMESPACE::WriteDescriptorSetInlineUniformBlockEXT;
+
+ //=== VK_KHR_surface ===
+ using VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR;
+ using VULKAN_HPP_NAMESPACE::SurfaceFormatKHR;
+
+ //=== VK_KHR_swapchain ===
+ using VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR;
+ using VULKAN_HPP_NAMESPACE::BindImageMemorySwapchainInfoKHR;
+ using VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR;
+ using VULKAN_HPP_NAMESPACE::DeviceGroupPresentInfoKHR;
+ using VULKAN_HPP_NAMESPACE::DeviceGroupSwapchainCreateInfoKHR;
+ using VULKAN_HPP_NAMESPACE::ImageSwapchainCreateInfoKHR;
+ using VULKAN_HPP_NAMESPACE::PresentInfoKHR;
+ using VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR;
+
+ //=== VK_KHR_display ===
+ using VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR;
+ using VULKAN_HPP_NAMESPACE::DisplayModeParametersKHR;
+ using VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR;
+ using VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR;
+ using VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR;
+ using VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR;
+ using VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR;
+
+ //=== VK_KHR_display_swapchain ===
+ using VULKAN_HPP_NAMESPACE::DisplayPresentInfoKHR;
+
+#if defined( VK_USE_PLATFORM_XLIB_KHR )
+ //=== VK_KHR_xlib_surface ===
+ using VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR;
+#endif /*VK_USE_PLATFORM_XLIB_KHR*/
+
+#if defined( VK_USE_PLATFORM_XCB_KHR )
+ //=== VK_KHR_xcb_surface ===
+ using VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR;
+#endif /*VK_USE_PLATFORM_XCB_KHR*/
+
+#if defined( VK_USE_PLATFORM_WAYLAND_KHR )
+ //=== VK_KHR_wayland_surface ===
+ using VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR;
+#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
+
+#if defined( VK_USE_PLATFORM_ANDROID_KHR )
+ //=== VK_KHR_android_surface ===
+ using VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR;
+#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
+
+#if defined( VK_USE_PLATFORM_WIN32_KHR )
+ //=== VK_KHR_win32_surface ===
+ using VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR;
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+ //=== VK_EXT_debug_report ===
+ using VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT;
+
+ //=== VK_AMD_rasterization_order ===
+ using VULKAN_HPP_NAMESPACE::PipelineRasterizationStateRasterizationOrderAMD;
+
+ //=== VK_EXT_debug_marker ===
+ using VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT;
+ using VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT;
+ using VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT;
+
+ //=== VK_KHR_video_queue ===
+ using VULKAN_HPP_NAMESPACE::BindVideoSessionMemoryInfoKHR;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR;
+ using VULKAN_HPP_NAMESPACE::QueueFamilyQueryResultStatusPropertiesKHR;
+ using VULKAN_HPP_NAMESPACE::QueueFamilyVideoPropertiesKHR;
+ using VULKAN_HPP_NAMESPACE::VideoBeginCodingInfoKHR;
+ using VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR;
+ using VULKAN_HPP_NAMESPACE::VideoCodingControlInfoKHR;
+ using VULKAN_HPP_NAMESPACE::VideoEndCodingInfoKHR;
+ using VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR;
+ using VULKAN_HPP_NAMESPACE::VideoPictureResourceInfoKHR;
+ using VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR;
+ using VULKAN_HPP_NAMESPACE::VideoProfileListInfoKHR;
+ using VULKAN_HPP_NAMESPACE::VideoReferenceSlotInfoKHR;
+ using VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR;
+ using VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR;
+ using VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR;
+ using VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR;
+
+ //=== VK_KHR_video_decode_queue ===
+ using VULKAN_HPP_NAMESPACE::VideoDecodeCapabilitiesKHR;
+ using VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR;
+ using VULKAN_HPP_NAMESPACE::VideoDecodeUsageInfoKHR;
+
+ //=== VK_NV_dedicated_allocation ===
+ using VULKAN_HPP_NAMESPACE::DedicatedAllocationBufferCreateInfoNV;
+ using VULKAN_HPP_NAMESPACE::DedicatedAllocationImageCreateInfoNV;
+ using VULKAN_HPP_NAMESPACE::DedicatedAllocationMemoryAllocateInfoNV;
+
+ //=== VK_EXT_transform_feedback ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceTransformFeedbackFeaturesEXT;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceTransformFeedbackPropertiesEXT;
+ using VULKAN_HPP_NAMESPACE::PipelineRasterizationStateStreamCreateInfoEXT;
+
+ //=== VK_NVX_binary_import ===
+ using VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX;
+ using VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX;
+ using VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX;
+
+ //=== VK_NVX_image_view_handle ===
+ using VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX;
+ using VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX;
+
+#if defined( VK_ENABLE_BETA_EXTENSIONS )
+ //=== VK_EXT_video_encode_h264 ===
+ using VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilitiesEXT;
+ using VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoEXT;
+ using VULKAN_HPP_NAMESPACE::VideoEncodeH264FrameSizeEXT;
+ using VULKAN_HPP_NAMESPACE::VideoEncodeH264GopRemainingFrameInfoEXT;
+ using VULKAN_HPP_NAMESPACE::VideoEncodeH264NaluSliceInfoEXT;
+ using VULKAN_HPP_NAMESPACE::VideoEncodeH264PictureInfoEXT;
+ using VULKAN_HPP_NAMESPACE::VideoEncodeH264ProfileInfoEXT;
+ using VULKAN_HPP_NAMESPACE::VideoEncodeH264QpEXT;
+ using VULKAN_HPP_NAMESPACE::VideoEncodeH264QualityLevelPropertiesEXT;
+ using VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlInfoEXT;
+ using VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlLayerInfoEXT;
+ using VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionCreateInfoEXT;
+ using VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersAddInfoEXT;
+ using VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersCreateInfoEXT;
+ using VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersFeedbackInfoEXT;
+ using VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersGetInfoEXT;
+#endif /*VK_ENABLE_BETA_EXTENSIONS*/
+
+#if defined( VK_ENABLE_BETA_EXTENSIONS )
+ //=== VK_EXT_video_encode_h265 ===
+ using VULKAN_HPP_NAMESPACE::VideoEncodeH265CapabilitiesEXT;
+ using VULKAN_HPP_NAMESPACE::VideoEncodeH265DpbSlotInfoEXT;
+ using VULKAN_HPP_NAMESPACE::VideoEncodeH265FrameSizeEXT;
+ using VULKAN_HPP_NAMESPACE::VideoEncodeH265GopRemainingFrameInfoEXT;
+ using VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceSegmentInfoEXT;
+ using VULKAN_HPP_NAMESPACE::VideoEncodeH265PictureInfoEXT;
+ using VULKAN_HPP_NAMESPACE::VideoEncodeH265ProfileInfoEXT;
+ using VULKAN_HPP_NAMESPACE::VideoEncodeH265QpEXT;
+ using VULKAN_HPP_NAMESPACE::VideoEncodeH265QualityLevelPropertiesEXT;
+ using VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlInfoEXT;
+ using VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlLayerInfoEXT;
+ using VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionCreateInfoEXT;
+ using VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersAddInfoEXT;
+ using VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersCreateInfoEXT;
+ using VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersFeedbackInfoEXT;
+ using VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersGetInfoEXT;
+#endif /*VK_ENABLE_BETA_EXTENSIONS*/
+
+ //=== VK_KHR_video_decode_h264 ===
+ using VULKAN_HPP_NAMESPACE::VideoDecodeH264CapabilitiesKHR;
+ using VULKAN_HPP_NAMESPACE::VideoDecodeH264DpbSlotInfoKHR;
+ using VULKAN_HPP_NAMESPACE::VideoDecodeH264PictureInfoKHR;
+ using VULKAN_HPP_NAMESPACE::VideoDecodeH264ProfileInfoKHR;
+ using VULKAN_HPP_NAMESPACE::VideoDecodeH264SessionParametersAddInfoKHR;
+ using VULKAN_HPP_NAMESPACE::VideoDecodeH264SessionParametersCreateInfoKHR;
+
+ //=== VK_AMD_texture_gather_bias_lod ===
+ using VULKAN_HPP_NAMESPACE::TextureLODGatherFormatPropertiesAMD;
+
+ //=== VK_AMD_shader_info ===
+ using VULKAN_HPP_NAMESPACE::ShaderResourceUsageAMD;
+ using VULKAN_HPP_NAMESPACE::ShaderStatisticsInfoAMD;
+
+ //=== VK_KHR_dynamic_rendering ===
+ using VULKAN_HPP_NAMESPACE::AttachmentSampleCountInfoAMD;
+ using VULKAN_HPP_NAMESPACE::AttachmentSampleCountInfoNV;
+ using VULKAN_HPP_NAMESPACE::MultiviewPerViewAttributesInfoNVX;
+ using VULKAN_HPP_NAMESPACE::RenderingFragmentDensityMapAttachmentInfoEXT;
+ using VULKAN_HPP_NAMESPACE::RenderingFragmentShadingRateAttachmentInfoKHR;
+
+#if defined( VK_USE_PLATFORM_GGP )
+ //=== VK_GGP_stream_descriptor_surface ===
+ using VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP;
+#endif /*VK_USE_PLATFORM_GGP*/
+
+ //=== VK_NV_corner_sampled_image ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceCornerSampledImageFeaturesNV;
+
+ //=== VK_NV_external_memory_capabilities ===
+ using VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV;
+
+ //=== VK_NV_external_memory ===
+ using VULKAN_HPP_NAMESPACE::ExportMemoryAllocateInfoNV;
+ using VULKAN_HPP_NAMESPACE::ExternalMemoryImageCreateInfoNV;
+
+#if defined( VK_USE_PLATFORM_WIN32_KHR )
+ //=== VK_NV_external_memory_win32 ===
+ using VULKAN_HPP_NAMESPACE::ExportMemoryWin32HandleInfoNV;
+ using VULKAN_HPP_NAMESPACE::ImportMemoryWin32HandleInfoNV;
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+#if defined( VK_USE_PLATFORM_WIN32_KHR )
+ //=== VK_NV_win32_keyed_mutex ===
+ using VULKAN_HPP_NAMESPACE::Win32KeyedMutexAcquireReleaseInfoNV;
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+ //=== VK_EXT_validation_flags ===
+ using VULKAN_HPP_NAMESPACE::ValidationFlagsEXT;
+
+#if defined( VK_USE_PLATFORM_VI_NN )
+ //=== VK_NN_vi_surface ===
+ using VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN;
+#endif /*VK_USE_PLATFORM_VI_NN*/
+
+ //=== VK_EXT_astc_decode_mode ===
+ using VULKAN_HPP_NAMESPACE::ImageViewASTCDecodeModeEXT;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceASTCDecodeFeaturesEXT;
+
+ //=== VK_EXT_pipeline_robustness ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineRobustnessFeaturesEXT;
+ using VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineRobustnessPropertiesEXT;
+ using VULKAN_HPP_NAMESPACE::PipelineRobustnessCreateInfoEXT;
+
+#if defined( VK_USE_PLATFORM_WIN32_KHR )
+ //=== VK_KHR_external_memory_win32 ===
+ using VULKAN_HPP_NAMESPACE::ExportMemoryWin32HandleInfoKHR;
+ using VULKAN_HPP_NAMESPACE::ImportMemoryWin32HandleInfoKHR;
+ using VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR;
+ using VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR;
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+ //=== VK_KHR_external_memory_fd ===
+ using VULKAN_HPP_NAMESPACE::ImportMemoryFdInfoKHR;
+ using VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR;
+ using VULKAN_HPP_NAMESPACE::MemoryGetFdInfoKHR;
+
+#if defined( VK_USE_PLATFORM_WIN32_KHR )
+ //=== VK_KHR_win32_keyed_mutex ===
+ using VULKAN_HPP_NAMESPACE::Win32KeyedMutexAcquireReleaseInfoKHR;
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+#if defined( VK_USE_PLATFORM_WIN32_KHR )
+ //=== VK_KHR_external_semaphore_win32 ===
+ using VULKAN_HPP_NAMESPACE::D3D12FenceSubmitInfoKHR;
+ using VULKAN_HPP_NAMESPACE::ExportSemaphoreWin32HandleInfoKHR;
+ using VULKAN_HPP_NAMESPACE::ImportSemaphoreWin32HandleInfoKHR;
+ using VULKAN_HPP_NAMESPACE::SemaphoreGetWin32HandleInfoKHR;
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+ //=== VK_KHR_external_semaphore_fd ===
+ using VULKAN_HPP_NAMESPACE::ImportSemaphoreFdInfoKHR;
+ using VULKAN_HPP_NAMESPACE::SemaphoreGetFdInfoKHR;
+
+ //=== VK_KHR_push_descriptor ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDevicePushDescriptorPropertiesKHR;
+
+ //=== VK_EXT_conditional_rendering ===
+ using VULKAN_HPP_NAMESPACE::CommandBufferInheritanceConditionalRenderingInfoEXT;
+ using VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfoEXT;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceConditionalRenderingFeaturesEXT;
+
+ //=== VK_KHR_incremental_present ===
+ using VULKAN_HPP_NAMESPACE::PresentRegionKHR;
+ using VULKAN_HPP_NAMESPACE::PresentRegionsKHR;
+ using VULKAN_HPP_NAMESPACE::RectLayerKHR;
+
+ //=== VK_NV_clip_space_w_scaling ===
+ using VULKAN_HPP_NAMESPACE::PipelineViewportWScalingStateCreateInfoNV;
+ using VULKAN_HPP_NAMESPACE::ViewportWScalingNV;
+
+ //=== VK_EXT_display_surface_counter ===
+ using VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT;
+
+ //=== VK_EXT_display_control ===
+ using VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT;
+ using VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT;
+ using VULKAN_HPP_NAMESPACE::DisplayPowerInfoEXT;
+ using VULKAN_HPP_NAMESPACE::SwapchainCounterCreateInfoEXT;
+
+ //=== VK_GOOGLE_display_timing ===
+ using VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE;
+ using VULKAN_HPP_NAMESPACE::PresentTimeGOOGLE;
+ using VULKAN_HPP_NAMESPACE::PresentTimesInfoGOOGLE;
+ using VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE;
+
+ //=== VK_NVX_multiview_per_view_attributes ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX;
+
+ //=== VK_NV_viewport_swizzle ===
+ using VULKAN_HPP_NAMESPACE::PipelineViewportSwizzleStateCreateInfoNV;
+ using VULKAN_HPP_NAMESPACE::ViewportSwizzleNV;
+
+ //=== VK_EXT_discard_rectangles ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceDiscardRectanglePropertiesEXT;
+ using VULKAN_HPP_NAMESPACE::PipelineDiscardRectangleStateCreateInfoEXT;
+
+ //=== VK_EXT_conservative_rasterization ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceConservativeRasterizationPropertiesEXT;
+ using VULKAN_HPP_NAMESPACE::PipelineRasterizationConservativeStateCreateInfoEXT;
+
+ //=== VK_EXT_depth_clip_enable ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClipEnableFeaturesEXT;
+ using VULKAN_HPP_NAMESPACE::PipelineRasterizationDepthClipStateCreateInfoEXT;
+
+ //=== VK_EXT_hdr_metadata ===
+ using VULKAN_HPP_NAMESPACE::HdrMetadataEXT;
+ using VULKAN_HPP_NAMESPACE::XYColorEXT;
+
+ //=== VK_KHR_shared_presentable_image ===
+ using VULKAN_HPP_NAMESPACE::SharedPresentSurfaceCapabilitiesKHR;
+
+#if defined( VK_USE_PLATFORM_WIN32_KHR )
+ //=== VK_KHR_external_fence_win32 ===
+ using VULKAN_HPP_NAMESPACE::ExportFenceWin32HandleInfoKHR;
+ using VULKAN_HPP_NAMESPACE::FenceGetWin32HandleInfoKHR;
+ using VULKAN_HPP_NAMESPACE::ImportFenceWin32HandleInfoKHR;
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+ //=== VK_KHR_external_fence_fd ===
+ using VULKAN_HPP_NAMESPACE::FenceGetFdInfoKHR;
+ using VULKAN_HPP_NAMESPACE::ImportFenceFdInfoKHR;
+
+ //=== VK_KHR_performance_query ===
+ using VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR;
+ using VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR;
+ using VULKAN_HPP_NAMESPACE::PerformanceCounterKHR;
+ using VULKAN_HPP_NAMESPACE::PerformanceCounterResultKHR;
+ using VULKAN_HPP_NAMESPACE::PerformanceQuerySubmitInfoKHR;
+ using VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceQueryFeaturesKHR;
+ using VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceQueryPropertiesKHR;
+ using VULKAN_HPP_NAMESPACE::QueryPoolPerformanceCreateInfoKHR;
+
+ //=== VK_KHR_get_surface_capabilities2 ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR;
+ using VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR;
+ using VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR;
+
+ //=== VK_KHR_get_display_properties2 ===
+ using VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR;
+ using VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR;
+ using VULKAN_HPP_NAMESPACE::DisplayPlaneInfo2KHR;
+ using VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR;
+ using VULKAN_HPP_NAMESPACE::DisplayProperties2KHR;
+
+#if defined( VK_USE_PLATFORM_IOS_MVK )
+ //=== VK_MVK_ios_surface ===
+ using VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK;
+#endif /*VK_USE_PLATFORM_IOS_MVK*/
+
+#if defined( VK_USE_PLATFORM_MACOS_MVK )
+ //=== VK_MVK_macos_surface ===
+ using VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK;
+#endif /*VK_USE_PLATFORM_MACOS_MVK*/
+
+ //=== VK_EXT_debug_utils ===
+ using VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT;
+ using VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataEXT;
+ using VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT;
+ using VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT;
+ using VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT;
+
+#if defined( VK_USE_PLATFORM_ANDROID_KHR )
+ //=== VK_ANDROID_external_memory_android_hardware_buffer ===
+ using VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatProperties2ANDROID;
+ using VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatPropertiesANDROID;
+ using VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID;
+ using VULKAN_HPP_NAMESPACE::AndroidHardwareBufferUsageANDROID;
+ using VULKAN_HPP_NAMESPACE::ExternalFormatANDROID;
+ using VULKAN_HPP_NAMESPACE::ImportAndroidHardwareBufferInfoANDROID;
+ using VULKAN_HPP_NAMESPACE::MemoryGetAndroidHardwareBufferInfoANDROID;
+#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
+
+#if defined( VK_ENABLE_BETA_EXTENSIONS )
+ //=== VK_AMDX_shader_enqueue ===
+ using VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstAMDX;
+ using VULKAN_HPP_NAMESPACE::DispatchGraphCountInfoAMDX;
+ using VULKAN_HPP_NAMESPACE::DispatchGraphInfoAMDX;
+ using VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX;
+ using VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineScratchSizeAMDX;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderEnqueueFeaturesAMDX;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderEnqueuePropertiesAMDX;
+ using VULKAN_HPP_NAMESPACE::PipelineShaderStageNodeCreateInfoAMDX;
+#endif /*VK_ENABLE_BETA_EXTENSIONS*/
+
+ //=== VK_EXT_sample_locations ===
+ using VULKAN_HPP_NAMESPACE::AttachmentSampleLocationsEXT;
+ using VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceSampleLocationsPropertiesEXT;
+ using VULKAN_HPP_NAMESPACE::PipelineSampleLocationsStateCreateInfoEXT;
+ using VULKAN_HPP_NAMESPACE::RenderPassSampleLocationsBeginInfoEXT;
+ using VULKAN_HPP_NAMESPACE::SampleLocationEXT;
+ using VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT;
+ using VULKAN_HPP_NAMESPACE::SubpassSampleLocationsEXT;
+
+ //=== VK_EXT_blend_operation_advanced ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceBlendOperationAdvancedFeaturesEXT;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceBlendOperationAdvancedPropertiesEXT;
+ using VULKAN_HPP_NAMESPACE::PipelineColorBlendAdvancedStateCreateInfoEXT;
+
+ //=== VK_NV_fragment_coverage_to_color ===
+ using VULKAN_HPP_NAMESPACE::PipelineCoverageToColorStateCreateInfoNV;
+
+ //=== VK_KHR_acceleration_structure ===
+ using VULKAN_HPP_NAMESPACE::AabbPositionsKHR;
+ using VULKAN_HPP_NAMESPACE::AabbPositionsNV;
+ using VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR;
+ using VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR;
+ using VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR;
+ using VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR;
+ using VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR;
+ using VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryAabbsDataKHR;
+ using VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryDataKHR;
+ using VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryInstancesDataKHR;
+ using VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryKHR;
+ using VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryTrianglesDataKHR;
+ using VULKAN_HPP_NAMESPACE::AccelerationStructureInstanceKHR;
+ using VULKAN_HPP_NAMESPACE::AccelerationStructureInstanceNV;
+ using VULKAN_HPP_NAMESPACE::AccelerationStructureVersionInfoKHR;
+ using VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR;
+ using VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR;
+ using VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR;
+ using VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstKHR;
+ using VULKAN_HPP_NAMESPACE::DeviceOrHostAddressKHR;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceAccelerationStructureFeaturesKHR;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceAccelerationStructurePropertiesKHR;
+ using VULKAN_HPP_NAMESPACE::TransformMatrixKHR;
+ using VULKAN_HPP_NAMESPACE::TransformMatrixNV;
+ using VULKAN_HPP_NAMESPACE::WriteDescriptorSetAccelerationStructureKHR;
+
+ //=== VK_KHR_ray_tracing_pipeline ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPipelineFeaturesKHR;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPipelinePropertiesKHR;
+ using VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR;
+ using VULKAN_HPP_NAMESPACE::RayTracingPipelineInterfaceCreateInfoKHR;
+ using VULKAN_HPP_NAMESPACE::RayTracingShaderGroupCreateInfoKHR;
+ using VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR;
+ using VULKAN_HPP_NAMESPACE::TraceRaysIndirectCommandKHR;
+
+ //=== VK_KHR_ray_query ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceRayQueryFeaturesKHR;
+
+ //=== VK_NV_framebuffer_mixed_samples ===
+ using VULKAN_HPP_NAMESPACE::PipelineCoverageModulationStateCreateInfoNV;
+
+ //=== VK_NV_shader_sm_builtins ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSMBuiltinsFeaturesNV;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSMBuiltinsPropertiesNV;
+
+ //=== VK_EXT_image_drm_format_modifier ===
+ using VULKAN_HPP_NAMESPACE::DrmFormatModifierProperties2EXT;
+ using VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesEXT;
+ using VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesList2EXT;
+ using VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesListEXT;
+ using VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierExplicitCreateInfoEXT;
+ using VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierListCreateInfoEXT;
+ using VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceImageDrmFormatModifierInfoEXT;
+
+ //=== VK_EXT_validation_cache ===
+ using VULKAN_HPP_NAMESPACE::ShaderModuleValidationCacheCreateInfoEXT;
+ using VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT;
+
+#if defined( VK_ENABLE_BETA_EXTENSIONS )
+ //=== VK_KHR_portability_subset ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDevicePortabilitySubsetFeaturesKHR;
+ using VULKAN_HPP_NAMESPACE::PhysicalDevicePortabilitySubsetPropertiesKHR;
+#endif /*VK_ENABLE_BETA_EXTENSIONS*/
+
+ //=== VK_NV_shading_rate_image ===
+ using VULKAN_HPP_NAMESPACE::CoarseSampleLocationNV;
+ using VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceShadingRateImageFeaturesNV;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceShadingRateImagePropertiesNV;
+ using VULKAN_HPP_NAMESPACE::PipelineViewportCoarseSampleOrderStateCreateInfoNV;
+ using VULKAN_HPP_NAMESPACE::PipelineViewportShadingRateImageStateCreateInfoNV;
+ using VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV;
+
+ //=== VK_NV_ray_tracing ===
+ using VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV;
+ using VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV;
+ using VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV;
+ using VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV;
+ using VULKAN_HPP_NAMESPACE::GeometryAABBNV;
+ using VULKAN_HPP_NAMESPACE::GeometryDataNV;
+ using VULKAN_HPP_NAMESPACE::GeometryNV;
+ using VULKAN_HPP_NAMESPACE::GeometryTrianglesNV;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPropertiesNV;
+ using VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV;
+ using VULKAN_HPP_NAMESPACE::RayTracingShaderGroupCreateInfoNV;
+ using VULKAN_HPP_NAMESPACE::WriteDescriptorSetAccelerationStructureNV;
+
+ //=== VK_NV_representative_fragment_test ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceRepresentativeFragmentTestFeaturesNV;
+ using VULKAN_HPP_NAMESPACE::PipelineRepresentativeFragmentTestStateCreateInfoNV;
+
+ //=== VK_EXT_filter_cubic ===
+ using VULKAN_HPP_NAMESPACE::FilterCubicImageViewImageFormatPropertiesEXT;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceImageViewImageFormatInfoEXT;
+
+ //=== VK_EXT_external_memory_host ===
+ using VULKAN_HPP_NAMESPACE::ImportMemoryHostPointerInfoEXT;
+ using VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryHostPropertiesEXT;
+
+ //=== VK_KHR_shader_clock ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderClockFeaturesKHR;
+
+ //=== VK_AMD_pipeline_compiler_control ===
+ using VULKAN_HPP_NAMESPACE::PipelineCompilerControlCreateInfoAMD;
+
+ //=== VK_EXT_calibrated_timestamps ===
+ using VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT;
+
+ //=== VK_AMD_shader_core_properties ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCorePropertiesAMD;
+
+ //=== VK_KHR_video_decode_h265 ===
+ using VULKAN_HPP_NAMESPACE::VideoDecodeH265CapabilitiesKHR;
+ using VULKAN_HPP_NAMESPACE::VideoDecodeH265DpbSlotInfoKHR;
+ using VULKAN_HPP_NAMESPACE::VideoDecodeH265PictureInfoKHR;
+ using VULKAN_HPP_NAMESPACE::VideoDecodeH265ProfileInfoKHR;
+ using VULKAN_HPP_NAMESPACE::VideoDecodeH265SessionParametersAddInfoKHR;
+ using VULKAN_HPP_NAMESPACE::VideoDecodeH265SessionParametersCreateInfoKHR;
+
+ //=== VK_KHR_global_priority ===
+ using VULKAN_HPP_NAMESPACE::DeviceQueueGlobalPriorityCreateInfoEXT;
+ using VULKAN_HPP_NAMESPACE::DeviceQueueGlobalPriorityCreateInfoKHR;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceGlobalPriorityQueryFeaturesEXT;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceGlobalPriorityQueryFeaturesKHR;
+ using VULKAN_HPP_NAMESPACE::QueueFamilyGlobalPriorityPropertiesEXT;
+ using VULKAN_HPP_NAMESPACE::QueueFamilyGlobalPriorityPropertiesKHR;
+
+ //=== VK_AMD_memory_overallocation_behavior ===
+ using VULKAN_HPP_NAMESPACE::DeviceMemoryOverallocationCreateInfoAMD;
+
+ //=== VK_EXT_vertex_attribute_divisor ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorFeaturesEXT;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorPropertiesEXT;
+ using VULKAN_HPP_NAMESPACE::PipelineVertexInputDivisorStateCreateInfoEXT;
+ using VULKAN_HPP_NAMESPACE::VertexInputBindingDivisorDescriptionEXT;
+
+#if defined( VK_USE_PLATFORM_GGP )
+ //=== VK_GGP_frame_token ===
+ using VULKAN_HPP_NAMESPACE::PresentFrameTokenGGP;
+#endif /*VK_USE_PLATFORM_GGP*/
+
+ //=== VK_NV_compute_shader_derivatives ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceComputeShaderDerivativesFeaturesNV;
+
+ //=== VK_NV_mesh_shader ===
+ using VULKAN_HPP_NAMESPACE::DrawMeshTasksIndirectCommandNV;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderFeaturesNV;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderPropertiesNV;
+
+ //=== VK_NV_shader_image_footprint ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderImageFootprintFeaturesNV;
+
+ //=== VK_NV_scissor_exclusive ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceExclusiveScissorFeaturesNV;
+ using VULKAN_HPP_NAMESPACE::PipelineViewportExclusiveScissorStateCreateInfoNV;
+
+ //=== VK_NV_device_diagnostic_checkpoints ===
+ using VULKAN_HPP_NAMESPACE::CheckpointDataNV;
+ using VULKAN_HPP_NAMESPACE::QueueFamilyCheckpointPropertiesNV;
+
+ //=== VK_INTEL_shader_integer_functions2 ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL;
+
+ //=== VK_INTEL_performance_query ===
+ using VULKAN_HPP_NAMESPACE::InitializePerformanceApiInfoINTEL;
+ using VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL;
+ using VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL;
+ using VULKAN_HPP_NAMESPACE::PerformanceOverrideInfoINTEL;
+ using VULKAN_HPP_NAMESPACE::PerformanceStreamMarkerInfoINTEL;
+ using VULKAN_HPP_NAMESPACE::PerformanceValueDataINTEL;
+ using VULKAN_HPP_NAMESPACE::PerformanceValueINTEL;
+ using VULKAN_HPP_NAMESPACE::QueryPoolCreateInfoINTEL;
+ using VULKAN_HPP_NAMESPACE::QueryPoolPerformanceQueryCreateInfoINTEL;
+
+ //=== VK_EXT_pci_bus_info ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDevicePCIBusInfoPropertiesEXT;
+
+ //=== VK_AMD_display_native_hdr ===
+ using VULKAN_HPP_NAMESPACE::DisplayNativeHdrSurfaceCapabilitiesAMD;
+ using VULKAN_HPP_NAMESPACE::SwapchainDisplayNativeHdrCreateInfoAMD;
+
+#if defined( VK_USE_PLATFORM_FUCHSIA )
+ //=== VK_FUCHSIA_imagepipe_surface ===
+ using VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA;
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
+
+#if defined( VK_USE_PLATFORM_METAL_EXT )
+ //=== VK_EXT_metal_surface ===
+ using VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT;
+#endif /*VK_USE_PLATFORM_METAL_EXT*/
+
+ //=== VK_EXT_fragment_density_map ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapFeaturesEXT;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapPropertiesEXT;
+ using VULKAN_HPP_NAMESPACE::RenderPassFragmentDensityMapCreateInfoEXT;
+
+ //=== VK_KHR_fragment_shading_rate ===
+ using VULKAN_HPP_NAMESPACE::FragmentShadingRateAttachmentInfoKHR;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateFeaturesKHR;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRatePropertiesKHR;
+ using VULKAN_HPP_NAMESPACE::PipelineFragmentShadingRateStateCreateInfoKHR;
+
+ //=== VK_AMD_shader_core_properties2 ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCoreProperties2AMD;
+
+ //=== VK_AMD_device_coherent_memory ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceCoherentMemoryFeaturesAMD;
+
+ //=== VK_EXT_shader_image_atomic_int64 ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderImageAtomicInt64FeaturesEXT;
+
+ //=== VK_EXT_memory_budget ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryBudgetPropertiesEXT;
+
+ //=== VK_EXT_memory_priority ===
+ using VULKAN_HPP_NAMESPACE::MemoryPriorityAllocateInfoEXT;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryPriorityFeaturesEXT;
+
+ //=== VK_KHR_surface_protected_capabilities ===
+ using VULKAN_HPP_NAMESPACE::SurfaceProtectedCapabilitiesKHR;
+
+ //=== VK_NV_dedicated_allocation_image_aliasing ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV;
+
+ //=== VK_EXT_buffer_device_address ===
+ using VULKAN_HPP_NAMESPACE::BufferDeviceAddressCreateInfoEXT;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceBufferAddressFeaturesEXT;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceBufferDeviceAddressFeaturesEXT;
+
+ //=== VK_EXT_validation_features ===
+ using VULKAN_HPP_NAMESPACE::ValidationFeaturesEXT;
+
+ //=== VK_KHR_present_wait ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDevicePresentWaitFeaturesKHR;
+
+ //=== VK_NV_cooperative_matrix ===
+ using VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixFeaturesNV;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixPropertiesNV;
+
+ //=== VK_NV_coverage_reduction_mode ===
+ using VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceCoverageReductionModeFeaturesNV;
+ using VULKAN_HPP_NAMESPACE::PipelineCoverageReductionStateCreateInfoNV;
+
+ //=== VK_EXT_fragment_shader_interlock ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderInterlockFeaturesEXT;
+
+ //=== VK_EXT_ycbcr_image_arrays ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcrImageArraysFeaturesEXT;
+
+ //=== VK_EXT_provoking_vertex ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceProvokingVertexFeaturesEXT;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceProvokingVertexPropertiesEXT;
+ using VULKAN_HPP_NAMESPACE::PipelineRasterizationProvokingVertexStateCreateInfoEXT;
+
+#if defined( VK_USE_PLATFORM_WIN32_KHR )
+ //=== VK_EXT_full_screen_exclusive ===
+ using VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesFullScreenExclusiveEXT;
+ using VULKAN_HPP_NAMESPACE::SurfaceFullScreenExclusiveInfoEXT;
+ using VULKAN_HPP_NAMESPACE::SurfaceFullScreenExclusiveWin32InfoEXT;
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+ //=== VK_EXT_headless_surface ===
+ using VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT;
+
+ //=== VK_EXT_line_rasterization ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationFeaturesEXT;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationPropertiesEXT;
+ using VULKAN_HPP_NAMESPACE::PipelineRasterizationLineStateCreateInfoEXT;
+
+ //=== VK_EXT_shader_atomic_float ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloatFeaturesEXT;
+
+ //=== VK_EXT_index_type_uint8 ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceIndexTypeUint8FeaturesEXT;
+
+ //=== VK_EXT_extended_dynamic_state ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicStateFeaturesEXT;
+
+ //=== VK_KHR_pipeline_executable_properties ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR;
+ using VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR;
+ using VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR;
+ using VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR;
+ using VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR;
+ using VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticValueKHR;
+ using VULKAN_HPP_NAMESPACE::PipelineInfoEXT;
+ using VULKAN_HPP_NAMESPACE::PipelineInfoKHR;
+
+ //=== VK_EXT_host_image_copy ===
+ using VULKAN_HPP_NAMESPACE::CopyImageToImageInfoEXT;
+ using VULKAN_HPP_NAMESPACE::CopyImageToMemoryInfoEXT;
+ using VULKAN_HPP_NAMESPACE::CopyMemoryToImageInfoEXT;
+ using VULKAN_HPP_NAMESPACE::HostImageCopyDevicePerformanceQueryEXT;
+ using VULKAN_HPP_NAMESPACE::HostImageLayoutTransitionInfoEXT;
+ using VULKAN_HPP_NAMESPACE::ImageToMemoryCopyEXT;
+ using VULKAN_HPP_NAMESPACE::MemoryToImageCopyEXT;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceHostImageCopyFeaturesEXT;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceHostImageCopyPropertiesEXT;
+ using VULKAN_HPP_NAMESPACE::SubresourceHostMemcpySizeEXT;
+
+ //=== VK_KHR_map_memory2 ===
+ using VULKAN_HPP_NAMESPACE::MemoryMapInfoKHR;
+ using VULKAN_HPP_NAMESPACE::MemoryUnmapInfoKHR;
+
+ //=== VK_EXT_shader_atomic_float2 ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloat2FeaturesEXT;
+
+ //=== VK_EXT_surface_maintenance1 ===
+ using VULKAN_HPP_NAMESPACE::SurfacePresentModeCompatibilityEXT;
+ using VULKAN_HPP_NAMESPACE::SurfacePresentModeEXT;
+ using VULKAN_HPP_NAMESPACE::SurfacePresentScalingCapabilitiesEXT;
+
+ //=== VK_EXT_swapchain_maintenance1 ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceSwapchainMaintenance1FeaturesEXT;
+ using VULKAN_HPP_NAMESPACE::ReleaseSwapchainImagesInfoEXT;
+ using VULKAN_HPP_NAMESPACE::SwapchainPresentFenceInfoEXT;
+ using VULKAN_HPP_NAMESPACE::SwapchainPresentModeInfoEXT;
+ using VULKAN_HPP_NAMESPACE::SwapchainPresentModesCreateInfoEXT;
+ using VULKAN_HPP_NAMESPACE::SwapchainPresentScalingCreateInfoEXT;
+
+ //=== VK_NV_device_generated_commands ===
+ using VULKAN_HPP_NAMESPACE::BindIndexBufferIndirectCommandNV;
+ using VULKAN_HPP_NAMESPACE::BindShaderGroupIndirectCommandNV;
+ using VULKAN_HPP_NAMESPACE::BindVertexBufferIndirectCommandNV;
+ using VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV;
+ using VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV;
+ using VULKAN_HPP_NAMESPACE::GraphicsPipelineShaderGroupsCreateInfoNV;
+ using VULKAN_HPP_NAMESPACE::GraphicsShaderGroupCreateInfoNV;
+ using VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV;
+ using VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutTokenNV;
+ using VULKAN_HPP_NAMESPACE::IndirectCommandsStreamNV;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsFeaturesNV;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsPropertiesNV;
+ using VULKAN_HPP_NAMESPACE::SetStateFlagsIndirectCommandNV;
+
+ //=== VK_NV_inherited_viewport_scissor ===
+ using VULKAN_HPP_NAMESPACE::CommandBufferInheritanceViewportScissorInfoNV;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceInheritedViewportScissorFeaturesNV;
+
+ //=== VK_EXT_texel_buffer_alignment ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceTexelBufferAlignmentFeaturesEXT;
+
+ //=== VK_QCOM_render_pass_transform ===
+ using VULKAN_HPP_NAMESPACE::CommandBufferInheritanceRenderPassTransformInfoQCOM;
+ using VULKAN_HPP_NAMESPACE::RenderPassTransformBeginInfoQCOM;
+
+ //=== VK_EXT_depth_bias_control ===
+ using VULKAN_HPP_NAMESPACE::DepthBiasInfoEXT;
+ using VULKAN_HPP_NAMESPACE::DepthBiasRepresentationInfoEXT;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthBiasControlFeaturesEXT;
+
+ //=== VK_EXT_device_memory_report ===
+ using VULKAN_HPP_NAMESPACE::DeviceDeviceMemoryReportCreateInfoEXT;
+ using VULKAN_HPP_NAMESPACE::DeviceMemoryReportCallbackDataEXT;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceMemoryReportFeaturesEXT;
+
+ //=== VK_EXT_robustness2 ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2FeaturesEXT;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2PropertiesEXT;
+
+ //=== VK_EXT_custom_border_color ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomBorderColorFeaturesEXT;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomBorderColorPropertiesEXT;
+ using VULKAN_HPP_NAMESPACE::SamplerCustomBorderColorCreateInfoEXT;
+
+ //=== VK_KHR_pipeline_library ===
+ using VULKAN_HPP_NAMESPACE::PipelineLibraryCreateInfoKHR;
+
+ //=== VK_NV_present_barrier ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDevicePresentBarrierFeaturesNV;
+ using VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesPresentBarrierNV;
+ using VULKAN_HPP_NAMESPACE::SwapchainPresentBarrierCreateInfoNV;
+
+ //=== VK_KHR_present_id ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDevicePresentIdFeaturesKHR;
+ using VULKAN_HPP_NAMESPACE::PresentIdKHR;
+
+#if defined( VK_ENABLE_BETA_EXTENSIONS )
+ //=== VK_KHR_video_encode_queue ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeQualityLevelInfoKHR;
+ using VULKAN_HPP_NAMESPACE::QueryPoolVideoEncodeFeedbackCreateInfoKHR;
+ using VULKAN_HPP_NAMESPACE::VideoEncodeCapabilitiesKHR;
+ using VULKAN_HPP_NAMESPACE::VideoEncodeInfoKHR;
+ using VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelInfoKHR;
+ using VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelPropertiesKHR;
+ using VULKAN_HPP_NAMESPACE::VideoEncodeRateControlInfoKHR;
+ using VULKAN_HPP_NAMESPACE::VideoEncodeRateControlLayerInfoKHR;
+ using VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersFeedbackInfoKHR;
+ using VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR;
+ using VULKAN_HPP_NAMESPACE::VideoEncodeUsageInfoKHR;
+#endif /*VK_ENABLE_BETA_EXTENSIONS*/
+
+ //=== VK_NV_device_diagnostics_config ===
+ using VULKAN_HPP_NAMESPACE::DeviceDiagnosticsConfigCreateInfoNV;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceDiagnosticsConfigFeaturesNV;
+
+ //=== VK_NV_low_latency ===
+ using VULKAN_HPP_NAMESPACE::QueryLowLatencySupportNV;
+
+#if defined( VK_USE_PLATFORM_METAL_EXT )
+ //=== VK_EXT_metal_objects ===
+ using VULKAN_HPP_NAMESPACE::ExportMetalBufferInfoEXT;
+ using VULKAN_HPP_NAMESPACE::ExportMetalCommandQueueInfoEXT;
+ using VULKAN_HPP_NAMESPACE::ExportMetalDeviceInfoEXT;
+ using VULKAN_HPP_NAMESPACE::ExportMetalIOSurfaceInfoEXT;
+ using VULKAN_HPP_NAMESPACE::ExportMetalObjectCreateInfoEXT;
+ using VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT;
+ using VULKAN_HPP_NAMESPACE::ExportMetalSharedEventInfoEXT;
+ using VULKAN_HPP_NAMESPACE::ExportMetalTextureInfoEXT;
+ using VULKAN_HPP_NAMESPACE::ImportMetalBufferInfoEXT;
+ using VULKAN_HPP_NAMESPACE::ImportMetalIOSurfaceInfoEXT;
+ using VULKAN_HPP_NAMESPACE::ImportMetalSharedEventInfoEXT;
+ using VULKAN_HPP_NAMESPACE::ImportMetalTextureInfoEXT;
+#endif /*VK_USE_PLATFORM_METAL_EXT*/
+
+ //=== VK_KHR_synchronization2 ===
+ using VULKAN_HPP_NAMESPACE::CheckpointData2NV;
+ using VULKAN_HPP_NAMESPACE::QueueFamilyCheckpointProperties2NV;
+
+ //=== VK_EXT_descriptor_buffer ===
+ using VULKAN_HPP_NAMESPACE::AccelerationStructureCaptureDescriptorDataInfoEXT;
+ using VULKAN_HPP_NAMESPACE::BufferCaptureDescriptorDataInfoEXT;
+ using VULKAN_HPP_NAMESPACE::DescriptorAddressInfoEXT;
+ using VULKAN_HPP_NAMESPACE::DescriptorBufferBindingInfoEXT;
+ using VULKAN_HPP_NAMESPACE::DescriptorBufferBindingPushDescriptorBufferHandleEXT;
+ using VULKAN_HPP_NAMESPACE::DescriptorDataEXT;
+ using VULKAN_HPP_NAMESPACE::DescriptorGetInfoEXT;
+ using VULKAN_HPP_NAMESPACE::ImageCaptureDescriptorDataInfoEXT;
+ using VULKAN_HPP_NAMESPACE::ImageViewCaptureDescriptorDataInfoEXT;
+ using VULKAN_HPP_NAMESPACE::OpaqueCaptureDescriptorDataCreateInfoEXT;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferFeaturesEXT;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferPropertiesEXT;
+ using VULKAN_HPP_NAMESPACE::SamplerCaptureDescriptorDataInfoEXT;
+
+ //=== VK_EXT_graphics_pipeline_library ===
+ using VULKAN_HPP_NAMESPACE::GraphicsPipelineLibraryCreateInfoEXT;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT;
+
+ //=== VK_AMD_shader_early_and_late_fragment_tests ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD;
+
+ //=== VK_KHR_fragment_shader_barycentric ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderBarycentricFeaturesKHR;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderBarycentricFeaturesNV;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderBarycentricPropertiesKHR;
+
+ //=== VK_KHR_shader_subgroup_uniform_control_flow ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR;
+
+ //=== VK_NV_fragment_shading_rate_enums ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateEnumsFeaturesNV;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateEnumsPropertiesNV;
+ using VULKAN_HPP_NAMESPACE::PipelineFragmentShadingRateEnumStateCreateInfoNV;
+
+ //=== VK_NV_ray_tracing_motion_blur ===
+ using VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryMotionTrianglesDataNV;
+ using VULKAN_HPP_NAMESPACE::AccelerationStructureMatrixMotionInstanceNV;
+ using VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInfoNV;
+ using VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInstanceDataNV;
+ using VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInstanceNV;
+ using VULKAN_HPP_NAMESPACE::AccelerationStructureSRTMotionInstanceNV;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingMotionBlurFeaturesNV;
+ using VULKAN_HPP_NAMESPACE::SRTDataNV;
+
+ //=== VK_EXT_mesh_shader ===
+ using VULKAN_HPP_NAMESPACE::DrawMeshTasksIndirectCommandEXT;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderFeaturesEXT;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderPropertiesEXT;
+
+ //=== VK_EXT_ycbcr_2plane_444_formats ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT;
+
+ //=== VK_EXT_fragment_density_map2 ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMap2FeaturesEXT;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMap2PropertiesEXT;
+
+ //=== VK_QCOM_rotated_copy_commands ===
+ using VULKAN_HPP_NAMESPACE::CopyCommandTransformInfoQCOM;
+
+ //=== VK_KHR_workgroup_memory_explicit_layout ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR;
+
+ //=== VK_EXT_image_compression_control ===
+ using VULKAN_HPP_NAMESPACE::ImageCompressionControlEXT;
+ using VULKAN_HPP_NAMESPACE::ImageCompressionPropertiesEXT;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceImageCompressionControlFeaturesEXT;
+
+ //=== VK_EXT_attachment_feedback_loop_layout ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT;
+
+ //=== VK_EXT_4444_formats ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDevice4444FormatsFeaturesEXT;
+
+ //=== VK_EXT_device_fault ===
+ using VULKAN_HPP_NAMESPACE::DeviceFaultAddressInfoEXT;
+ using VULKAN_HPP_NAMESPACE::DeviceFaultCountsEXT;
+ using VULKAN_HPP_NAMESPACE::DeviceFaultInfoEXT;
+ using VULKAN_HPP_NAMESPACE::DeviceFaultVendorBinaryHeaderVersionOneEXT;
+ using VULKAN_HPP_NAMESPACE::DeviceFaultVendorInfoEXT;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceFaultFeaturesEXT;
+
+ //=== VK_EXT_rgba10x6_formats ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceRGBA10X6FormatsFeaturesEXT;
+
+#if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
+ //=== VK_EXT_directfb_surface ===
+ using VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT;
+#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
+
+ //=== VK_EXT_vertex_input_dynamic_state ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexInputDynamicStateFeaturesEXT;
+ using VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT;
+ using VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT;
+
+ //=== VK_EXT_physical_device_drm ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceDrmPropertiesEXT;
+
+ //=== VK_EXT_device_address_binding_report ===
+ using VULKAN_HPP_NAMESPACE::DeviceAddressBindingCallbackDataEXT;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceAddressBindingReportFeaturesEXT;
+
+ //=== VK_EXT_depth_clip_control ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClipControlFeaturesEXT;
+ using VULKAN_HPP_NAMESPACE::PipelineViewportDepthClipControlCreateInfoEXT;
+
+ //=== VK_EXT_primitive_topology_list_restart ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT;
+
+#if defined( VK_USE_PLATFORM_FUCHSIA )
+ //=== VK_FUCHSIA_external_memory ===
+ using VULKAN_HPP_NAMESPACE::ImportMemoryZirconHandleInfoFUCHSIA;
+ using VULKAN_HPP_NAMESPACE::MemoryGetZirconHandleInfoFUCHSIA;
+ using VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA;
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
+
+#if defined( VK_USE_PLATFORM_FUCHSIA )
+ //=== VK_FUCHSIA_external_semaphore ===
+ using VULKAN_HPP_NAMESPACE::ImportSemaphoreZirconHandleInfoFUCHSIA;
+ using VULKAN_HPP_NAMESPACE::SemaphoreGetZirconHandleInfoFUCHSIA;
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
+
+#if defined( VK_USE_PLATFORM_FUCHSIA )
+ //=== VK_FUCHSIA_buffer_collection ===
+ using VULKAN_HPP_NAMESPACE::BufferCollectionBufferCreateInfoFUCHSIA;
+ using VULKAN_HPP_NAMESPACE::BufferCollectionConstraintsInfoFUCHSIA;
+ using VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA;
+ using VULKAN_HPP_NAMESPACE::BufferCollectionImageCreateInfoFUCHSIA;
+ using VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA;
+ using VULKAN_HPP_NAMESPACE::BufferConstraintsInfoFUCHSIA;
+ using VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFUCHSIA;
+ using VULKAN_HPP_NAMESPACE::ImageFormatConstraintsInfoFUCHSIA;
+ using VULKAN_HPP_NAMESPACE::ImportMemoryBufferCollectionFUCHSIA;
+ using VULKAN_HPP_NAMESPACE::SysmemColorSpaceFUCHSIA;
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
+
+ //=== VK_HUAWEI_subpass_shading ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassShadingFeaturesHUAWEI;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassShadingPropertiesHUAWEI;
+ using VULKAN_HPP_NAMESPACE::SubpassShadingPipelineCreateInfoHUAWEI;
+
+ //=== VK_HUAWEI_invocation_mask ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceInvocationMaskFeaturesHUAWEI;
+
+ //=== VK_NV_external_memory_rdma ===
+ using VULKAN_HPP_NAMESPACE::MemoryGetRemoteAddressInfoNV;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryRDMAFeaturesNV;
+
+ //=== VK_EXT_pipeline_properties ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDevicePipelinePropertiesFeaturesEXT;
+ using VULKAN_HPP_NAMESPACE::PipelinePropertiesIdentifierEXT;
+
+ //=== VK_EXT_frame_boundary ===
+ using VULKAN_HPP_NAMESPACE::FrameBoundaryEXT;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceFrameBoundaryFeaturesEXT;
+
+ //=== VK_EXT_multisampled_render_to_single_sampled ===
+ using VULKAN_HPP_NAMESPACE::MultisampledRenderToSingleSampledInfoEXT;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT;
+ using VULKAN_HPP_NAMESPACE::SubpassResolvePerformanceQueryEXT;
+
+ //=== VK_EXT_extended_dynamic_state2 ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState2FeaturesEXT;
+
+#if defined( VK_USE_PLATFORM_SCREEN_QNX )
+ //=== VK_QNX_screen_surface ===
+ using VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX;
+#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
+
+ //=== VK_EXT_color_write_enable ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceColorWriteEnableFeaturesEXT;
+ using VULKAN_HPP_NAMESPACE::PipelineColorWriteCreateInfoEXT;
+
+ //=== VK_EXT_primitives_generated_query ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT;
+
+ //=== VK_KHR_ray_tracing_maintenance1 ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingMaintenance1FeaturesKHR;
+ using VULKAN_HPP_NAMESPACE::TraceRaysIndirectCommand2KHR;
+
+ //=== VK_EXT_image_view_min_lod ===
+ using VULKAN_HPP_NAMESPACE::ImageViewMinLodCreateInfoEXT;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceImageViewMinLodFeaturesEXT;
+
+ //=== VK_EXT_multi_draw ===
+ using VULKAN_HPP_NAMESPACE::MultiDrawIndexedInfoEXT;
+ using VULKAN_HPP_NAMESPACE::MultiDrawInfoEXT;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiDrawFeaturesEXT;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiDrawPropertiesEXT;
+
+ //=== VK_EXT_image_2d_view_of_3d ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceImage2DViewOf3DFeaturesEXT;
+
+ //=== VK_EXT_shader_tile_image ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderTileImageFeaturesEXT;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderTileImagePropertiesEXT;
+
+ //=== VK_EXT_opacity_micromap ===
+ using VULKAN_HPP_NAMESPACE::AccelerationStructureTrianglesOpacityMicromapEXT;
+ using VULKAN_HPP_NAMESPACE::CopyMemoryToMicromapInfoEXT;
+ using VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT;
+ using VULKAN_HPP_NAMESPACE::CopyMicromapToMemoryInfoEXT;
+ using VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT;
+ using VULKAN_HPP_NAMESPACE::MicromapBuildSizesInfoEXT;
+ using VULKAN_HPP_NAMESPACE::MicromapCreateInfoEXT;
+ using VULKAN_HPP_NAMESPACE::MicromapTriangleEXT;
+ using VULKAN_HPP_NAMESPACE::MicromapUsageEXT;
+ using VULKAN_HPP_NAMESPACE::MicromapVersionInfoEXT;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceOpacityMicromapFeaturesEXT;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceOpacityMicromapPropertiesEXT;
+
+#if defined( VK_ENABLE_BETA_EXTENSIONS )
+ //=== VK_NV_displacement_micromap ===
+ using VULKAN_HPP_NAMESPACE::AccelerationStructureTrianglesDisplacementMicromapNV;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceDisplacementMicromapFeaturesNV;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceDisplacementMicromapPropertiesNV;
+#endif /*VK_ENABLE_BETA_EXTENSIONS*/
+
+ //=== VK_HUAWEI_cluster_culling_shader ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterCullingShaderFeaturesHUAWEI;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterCullingShaderPropertiesHUAWEI;
+
+ //=== VK_EXT_border_color_swizzle ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceBorderColorSwizzleFeaturesEXT;
+ using VULKAN_HPP_NAMESPACE::SamplerBorderColorComponentMappingCreateInfoEXT;
+
+ //=== VK_EXT_pageable_device_local_memory ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT;
+
+ //=== VK_ARM_shader_core_properties ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCorePropertiesARM;
+
+ //=== VK_EXT_image_sliced_view_of_3d ===
+ using VULKAN_HPP_NAMESPACE::ImageViewSlicedCreateInfoEXT;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceImageSlicedViewOf3DFeaturesEXT;
+
+ //=== VK_VALVE_descriptor_set_host_mapping ===
+ using VULKAN_HPP_NAMESPACE::DescriptorSetBindingReferenceVALVE;
+ using VULKAN_HPP_NAMESPACE::DescriptorSetLayoutHostMappingInfoVALVE;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE;
+
+ //=== VK_EXT_depth_clamp_zero_one ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClampZeroOneFeaturesEXT;
+
+ //=== VK_EXT_non_seamless_cube_map ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceNonSeamlessCubeMapFeaturesEXT;
+
+ //=== VK_QCOM_fragment_density_map_offset ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM;
+ using VULKAN_HPP_NAMESPACE::SubpassFragmentDensityMapOffsetEndInfoQCOM;
+
+ //=== VK_NV_copy_memory_indirect ===
+ using VULKAN_HPP_NAMESPACE::CopyMemoryIndirectCommandNV;
+ using VULKAN_HPP_NAMESPACE::CopyMemoryToImageIndirectCommandNV;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectFeaturesNV;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectPropertiesNV;
+
+ //=== VK_NV_memory_decompression ===
+ using VULKAN_HPP_NAMESPACE::DecompressMemoryRegionNV;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryDecompressionFeaturesNV;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryDecompressionPropertiesNV;
+
+ //=== VK_NV_device_generated_commands_compute ===
+ using VULKAN_HPP_NAMESPACE::BindPipelineIndirectCommandNV;
+ using VULKAN_HPP_NAMESPACE::ComputePipelineIndirectBufferInfoNV;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV;
+ using VULKAN_HPP_NAMESPACE::PipelineIndirectDeviceAddressInfoNV;
+
+ //=== VK_NV_linear_color_attachment ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceLinearColorAttachmentFeaturesNV;
+
+ //=== VK_EXT_image_compression_control_swapchain ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT;
+
+ //=== VK_QCOM_image_processing ===
+ using VULKAN_HPP_NAMESPACE::ImageViewSampleWeightCreateInfoQCOM;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessingFeaturesQCOM;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessingPropertiesQCOM;
+
+ //=== VK_EXT_external_memory_acquire_unmodified ===
+ using VULKAN_HPP_NAMESPACE::ExternalMemoryAcquireUnmodifiedEXT;
+
+ //=== VK_EXT_extended_dynamic_state3 ===
+ using VULKAN_HPP_NAMESPACE::ColorBlendAdvancedEXT;
+ using VULKAN_HPP_NAMESPACE::ColorBlendEquationEXT;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState3FeaturesEXT;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState3PropertiesEXT;
+
+ //=== VK_EXT_subpass_merge_feedback ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassMergeFeedbackFeaturesEXT;
+ using VULKAN_HPP_NAMESPACE::RenderPassCreationControlEXT;
+ using VULKAN_HPP_NAMESPACE::RenderPassCreationFeedbackCreateInfoEXT;
+ using VULKAN_HPP_NAMESPACE::RenderPassCreationFeedbackInfoEXT;
+ using VULKAN_HPP_NAMESPACE::RenderPassSubpassFeedbackCreateInfoEXT;
+ using VULKAN_HPP_NAMESPACE::RenderPassSubpassFeedbackInfoEXT;
+
+ //=== VK_LUNARG_direct_driver_loading ===
+ using VULKAN_HPP_NAMESPACE::DirectDriverLoadingInfoLUNARG;
+ using VULKAN_HPP_NAMESPACE::DirectDriverLoadingListLUNARG;
+
+ //=== VK_EXT_shader_module_identifier ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderModuleIdentifierFeaturesEXT;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderModuleIdentifierPropertiesEXT;
+ using VULKAN_HPP_NAMESPACE::PipelineShaderStageModuleIdentifierCreateInfoEXT;
+ using VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT;
+
+ //=== VK_EXT_rasterization_order_attachment_access ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT;
+
+ //=== VK_NV_optical_flow ===
+ using VULKAN_HPP_NAMESPACE::OpticalFlowExecuteInfoNV;
+ using VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatInfoNV;
+ using VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV;
+ using VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreateInfoNV;
+ using VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreatePrivateDataInfoNV;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceOpticalFlowFeaturesNV;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceOpticalFlowPropertiesNV;
+
+ //=== VK_EXT_legacy_dithering ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceLegacyDitheringFeaturesEXT;
+
+ //=== VK_EXT_pipeline_protected_access ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineProtectedAccessFeaturesEXT;
+
+#if defined( VK_USE_PLATFORM_ANDROID_KHR )
+ //=== VK_ANDROID_external_format_resolve ===
+ using VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatResolvePropertiesANDROID;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFormatResolveFeaturesANDROID;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFormatResolvePropertiesANDROID;
+#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
+
+ //=== VK_KHR_maintenance5 ===
+ using VULKAN_HPP_NAMESPACE::BufferUsageFlags2CreateInfoKHR;
+ using VULKAN_HPP_NAMESPACE::DeviceImageSubresourceInfoKHR;
+ using VULKAN_HPP_NAMESPACE::ImageSubresource2EXT;
+ using VULKAN_HPP_NAMESPACE::ImageSubresource2KHR;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance5FeaturesKHR;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance5PropertiesKHR;
+ using VULKAN_HPP_NAMESPACE::PipelineCreateFlags2CreateInfoKHR;
+ using VULKAN_HPP_NAMESPACE::RenderingAreaInfoKHR;
+ using VULKAN_HPP_NAMESPACE::SubresourceLayout2EXT;
+ using VULKAN_HPP_NAMESPACE::SubresourceLayout2KHR;
+
+ //=== VK_KHR_ray_tracing_position_fetch ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPositionFetchFeaturesKHR;
+
+ //=== VK_EXT_shader_object ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderObjectFeaturesEXT;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderObjectPropertiesEXT;
+ using VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT;
+
+ //=== VK_QCOM_tile_properties ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceTilePropertiesFeaturesQCOM;
+ using VULKAN_HPP_NAMESPACE::TilePropertiesQCOM;
+
+ //=== VK_SEC_amigo_profiling ===
+ using VULKAN_HPP_NAMESPACE::AmigoProfilingSubmitInfoSEC;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceAmigoProfilingFeaturesSEC;
+
+ //=== VK_QCOM_multiview_per_view_viewports ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM;
+
+ //=== VK_NV_ray_tracing_invocation_reorder ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderFeaturesNV;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderPropertiesNV;
+
+ //=== VK_EXT_mutable_descriptor_type ===
+ using VULKAN_HPP_NAMESPACE::MutableDescriptorTypeCreateInfoEXT;
+ using VULKAN_HPP_NAMESPACE::MutableDescriptorTypeCreateInfoVALVE;
+ using VULKAN_HPP_NAMESPACE::MutableDescriptorTypeListEXT;
+ using VULKAN_HPP_NAMESPACE::MutableDescriptorTypeListVALVE;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceMutableDescriptorTypeFeaturesEXT;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceMutableDescriptorTypeFeaturesVALVE;
+
+ //=== VK_ARM_shader_core_builtins ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCoreBuiltinsFeaturesARM;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCoreBuiltinsPropertiesARM;
+
+ //=== VK_EXT_pipeline_library_group_handles ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT;
+
+ //=== VK_EXT_dynamic_rendering_unused_attachments ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT;
+
+ //=== VK_NV_low_latency2 ===
+ using VULKAN_HPP_NAMESPACE::GetLatencyMarkerInfoNV;
+ using VULKAN_HPP_NAMESPACE::LatencySleepInfoNV;
+ using VULKAN_HPP_NAMESPACE::LatencySleepModeInfoNV;
+ using VULKAN_HPP_NAMESPACE::LatencySubmissionPresentIdNV;
+ using VULKAN_HPP_NAMESPACE::LatencySurfaceCapabilitiesNV;
+ using VULKAN_HPP_NAMESPACE::LatencyTimingsFrameReportNV;
+ using VULKAN_HPP_NAMESPACE::OutOfBandQueueTypeInfoNV;
+ using VULKAN_HPP_NAMESPACE::SetLatencyMarkerInfoNV;
+ using VULKAN_HPP_NAMESPACE::SwapchainLatencyCreateInfoNV;
+
+ //=== VK_KHR_cooperative_matrix ===
+ using VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixFeaturesKHR;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixPropertiesKHR;
+
+ //=== VK_QCOM_multiview_per_view_render_areas ===
+ using VULKAN_HPP_NAMESPACE::MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM;
+
+ //=== VK_QCOM_image_processing2 ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessing2FeaturesQCOM;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessing2PropertiesQCOM;
+ using VULKAN_HPP_NAMESPACE::SamplerBlockMatchWindowCreateInfoQCOM;
+
+ //=== VK_QCOM_filter_cubic_weights ===
+ using VULKAN_HPP_NAMESPACE::BlitImageCubicWeightsInfoQCOM;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceCubicWeightsFeaturesQCOM;
+ using VULKAN_HPP_NAMESPACE::SamplerCubicWeightsCreateInfoQCOM;
+
+ //=== VK_QCOM_ycbcr_degamma ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcrDegammaFeaturesQCOM;
+ using VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM;
+
+ //=== VK_QCOM_filter_cubic_clamp ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceCubicClampFeaturesQCOM;
+
+ //=== VK_EXT_attachment_feedback_loop_dynamic_state ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT;
+
+#if defined( VK_USE_PLATFORM_SCREEN_QNX )
+ //=== VK_QNX_external_memory_screen_buffer ===
+ using VULKAN_HPP_NAMESPACE::ExternalFormatQNX;
+ using VULKAN_HPP_NAMESPACE::ImportScreenBufferInfoQNX;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX;
+ using VULKAN_HPP_NAMESPACE::ScreenBufferFormatPropertiesQNX;
+ using VULKAN_HPP_NAMESPACE::ScreenBufferPropertiesQNX;
+#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
+
+ //=== VK_MSFT_layered_driver ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredDriverPropertiesMSFT;
+
+ //=== VK_NV_descriptor_pool_overallocation ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorPoolOverallocationFeaturesNV;
+
+ //===============
+ //=== HANDLEs ===
+ //===============
+
+ using VULKAN_HPP_NAMESPACE::isVulkanHandleType;
+
+ //=== VK_VERSION_1_0 ===
+ using VULKAN_HPP_NAMESPACE::Buffer;
+ using VULKAN_HPP_NAMESPACE::BufferView;
+ using VULKAN_HPP_NAMESPACE::CommandBuffer;
+ using VULKAN_HPP_NAMESPACE::CommandPool;
+ using VULKAN_HPP_NAMESPACE::DescriptorPool;
+ using VULKAN_HPP_NAMESPACE::DescriptorSet;
+ using VULKAN_HPP_NAMESPACE::DescriptorSetLayout;
+ using VULKAN_HPP_NAMESPACE::Device;
+ using VULKAN_HPP_NAMESPACE::DeviceMemory;
+ using VULKAN_HPP_NAMESPACE::Event;
+ using VULKAN_HPP_NAMESPACE::Fence;
+ using VULKAN_HPP_NAMESPACE::Framebuffer;
+ using VULKAN_HPP_NAMESPACE::Image;
+ using VULKAN_HPP_NAMESPACE::ImageView;
+ using VULKAN_HPP_NAMESPACE::Instance;
+ using VULKAN_HPP_NAMESPACE::PhysicalDevice;
+ using VULKAN_HPP_NAMESPACE::Pipeline;
+ using VULKAN_HPP_NAMESPACE::PipelineCache;
+ using VULKAN_HPP_NAMESPACE::PipelineLayout;
+ using VULKAN_HPP_NAMESPACE::QueryPool;
+ using VULKAN_HPP_NAMESPACE::Queue;
+ using VULKAN_HPP_NAMESPACE::RenderPass;
+ using VULKAN_HPP_NAMESPACE::Sampler;
+ using VULKAN_HPP_NAMESPACE::Semaphore;
+ using VULKAN_HPP_NAMESPACE::ShaderModule;
+
+ //=== VK_VERSION_1_1 ===
+ using VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate;
+ using VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion;
+
+ //=== VK_VERSION_1_3 ===
+ using VULKAN_HPP_NAMESPACE::PrivateDataSlot;
+
+ //=== VK_KHR_surface ===
+ using VULKAN_HPP_NAMESPACE::SurfaceKHR;
+
+ //=== VK_KHR_swapchain ===
+ using VULKAN_HPP_NAMESPACE::SwapchainKHR;
+
+ //=== VK_KHR_display ===
+ using VULKAN_HPP_NAMESPACE::DisplayKHR;
+ using VULKAN_HPP_NAMESPACE::DisplayModeKHR;
+
+ //=== VK_EXT_debug_report ===
+ using VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT;
+
+ //=== VK_KHR_video_queue ===
+ using VULKAN_HPP_NAMESPACE::VideoSessionKHR;
+ using VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR;
+
+ //=== VK_NVX_binary_import ===
+ using VULKAN_HPP_NAMESPACE::CuFunctionNVX;
+ using VULKAN_HPP_NAMESPACE::CuModuleNVX;
+
+ //=== VK_EXT_debug_utils ===
+ using VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT;
+
+ //=== VK_KHR_acceleration_structure ===
+ using VULKAN_HPP_NAMESPACE::AccelerationStructureKHR;
+
+ //=== VK_EXT_validation_cache ===
+ using VULKAN_HPP_NAMESPACE::ValidationCacheEXT;
+
+ //=== VK_NV_ray_tracing ===
+ using VULKAN_HPP_NAMESPACE::AccelerationStructureNV;
+
+ //=== VK_INTEL_performance_query ===
+ using VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL;
+
+ //=== VK_KHR_deferred_host_operations ===
+ using VULKAN_HPP_NAMESPACE::DeferredOperationKHR;
+
+ //=== VK_NV_device_generated_commands ===
+ using VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV;
+
+#if defined( VK_USE_PLATFORM_FUCHSIA )
+ //=== VK_FUCHSIA_buffer_collection ===
+ using VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA;
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
+
+ //=== VK_EXT_opacity_micromap ===
+ using VULKAN_HPP_NAMESPACE::MicromapEXT;
+
+ //=== VK_NV_optical_flow ===
+ using VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV;
+
+ //=== VK_EXT_shader_object ===
+ using VULKAN_HPP_NAMESPACE::ShaderEXT;
+
+ //======================
+ //=== UNIQUE HANDLEs ===
+ //======================
+
+#if !defined( VULKAN_HPP_NO_SMART_HANDLE )
+
+ //=== VK_VERSION_1_0 ===
+ using VULKAN_HPP_NAMESPACE::UniqueBuffer;
+ using VULKAN_HPP_NAMESPACE::UniqueBufferView;
+ using VULKAN_HPP_NAMESPACE::UniqueCommandBuffer;
+ using VULKAN_HPP_NAMESPACE::UniqueCommandPool;
+ using VULKAN_HPP_NAMESPACE::UniqueDescriptorPool;
+ using VULKAN_HPP_NAMESPACE::UniqueDescriptorSet;
+ using VULKAN_HPP_NAMESPACE::UniqueDescriptorSetLayout;
+ using VULKAN_HPP_NAMESPACE::UniqueDevice;
+ using VULKAN_HPP_NAMESPACE::UniqueDeviceMemory;
+ using VULKAN_HPP_NAMESPACE::UniqueEvent;
+ using VULKAN_HPP_NAMESPACE::UniqueFence;
+ using VULKAN_HPP_NAMESPACE::UniqueFramebuffer;
+ using VULKAN_HPP_NAMESPACE::UniqueImage;
+ using VULKAN_HPP_NAMESPACE::UniqueImageView;
+ using VULKAN_HPP_NAMESPACE::UniqueInstance;
+ using VULKAN_HPP_NAMESPACE::UniquePipeline;
+ using VULKAN_HPP_NAMESPACE::UniquePipelineCache;
+ using VULKAN_HPP_NAMESPACE::UniquePipelineLayout;
+ using VULKAN_HPP_NAMESPACE::UniqueQueryPool;
+ using VULKAN_HPP_NAMESPACE::UniqueRenderPass;
+ using VULKAN_HPP_NAMESPACE::UniqueSampler;
+ using VULKAN_HPP_NAMESPACE::UniqueSemaphore;
+ using VULKAN_HPP_NAMESPACE::UniqueShaderModule;
+
+ //=== VK_VERSION_1_1 ===
+ using VULKAN_HPP_NAMESPACE::UniqueDescriptorUpdateTemplate;
+ using VULKAN_HPP_NAMESPACE::UniqueSamplerYcbcrConversion;
+
+ //=== VK_VERSION_1_3 ===
+ using VULKAN_HPP_NAMESPACE::UniquePrivateDataSlot;
+
+ //=== VK_KHR_surface ===
+ using VULKAN_HPP_NAMESPACE::UniqueSurfaceKHR;
+
+ //=== VK_KHR_swapchain ===
+ using VULKAN_HPP_NAMESPACE::UniqueSwapchainKHR;
+
+ //=== VK_EXT_debug_report ===
+ using VULKAN_HPP_NAMESPACE::UniqueDebugReportCallbackEXT;
+
+ //=== VK_KHR_video_queue ===
+ using VULKAN_HPP_NAMESPACE::UniqueVideoSessionKHR;
+ using VULKAN_HPP_NAMESPACE::UniqueVideoSessionParametersKHR;
+
+ //=== VK_NVX_binary_import ===
+ using VULKAN_HPP_NAMESPACE::UniqueCuFunctionNVX;
+ using VULKAN_HPP_NAMESPACE::UniqueCuModuleNVX;
+
+ //=== VK_EXT_debug_utils ===
+ using VULKAN_HPP_NAMESPACE::UniqueDebugUtilsMessengerEXT;
+
+ //=== VK_KHR_acceleration_structure ===
+ using VULKAN_HPP_NAMESPACE::UniqueAccelerationStructureKHR;
+
+ //=== VK_EXT_validation_cache ===
+ using VULKAN_HPP_NAMESPACE::UniqueValidationCacheEXT;
+
+ //=== VK_NV_ray_tracing ===
+ using VULKAN_HPP_NAMESPACE::UniqueAccelerationStructureNV;
+
+ //=== VK_KHR_deferred_host_operations ===
+ using VULKAN_HPP_NAMESPACE::UniqueDeferredOperationKHR;
+
+ //=== VK_NV_device_generated_commands ===
+ using VULKAN_HPP_NAMESPACE::UniqueIndirectCommandsLayoutNV;
+
+# if defined( VK_USE_PLATFORM_FUCHSIA )
+ //=== VK_FUCHSIA_buffer_collection ===
+ using VULKAN_HPP_NAMESPACE::UniqueBufferCollectionFUCHSIA;
+# endif /*VK_USE_PLATFORM_FUCHSIA*/
+
+ //=== VK_EXT_opacity_micromap ===
+ using VULKAN_HPP_NAMESPACE::UniqueMicromapEXT;
+
+ //=== VK_NV_optical_flow ===
+ using VULKAN_HPP_NAMESPACE::UniqueOpticalFlowSessionNV;
+
+ //=== VK_EXT_shader_object ===
+ using VULKAN_HPP_NAMESPACE::UniqueHandleTraits;
+ using VULKAN_HPP_NAMESPACE::UniqueShaderEXT;
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+
+ //======================
+ //=== SHARED HANDLEs ===
+ //======================
+
+#if !defined( VULKAN_HPP_NO_SMART_HANDLE )
+
+ //=== VK_VERSION_1_0 ===
+ using VULKAN_HPP_NAMESPACE::SharedBuffer;
+ using VULKAN_HPP_NAMESPACE::SharedBufferView;
+ using VULKAN_HPP_NAMESPACE::SharedCommandBuffer;
+ using VULKAN_HPP_NAMESPACE::SharedCommandPool;
+ using VULKAN_HPP_NAMESPACE::SharedDescriptorPool;
+ using VULKAN_HPP_NAMESPACE::SharedDescriptorSet;
+ using VULKAN_HPP_NAMESPACE::SharedDescriptorSetLayout;
+ using VULKAN_HPP_NAMESPACE::SharedDevice;
+ using VULKAN_HPP_NAMESPACE::SharedDeviceMemory;
+ using VULKAN_HPP_NAMESPACE::SharedEvent;
+ using VULKAN_HPP_NAMESPACE::SharedFence;
+ using VULKAN_HPP_NAMESPACE::SharedFramebuffer;
+ using VULKAN_HPP_NAMESPACE::SharedImage;
+ using VULKAN_HPP_NAMESPACE::SharedImageView;
+ using VULKAN_HPP_NAMESPACE::SharedInstance;
+ using VULKAN_HPP_NAMESPACE::SharedPhysicalDevice;
+ using VULKAN_HPP_NAMESPACE::SharedPipeline;
+ using VULKAN_HPP_NAMESPACE::SharedPipelineCache;
+ using VULKAN_HPP_NAMESPACE::SharedPipelineLayout;
+ using VULKAN_HPP_NAMESPACE::SharedQueryPool;
+ using VULKAN_HPP_NAMESPACE::SharedQueue;
+ using VULKAN_HPP_NAMESPACE::SharedRenderPass;
+ using VULKAN_HPP_NAMESPACE::SharedSampler;
+ using VULKAN_HPP_NAMESPACE::SharedSemaphore;
+ using VULKAN_HPP_NAMESPACE::SharedShaderModule;
+
+ //=== VK_VERSION_1_1 ===
+ using VULKAN_HPP_NAMESPACE::SharedDescriptorUpdateTemplate;
+ using VULKAN_HPP_NAMESPACE::SharedSamplerYcbcrConversion;
+
+ //=== VK_VERSION_1_3 ===
+ using VULKAN_HPP_NAMESPACE::SharedPrivateDataSlot;
+
+ //=== VK_KHR_surface ===
+ using VULKAN_HPP_NAMESPACE::SharedSurfaceKHR;
+
+ //=== VK_KHR_swapchain ===
+ using VULKAN_HPP_NAMESPACE::SharedSwapchainKHR;
+
+ //=== VK_KHR_display ===
+ using VULKAN_HPP_NAMESPACE::SharedDisplayKHR;
+ using VULKAN_HPP_NAMESPACE::SharedDisplayModeKHR;
+
+ //=== VK_EXT_debug_report ===
+ using VULKAN_HPP_NAMESPACE::SharedDebugReportCallbackEXT;
+
+ //=== VK_KHR_video_queue ===
+ using VULKAN_HPP_NAMESPACE::SharedVideoSessionKHR;
+ using VULKAN_HPP_NAMESPACE::SharedVideoSessionParametersKHR;
+
+ //=== VK_NVX_binary_import ===
+ using VULKAN_HPP_NAMESPACE::SharedCuFunctionNVX;
+ using VULKAN_HPP_NAMESPACE::SharedCuModuleNVX;
+
+ //=== VK_EXT_debug_utils ===
+ using VULKAN_HPP_NAMESPACE::SharedDebugUtilsMessengerEXT;
+
+ //=== VK_KHR_acceleration_structure ===
+ using VULKAN_HPP_NAMESPACE::SharedAccelerationStructureKHR;
+
+ //=== VK_EXT_validation_cache ===
+ using VULKAN_HPP_NAMESPACE::SharedValidationCacheEXT;
+
+ //=== VK_NV_ray_tracing ===
+ using VULKAN_HPP_NAMESPACE::SharedAccelerationStructureNV;
+
+ //=== VK_INTEL_performance_query ===
+ using VULKAN_HPP_NAMESPACE::SharedPerformanceConfigurationINTEL;
+
+ //=== VK_KHR_deferred_host_operations ===
+ using VULKAN_HPP_NAMESPACE::SharedDeferredOperationKHR;
+
+ //=== VK_NV_device_generated_commands ===
+ using VULKAN_HPP_NAMESPACE::SharedIndirectCommandsLayoutNV;
+
+# if defined( VK_USE_PLATFORM_FUCHSIA )
+ //=== VK_FUCHSIA_buffer_collection ===
+ using VULKAN_HPP_NAMESPACE::SharedBufferCollectionFUCHSIA;
+# endif /*VK_USE_PLATFORM_FUCHSIA*/
+
+ //=== VK_EXT_opacity_micromap ===
+ using VULKAN_HPP_NAMESPACE::SharedMicromapEXT;
+
+ //=== VK_NV_optical_flow ===
+ using VULKAN_HPP_NAMESPACE::SharedOpticalFlowSessionNV;
+
+ //=== VK_EXT_shader_object ===
+ using VULKAN_HPP_NAMESPACE::SharedHandleTraits;
+ using VULKAN_HPP_NAMESPACE::SharedShaderEXT;
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+
+ //===========================
+ //=== COMMAND Definitions ===
+ //===========================
+ using VULKAN_HPP_NAMESPACE::createInstance;
+ using VULKAN_HPP_NAMESPACE::enumerateInstanceExtensionProperties;
+ using VULKAN_HPP_NAMESPACE::enumerateInstanceLayerProperties;
+ using VULKAN_HPP_NAMESPACE::enumerateInstanceVersion;
+
+#if !defined( VULKAN_HPP_NO_SMART_HANDLE )
+ using VULKAN_HPP_NAMESPACE::createInstanceUnique;
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+
+#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+ using VULKAN_HPP_NAMESPACE::StructExtends;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#if defined( VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL )
+ using VULKAN_HPP_NAMESPACE::DynamicLoader;
+#endif /*VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL*/
+
+ //=====================
+ //=== Format Traits ===
+ //=====================
+ using VULKAN_HPP_NAMESPACE::blockExtent;
+ using VULKAN_HPP_NAMESPACE::blockSize;
+ using VULKAN_HPP_NAMESPACE::compatibilityClass;
+ using VULKAN_HPP_NAMESPACE::componentBits;
+ using VULKAN_HPP_NAMESPACE::componentCount;
+ using VULKAN_HPP_NAMESPACE::componentName;
+ using VULKAN_HPP_NAMESPACE::componentNumericFormat;
+ using VULKAN_HPP_NAMESPACE::componentPlaneIndex;
+ using VULKAN_HPP_NAMESPACE::componentsAreCompressed;
+ using VULKAN_HPP_NAMESPACE::compressionScheme;
+ using VULKAN_HPP_NAMESPACE::isCompressed;
+ using VULKAN_HPP_NAMESPACE::packed;
+ using VULKAN_HPP_NAMESPACE::planeCompatibleFormat;
+ using VULKAN_HPP_NAMESPACE::planeCount;
+ using VULKAN_HPP_NAMESPACE::planeHeightDivisor;
+ using VULKAN_HPP_NAMESPACE::planeWidthDivisor;
+ using VULKAN_HPP_NAMESPACE::texelsPerBlock;
+
+ //======================================
+ //=== Extension inspection functions ===
+ //======================================
+ using VULKAN_HPP_NAMESPACE::getDeprecatedExtensions;
+ using VULKAN_HPP_NAMESPACE::getDeviceExtensions;
+ using VULKAN_HPP_NAMESPACE::getExtensionDepends;
+ using VULKAN_HPP_NAMESPACE::getExtensionDeprecatedBy;
+ using VULKAN_HPP_NAMESPACE::getExtensionObsoletedBy;
+ using VULKAN_HPP_NAMESPACE::getExtensionPromotedTo;
+ using VULKAN_HPP_NAMESPACE::getInstanceExtensions;
+ using VULKAN_HPP_NAMESPACE::getObsoletedExtensions;
+ using VULKAN_HPP_NAMESPACE::getPromotedExtensions;
+ using VULKAN_HPP_NAMESPACE::isDeprecatedExtension;
+ using VULKAN_HPP_NAMESPACE::isDeviceExtension;
+ using VULKAN_HPP_NAMESPACE::isInstanceExtension;
+ using VULKAN_HPP_NAMESPACE::isObsoletedExtension;
+ using VULKAN_HPP_NAMESPACE::isPromotedExtension;
+
+#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) && !defined( VULKAN_HPP_NO_EXCEPTIONS )
+ namespace VULKAN_HPP_RAII_NAMESPACE
+ {
+ //======================
+ //=== RAII HARDCODED ===
+ //======================
+
+ using VULKAN_HPP_RAII_NAMESPACE::Context;
+ using VULKAN_HPP_RAII_NAMESPACE::ContextDispatcher;
+ using VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher;
+ using VULKAN_HPP_RAII_NAMESPACE::exchange;
+ using VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher;
+
+ //====================
+ //=== RAII HANDLEs ===
+ //====================
+
+ //=== VK_VERSION_1_0 ===
+ using VULKAN_HPP_RAII_NAMESPACE::Buffer;
+ using VULKAN_HPP_RAII_NAMESPACE::BufferView;
+ using VULKAN_HPP_RAII_NAMESPACE::CommandBuffer;
+ using VULKAN_HPP_RAII_NAMESPACE::CommandBuffers;
+ using VULKAN_HPP_RAII_NAMESPACE::CommandPool;
+ using VULKAN_HPP_RAII_NAMESPACE::DescriptorPool;
+ using VULKAN_HPP_RAII_NAMESPACE::DescriptorSet;
+ using VULKAN_HPP_RAII_NAMESPACE::DescriptorSetLayout;
+ using VULKAN_HPP_RAII_NAMESPACE::DescriptorSets;
+ using VULKAN_HPP_RAII_NAMESPACE::Device;
+ using VULKAN_HPP_RAII_NAMESPACE::DeviceMemory;
+ using VULKAN_HPP_RAII_NAMESPACE::Event;
+ using VULKAN_HPP_RAII_NAMESPACE::Fence;
+ using VULKAN_HPP_RAII_NAMESPACE::Framebuffer;
+ using VULKAN_HPP_RAII_NAMESPACE::Image;
+ using VULKAN_HPP_RAII_NAMESPACE::ImageView;
+ using VULKAN_HPP_RAII_NAMESPACE::Instance;
+ using VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice;
+ using VULKAN_HPP_RAII_NAMESPACE::PhysicalDevices;
+ using VULKAN_HPP_RAII_NAMESPACE::Pipeline;
+ using VULKAN_HPP_RAII_NAMESPACE::PipelineCache;
+ using VULKAN_HPP_RAII_NAMESPACE::PipelineLayout;
+ using VULKAN_HPP_RAII_NAMESPACE::Pipelines;
+ using VULKAN_HPP_RAII_NAMESPACE::QueryPool;
+ using VULKAN_HPP_RAII_NAMESPACE::Queue;
+ using VULKAN_HPP_RAII_NAMESPACE::RenderPass;
+ using VULKAN_HPP_RAII_NAMESPACE::Sampler;
+ using VULKAN_HPP_RAII_NAMESPACE::Semaphore;
+ using VULKAN_HPP_RAII_NAMESPACE::ShaderModule;
+
+ //=== VK_VERSION_1_1 ===
+ using VULKAN_HPP_RAII_NAMESPACE::DescriptorUpdateTemplate;
+ using VULKAN_HPP_RAII_NAMESPACE::SamplerYcbcrConversion;
+
+ //=== VK_VERSION_1_3 ===
+ using VULKAN_HPP_RAII_NAMESPACE::PrivateDataSlot;
+
+ //=== VK_KHR_surface ===
+ using VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR;
+
+ //=== VK_KHR_swapchain ===
+ using VULKAN_HPP_RAII_NAMESPACE::SwapchainKHR;
+ using VULKAN_HPP_RAII_NAMESPACE::SwapchainKHRs;
+
+ //=== VK_KHR_display ===
+ using VULKAN_HPP_RAII_NAMESPACE::DisplayKHR;
+ using VULKAN_HPP_RAII_NAMESPACE::DisplayKHRs;
+ using VULKAN_HPP_RAII_NAMESPACE::DisplayModeKHR;
+
+ //=== VK_EXT_debug_report ===
+ using VULKAN_HPP_RAII_NAMESPACE::DebugReportCallbackEXT;
+
+ //=== VK_KHR_video_queue ===
+ using VULKAN_HPP_RAII_NAMESPACE::VideoSessionKHR;
+ using VULKAN_HPP_RAII_NAMESPACE::VideoSessionParametersKHR;
+
+ //=== VK_NVX_binary_import ===
+ using VULKAN_HPP_RAII_NAMESPACE::CuFunctionNVX;
+ using VULKAN_HPP_RAII_NAMESPACE::CuModuleNVX;
+
+ //=== VK_EXT_debug_utils ===
+ using VULKAN_HPP_RAII_NAMESPACE::DebugUtilsMessengerEXT;
+
+ //=== VK_KHR_acceleration_structure ===
+ using VULKAN_HPP_RAII_NAMESPACE::AccelerationStructureKHR;
+
+ //=== VK_EXT_validation_cache ===
+ using VULKAN_HPP_RAII_NAMESPACE::ValidationCacheEXT;
+
+ //=== VK_NV_ray_tracing ===
+ using VULKAN_HPP_RAII_NAMESPACE::AccelerationStructureNV;
+
+ //=== VK_INTEL_performance_query ===
+ using VULKAN_HPP_RAII_NAMESPACE::PerformanceConfigurationINTEL;
+
+ //=== VK_KHR_deferred_host_operations ===
+ using VULKAN_HPP_RAII_NAMESPACE::DeferredOperationKHR;
+
+ //=== VK_NV_device_generated_commands ===
+ using VULKAN_HPP_RAII_NAMESPACE::IndirectCommandsLayoutNV;
+
+# if defined( VK_USE_PLATFORM_FUCHSIA )
+ //=== VK_FUCHSIA_buffer_collection ===
+ using VULKAN_HPP_RAII_NAMESPACE::BufferCollectionFUCHSIA;
+# endif /*VK_USE_PLATFORM_FUCHSIA*/
+
+ //=== VK_EXT_opacity_micromap ===
+ using VULKAN_HPP_RAII_NAMESPACE::MicromapEXT;
+
+ //=== VK_NV_optical_flow ===
+ using VULKAN_HPP_RAII_NAMESPACE::OpticalFlowSessionNV;
+
+ //=== VK_EXT_shader_object ===
+ using VULKAN_HPP_RAII_NAMESPACE::ShaderEXT;
+ using VULKAN_HPP_RAII_NAMESPACE::ShaderEXTs;
+
+ } // namespace VULKAN_HPP_RAII_NAMESPACE
+#endif
+} // namespace VULKAN_HPP_NAMESPACE
diff --git a/include/vulkan/vulkan.hpp b/include/vulkan/vulkan.hpp
index f95d855..796ef40 100644
--- a/include/vulkan/vulkan.hpp
+++ b/include/vulkan/vulkan.hpp
@@ -8,37 +8,17 @@
#ifndef VULKAN_HPP
#define VULKAN_HPP
-#if defined( _MSVC_LANG )
-# define VULKAN_HPP_CPLUSPLUS _MSVC_LANG
-#else
-# define VULKAN_HPP_CPLUSPLUS __cplusplus
-#endif
-
-#if 201703L < VULKAN_HPP_CPLUSPLUS
-# define VULKAN_HPP_CPP_VERSION 20
-#elif 201402L < VULKAN_HPP_CPLUSPLUS
-# define VULKAN_HPP_CPP_VERSION 17
-#elif 201103L < VULKAN_HPP_CPLUSPLUS
-# define VULKAN_HPP_CPP_VERSION 14
-#elif 199711L < VULKAN_HPP_CPLUSPLUS
-# define VULKAN_HPP_CPP_VERSION 11
-#else
-# error "vulkan.hpp needs at least c++ standard version 11"
-#endif
-
#include <algorithm>
#include <array> // ArrayWrapperND
#include <string> // std::string
#include <vulkan/vulkan.h>
+#include <vulkan/vulkan_hpp_macros.hpp>
+
#if 17 <= VULKAN_HPP_CPP_VERSION
# include <string_view> // std::string_view
#endif
-#if defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
-# if !defined( VULKAN_HPP_NO_SMART_HANDLE )
-# define VULKAN_HPP_NO_SMART_HANDLE
-# endif
-#else
+#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
# include <tuple> // std::tie
# include <vector> // std::vector
#endif
@@ -47,39 +27,8 @@
# include <system_error> // std::is_error_code_enum
#endif
-#if defined( VULKAN_HPP_NO_CONSTRUCTORS )
-# if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
-# define VULKAN_HPP_NO_STRUCT_CONSTRUCTORS
-# endif
-# if !defined( VULKAN_HPP_NO_UNION_CONSTRUCTORS )
-# define VULKAN_HPP_NO_UNION_CONSTRUCTORS
-# endif
-#endif
-
-#if defined( VULKAN_HPP_NO_SETTERS )
-# if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
-# define VULKAN_HPP_NO_STRUCT_SETTERS
-# endif
-# if !defined( VULKAN_HPP_NO_UNION_SETTERS )
-# define VULKAN_HPP_NO_UNION_SETTERS
-# endif
-#endif
-
-#if !defined( VULKAN_HPP_ASSERT )
+#if ( VULKAN_HPP_ASSERT == assert )
# include <cassert>
-# define VULKAN_HPP_ASSERT assert
-#endif
-
-#if !defined( VULKAN_HPP_ASSERT_ON_RESULT )
-# define VULKAN_HPP_ASSERT_ON_RESULT VULKAN_HPP_ASSERT
-#endif
-
-#if !defined( VULKAN_HPP_STATIC_ASSERT )
-# define VULKAN_HPP_STATIC_ASSERT static_assert
-#endif
-
-#if !defined( VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL )
-# define VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL 1
#endif
#if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL == 1
@@ -98,31 +47,15 @@
# endif
#endif
-#if !defined( __has_include )
-# define __has_include( x ) false
-#endif
-
-#if ( 201907 <= __cpp_lib_three_way_comparison ) && __has_include( <compare> ) && !defined( VULKAN_HPP_NO_SPACESHIP_OPERATOR )
-# define VULKAN_HPP_HAS_SPACESHIP_OPERATOR
-#endif
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
# include <compare>
#endif
-#if ( 201803 <= __cpp_lib_span )
-# define VULKAN_HPP_SUPPORT_SPAN
+#if defined( VULKAN_HPP_SUPPORT_SPAN )
# include <span>
#endif
-static_assert( VK_HEADER_VERSION == 263, "Wrong VK_HEADER_VERSION!" );
-
-// 32-bit vulkan is not typesafe for non-dispatchable handles, so don't allow copy constructors on this platform by default.
-// To enable this feature on 32-bit platforms please define VULKAN_HPP_TYPESAFE_CONVERSION
-#if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
-# if !defined( VULKAN_HPP_TYPESAFE_CONVERSION )
-# define VULKAN_HPP_TYPESAFE_CONVERSION
-# endif
-#endif
+static_assert( VK_HEADER_VERSION == 266, "Wrong VK_HEADER_VERSION!" );
// <tuple> includes <sys/sysmacros.h> through some other header
// this results in major(x) being resolved to gnu_dev_major(x)
@@ -151,115 +84,6 @@
constexpr int False = 0;
#endif
-#if defined( __GNUC__ )
-# define GCC_VERSION ( __GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__ )
-#endif
-
-#if !defined( VULKAN_HPP_HAS_UNRESTRICTED_UNIONS )
-# if defined( __clang__ )
-# if __has_feature( cxx_unrestricted_unions )
-# define VULKAN_HPP_HAS_UNRESTRICTED_UNIONS
-# endif
-# elif defined( __GNUC__ )
-# if 40600 <= GCC_VERSION
-# define VULKAN_HPP_HAS_UNRESTRICTED_UNIONS
-# endif
-# elif defined( _MSC_VER )
-# if 1900 <= _MSC_VER
-# define VULKAN_HPP_HAS_UNRESTRICTED_UNIONS
-# endif
-# endif
-#endif
-
-#if !defined( VULKAN_HPP_INLINE )
-# if defined( __clang__ )
-# if __has_attribute( always_inline )
-# define VULKAN_HPP_INLINE __attribute__( ( always_inline ) ) __inline__
-# else
-# define VULKAN_HPP_INLINE inline
-# endif
-# elif defined( __GNUC__ )
-# define VULKAN_HPP_INLINE __attribute__( ( always_inline ) ) __inline__
-# elif defined( _MSC_VER )
-# define VULKAN_HPP_INLINE inline
-# else
-# define VULKAN_HPP_INLINE inline
-# endif
-#endif
-
-#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
-# define VULKAN_HPP_TYPESAFE_EXPLICIT
-#else
-# define VULKAN_HPP_TYPESAFE_EXPLICIT explicit
-#endif
-
-#if defined( __cpp_constexpr )
-# define VULKAN_HPP_CONSTEXPR constexpr
-# if 201304 <= __cpp_constexpr
-# define VULKAN_HPP_CONSTEXPR_14 constexpr
-# else
-# define VULKAN_HPP_CONSTEXPR_14
-# endif
-# if ( 201907 <= __cpp_constexpr ) && ( !defined( __GNUC__ ) || ( 110400 < GCC_VERSION ) )
-# define VULKAN_HPP_CONSTEXPR_20 constexpr
-# else
-# define VULKAN_HPP_CONSTEXPR_20
-# endif
-# define VULKAN_HPP_CONST_OR_CONSTEXPR constexpr
-#else
-# define VULKAN_HPP_CONSTEXPR
-# define VULKAN_HPP_CONSTEXPR_14
-# define VULKAN_HPP_CONST_OR_CONSTEXPR const
-#endif
-
-#if !defined( VULKAN_HPP_CONSTEXPR_INLINE )
-# if 201606L <= __cpp_inline_variables
-# define VULKAN_HPP_CONSTEXPR_INLINE VULKAN_HPP_CONSTEXPR inline
-# else
-# define VULKAN_HPP_CONSTEXPR_INLINE VULKAN_HPP_CONSTEXPR
-# endif
-#endif
-
-#if !defined( VULKAN_HPP_NOEXCEPT )
-# if defined( _MSC_VER ) && ( _MSC_VER <= 1800 )
-# define VULKAN_HPP_NOEXCEPT
-# else
-# define VULKAN_HPP_NOEXCEPT noexcept
-# define VULKAN_HPP_HAS_NOEXCEPT 1
-# if defined( VULKAN_HPP_NO_EXCEPTIONS )
-# define VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS noexcept
-# else
-# define VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
-# endif
-# endif
-#endif
-
-#if 14 <= VULKAN_HPP_CPP_VERSION
-# define VULKAN_HPP_DEPRECATED( msg ) [[deprecated( msg )]]
-#else
-# define VULKAN_HPP_DEPRECATED( msg )
-#endif
-
-#if ( 17 <= VULKAN_HPP_CPP_VERSION ) && !defined( VULKAN_HPP_NO_NODISCARD_WARNINGS )
-# define VULKAN_HPP_NODISCARD [[nodiscard]]
-# if defined( VULKAN_HPP_NO_EXCEPTIONS )
-# define VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS [[nodiscard]]
-# else
-# define VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
-# endif
-#else
-# define VULKAN_HPP_NODISCARD
-# define VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
-#endif
-
-#if !defined( VULKAN_HPP_NAMESPACE )
-# define VULKAN_HPP_NAMESPACE vk
-#endif
-
-#define VULKAN_HPP_STRINGIFY2( text ) #text
-#define VULKAN_HPP_STRINGIFY( text ) VULKAN_HPP_STRINGIFY2( text )
-#define VULKAN_HPP_NAMESPACE_STRING VULKAN_HPP_STRINGIFY( VULKAN_HPP_NAMESPACE )
-
namespace VULKAN_HPP_NAMESPACE
{
template <typename T, size_t N>
@@ -401,212 +225,6 @@
}
};
- template <typename FlagBitsType>
- struct FlagTraits
- {
- static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = false;
- };
-
- template <typename BitType>
- class Flags
- {
- public:
- using MaskType = typename std::underlying_type<BitType>::type;
-
- // constructors
- VULKAN_HPP_CONSTEXPR Flags() VULKAN_HPP_NOEXCEPT : m_mask( 0 ) {}
-
- VULKAN_HPP_CONSTEXPR Flags( BitType bit ) VULKAN_HPP_NOEXCEPT : m_mask( static_cast<MaskType>( bit ) ) {}
-
- VULKAN_HPP_CONSTEXPR Flags( Flags<BitType> const & rhs ) VULKAN_HPP_NOEXCEPT = default;
-
- VULKAN_HPP_CONSTEXPR explicit Flags( MaskType flags ) VULKAN_HPP_NOEXCEPT : m_mask( flags ) {}
-
- // relational operators
-#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
- auto operator<=>( Flags<BitType> const & ) const = default;
-#else
- VULKAN_HPP_CONSTEXPR bool operator<( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
- {
- return m_mask < rhs.m_mask;
- }
-
- VULKAN_HPP_CONSTEXPR bool operator<=( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
- {
- return m_mask <= rhs.m_mask;
- }
-
- VULKAN_HPP_CONSTEXPR bool operator>( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
- {
- return m_mask > rhs.m_mask;
- }
-
- VULKAN_HPP_CONSTEXPR bool operator>=( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
- {
- return m_mask >= rhs.m_mask;
- }
-
- VULKAN_HPP_CONSTEXPR bool operator==( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
- {
- return m_mask == rhs.m_mask;
- }
-
- VULKAN_HPP_CONSTEXPR bool operator!=( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
- {
- return m_mask != rhs.m_mask;
- }
-#endif
-
- // logical operator
- VULKAN_HPP_CONSTEXPR bool operator!() const VULKAN_HPP_NOEXCEPT
- {
- return !m_mask;
- }
-
- // bitwise operators
- VULKAN_HPP_CONSTEXPR Flags<BitType> operator&( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
- {
- return Flags<BitType>( m_mask & rhs.m_mask );
- }
-
- VULKAN_HPP_CONSTEXPR Flags<BitType> operator|( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
- {
- return Flags<BitType>( m_mask | rhs.m_mask );
- }
-
- VULKAN_HPP_CONSTEXPR Flags<BitType> operator^( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
- {
- return Flags<BitType>( m_mask ^ rhs.m_mask );
- }
-
- VULKAN_HPP_CONSTEXPR Flags<BitType> operator~() const VULKAN_HPP_NOEXCEPT
- {
- return Flags<BitType>( m_mask ^ FlagTraits<BitType>::allFlags.m_mask );
- }
-
- // assignment operators
- VULKAN_HPP_CONSTEXPR_14 Flags<BitType> & operator=( Flags<BitType> const & rhs ) VULKAN_HPP_NOEXCEPT = default;
-
- VULKAN_HPP_CONSTEXPR_14 Flags<BitType> & operator|=( Flags<BitType> const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- m_mask |= rhs.m_mask;
- return *this;
- }
-
- VULKAN_HPP_CONSTEXPR_14 Flags<BitType> & operator&=( Flags<BitType> const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- m_mask &= rhs.m_mask;
- return *this;
- }
-
- VULKAN_HPP_CONSTEXPR_14 Flags<BitType> & operator^=( Flags<BitType> const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- m_mask ^= rhs.m_mask;
- return *this;
- }
-
- // cast operators
- explicit VULKAN_HPP_CONSTEXPR operator bool() const VULKAN_HPP_NOEXCEPT
- {
- return !!m_mask;
- }
-
- explicit VULKAN_HPP_CONSTEXPR operator MaskType() const VULKAN_HPP_NOEXCEPT
- {
- return m_mask;
- }
-
-#if defined( VULKAN_HPP_FLAGS_MASK_TYPE_AS_PUBLIC )
- public:
-#else
- private:
-#endif
- MaskType m_mask;
- };
-
-#if !defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
- // relational operators only needed for pre C++20
- template <typename BitType>
- VULKAN_HPP_CONSTEXPR bool operator<( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
- {
- return flags.operator>( bit );
- }
-
- template <typename BitType>
- VULKAN_HPP_CONSTEXPR bool operator<=( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
- {
- return flags.operator>=( bit );
- }
-
- template <typename BitType>
- VULKAN_HPP_CONSTEXPR bool operator>( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
- {
- return flags.operator<( bit );
- }
-
- template <typename BitType>
- VULKAN_HPP_CONSTEXPR bool operator>=( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
- {
- return flags.operator<=( bit );
- }
-
- template <typename BitType>
- VULKAN_HPP_CONSTEXPR bool operator==( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
- {
- return flags.operator==( bit );
- }
-
- template <typename BitType>
- VULKAN_HPP_CONSTEXPR bool operator!=( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
- {
- return flags.operator!=( bit );
- }
-#endif
-
- // bitwise operators
- template <typename BitType>
- VULKAN_HPP_CONSTEXPR Flags<BitType> operator&( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
- {
- return flags.operator&( bit );
- }
-
- template <typename BitType>
- VULKAN_HPP_CONSTEXPR Flags<BitType> operator|( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
- {
- return flags.operator|( bit );
- }
-
- template <typename BitType>
- VULKAN_HPP_CONSTEXPR Flags<BitType> operator^( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
- {
- return flags.operator^( bit );
- }
-
- // bitwise operators on BitType
- template <typename BitType, typename std::enable_if<FlagTraits<BitType>::isBitmask, bool>::type = true>
- VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR Flags<BitType> operator&( BitType lhs, BitType rhs ) VULKAN_HPP_NOEXCEPT
- {
- return Flags<BitType>( lhs ) & rhs;
- }
-
- template <typename BitType, typename std::enable_if<FlagTraits<BitType>::isBitmask, bool>::type = true>
- VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR Flags<BitType> operator|( BitType lhs, BitType rhs ) VULKAN_HPP_NOEXCEPT
- {
- return Flags<BitType>( lhs ) | rhs;
- }
-
- template <typename BitType, typename std::enable_if<FlagTraits<BitType>::isBitmask, bool>::type = true>
- VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR Flags<BitType> operator^( BitType lhs, BitType rhs ) VULKAN_HPP_NOEXCEPT
- {
- return Flags<BitType>( lhs ) ^ rhs;
- }
-
- template <typename BitType, typename std::enable_if<FlagTraits<BitType>::isBitmask, bool>::type = true>
- VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR Flags<BitType> operator~( BitType bit ) VULKAN_HPP_NOEXCEPT
- {
- return ~( Flags<BitType>( bit ) );
- }
-
#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
template <typename T>
class ArrayProxy
@@ -6093,6 +5711,36 @@
return ::vkGetDynamicRenderingTilePropertiesQCOM( device, pRenderingInfo, pProperties );
}
+ //=== VK_NV_low_latency2 ===
+
+ VkResult vkSetLatencySleepModeNV( VkDevice device, VkSwapchainKHR swapchain, VkLatencySleepModeInfoNV * pSleepModeInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkSetLatencySleepModeNV( device, swapchain, pSleepModeInfo );
+ }
+
+ VkResult vkLatencySleepNV( VkDevice device, VkSwapchainKHR swapchain, VkLatencySleepInfoNV * pSleepInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkLatencySleepNV( device, swapchain, pSleepInfo );
+ }
+
+ void vkSetLatencyMarkerNV( VkDevice device, VkSwapchainKHR swapchain, VkSetLatencyMarkerInfoNV * pLatencyMarkerInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkSetLatencyMarkerNV( device, swapchain, pLatencyMarkerInfo );
+ }
+
+ void vkGetLatencyTimingsNV( VkDevice device,
+ VkSwapchainKHR swapchain,
+ uint32_t * pTimingCount,
+ VkGetLatencyMarkerInfoNV * pLatencyMarkerInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetLatencyTimingsNV( device, swapchain, pTimingCount, pLatencyMarkerInfo );
+ }
+
+ void vkQueueNotifyOutOfBandNV( VkQueue queue, VkOutOfBandQueueTypeInfoNV pQueueTypeInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkQueueNotifyOutOfBandNV( queue, pQueueTypeInfo );
+ }
+
//=== VK_KHR_cooperative_matrix ===
VkResult vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR( VkPhysicalDevice physicalDevice,
@@ -6120,76 +5768,12 @@
}
# endif /*VK_USE_PLATFORM_SCREEN_QNX*/
};
-#endif
- class DispatchLoaderDynamic;
-#if !defined( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC )
-# if defined( VK_NO_PROTOTYPES )
-# define VULKAN_HPP_DISPATCH_LOADER_DYNAMIC 1
-# else
-# define VULKAN_HPP_DISPATCH_LOADER_DYNAMIC 0
-# endif
-#endif
-
-#if !defined( VULKAN_HPP_STORAGE_API )
-# if defined( VULKAN_HPP_STORAGE_SHARED )
-# if defined( _MSC_VER )
-# if defined( VULKAN_HPP_STORAGE_SHARED_EXPORT )
-# define VULKAN_HPP_STORAGE_API __declspec( dllexport )
-# else
-# define VULKAN_HPP_STORAGE_API __declspec( dllimport )
-# endif
-# elif defined( __clang__ ) || defined( __GNUC__ )
-# if defined( VULKAN_HPP_STORAGE_SHARED_EXPORT )
-# define VULKAN_HPP_STORAGE_API __attribute__( ( visibility( "default" ) ) )
-# else
-# define VULKAN_HPP_STORAGE_API
-# endif
-# else
-# define VULKAN_HPP_STORAGE_API
-# pragma warning Unknown import / export semantics
-# endif
-# else
-# define VULKAN_HPP_STORAGE_API
-# endif
-#endif
-
-#if !defined( VULKAN_HPP_DEFAULT_DISPATCHER )
-# if VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1
-# define VULKAN_HPP_DEFAULT_DISPATCHER ::VULKAN_HPP_NAMESPACE::defaultDispatchLoaderDynamic
-# define VULKAN_HPP_DEFAULT_DISPATCH_LOADER_DYNAMIC_STORAGE \
- namespace VULKAN_HPP_NAMESPACE \
- { \
- VULKAN_HPP_STORAGE_API DispatchLoaderDynamic defaultDispatchLoaderDynamic; \
- }
- extern VULKAN_HPP_STORAGE_API DispatchLoaderDynamic defaultDispatchLoaderDynamic;
-# else
inline ::VULKAN_HPP_NAMESPACE::DispatchLoaderStatic & getDispatchLoaderStatic()
{
static ::VULKAN_HPP_NAMESPACE::DispatchLoaderStatic dls;
return dls;
}
-# define VULKAN_HPP_DEFAULT_DISPATCHER ::VULKAN_HPP_NAMESPACE::getDispatchLoaderStatic()
-# define VULKAN_HPP_DEFAULT_DISPATCH_LOADER_DYNAMIC_STORAGE
-# endif
-#endif
-
-#if !defined( VULKAN_HPP_DEFAULT_DISPATCHER_TYPE )
-# if VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1
-# define VULKAN_HPP_DEFAULT_DISPATCHER_TYPE ::VULKAN_HPP_NAMESPACE::DispatchLoaderDynamic
-# else
-# define VULKAN_HPP_DEFAULT_DISPATCHER_TYPE ::VULKAN_HPP_NAMESPACE::DispatchLoaderStatic
-# endif
-#endif
-
-#if defined( VULKAN_HPP_NO_DEFAULT_DISPATCHER )
-# define VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT
-# define VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT
-# define VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT
-#else
-# define VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT = {}
-# define VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT = nullptr
-# define VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT = VULKAN_HPP_DEFAULT_DISPATCHER
#endif
#if !defined( VULKAN_HPP_NO_SMART_HANDLE )
@@ -7034,40 +6618,40 @@
VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxDriverInfoSize = VK_MAX_DRIVER_INFO_SIZE;
//=== VK_KHR_device_group_creation ===
- VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxDeviceGroupSizeKhr = VK_MAX_DEVICE_GROUP_SIZE_KHR;
+ VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxDeviceGroupSizeKHR = VK_MAX_DEVICE_GROUP_SIZE_KHR;
//=== VK_KHR_external_memory_capabilities ===
- VULKAN_HPP_CONSTEXPR_INLINE uint32_t LuidSizeKhr = VK_LUID_SIZE_KHR;
+ VULKAN_HPP_CONSTEXPR_INLINE uint32_t LuidSizeKHR = VK_LUID_SIZE_KHR;
//=== VK_KHR_external_memory ===
- VULKAN_HPP_CONSTEXPR_INLINE uint32_t QueueFamilyExternalKhr = VK_QUEUE_FAMILY_EXTERNAL_KHR;
+ VULKAN_HPP_CONSTEXPR_INLINE uint32_t QueueFamilyExternalKHR = VK_QUEUE_FAMILY_EXTERNAL_KHR;
#if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_AMDX_shader_enqueue ===
- VULKAN_HPP_CONSTEXPR_INLINE uint32_t ShaderIndexUnusedAmdx = VK_SHADER_INDEX_UNUSED_AMDX;
+ VULKAN_HPP_CONSTEXPR_INLINE uint32_t ShaderIndexUnusedAMDX = VK_SHADER_INDEX_UNUSED_AMDX;
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
//=== VK_KHR_ray_tracing_pipeline ===
- VULKAN_HPP_CONSTEXPR_INLINE uint32_t ShaderUnusedKhr = VK_SHADER_UNUSED_KHR;
+ VULKAN_HPP_CONSTEXPR_INLINE uint32_t ShaderUnusedKHR = VK_SHADER_UNUSED_KHR;
//=== VK_NV_ray_tracing ===
- VULKAN_HPP_CONSTEXPR_INLINE uint32_t ShaderUnusedNv = VK_SHADER_UNUSED_NV;
+ VULKAN_HPP_CONSTEXPR_INLINE uint32_t ShaderUnusedNV = VK_SHADER_UNUSED_NV;
//=== VK_KHR_global_priority ===
- VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxGlobalPrioritySizeKhr = VK_MAX_GLOBAL_PRIORITY_SIZE_KHR;
+ VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxGlobalPrioritySizeKHR = VK_MAX_GLOBAL_PRIORITY_SIZE_KHR;
//=== VK_KHR_driver_properties ===
- VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxDriverNameSizeKhr = VK_MAX_DRIVER_NAME_SIZE_KHR;
- VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxDriverInfoSizeKhr = VK_MAX_DRIVER_INFO_SIZE_KHR;
+ VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxDriverNameSizeKHR = VK_MAX_DRIVER_NAME_SIZE_KHR;
+ VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxDriverInfoSizeKHR = VK_MAX_DRIVER_INFO_SIZE_KHR;
//=== VK_EXT_global_priority_query ===
- VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxGlobalPrioritySizeExt = VK_MAX_GLOBAL_PRIORITY_SIZE_EXT;
+ VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxGlobalPrioritySizeEXT = VK_MAX_GLOBAL_PRIORITY_SIZE_EXT;
//=== VK_EXT_image_sliced_view_of_3d ===
- VULKAN_HPP_CONSTEXPR_INLINE uint32_t Remaining3DSlicesExt = VK_REMAINING_3D_SLICES_EXT;
+ VULKAN_HPP_CONSTEXPR_INLINE uint32_t Remaining3DSlicesEXT = VK_REMAINING_3D_SLICES_EXT;
//=== VK_EXT_shader_module_identifier ===
- VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxShaderModuleIdentifierSizeExt = VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT;
+ VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxShaderModuleIdentifierSizeEXT = VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT;
//========================
//=== CONSTEXPR VALUEs ===
@@ -9508,6 +9092,30 @@
};
};
template <>
+ struct StructExtends<ExternalFormatANDROID, AttachmentDescription2>
+ {
+ enum
+ {
+ value = true
+ };
+ };
+ template <>
+ struct StructExtends<ExternalFormatANDROID, GraphicsPipelineCreateInfo>
+ {
+ enum
+ {
+ value = true
+ };
+ };
+ template <>
+ struct StructExtends<ExternalFormatANDROID, CommandBufferInheritanceInfo>
+ {
+ enum
+ {
+ value = true
+ };
+ };
+ template <>
struct StructExtends<AndroidHardwareBufferFormatProperties2ANDROID, AndroidHardwareBufferPropertiesANDROID>
{
enum
@@ -12249,6 +11857,56 @@
};
};
+ //=== VK_EXT_frame_boundary ===
+ template <>
+ struct StructExtends<PhysicalDeviceFrameBoundaryFeaturesEXT, PhysicalDeviceFeatures2>
+ {
+ enum
+ {
+ value = true
+ };
+ };
+ template <>
+ struct StructExtends<PhysicalDeviceFrameBoundaryFeaturesEXT, DeviceCreateInfo>
+ {
+ enum
+ {
+ value = true
+ };
+ };
+ template <>
+ struct StructExtends<FrameBoundaryEXT, SubmitInfo>
+ {
+ enum
+ {
+ value = true
+ };
+ };
+ template <>
+ struct StructExtends<FrameBoundaryEXT, SubmitInfo2>
+ {
+ enum
+ {
+ value = true
+ };
+ };
+ template <>
+ struct StructExtends<FrameBoundaryEXT, PresentInfoKHR>
+ {
+ enum
+ {
+ value = true
+ };
+ };
+ template <>
+ struct StructExtends<FrameBoundaryEXT, BindSparseInfo>
+ {
+ enum
+ {
+ value = true
+ };
+ };
+
//=== VK_EXT_multisampled_render_to_single_sampled ===
template <>
struct StructExtends<PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT, PhysicalDeviceFeatures2>
@@ -13129,6 +12787,42 @@
};
};
+# if defined( VK_USE_PLATFORM_ANDROID_KHR )
+ //=== VK_ANDROID_external_format_resolve ===
+ template <>
+ struct StructExtends<PhysicalDeviceExternalFormatResolveFeaturesANDROID, PhysicalDeviceFeatures2>
+ {
+ enum
+ {
+ value = true
+ };
+ };
+ template <>
+ struct StructExtends<PhysicalDeviceExternalFormatResolveFeaturesANDROID, DeviceCreateInfo>
+ {
+ enum
+ {
+ value = true
+ };
+ };
+ template <>
+ struct StructExtends<PhysicalDeviceExternalFormatResolvePropertiesANDROID, PhysicalDeviceProperties2>
+ {
+ enum
+ {
+ value = true
+ };
+ };
+ template <>
+ struct StructExtends<AndroidHardwareBufferFormatResolvePropertiesANDROID, AndroidHardwareBufferPropertiesANDROID>
+ {
+ enum
+ {
+ value = true
+ };
+ };
+# endif /*VK_USE_PLATFORM_ANDROID_KHR*/
+
//=== VK_KHR_maintenance5 ===
template <>
struct StructExtends<PhysicalDeviceMaintenance5FeaturesKHR, PhysicalDeviceFeatures2>
@@ -13447,6 +13141,40 @@
};
};
+ //=== VK_NV_low_latency2 ===
+ template <>
+ struct StructExtends<LatencySubmissionPresentIdNV, SubmitInfo>
+ {
+ enum
+ {
+ value = true
+ };
+ };
+ template <>
+ struct StructExtends<LatencySubmissionPresentIdNV, SubmitInfo2>
+ {
+ enum
+ {
+ value = true
+ };
+ };
+ template <>
+ struct StructExtends<SwapchainLatencyCreateInfoNV, SwapchainCreateInfoKHR>
+ {
+ enum
+ {
+ value = true
+ };
+ };
+ template <>
+ struct StructExtends<LatencySurfaceCapabilitiesNV, SurfaceCapabilities2KHR>
+ {
+ enum
+ {
+ value = true
+ };
+ };
+
//=== VK_KHR_cooperative_matrix ===
template <>
struct StructExtends<PhysicalDeviceCooperativeMatrixFeaturesKHR, PhysicalDeviceFeatures2>
@@ -13689,6 +13417,16 @@
};
# endif /*VK_USE_PLATFORM_SCREEN_QNX*/
+ //=== VK_MSFT_layered_driver ===
+ template <>
+ struct StructExtends<PhysicalDeviceLayeredDriverPropertiesMSFT, PhysicalDeviceProperties2>
+ {
+ enum
+ {
+ value = true
+ };
+ };
+
//=== VK_NV_descriptor_pool_overallocation ===
template <>
struct StructExtends<PhysicalDeviceDescriptorPoolOverallocationFeaturesNV, PhysicalDeviceFeatures2>
@@ -14893,6 +14631,13 @@
PFN_vkGetFramebufferTilePropertiesQCOM vkGetFramebufferTilePropertiesQCOM = 0;
PFN_vkGetDynamicRenderingTilePropertiesQCOM vkGetDynamicRenderingTilePropertiesQCOM = 0;
+ //=== VK_NV_low_latency2 ===
+ PFN_vkSetLatencySleepModeNV vkSetLatencySleepModeNV = 0;
+ PFN_vkLatencySleepNV vkLatencySleepNV = 0;
+ PFN_vkSetLatencyMarkerNV vkSetLatencyMarkerNV = 0;
+ PFN_vkGetLatencyTimingsNV vkGetLatencyTimingsNV = 0;
+ PFN_vkQueueNotifyOutOfBandNV vkQueueNotifyOutOfBandNV = 0;
+
//=== VK_KHR_cooperative_matrix ===
PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR = 0;
@@ -14915,6 +14660,33 @@
init( getInstanceProcAddr );
}
+ // This interface does not require a linked vulkan library.
+ DispatchLoaderDynamic( VkInstance instance,
+ PFN_vkGetInstanceProcAddr getInstanceProcAddr,
+ VkDevice device = {},
+ PFN_vkGetDeviceProcAddr getDeviceProcAddr = nullptr ) VULKAN_HPP_NOEXCEPT
+ {
+ init( instance, getInstanceProcAddr, device, getDeviceProcAddr );
+ }
+
+ template <typename DynamicLoader
+#if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL
+ = VULKAN_HPP_NAMESPACE::DynamicLoader
+#endif
+ >
+ void init()
+ {
+ static DynamicLoader dl;
+ init( dl );
+ }
+
+ template <typename DynamicLoader>
+ void init( DynamicLoader const & dl ) VULKAN_HPP_NOEXCEPT
+ {
+ PFN_vkGetInstanceProcAddr getInstanceProcAddr = dl.template getProcAddress<PFN_vkGetInstanceProcAddr>( "vkGetInstanceProcAddr" );
+ init( getInstanceProcAddr );
+ }
+
void init( PFN_vkGetInstanceProcAddr getInstanceProcAddr ) VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( getInstanceProcAddr );
@@ -14932,15 +14704,6 @@
}
// This interface does not require a linked vulkan library.
- DispatchLoaderDynamic( VkInstance instance,
- PFN_vkGetInstanceProcAddr getInstanceProcAddr,
- VkDevice device = {},
- PFN_vkGetDeviceProcAddr getDeviceProcAddr = nullptr ) VULKAN_HPP_NOEXCEPT
- {
- init( instance, getInstanceProcAddr, device, getDeviceProcAddr );
- }
-
- // This interface does not require a linked vulkan library.
void init( VkInstance instance,
PFN_vkGetInstanceProcAddr getInstanceProcAddr,
VkDevice device = {},
@@ -16236,6 +15999,13 @@
vkGetDynamicRenderingTilePropertiesQCOM =
PFN_vkGetDynamicRenderingTilePropertiesQCOM( vkGetInstanceProcAddr( instance, "vkGetDynamicRenderingTilePropertiesQCOM" ) );
+ //=== VK_NV_low_latency2 ===
+ vkSetLatencySleepModeNV = PFN_vkSetLatencySleepModeNV( vkGetInstanceProcAddr( instance, "vkSetLatencySleepModeNV" ) );
+ vkLatencySleepNV = PFN_vkLatencySleepNV( vkGetInstanceProcAddr( instance, "vkLatencySleepNV" ) );
+ vkSetLatencyMarkerNV = PFN_vkSetLatencyMarkerNV( vkGetInstanceProcAddr( instance, "vkSetLatencyMarkerNV" ) );
+ vkGetLatencyTimingsNV = PFN_vkGetLatencyTimingsNV( vkGetInstanceProcAddr( instance, "vkGetLatencyTimingsNV" ) );
+ vkQueueNotifyOutOfBandNV = PFN_vkQueueNotifyOutOfBandNV( vkGetInstanceProcAddr( instance, "vkQueueNotifyOutOfBandNV" ) );
+
//=== VK_KHR_cooperative_matrix ===
vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR =
PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR" ) );
@@ -17243,6 +17013,13 @@
vkGetDynamicRenderingTilePropertiesQCOM =
PFN_vkGetDynamicRenderingTilePropertiesQCOM( vkGetDeviceProcAddr( device, "vkGetDynamicRenderingTilePropertiesQCOM" ) );
+ //=== VK_NV_low_latency2 ===
+ vkSetLatencySleepModeNV = PFN_vkSetLatencySleepModeNV( vkGetDeviceProcAddr( device, "vkSetLatencySleepModeNV" ) );
+ vkLatencySleepNV = PFN_vkLatencySleepNV( vkGetDeviceProcAddr( device, "vkLatencySleepNV" ) );
+ vkSetLatencyMarkerNV = PFN_vkSetLatencyMarkerNV( vkGetDeviceProcAddr( device, "vkSetLatencyMarkerNV" ) );
+ vkGetLatencyTimingsNV = PFN_vkGetLatencyTimingsNV( vkGetDeviceProcAddr( device, "vkGetLatencyTimingsNV" ) );
+ vkQueueNotifyOutOfBandNV = PFN_vkQueueNotifyOutOfBandNV( vkGetDeviceProcAddr( device, "vkQueueNotifyOutOfBandNV" ) );
+
//=== VK_EXT_attachment_feedback_loop_dynamic_state ===
vkCmdSetAttachmentFeedbackLoopEnableEXT =
PFN_vkCmdSetAttachmentFeedbackLoopEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetAttachmentFeedbackLoopEnableEXT" ) );
diff --git a/include/vulkan/vulkan_android.h b/include/vulkan/vulkan_android.h
index d86f43f..40b3c67 100644
--- a/include/vulkan/vulkan_android.h
+++ b/include/vulkan/vulkan_android.h
@@ -120,6 +120,32 @@
struct AHardwareBuffer** pBuffer);
#endif
+
+// VK_ANDROID_external_format_resolve is a preprocessor guard. Do not pass it to API calls.
+#define VK_ANDROID_external_format_resolve 1
+#define VK_ANDROID_EXTERNAL_FORMAT_RESOLVE_SPEC_VERSION 1
+#define VK_ANDROID_EXTERNAL_FORMAT_RESOLVE_EXTENSION_NAME "VK_ANDROID_external_format_resolve"
+typedef struct VkPhysicalDeviceExternalFormatResolveFeaturesANDROID {
+ VkStructureType sType;
+ void* pNext;
+ VkBool32 externalFormatResolve;
+} VkPhysicalDeviceExternalFormatResolveFeaturesANDROID;
+
+typedef struct VkPhysicalDeviceExternalFormatResolvePropertiesANDROID {
+ VkStructureType sType;
+ void* pNext;
+ VkBool32 nullColorAttachmentWithExternalFormatResolve;
+ VkChromaLocation externalFormatResolveChromaOffsetX;
+ VkChromaLocation externalFormatResolveChromaOffsetY;
+} VkPhysicalDeviceExternalFormatResolvePropertiesANDROID;
+
+typedef struct VkAndroidHardwareBufferFormatResolvePropertiesANDROID {
+ VkStructureType sType;
+ void* pNext;
+ VkFormat colorAttachmentFormat;
+} VkAndroidHardwareBufferFormatResolvePropertiesANDROID;
+
+
#ifdef __cplusplus
}
#endif
diff --git a/include/vulkan/vulkan_core.h b/include/vulkan/vulkan_core.h
index bd88270..c6e8aab 100644
--- a/include/vulkan/vulkan_core.h
+++ b/include/vulkan/vulkan_core.h
@@ -27,7 +27,7 @@
#ifndef VK_USE_64_BIT_PTR_DEFINES
- #if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__) ) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__)
+ #if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__) ) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__) || (defined(__riscv) && __riscv_xlen == 64)
#define VK_USE_64_BIT_PTR_DEFINES 1
#else
#define VK_USE_64_BIT_PTR_DEFINES 0
@@ -69,7 +69,7 @@
#define VK_API_VERSION_1_0 VK_MAKE_API_VERSION(0, 1, 0, 0)// Patch version should always be set to 0
// Version of this file
-#define VK_HEADER_VERSION 263
+#define VK_HEADER_VERSION 266
// Complete version of this file
#define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 3, VK_HEADER_VERSION)
@@ -992,6 +992,8 @@
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV = 1000371001,
VK_STRUCTURE_TYPE_PIPELINE_PROPERTIES_IDENTIFIER_EXT = 1000372000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT = 1000372001,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT = 1000375000,
+ VK_STRUCTURE_TYPE_FRAME_BOUNDARY_EXT = 1000375001,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT = 1000376000,
VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT = 1000376001,
VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT = 1000376002,
@@ -1078,6 +1080,9 @@
VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV = 1000464010,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT = 1000465000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT = 1000466000,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_FEATURES_ANDROID = 1000468000,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_PROPERTIES_ANDROID = 1000468001,
+ VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_RESOLVE_PROPERTIES_ANDROID = 1000468002,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR = 1000470000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR = 1000470001,
VK_STRUCTURE_TYPE_RENDERING_AREA_INFO_KHR = 1000470003,
@@ -1103,6 +1108,15 @@
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM = 1000497001,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT = 1000498000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT = 1000499000,
+ VK_STRUCTURE_TYPE_LATENCY_SLEEP_MODE_INFO_NV = 1000505000,
+ VK_STRUCTURE_TYPE_LATENCY_SLEEP_INFO_NV = 1000505001,
+ VK_STRUCTURE_TYPE_SET_LATENCY_MARKER_INFO_NV = 1000505002,
+ VK_STRUCTURE_TYPE_GET_LATENCY_MARKER_INFO_NV = 1000505003,
+ VK_STRUCTURE_TYPE_LATENCY_TIMINGS_FRAME_REPORT_NV = 1000505004,
+ VK_STRUCTURE_TYPE_LATENCY_SUBMISSION_PRESENT_ID_NV = 1000505005,
+ VK_STRUCTURE_TYPE_OUT_OF_BAND_QUEUE_TYPE_INFO_NV = 1000505006,
+ VK_STRUCTURE_TYPE_SWAPCHAIN_LATENCY_CREATE_INFO_NV = 1000505007,
+ VK_STRUCTURE_TYPE_LATENCY_SURFACE_CAPABILITIES_NV = 1000505008,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR = 1000506000,
VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_KHR = 1000506001,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR = 1000506002,
@@ -1123,6 +1137,7 @@
VK_STRUCTURE_TYPE_IMPORT_SCREEN_BUFFER_INFO_QNX = 1000529002,
VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_QNX = 1000529003,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX = 1000529004,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT = 1000530000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV = 1000546000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES,
@@ -5796,6 +5811,7 @@
VK_DRIVER_ID_MESA_DOZEN = 23,
VK_DRIVER_ID_MESA_NVK = 24,
VK_DRIVER_ID_IMAGINATION_OPEN_SOURCE_MESA = 25,
+ VK_DRIVER_ID_MESA_AGXV = 26,
VK_DRIVER_ID_AMD_PROPRIETARY_KHR = VK_DRIVER_ID_AMD_PROPRIETARY,
VK_DRIVER_ID_AMD_OPEN_SOURCE_KHR = VK_DRIVER_ID_AMD_OPEN_SOURCE,
VK_DRIVER_ID_MESA_RADV_KHR = VK_DRIVER_ID_MESA_RADV,
@@ -5846,6 +5862,7 @@
VK_RESOLVE_MODE_AVERAGE_BIT = 0x00000002,
VK_RESOLVE_MODE_MIN_BIT = 0x00000004,
VK_RESOLVE_MODE_MAX_BIT = 0x00000008,
+ VK_RESOLVE_MODE_EXTERNAL_FORMAT_DOWNSAMPLE_ANDROID = 0x00000010,
VK_RESOLVE_MODE_NONE_KHR = VK_RESOLVE_MODE_NONE,
VK_RESOLVE_MODE_SAMPLE_ZERO_BIT_KHR = VK_RESOLVE_MODE_SAMPLE_ZERO_BIT,
VK_RESOLVE_MODE_AVERAGE_BIT_KHR = VK_RESOLVE_MODE_AVERAGE_BIT,
@@ -15830,6 +15847,38 @@
#endif
+// VK_EXT_frame_boundary is a preprocessor guard. Do not pass it to API calls.
+#define VK_EXT_frame_boundary 1
+#define VK_EXT_FRAME_BOUNDARY_SPEC_VERSION 1
+#define VK_EXT_FRAME_BOUNDARY_EXTENSION_NAME "VK_EXT_frame_boundary"
+
+typedef enum VkFrameBoundaryFlagBitsEXT {
+ VK_FRAME_BOUNDARY_FRAME_END_BIT_EXT = 0x00000001,
+ VK_FRAME_BOUNDARY_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
+} VkFrameBoundaryFlagBitsEXT;
+typedef VkFlags VkFrameBoundaryFlagsEXT;
+typedef struct VkPhysicalDeviceFrameBoundaryFeaturesEXT {
+ VkStructureType sType;
+ void* pNext;
+ VkBool32 frameBoundary;
+} VkPhysicalDeviceFrameBoundaryFeaturesEXT;
+
+typedef struct VkFrameBoundaryEXT {
+ VkStructureType sType;
+ const void* pNext;
+ VkFrameBoundaryFlagsEXT flags;
+ uint64_t frameID;
+ uint32_t imageCount;
+ const VkImage* pImages;
+ uint32_t bufferCount;
+ const VkBuffer* pBuffers;
+ uint64_t tagName;
+ size_t tagSize;
+ const void* pTag;
+} VkFrameBoundaryEXT;
+
+
+
// VK_EXT_multisampled_render_to_single_sampled is a preprocessor guard. Do not pass it to API calls.
#define VK_EXT_multisampled_render_to_single_sampled 1
#define VK_EXT_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_SPEC_VERSION 1
@@ -17546,6 +17595,138 @@
+// VK_NV_low_latency2 is a preprocessor guard. Do not pass it to API calls.
+#define VK_NV_low_latency2 1
+#define VK_NV_LOW_LATENCY_2_SPEC_VERSION 1
+#define VK_NV_LOW_LATENCY_2_EXTENSION_NAME "VK_NV_low_latency2"
+
+typedef enum VkLatencyMarkerNV {
+ VK_LATENCY_MARKER_SIMULATION_START_NV = 0,
+ VK_LATENCY_MARKER_SIMULATION_END_NV = 1,
+ VK_LATENCY_MARKER_RENDERSUBMIT_START_NV = 2,
+ VK_LATENCY_MARKER_RENDERSUBMIT_END_NV = 3,
+ VK_LATENCY_MARKER_PRESENT_START_NV = 4,
+ VK_LATENCY_MARKER_PRESENT_END_NV = 5,
+ VK_LATENCY_MARKER_INPUT_SAMPLE_NV = 6,
+ VK_LATENCY_MARKER_TRIGGER_FLASH_NV = 7,
+ VK_LATENCY_MARKER_OUT_OF_BAND_RENDERSUBMIT_START_NV = 8,
+ VK_LATENCY_MARKER_OUT_OF_BAND_RENDERSUBMIT_END_NV = 9,
+ VK_LATENCY_MARKER_OUT_OF_BAND_PRESENT_START_NV = 10,
+ VK_LATENCY_MARKER_OUT_OF_BAND_PRESENT_END_NV = 11,
+ VK_LATENCY_MARKER_MAX_ENUM_NV = 0x7FFFFFFF
+} VkLatencyMarkerNV;
+
+typedef enum VkOutOfBandQueueTypeNV {
+ VK_OUT_OF_BAND_QUEUE_TYPE_RENDER_NV = 0,
+ VK_OUT_OF_BAND_QUEUE_TYPE_PRESENT_NV = 1,
+ VK_OUT_OF_BAND_QUEUE_TYPE_MAX_ENUM_NV = 0x7FFFFFFF
+} VkOutOfBandQueueTypeNV;
+typedef struct VkLatencySleepModeInfoNV {
+ VkStructureType sType;
+ const void* pNext;
+ VkBool32 lowLatencyMode;
+ VkBool32 lowLatencyBoost;
+ uint32_t minimumIntervalUs;
+} VkLatencySleepModeInfoNV;
+
+typedef struct VkLatencySleepInfoNV {
+ VkStructureType sType;
+ const void* pNext;
+ VkSemaphore signalSemaphore;
+ uint64_t value;
+} VkLatencySleepInfoNV;
+
+typedef struct VkSetLatencyMarkerInfoNV {
+ VkStructureType sType;
+ const void* pNext;
+ uint64_t presentID;
+ VkLatencyMarkerNV marker;
+} VkSetLatencyMarkerInfoNV;
+
+typedef struct VkLatencyTimingsFrameReportNV {
+ VkStructureType sType;
+ const void* pNext;
+ uint64_t presentID;
+ uint64_t inputSampleTimeUs;
+ uint64_t simStartTimeUs;
+ uint64_t simEndTimeUs;
+ uint64_t renderSubmitStartTimeUs;
+ uint64_t renderSubmitEndTimeUs;
+ uint64_t presentStartTimeUs;
+ uint64_t presentEndTimeUs;
+ uint64_t driverStartTimeUs;
+ uint64_t driverEndTimeUs;
+ uint64_t osRenderQueueStartTimeUs;
+ uint64_t osRenderQueueEndTimeUs;
+ uint64_t gpuRenderStartTimeUs;
+ uint64_t gpuRenderEndTimeUs;
+} VkLatencyTimingsFrameReportNV;
+
+typedef struct VkGetLatencyMarkerInfoNV {
+ VkStructureType sType;
+ const void* pNext;
+ VkLatencyTimingsFrameReportNV* pTimings;
+} VkGetLatencyMarkerInfoNV;
+
+typedef struct VkLatencySubmissionPresentIdNV {
+ VkStructureType sType;
+ const void* pNext;
+ uint64_t presentID;
+} VkLatencySubmissionPresentIdNV;
+
+typedef struct VkSwapchainLatencyCreateInfoNV {
+ VkStructureType sType;
+ const void* pNext;
+ VkBool32 latencyModeEnable;
+} VkSwapchainLatencyCreateInfoNV;
+
+typedef struct VkOutOfBandQueueTypeInfoNV {
+ VkStructureType sType;
+ const void* pNext;
+ VkOutOfBandQueueTypeNV queueType;
+} VkOutOfBandQueueTypeInfoNV;
+
+typedef struct VkLatencySurfaceCapabilitiesNV {
+ VkStructureType sType;
+ const void* pNext;
+ uint32_t presentModeCount;
+ VkPresentModeKHR* pPresentModes;
+} VkLatencySurfaceCapabilitiesNV;
+
+typedef VkResult (VKAPI_PTR *PFN_vkSetLatencySleepModeNV)(VkDevice device, VkSwapchainKHR swapchain, VkLatencySleepModeInfoNV* pSleepModeInfo);
+typedef VkResult (VKAPI_PTR *PFN_vkLatencySleepNV)(VkDevice device, VkSwapchainKHR swapchain, VkLatencySleepInfoNV* pSleepInfo);
+typedef void (VKAPI_PTR *PFN_vkSetLatencyMarkerNV)(VkDevice device, VkSwapchainKHR swapchain, VkSetLatencyMarkerInfoNV* pLatencyMarkerInfo);
+typedef void (VKAPI_PTR *PFN_vkGetLatencyTimingsNV)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pTimingCount, VkGetLatencyMarkerInfoNV* pLatencyMarkerInfo);
+typedef void (VKAPI_PTR *PFN_vkQueueNotifyOutOfBandNV)(VkQueue queue, VkOutOfBandQueueTypeInfoNV pQueueTypeInfo);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkSetLatencySleepModeNV(
+ VkDevice device,
+ VkSwapchainKHR swapchain,
+ VkLatencySleepModeInfoNV* pSleepModeInfo);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkLatencySleepNV(
+ VkDevice device,
+ VkSwapchainKHR swapchain,
+ VkLatencySleepInfoNV* pSleepInfo);
+
+VKAPI_ATTR void VKAPI_CALL vkSetLatencyMarkerNV(
+ VkDevice device,
+ VkSwapchainKHR swapchain,
+ VkSetLatencyMarkerInfoNV* pLatencyMarkerInfo);
+
+VKAPI_ATTR void VKAPI_CALL vkGetLatencyTimingsNV(
+ VkDevice device,
+ VkSwapchainKHR swapchain,
+ uint32_t* pTimingCount,
+ VkGetLatencyMarkerInfoNV* pLatencyMarkerInfo);
+
+VKAPI_ATTR void VKAPI_CALL vkQueueNotifyOutOfBandNV(
+ VkQueue queue,
+ VkOutOfBandQueueTypeInfoNV pQueueTypeInfo);
+#endif
+
+
// VK_QCOM_multiview_per_view_render_areas is a preprocessor guard. Do not pass it to API calls.
#define VK_QCOM_multiview_per_view_render_areas 1
#define VK_QCOM_MULTIVIEW_PER_VIEW_RENDER_AREAS_SPEC_VERSION 1
@@ -17678,6 +17859,24 @@
#endif
+// VK_MSFT_layered_driver is a preprocessor guard. Do not pass it to API calls.
+#define VK_MSFT_layered_driver 1
+#define VK_MSFT_LAYERED_DRIVER_SPEC_VERSION 1
+#define VK_MSFT_LAYERED_DRIVER_EXTENSION_NAME "VK_MSFT_layered_driver"
+
+typedef enum VkLayeredDriverUnderlyingApiMSFT {
+ VK_LAYERED_DRIVER_UNDERLYING_API_NONE_MSFT = 0,
+ VK_LAYERED_DRIVER_UNDERLYING_API_D3D12_MSFT = 1,
+ VK_LAYERED_DRIVER_UNDERLYING_API_MAX_ENUM_MSFT = 0x7FFFFFFF
+} VkLayeredDriverUnderlyingApiMSFT;
+typedef struct VkPhysicalDeviceLayeredDriverPropertiesMSFT {
+ VkStructureType sType;
+ void* pNext;
+ VkLayeredDriverUnderlyingApiMSFT underlyingAPI;
+} VkPhysicalDeviceLayeredDriverPropertiesMSFT;
+
+
+
// VK_NV_descriptor_pool_overallocation is a preprocessor guard. Do not pass it to API calls.
#define VK_NV_descriptor_pool_overallocation 1
#define VK_NV_DESCRIPTOR_POOL_OVERALLOCATION_SPEC_VERSION 1
diff --git a/include/vulkan/vulkan_enums.hpp b/include/vulkan/vulkan_enums.hpp
index 9c5f90c..283db66 100644
--- a/include/vulkan/vulkan_enums.hpp
+++ b/include/vulkan/vulkan_enums.hpp
@@ -10,6 +10,212 @@
namespace VULKAN_HPP_NAMESPACE
{
+ template <typename FlagBitsType>
+ struct FlagTraits
+ {
+ static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = false;
+ };
+
+ template <typename BitType>
+ class Flags
+ {
+ public:
+ using MaskType = typename std::underlying_type<BitType>::type;
+
+ // constructors
+ VULKAN_HPP_CONSTEXPR Flags() VULKAN_HPP_NOEXCEPT : m_mask( 0 ) {}
+
+ VULKAN_HPP_CONSTEXPR Flags( BitType bit ) VULKAN_HPP_NOEXCEPT : m_mask( static_cast<MaskType>( bit ) ) {}
+
+ VULKAN_HPP_CONSTEXPR Flags( Flags<BitType> const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+ VULKAN_HPP_CONSTEXPR explicit Flags( MaskType flags ) VULKAN_HPP_NOEXCEPT : m_mask( flags ) {}
+
+ // relational operators
+#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+ auto operator<=>( Flags<BitType> const & ) const = default;
+#else
+ VULKAN_HPP_CONSTEXPR bool operator<( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return m_mask < rhs.m_mask;
+ }
+
+ VULKAN_HPP_CONSTEXPR bool operator<=( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return m_mask <= rhs.m_mask;
+ }
+
+ VULKAN_HPP_CONSTEXPR bool operator>( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return m_mask > rhs.m_mask;
+ }
+
+ VULKAN_HPP_CONSTEXPR bool operator>=( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return m_mask >= rhs.m_mask;
+ }
+
+ VULKAN_HPP_CONSTEXPR bool operator==( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return m_mask == rhs.m_mask;
+ }
+
+ VULKAN_HPP_CONSTEXPR bool operator!=( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return m_mask != rhs.m_mask;
+ }
+#endif
+
+ // logical operator
+ VULKAN_HPP_CONSTEXPR bool operator!() const VULKAN_HPP_NOEXCEPT
+ {
+ return !m_mask;
+ }
+
+ // bitwise operators
+ VULKAN_HPP_CONSTEXPR Flags<BitType> operator&( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return Flags<BitType>( m_mask & rhs.m_mask );
+ }
+
+ VULKAN_HPP_CONSTEXPR Flags<BitType> operator|( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return Flags<BitType>( m_mask | rhs.m_mask );
+ }
+
+ VULKAN_HPP_CONSTEXPR Flags<BitType> operator^( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return Flags<BitType>( m_mask ^ rhs.m_mask );
+ }
+
+ VULKAN_HPP_CONSTEXPR Flags<BitType> operator~() const VULKAN_HPP_NOEXCEPT
+ {
+ return Flags<BitType>( m_mask ^ FlagTraits<BitType>::allFlags.m_mask );
+ }
+
+ // assignment operators
+ VULKAN_HPP_CONSTEXPR_14 Flags<BitType> & operator=( Flags<BitType> const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+ VULKAN_HPP_CONSTEXPR_14 Flags<BitType> & operator|=( Flags<BitType> const & rhs ) VULKAN_HPP_NOEXCEPT
+ {
+ m_mask |= rhs.m_mask;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 Flags<BitType> & operator&=( Flags<BitType> const & rhs ) VULKAN_HPP_NOEXCEPT
+ {
+ m_mask &= rhs.m_mask;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 Flags<BitType> & operator^=( Flags<BitType> const & rhs ) VULKAN_HPP_NOEXCEPT
+ {
+ m_mask ^= rhs.m_mask;
+ return *this;
+ }
+
+ // cast operators
+ explicit VULKAN_HPP_CONSTEXPR operator bool() const VULKAN_HPP_NOEXCEPT
+ {
+ return !!m_mask;
+ }
+
+ explicit VULKAN_HPP_CONSTEXPR operator MaskType() const VULKAN_HPP_NOEXCEPT
+ {
+ return m_mask;
+ }
+
+#if defined( VULKAN_HPP_FLAGS_MASK_TYPE_AS_PUBLIC )
+ public:
+#else
+ private:
+#endif
+ MaskType m_mask;
+ };
+
+#if !defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+ // relational operators only needed for pre C++20
+ template <typename BitType>
+ VULKAN_HPP_CONSTEXPR bool operator<( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
+ {
+ return flags.operator>( bit );
+ }
+
+ template <typename BitType>
+ VULKAN_HPP_CONSTEXPR bool operator<=( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
+ {
+ return flags.operator>=( bit );
+ }
+
+ template <typename BitType>
+ VULKAN_HPP_CONSTEXPR bool operator>( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
+ {
+ return flags.operator<( bit );
+ }
+
+ template <typename BitType>
+ VULKAN_HPP_CONSTEXPR bool operator>=( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
+ {
+ return flags.operator<=( bit );
+ }
+
+ template <typename BitType>
+ VULKAN_HPP_CONSTEXPR bool operator==( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
+ {
+ return flags.operator==( bit );
+ }
+
+ template <typename BitType>
+ VULKAN_HPP_CONSTEXPR bool operator!=( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
+ {
+ return flags.operator!=( bit );
+ }
+#endif
+
+ // bitwise operators
+ template <typename BitType>
+ VULKAN_HPP_CONSTEXPR Flags<BitType> operator&( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
+ {
+ return flags.operator&( bit );
+ }
+
+ template <typename BitType>
+ VULKAN_HPP_CONSTEXPR Flags<BitType> operator|( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
+ {
+ return flags.operator|( bit );
+ }
+
+ template <typename BitType>
+ VULKAN_HPP_CONSTEXPR Flags<BitType> operator^( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
+ {
+ return flags.operator^( bit );
+ }
+
+ // bitwise operators on BitType
+ template <typename BitType, typename std::enable_if<FlagTraits<BitType>::isBitmask, bool>::type = true>
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR Flags<BitType> operator&( BitType lhs, BitType rhs ) VULKAN_HPP_NOEXCEPT
+ {
+ return Flags<BitType>( lhs ) & rhs;
+ }
+
+ template <typename BitType, typename std::enable_if<FlagTraits<BitType>::isBitmask, bool>::type = true>
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR Flags<BitType> operator|( BitType lhs, BitType rhs ) VULKAN_HPP_NOEXCEPT
+ {
+ return Flags<BitType>( lhs ) | rhs;
+ }
+
+ template <typename BitType, typename std::enable_if<FlagTraits<BitType>::isBitmask, bool>::type = true>
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR Flags<BitType> operator^( BitType lhs, BitType rhs ) VULKAN_HPP_NOEXCEPT
+ {
+ return Flags<BitType>( lhs ) ^ rhs;
+ }
+
+ template <typename BitType, typename std::enable_if<FlagTraits<BitType>::isBitmask, bool>::type = true>
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR Flags<BitType> operator~( BitType bit ) VULKAN_HPP_NOEXCEPT
+ {
+ return ~( Flags<BitType>( bit ) );
+ }
+
template <typename EnumType, EnumType value>
struct CppType
{
@@ -1007,6 +1213,8 @@
ePipelinePropertiesIdentifierEXT = VK_STRUCTURE_TYPE_PIPELINE_PROPERTIES_IDENTIFIER_EXT,
ePhysicalDevicePipelinePropertiesFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT,
ePipelineInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_INFO_EXT,
+ ePhysicalDeviceFrameBoundaryFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT,
+ eFrameBoundaryEXT = VK_STRUCTURE_TYPE_FRAME_BOUNDARY_EXT,
ePhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT,
eSubpassResolvePerformanceQueryEXT = VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT,
eMultisampledRenderToSingleSampledInfoEXT = VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT,
@@ -1097,6 +1305,11 @@
eOpticalFlowSessionCreatePrivateDataInfoNV = VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV,
ePhysicalDeviceLegacyDitheringFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT,
ePhysicalDevicePipelineProtectedAccessFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT,
+#if defined( VK_USE_PLATFORM_ANDROID_KHR )
+ ePhysicalDeviceExternalFormatResolveFeaturesANDROID = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_FEATURES_ANDROID,
+ ePhysicalDeviceExternalFormatResolvePropertiesANDROID = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_PROPERTIES_ANDROID,
+ eAndroidHardwareBufferFormatResolvePropertiesANDROID = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_RESOLVE_PROPERTIES_ANDROID,
+#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
ePhysicalDeviceMaintenance5FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR,
ePhysicalDeviceMaintenance5PropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR,
eRenderingAreaInfoKHR = VK_STRUCTURE_TYPE_RENDERING_AREA_INFO_KHR,
@@ -1123,6 +1336,15 @@
ePhysicalDeviceShaderCoreBuiltinsPropertiesARM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM,
ePhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT,
ePhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT,
+ eLatencySleepModeInfoNV = VK_STRUCTURE_TYPE_LATENCY_SLEEP_MODE_INFO_NV,
+ eLatencySleepInfoNV = VK_STRUCTURE_TYPE_LATENCY_SLEEP_INFO_NV,
+ eSetLatencyMarkerInfoNV = VK_STRUCTURE_TYPE_SET_LATENCY_MARKER_INFO_NV,
+ eGetLatencyMarkerInfoNV = VK_STRUCTURE_TYPE_GET_LATENCY_MARKER_INFO_NV,
+ eLatencyTimingsFrameReportNV = VK_STRUCTURE_TYPE_LATENCY_TIMINGS_FRAME_REPORT_NV,
+ eLatencySubmissionPresentIdNV = VK_STRUCTURE_TYPE_LATENCY_SUBMISSION_PRESENT_ID_NV,
+ eOutOfBandQueueTypeInfoNV = VK_STRUCTURE_TYPE_OUT_OF_BAND_QUEUE_TYPE_INFO_NV,
+ eSwapchainLatencyCreateInfoNV = VK_STRUCTURE_TYPE_SWAPCHAIN_LATENCY_CREATE_INFO_NV,
+ eLatencySurfaceCapabilitiesNV = VK_STRUCTURE_TYPE_LATENCY_SURFACE_CAPABILITIES_NV,
ePhysicalDeviceCooperativeMatrixFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR,
eCooperativeMatrixPropertiesKHR = VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_KHR,
ePhysicalDeviceCooperativeMatrixPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR,
@@ -1145,6 +1367,7 @@
eExternalFormatQNX = VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_QNX,
ePhysicalDeviceExternalMemoryScreenBufferFeaturesQNX = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX,
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
+ ePhysicalDeviceLayeredDriverPropertiesMSFT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT,
ePhysicalDeviceDescriptorPoolOverallocationFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV
};
@@ -3618,7 +3841,8 @@
eMesaVenus = VK_DRIVER_ID_MESA_VENUS,
eMesaDozen = VK_DRIVER_ID_MESA_DOZEN,
eMesaNvk = VK_DRIVER_ID_MESA_NVK,
- eImaginationOpenSourceMESA = VK_DRIVER_ID_IMAGINATION_OPEN_SOURCE_MESA
+ eImaginationOpenSourceMESA = VK_DRIVER_ID_IMAGINATION_OPEN_SOURCE_MESA,
+ eMesaAgxv = VK_DRIVER_ID_MESA_AGXV
};
using DriverIdKHR = DriverId;
@@ -3657,7 +3881,10 @@
eSampleZero = VK_RESOLVE_MODE_SAMPLE_ZERO_BIT,
eAverage = VK_RESOLVE_MODE_AVERAGE_BIT,
eMin = VK_RESOLVE_MODE_MIN_BIT,
- eMax = VK_RESOLVE_MODE_MAX_BIT
+ eMax = VK_RESOLVE_MODE_MAX_BIT,
+#if defined( VK_USE_PLATFORM_ANDROID_KHR )
+ eExternalFormatDownsampleANDROID = VK_RESOLVE_MODE_EXTERNAL_FORMAT_DOWNSAMPLE_ANDROID
+#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
};
using ResolveModeFlagBitsKHR = ResolveModeFlagBits;
@@ -3668,8 +3895,12 @@
struct FlagTraits<ResolveModeFlagBits>
{
static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true;
- static VULKAN_HPP_CONST_OR_CONSTEXPR ResolveModeFlags allFlags =
- ResolveModeFlagBits::eNone | ResolveModeFlagBits::eSampleZero | ResolveModeFlagBits::eAverage | ResolveModeFlagBits::eMin | ResolveModeFlagBits::eMax;
+ static VULKAN_HPP_CONST_OR_CONSTEXPR ResolveModeFlags allFlags = ResolveModeFlagBits::eNone | ResolveModeFlagBits::eSampleZero |
+ ResolveModeFlagBits::eAverage | ResolveModeFlagBits::eMin | ResolveModeFlagBits::eMax
+#if defined( VK_USE_PLATFORM_ANDROID_KHR )
+ | ResolveModeFlagBits::eExternalFormatDownsampleANDROID
+#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
+ ;
};
enum class SamplerReductionMode
@@ -6370,6 +6601,22 @@
};
#endif /*VK_USE_PLATFORM_FUCHSIA*/
+ //=== VK_EXT_frame_boundary ===
+
+ enum class FrameBoundaryFlagBitsEXT : VkFrameBoundaryFlagsEXT
+ {
+ eFrameEnd = VK_FRAME_BOUNDARY_FRAME_END_BIT_EXT
+ };
+
+ using FrameBoundaryFlagsEXT = Flags<FrameBoundaryFlagBitsEXT>;
+
+ template <>
+ struct FlagTraits<FrameBoundaryFlagBitsEXT>
+ {
+ static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true;
+ static VULKAN_HPP_CONST_OR_CONSTEXPR FrameBoundaryFlagsEXT allFlags = FrameBoundaryFlagBitsEXT::eFrameEnd;
+ };
+
#if defined( VK_USE_PLATFORM_SCREEN_QNX )
//=== VK_QNX_screen_surface ===
@@ -6818,6 +7065,30 @@
eReorder = VK_RAY_TRACING_INVOCATION_REORDER_MODE_REORDER_NV
};
+ //=== VK_NV_low_latency2 ===
+
+ enum class LatencyMarkerNV
+ {
+ eSimulationStart = VK_LATENCY_MARKER_SIMULATION_START_NV,
+ eSimulationEnd = VK_LATENCY_MARKER_SIMULATION_END_NV,
+ eRendersubmitStart = VK_LATENCY_MARKER_RENDERSUBMIT_START_NV,
+ eRendersubmitEnd = VK_LATENCY_MARKER_RENDERSUBMIT_END_NV,
+ ePresentStart = VK_LATENCY_MARKER_PRESENT_START_NV,
+ ePresentEnd = VK_LATENCY_MARKER_PRESENT_END_NV,
+ eInputSample = VK_LATENCY_MARKER_INPUT_SAMPLE_NV,
+ eTriggerFlash = VK_LATENCY_MARKER_TRIGGER_FLASH_NV,
+ eOutOfBandRendersubmitStart = VK_LATENCY_MARKER_OUT_OF_BAND_RENDERSUBMIT_START_NV,
+ eOutOfBandRendersubmitEnd = VK_LATENCY_MARKER_OUT_OF_BAND_RENDERSUBMIT_END_NV,
+ eOutOfBandPresentStart = VK_LATENCY_MARKER_OUT_OF_BAND_PRESENT_START_NV,
+ eOutOfBandPresentEnd = VK_LATENCY_MARKER_OUT_OF_BAND_PRESENT_END_NV
+ };
+
+ enum class OutOfBandQueueTypeNV
+ {
+ eRender = VK_OUT_OF_BAND_QUEUE_TYPE_RENDER_NV,
+ ePresent = VK_OUT_OF_BAND_QUEUE_TYPE_PRESENT_NV
+ };
+
//=== VK_KHR_cooperative_matrix ===
enum class ScopeKHR
@@ -6863,6 +7134,14 @@
eMitchellNetravali = VK_CUBIC_FILTER_WEIGHTS_MITCHELL_NETRAVALI_QCOM
};
+ //=== VK_MSFT_layered_driver ===
+
+ enum class LayeredDriverUnderlyingApiMSFT
+ {
+ eNone = VK_LAYERED_DRIVER_UNDERLYING_API_NONE_MSFT,
+ eD3D12 = VK_LAYERED_DRIVER_UNDERLYING_API_D3D12_MSFT
+ };
+
//=========================
//=== Index Type Traits ===
//=========================
diff --git a/include/vulkan/vulkan_extension_inspection.hpp b/include/vulkan/vulkan_extension_inspection.hpp
index 7590193..d9cc0e8 100644
--- a/include/vulkan/vulkan_extension_inspection.hpp
+++ b/include/vulkan/vulkan_extension_inspection.hpp
@@ -343,6 +343,7 @@
"VK_HUAWEI_invocation_mask",
"VK_NV_external_memory_rdma",
"VK_EXT_pipeline_properties",
+"VK_EXT_frame_boundary",
"VK_EXT_multisampled_render_to_single_sampled",
"VK_EXT_extended_dynamic_state2",
"VK_EXT_color_write_enable",
@@ -381,7 +382,10 @@
"VK_EXT_rasterization_order_attachment_access",
"VK_NV_optical_flow",
"VK_EXT_legacy_dithering",
-"VK_EXT_pipeline_protected_access",
+"VK_EXT_pipeline_protected_access",
+#if defined( VK_USE_PLATFORM_ANDROID_KHR )
+"VK_ANDROID_external_format_resolve",
+#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
"VK_KHR_maintenance5",
"VK_KHR_ray_tracing_position_fetch",
"VK_EXT_shader_object",
@@ -393,6 +397,7 @@
"VK_ARM_shader_core_builtins",
"VK_EXT_pipeline_library_group_handles",
"VK_EXT_dynamic_rendering_unused_attachments",
+"VK_NV_low_latency2",
"VK_KHR_cooperative_matrix",
"VK_QCOM_multiview_per_view_render_areas",
"VK_QCOM_image_processing2",
@@ -403,6 +408,7 @@
#if defined( VK_USE_PLATFORM_SCREEN_QNX )
"VK_QNX_external_memory_screen_buffer",
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
+"VK_MSFT_layered_driver",
"VK_NV_descriptor_pool_overallocation" };
return deviceExtensions;
}
@@ -784,7 +790,10 @@
{ "VK_EXT_rasterization_order_attachment_access", { { "VK_VERSION_1_0", { { "VK_KHR_get_physical_device_properties2", } } } } },
{ "VK_NV_optical_flow", { { "VK_VERSION_1_0", { { "VK_KHR_get_physical_device_properties2", "VK_KHR_format_feature_flags2", "VK_KHR_synchronization2", } } } } },
{ "VK_EXT_legacy_dithering", { { "VK_VERSION_1_0", { { "VK_KHR_get_physical_device_properties2", } } } } },
-{ "VK_EXT_pipeline_protected_access", { { "VK_VERSION_1_0", { { "VK_KHR_get_physical_device_properties2", } } } } },
+{ "VK_EXT_pipeline_protected_access", { { "VK_VERSION_1_0", { { "VK_KHR_get_physical_device_properties2", } } } } },
+#if defined( VK_USE_PLATFORM_ANDROID_KHR )
+{ "VK_ANDROID_external_format_resolve", { { "VK_VERSION_1_0", { { "VK_ANDROID_external_memory_android_hardware_buffer", } } } } },
+#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
{ "VK_KHR_maintenance5", { { "VK_VERSION_1_1", { { "VK_KHR_dynamic_rendering", } } } } },
{ "VK_KHR_ray_tracing_position_fetch", { { "VK_VERSION_1_0", { { "VK_KHR_acceleration_structure", } } } } },
{ "VK_EXT_shader_object", { { "VK_VERSION_1_0", { { "VK_KHR_get_physical_device_properties2", "VK_KHR_dynamic_rendering", } } }, { "VK_VERSION_1_1", { { "VK_KHR_dynamic_rendering", } } }, { "VK_VERSION_1_3", { { } } } } },
@@ -804,6 +813,7 @@
#if defined( VK_USE_PLATFORM_SCREEN_QNX )
{ "VK_QNX_external_memory_screen_buffer", { { "VK_VERSION_1_0", { { "VK_KHR_sampler_ycbcr_conversion", "VK_KHR_external_memory", "VK_KHR_dedicated_allocation", } } }, { "VK_VERSION_1_1", { { "VK_EXT_queue_family_foreign", } } } } },
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
+{ "VK_MSFT_layered_driver", { { "VK_VERSION_1_0", { { "VK_KHR_get_physical_device_properties2", } } } } },
{ "VK_NV_descriptor_pool_overallocation", { { "VK_VERSION_1_1", { { } } } } } };
auto depIt = dependencies.find( extension );
return ( depIt != dependencies.end() ) ? depIt->second : noDependencies;
@@ -1493,11 +1503,12 @@
( extension == "VK_FUCHSIA_buffer_collection" )
#endif /*VK_USE_PLATFORM_FUCHSIA*/
|| ( extension == "VK_HUAWEI_subpass_shading" ) || ( extension == "VK_HUAWEI_invocation_mask" ) || ( extension == "VK_NV_external_memory_rdma" ) ||
- ( extension == "VK_EXT_pipeline_properties" ) || ( extension == "VK_EXT_multisampled_render_to_single_sampled" ) ||
- ( extension == "VK_EXT_extended_dynamic_state2" ) || ( extension == "VK_EXT_color_write_enable" ) ||
- ( extension == "VK_EXT_primitives_generated_query" ) || ( extension == "VK_KHR_ray_tracing_maintenance1" ) ||
- ( extension == "VK_EXT_global_priority_query" ) || ( extension == "VK_EXT_image_view_min_lod" ) || ( extension == "VK_EXT_multi_draw" ) ||
- ( extension == "VK_EXT_image_2d_view_of_3d" ) || ( extension == "VK_EXT_shader_tile_image" ) || ( extension == "VK_EXT_opacity_micromap" )
+ ( extension == "VK_EXT_pipeline_properties" ) || ( extension == "VK_EXT_frame_boundary" ) ||
+ ( extension == "VK_EXT_multisampled_render_to_single_sampled" ) || ( extension == "VK_EXT_extended_dynamic_state2" ) ||
+ ( extension == "VK_EXT_color_write_enable" ) || ( extension == "VK_EXT_primitives_generated_query" ) ||
+ ( extension == "VK_KHR_ray_tracing_maintenance1" ) || ( extension == "VK_EXT_global_priority_query" ) ||
+ ( extension == "VK_EXT_image_view_min_lod" ) || ( extension == "VK_EXT_multi_draw" ) || ( extension == "VK_EXT_image_2d_view_of_3d" ) ||
+ ( extension == "VK_EXT_shader_tile_image" ) || ( extension == "VK_EXT_opacity_micromap" )
#if defined( VK_ENABLE_BETA_EXTENSIONS )
|| ( extension == "VK_NV_displacement_micromap" )
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
@@ -1512,19 +1523,22 @@
( extension == "VK_EXT_external_memory_acquire_unmodified" ) || ( extension == "VK_EXT_extended_dynamic_state3" ) ||
( extension == "VK_EXT_subpass_merge_feedback" ) || ( extension == "VK_EXT_shader_module_identifier" ) ||
( extension == "VK_EXT_rasterization_order_attachment_access" ) || ( extension == "VK_NV_optical_flow" ) ||
- ( extension == "VK_EXT_legacy_dithering" ) || ( extension == "VK_EXT_pipeline_protected_access" ) || ( extension == "VK_KHR_maintenance5" ) ||
- ( extension == "VK_KHR_ray_tracing_position_fetch" ) || ( extension == "VK_EXT_shader_object" ) || ( extension == "VK_QCOM_tile_properties" ) ||
- ( extension == "VK_SEC_amigo_profiling" ) || ( extension == "VK_QCOM_multiview_per_view_viewports" ) ||
+ ( extension == "VK_EXT_legacy_dithering" ) || ( extension == "VK_EXT_pipeline_protected_access" )
+#if defined( VK_USE_PLATFORM_ANDROID_KHR )
+ || ( extension == "VK_ANDROID_external_format_resolve" )
+#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
+ || ( extension == "VK_KHR_maintenance5" ) || ( extension == "VK_KHR_ray_tracing_position_fetch" ) || ( extension == "VK_EXT_shader_object" ) ||
+ ( extension == "VK_QCOM_tile_properties" ) || ( extension == "VK_SEC_amigo_profiling" ) || ( extension == "VK_QCOM_multiview_per_view_viewports" ) ||
( extension == "VK_NV_ray_tracing_invocation_reorder" ) || ( extension == "VK_EXT_mutable_descriptor_type" ) ||
( extension == "VK_ARM_shader_core_builtins" ) || ( extension == "VK_EXT_pipeline_library_group_handles" ) ||
- ( extension == "VK_EXT_dynamic_rendering_unused_attachments" ) || ( extension == "VK_KHR_cooperative_matrix" ) ||
- ( extension == "VK_QCOM_multiview_per_view_render_areas" ) || ( extension == "VK_QCOM_image_processing2" ) ||
- ( extension == "VK_QCOM_filter_cubic_weights" ) || ( extension == "VK_QCOM_ycbcr_degamma" ) || ( extension == "VK_QCOM_filter_cubic_clamp" ) ||
- ( extension == "VK_EXT_attachment_feedback_loop_dynamic_state" )
+ ( extension == "VK_EXT_dynamic_rendering_unused_attachments" ) || ( extension == "VK_NV_low_latency2" ) ||
+ ( extension == "VK_KHR_cooperative_matrix" ) || ( extension == "VK_QCOM_multiview_per_view_render_areas" ) ||
+ ( extension == "VK_QCOM_image_processing2" ) || ( extension == "VK_QCOM_filter_cubic_weights" ) || ( extension == "VK_QCOM_ycbcr_degamma" ) ||
+ ( extension == "VK_QCOM_filter_cubic_clamp" ) || ( extension == "VK_EXT_attachment_feedback_loop_dynamic_state" )
#if defined( VK_USE_PLATFORM_SCREEN_QNX )
|| ( extension == "VK_QNX_external_memory_screen_buffer" )
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
- || ( extension == "VK_NV_descriptor_pool_overallocation" );
+ || ( extension == "VK_MSFT_layered_driver" ) || ( extension == "VK_NV_descriptor_pool_overallocation" );
}
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 bool isInstanceExtension( std::string const & extension )
diff --git a/include/vulkan/vulkan_funcs.hpp b/include/vulkan/vulkan_funcs.hpp
index 1ab8736..137c80c 100644
--- a/include/vulkan/vulkan_funcs.hpp
+++ b/include/vulkan/vulkan_funcs.hpp
@@ -22786,6 +22786,117 @@
}
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
+ //=== VK_NV_low_latency2 ===
+
+ template <typename Dispatch>
+ VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::setLatencySleepModeNV( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
+ VULKAN_HPP_NAMESPACE::LatencySleepModeInfoNV * pSleepModeInfo,
+ Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+ {
+ VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+ return static_cast<Result>(
+ d.vkSetLatencySleepModeNV( m_device, static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<VkLatencySleepModeInfoNV *>( pSleepModeInfo ) ) );
+ }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template <typename Dispatch>
+ VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::LatencySleepModeInfoNV>::type
+ Device::setLatencySleepModeNV( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d ) const
+ {
+ VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+
+ VULKAN_HPP_NAMESPACE::LatencySleepModeInfoNV sleepModeInfo;
+ VkResult result =
+ d.vkSetLatencySleepModeNV( m_device, static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<VkLatencySleepModeInfoNV *>( &sleepModeInfo ) );
+ resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::setLatencySleepModeNV" );
+
+ return createResultValueType( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), sleepModeInfo );
+ }
+#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
+
+ template <typename Dispatch>
+ VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::latencySleepNV( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
+ VULKAN_HPP_NAMESPACE::LatencySleepInfoNV * pSleepInfo,
+ Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+ {
+ VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+ return static_cast<Result>(
+ d.vkLatencySleepNV( m_device, static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<VkLatencySleepInfoNV *>( pSleepInfo ) ) );
+ }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template <typename Dispatch>
+ VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::LatencySleepInfoNV>::type
+ Device::latencySleepNV( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d ) const
+ {
+ VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+
+ VULKAN_HPP_NAMESPACE::LatencySleepInfoNV sleepInfo;
+ VkResult result = d.vkLatencySleepNV( m_device, static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<VkLatencySleepInfoNV *>( &sleepInfo ) );
+ resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::latencySleepNV" );
+
+ return createResultValueType( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), sleepInfo );
+ }
+#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
+
+ template <typename Dispatch>
+ VULKAN_HPP_INLINE void Device::setLatencyMarkerNV( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
+ VULKAN_HPP_NAMESPACE::SetLatencyMarkerInfoNV * pLatencyMarkerInfo,
+ Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+ {
+ VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+ d.vkSetLatencyMarkerNV( m_device, static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<VkSetLatencyMarkerInfoNV *>( pLatencyMarkerInfo ) );
+ }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template <typename Dispatch>
+ VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::SetLatencyMarkerInfoNV Device::setLatencyMarkerNV( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
+ Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+ {
+ VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+
+ VULKAN_HPP_NAMESPACE::SetLatencyMarkerInfoNV latencyMarkerInfo;
+ d.vkSetLatencyMarkerNV( m_device, static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<VkSetLatencyMarkerInfoNV *>( &latencyMarkerInfo ) );
+
+ return latencyMarkerInfo;
+ }
+#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
+
+ template <typename Dispatch>
+ VULKAN_HPP_INLINE void Device::getLatencyTimingsNV( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
+ uint32_t * pTimingCount,
+ VULKAN_HPP_NAMESPACE::GetLatencyMarkerInfoNV * pLatencyMarkerInfo,
+ Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+ {
+ VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+ d.vkGetLatencyTimingsNV(
+ m_device, static_cast<VkSwapchainKHR>( swapchain ), pTimingCount, reinterpret_cast<VkGetLatencyMarkerInfoNV *>( pLatencyMarkerInfo ) );
+ }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template <typename Dispatch>
+ VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair<uint32_t, VULKAN_HPP_NAMESPACE::GetLatencyMarkerInfoNV>
+ Device::getLatencyTimingsNV( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+ {
+ VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+
+ std::pair<uint32_t, VULKAN_HPP_NAMESPACE::GetLatencyMarkerInfoNV> data_;
+ uint32_t & timingCount = data_.first;
+ VULKAN_HPP_NAMESPACE::GetLatencyMarkerInfoNV & latencyMarkerInfo = data_.second;
+ d.vkGetLatencyTimingsNV(
+ m_device, static_cast<VkSwapchainKHR>( swapchain ), &timingCount, reinterpret_cast<VkGetLatencyMarkerInfoNV *>( &latencyMarkerInfo ) );
+
+ return data_;
+ }
+#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
+
+ template <typename Dispatch>
+ VULKAN_HPP_INLINE void Queue::notifyOutOfBandNV( VULKAN_HPP_NAMESPACE::OutOfBandQueueTypeInfoNV pQueueTypeInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+ {
+ VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+ d.vkQueueNotifyOutOfBandNV( m_queue, static_cast<VkOutOfBandQueueTypeInfoNV>( pQueueTypeInfo ) );
+ }
+
//=== VK_KHR_cooperative_matrix ===
template <typename Dispatch>
diff --git a/include/vulkan/vulkan_handles.hpp b/include/vulkan/vulkan_handles.hpp
index e0515c3..b76b87a 100644
--- a/include/vulkan/vulkan_handles.hpp
+++ b/include/vulkan/vulkan_handles.hpp
@@ -1438,6 +1438,10 @@
struct PipelinePropertiesIdentifierEXT;
struct PhysicalDevicePipelinePropertiesFeaturesEXT;
+ //=== VK_EXT_frame_boundary ===
+ struct PhysicalDeviceFrameBoundaryFeaturesEXT;
+ struct FrameBoundaryEXT;
+
//=== VK_EXT_multisampled_render_to_single_sampled ===
struct PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT;
struct SubpassResolvePerformanceQueryEXT;
@@ -1608,6 +1612,13 @@
//=== VK_EXT_pipeline_protected_access ===
struct PhysicalDevicePipelineProtectedAccessFeaturesEXT;
+#if defined( VK_USE_PLATFORM_ANDROID_KHR )
+ //=== VK_ANDROID_external_format_resolve ===
+ struct PhysicalDeviceExternalFormatResolveFeaturesANDROID;
+ struct PhysicalDeviceExternalFormatResolvePropertiesANDROID;
+ struct AndroidHardwareBufferFormatResolvePropertiesANDROID;
+#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
+
//=== VK_KHR_maintenance5 ===
struct PhysicalDeviceMaintenance5FeaturesKHR;
struct PhysicalDeviceMaintenance5PropertiesKHR;
@@ -1661,6 +1672,17 @@
//=== VK_EXT_dynamic_rendering_unused_attachments ===
struct PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT;
+ //=== VK_NV_low_latency2 ===
+ struct LatencySleepModeInfoNV;
+ struct LatencySleepInfoNV;
+ struct SetLatencyMarkerInfoNV;
+ struct GetLatencyMarkerInfoNV;
+ struct LatencyTimingsFrameReportNV;
+ struct LatencySubmissionPresentIdNV;
+ struct SwapchainLatencyCreateInfoNV;
+ struct OutOfBandQueueTypeInfoNV;
+ struct LatencySurfaceCapabilitiesNV;
+
//=== VK_KHR_cooperative_matrix ===
struct CooperativeMatrixPropertiesKHR;
struct PhysicalDeviceCooperativeMatrixFeaturesKHR;
@@ -1699,6 +1721,9 @@
struct PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX;
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
+ //=== VK_MSFT_layered_driver ===
+ struct PhysicalDeviceLayeredDriverPropertiesMSFT;
+
//=== VK_NV_descriptor_pool_overallocation ===
struct PhysicalDeviceDescriptorPoolOverallocationFeaturesNV;
@@ -8193,6 +8218,12 @@
getCheckpointData2NV( CheckpointData2NVAllocator & checkpointData2NVAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
+ //=== VK_NV_low_latency2 ===
+
+ template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void notifyOutOfBandNV( VULKAN_HPP_NAMESPACE::OutOfBandQueueTypeInfoNV pQueueTypeInfo,
+ Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+
operator VkQueue() const VULKAN_HPP_NOEXCEPT
{
return m_queue;
@@ -13137,6 +13168,50 @@
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
+ //=== VK_NV_low_latency2 ===
+
+ template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ VULKAN_HPP_NODISCARD Result setLatencySleepModeNV( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
+ VULKAN_HPP_NAMESPACE::LatencySleepModeInfoNV * pSleepModeInfo,
+ Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::LatencySleepModeInfoNV>::type
+ setLatencySleepModeNV( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
+
+ template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ VULKAN_HPP_NODISCARD Result latencySleepNV( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
+ VULKAN_HPP_NAMESPACE::LatencySleepInfoNV * pSleepInfo,
+ Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::LatencySleepInfoNV>::type
+ latencySleepNV( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
+
+ template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void setLatencyMarkerNV( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
+ VULKAN_HPP_NAMESPACE::SetLatencyMarkerInfoNV * pLatencyMarkerInfo,
+ Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::SetLatencyMarkerInfoNV
+ setLatencyMarkerNV( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
+
+ template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void getLatencyTimingsNV( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
+ uint32_t * pTimingCount,
+ VULKAN_HPP_NAMESPACE::GetLatencyMarkerInfoNV * pLatencyMarkerInfo,
+ Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ VULKAN_HPP_NODISCARD std::pair<uint32_t, VULKAN_HPP_NAMESPACE::GetLatencyMarkerInfoNV>
+ getLatencyTimingsNV( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
+ Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
+
#if defined( VK_USE_PLATFORM_SCREEN_QNX )
//=== VK_QNX_external_memory_screen_buffer ===
diff --git a/include/vulkan/vulkan_hash.hpp b/include/vulkan/vulkan_hash.hpp
index da632ac..b1428a0 100644
--- a/include/vulkan/vulkan_hash.hpp
+++ b/include/vulkan/vulkan_hash.hpp
@@ -977,6 +977,23 @@
# if defined( VK_USE_PLATFORM_ANDROID_KHR )
template <>
+ struct hash<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatResolvePropertiesANDROID>
+ {
+ std::size_t
+ operator()( VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatResolvePropertiesANDROID const & androidHardwareBufferFormatResolvePropertiesANDROID ) const
+ VULKAN_HPP_NOEXCEPT
+ {
+ std::size_t seed = 0;
+ VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatResolvePropertiesANDROID.sType );
+ VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatResolvePropertiesANDROID.pNext );
+ VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatResolvePropertiesANDROID.colorAttachmentFormat );
+ return seed;
+ }
+ };
+# endif /*VK_USE_PLATFORM_ANDROID_KHR*/
+
+# if defined( VK_USE_PLATFORM_ANDROID_KHR )
+ template <>
struct hash<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID>
{
std::size_t
@@ -4901,6 +4918,27 @@
};
template <>
+ struct hash<VULKAN_HPP_NAMESPACE::FrameBoundaryEXT>
+ {
+ std::size_t operator()( VULKAN_HPP_NAMESPACE::FrameBoundaryEXT const & frameBoundaryEXT ) const VULKAN_HPP_NOEXCEPT
+ {
+ std::size_t seed = 0;
+ VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.sType );
+ VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.pNext );
+ VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.flags );
+ VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.frameID );
+ VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.imageCount );
+ VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.pImages );
+ VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.bufferCount );
+ VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.pBuffers );
+ VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.tagName );
+ VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.tagSize );
+ VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.pTag );
+ return seed;
+ }
+ };
+
+ template <>
struct hash<VULKAN_HPP_NAMESPACE::FramebufferAttachmentImageInfo>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::FramebufferAttachmentImageInfo const & framebufferAttachmentImageInfo ) const VULKAN_HPP_NOEXCEPT
@@ -5023,6 +5061,45 @@
};
template <>
+ struct hash<VULKAN_HPP_NAMESPACE::LatencyTimingsFrameReportNV>
+ {
+ std::size_t operator()( VULKAN_HPP_NAMESPACE::LatencyTimingsFrameReportNV const & latencyTimingsFrameReportNV ) const VULKAN_HPP_NOEXCEPT
+ {
+ std::size_t seed = 0;
+ VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.sType );
+ VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.pNext );
+ VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.presentID );
+ VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.inputSampleTimeUs );
+ VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.simStartTimeUs );
+ VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.simEndTimeUs );
+ VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.renderSubmitStartTimeUs );
+ VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.renderSubmitEndTimeUs );
+ VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.presentStartTimeUs );
+ VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.presentEndTimeUs );
+ VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.driverStartTimeUs );
+ VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.driverEndTimeUs );
+ VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.osRenderQueueStartTimeUs );
+ VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.osRenderQueueEndTimeUs );
+ VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.gpuRenderStartTimeUs );
+ VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.gpuRenderEndTimeUs );
+ return seed;
+ }
+ };
+
+ template <>
+ struct hash<VULKAN_HPP_NAMESPACE::GetLatencyMarkerInfoNV>
+ {
+ std::size_t operator()( VULKAN_HPP_NAMESPACE::GetLatencyMarkerInfoNV const & getLatencyMarkerInfoNV ) const VULKAN_HPP_NOEXCEPT
+ {
+ std::size_t seed = 0;
+ VULKAN_HPP_HASH_COMBINE( seed, getLatencyMarkerInfoNV.sType );
+ VULKAN_HPP_HASH_COMBINE( seed, getLatencyMarkerInfoNV.pNext );
+ VULKAN_HPP_HASH_COMBINE( seed, getLatencyMarkerInfoNV.pTimings );
+ return seed;
+ }
+ };
+
+ template <>
struct hash<VULKAN_HPP_NAMESPACE::VertexInputBindingDescription>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::VertexInputBindingDescription const & vertexInputBindingDescription ) const VULKAN_HPP_NOEXCEPT
@@ -6251,6 +6328,62 @@
};
template <>
+ struct hash<VULKAN_HPP_NAMESPACE::LatencySleepInfoNV>
+ {
+ std::size_t operator()( VULKAN_HPP_NAMESPACE::LatencySleepInfoNV const & latencySleepInfoNV ) const VULKAN_HPP_NOEXCEPT
+ {
+ std::size_t seed = 0;
+ VULKAN_HPP_HASH_COMBINE( seed, latencySleepInfoNV.sType );
+ VULKAN_HPP_HASH_COMBINE( seed, latencySleepInfoNV.pNext );
+ VULKAN_HPP_HASH_COMBINE( seed, latencySleepInfoNV.signalSemaphore );
+ VULKAN_HPP_HASH_COMBINE( seed, latencySleepInfoNV.value );
+ return seed;
+ }
+ };
+
+ template <>
+ struct hash<VULKAN_HPP_NAMESPACE::LatencySleepModeInfoNV>
+ {
+ std::size_t operator()( VULKAN_HPP_NAMESPACE::LatencySleepModeInfoNV const & latencySleepModeInfoNV ) const VULKAN_HPP_NOEXCEPT
+ {
+ std::size_t seed = 0;
+ VULKAN_HPP_HASH_COMBINE( seed, latencySleepModeInfoNV.sType );
+ VULKAN_HPP_HASH_COMBINE( seed, latencySleepModeInfoNV.pNext );
+ VULKAN_HPP_HASH_COMBINE( seed, latencySleepModeInfoNV.lowLatencyMode );
+ VULKAN_HPP_HASH_COMBINE( seed, latencySleepModeInfoNV.lowLatencyBoost );
+ VULKAN_HPP_HASH_COMBINE( seed, latencySleepModeInfoNV.minimumIntervalUs );
+ return seed;
+ }
+ };
+
+ template <>
+ struct hash<VULKAN_HPP_NAMESPACE::LatencySubmissionPresentIdNV>
+ {
+ std::size_t operator()( VULKAN_HPP_NAMESPACE::LatencySubmissionPresentIdNV const & latencySubmissionPresentIdNV ) const VULKAN_HPP_NOEXCEPT
+ {
+ std::size_t seed = 0;
+ VULKAN_HPP_HASH_COMBINE( seed, latencySubmissionPresentIdNV.sType );
+ VULKAN_HPP_HASH_COMBINE( seed, latencySubmissionPresentIdNV.pNext );
+ VULKAN_HPP_HASH_COMBINE( seed, latencySubmissionPresentIdNV.presentID );
+ return seed;
+ }
+ };
+
+ template <>
+ struct hash<VULKAN_HPP_NAMESPACE::LatencySurfaceCapabilitiesNV>
+ {
+ std::size_t operator()( VULKAN_HPP_NAMESPACE::LatencySurfaceCapabilitiesNV const & latencySurfaceCapabilitiesNV ) const VULKAN_HPP_NOEXCEPT
+ {
+ std::size_t seed = 0;
+ VULKAN_HPP_HASH_COMBINE( seed, latencySurfaceCapabilitiesNV.sType );
+ VULKAN_HPP_HASH_COMBINE( seed, latencySurfaceCapabilitiesNV.pNext );
+ VULKAN_HPP_HASH_COMBINE( seed, latencySurfaceCapabilitiesNV.presentModeCount );
+ VULKAN_HPP_HASH_COMBINE( seed, latencySurfaceCapabilitiesNV.pPresentModes );
+ return seed;
+ }
+ };
+
+ template <>
struct hash<VULKAN_HPP_NAMESPACE::LayerProperties>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::LayerProperties const & layerProperties ) const VULKAN_HPP_NOEXCEPT
@@ -6887,6 +7020,19 @@
};
template <>
+ struct hash<VULKAN_HPP_NAMESPACE::OutOfBandQueueTypeInfoNV>
+ {
+ std::size_t operator()( VULKAN_HPP_NAMESPACE::OutOfBandQueueTypeInfoNV const & outOfBandQueueTypeInfoNV ) const VULKAN_HPP_NOEXCEPT
+ {
+ std::size_t seed = 0;
+ VULKAN_HPP_HASH_COMBINE( seed, outOfBandQueueTypeInfoNV.sType );
+ VULKAN_HPP_HASH_COMBINE( seed, outOfBandQueueTypeInfoNV.pNext );
+ VULKAN_HPP_HASH_COMBINE( seed, outOfBandQueueTypeInfoNV.queueType );
+ return seed;
+ }
+ };
+
+ template <>
struct hash<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE const & pastPresentationTimingGOOGLE ) const VULKAN_HPP_NOEXCEPT
@@ -8124,6 +8270,41 @@
}
};
+# if defined( VK_USE_PLATFORM_ANDROID_KHR )
+ template <>
+ struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFormatResolveFeaturesANDROID>
+ {
+ std::size_t
+ operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFormatResolveFeaturesANDROID const & physicalDeviceExternalFormatResolveFeaturesANDROID ) const
+ VULKAN_HPP_NOEXCEPT
+ {
+ std::size_t seed = 0;
+ VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFormatResolveFeaturesANDROID.sType );
+ VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFormatResolveFeaturesANDROID.pNext );
+ VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFormatResolveFeaturesANDROID.externalFormatResolve );
+ return seed;
+ }
+ };
+# endif /*VK_USE_PLATFORM_ANDROID_KHR*/
+
+# if defined( VK_USE_PLATFORM_ANDROID_KHR )
+ template <>
+ struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFormatResolvePropertiesANDROID>
+ {
+ std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFormatResolvePropertiesANDROID const &
+ physicalDeviceExternalFormatResolvePropertiesANDROID ) const VULKAN_HPP_NOEXCEPT
+ {
+ std::size_t seed = 0;
+ VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFormatResolvePropertiesANDROID.sType );
+ VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFormatResolvePropertiesANDROID.pNext );
+ VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFormatResolvePropertiesANDROID.nullColorAttachmentWithExternalFormatResolve );
+ VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFormatResolvePropertiesANDROID.externalFormatResolveChromaOffsetX );
+ VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFormatResolvePropertiesANDROID.externalFormatResolveChromaOffsetY );
+ return seed;
+ }
+ };
+# endif /*VK_USE_PLATFORM_ANDROID_KHR*/
+
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalImageFormatInfo>
{
@@ -8482,6 +8663,20 @@
};
template <>
+ struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFrameBoundaryFeaturesEXT>
+ {
+ std::size_t
+ operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFrameBoundaryFeaturesEXT const & physicalDeviceFrameBoundaryFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
+ {
+ std::size_t seed = 0;
+ VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFrameBoundaryFeaturesEXT.sType );
+ VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFrameBoundaryFeaturesEXT.pNext );
+ VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFrameBoundaryFeaturesEXT.frameBoundary );
+ return seed;
+ }
+ };
+
+ template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceGlobalPriorityQueryFeaturesKHR>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceGlobalPriorityQueryFeaturesKHR const & physicalDeviceGlobalPriorityQueryFeaturesKHR ) const
@@ -8902,6 +9097,20 @@
};
template <>
+ struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredDriverPropertiesMSFT>
+ {
+ std::size_t
+ operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredDriverPropertiesMSFT const & physicalDeviceLayeredDriverPropertiesMSFT ) const VULKAN_HPP_NOEXCEPT
+ {
+ std::size_t seed = 0;
+ VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredDriverPropertiesMSFT.sType );
+ VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredDriverPropertiesMSFT.pNext );
+ VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredDriverPropertiesMSFT.underlyingAPI );
+ return seed;
+ }
+ };
+
+ template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLegacyDitheringFeaturesEXT>
{
std::size_t
@@ -13551,6 +13760,20 @@
};
template <>
+ struct hash<VULKAN_HPP_NAMESPACE::SetLatencyMarkerInfoNV>
+ {
+ std::size_t operator()( VULKAN_HPP_NAMESPACE::SetLatencyMarkerInfoNV const & setLatencyMarkerInfoNV ) const VULKAN_HPP_NOEXCEPT
+ {
+ std::size_t seed = 0;
+ VULKAN_HPP_HASH_COMBINE( seed, setLatencyMarkerInfoNV.sType );
+ VULKAN_HPP_HASH_COMBINE( seed, setLatencyMarkerInfoNV.pNext );
+ VULKAN_HPP_HASH_COMBINE( seed, setLatencyMarkerInfoNV.presentID );
+ VULKAN_HPP_HASH_COMBINE( seed, setLatencyMarkerInfoNV.marker );
+ return seed;
+ }
+ };
+
+ template <>
struct hash<VULKAN_HPP_NAMESPACE::SetStateFlagsIndirectCommandNV>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::SetStateFlagsIndirectCommandNV const & setStateFlagsIndirectCommandNV ) const VULKAN_HPP_NOEXCEPT
@@ -14167,6 +14390,19 @@
};
template <>
+ struct hash<VULKAN_HPP_NAMESPACE::SwapchainLatencyCreateInfoNV>
+ {
+ std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainLatencyCreateInfoNV const & swapchainLatencyCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
+ {
+ std::size_t seed = 0;
+ VULKAN_HPP_HASH_COMBINE( seed, swapchainLatencyCreateInfoNV.sType );
+ VULKAN_HPP_HASH_COMBINE( seed, swapchainLatencyCreateInfoNV.pNext );
+ VULKAN_HPP_HASH_COMBINE( seed, swapchainLatencyCreateInfoNV.latencyModeEnable );
+ return seed;
+ }
+ };
+
+ template <>
struct hash<VULKAN_HPP_NAMESPACE::SwapchainPresentBarrierCreateInfoNV>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainPresentBarrierCreateInfoNV const & swapchainPresentBarrierCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
diff --git a/include/vulkan/vulkan_hpp_macros.hpp b/include/vulkan/vulkan_hpp_macros.hpp
new file mode 100644
index 0000000..13fa815
--- /dev/null
+++ b/include/vulkan/vulkan_hpp_macros.hpp
@@ -0,0 +1,270 @@
+// Copyright 2015-2023 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_HPP_MACROS_HPP
+#define VULKAN_HPP_MACROS_HPP
+
+#if defined( _MSVC_LANG )
+# define VULKAN_HPP_CPLUSPLUS _MSVC_LANG
+#else
+# define VULKAN_HPP_CPLUSPLUS __cplusplus
+#endif
+
+#if 201703L < VULKAN_HPP_CPLUSPLUS
+# define VULKAN_HPP_CPP_VERSION 20
+#elif 201402L < VULKAN_HPP_CPLUSPLUS
+# define VULKAN_HPP_CPP_VERSION 17
+#elif 201103L < VULKAN_HPP_CPLUSPLUS
+# define VULKAN_HPP_CPP_VERSION 14
+#elif 199711L < VULKAN_HPP_CPLUSPLUS
+# define VULKAN_HPP_CPP_VERSION 11
+#else
+# error "vulkan.hpp needs at least c++ standard version 11"
+#endif
+
+#if defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+# if !defined( VULKAN_HPP_NO_SMART_HANDLE )
+# define VULKAN_HPP_NO_SMART_HANDLE
+# endif
+#endif
+
+#if defined( VULKAN_HPP_NO_CONSTRUCTORS )
+# if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+# define VULKAN_HPP_NO_STRUCT_CONSTRUCTORS
+# endif
+# if !defined( VULKAN_HPP_NO_UNION_CONSTRUCTORS )
+# define VULKAN_HPP_NO_UNION_CONSTRUCTORS
+# endif
+#endif
+
+#if defined( VULKAN_HPP_NO_SETTERS )
+# if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
+# define VULKAN_HPP_NO_STRUCT_SETTERS
+# endif
+# if !defined( VULKAN_HPP_NO_UNION_SETTERS )
+# define VULKAN_HPP_NO_UNION_SETTERS
+# endif
+#endif
+
+#if !defined( VULKAN_HPP_ASSERT )
+# define VULKAN_HPP_ASSERT assert
+#endif
+
+#if !defined( VULKAN_HPP_ASSERT_ON_RESULT )
+# define VULKAN_HPP_ASSERT_ON_RESULT VULKAN_HPP_ASSERT
+#endif
+
+#if !defined( VULKAN_HPP_STATIC_ASSERT )
+# define VULKAN_HPP_STATIC_ASSERT static_assert
+#endif
+
+#if !defined( VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL )
+# define VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL 1
+#endif
+
+#if !defined( __has_include )
+# define __has_include( x ) false
+#endif
+
+#if ( 201907 <= __cpp_lib_three_way_comparison ) && __has_include( <compare> ) && !defined( VULKAN_HPP_NO_SPACESHIP_OPERATOR )
+# define VULKAN_HPP_HAS_SPACESHIP_OPERATOR
+#endif
+
+#if ( 201803 <= __cpp_lib_span )
+# define VULKAN_HPP_SUPPORT_SPAN
+#endif
+
+// 32-bit vulkan is not typesafe for non-dispatchable handles, so don't allow copy constructors on this platform by default.
+// To enable this feature on 32-bit platforms please define VULKAN_HPP_TYPESAFE_CONVERSION
+#if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
+# if !defined( VULKAN_HPP_TYPESAFE_CONVERSION )
+# define VULKAN_HPP_TYPESAFE_CONVERSION
+# endif
+#endif
+
+#if defined( __GNUC__ )
+# define GCC_VERSION ( __GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__ )
+#endif
+
+#if !defined( VULKAN_HPP_HAS_UNRESTRICTED_UNIONS )
+# if defined( __clang__ )
+# if __has_feature( cxx_unrestricted_unions )
+# define VULKAN_HPP_HAS_UNRESTRICTED_UNIONS
+# endif
+# elif defined( __GNUC__ )
+# if 40600 <= GCC_VERSION
+# define VULKAN_HPP_HAS_UNRESTRICTED_UNIONS
+# endif
+# elif defined( _MSC_VER )
+# if 1900 <= _MSC_VER
+# define VULKAN_HPP_HAS_UNRESTRICTED_UNIONS
+# endif
+# endif
+#endif
+
+#if !defined( VULKAN_HPP_INLINE )
+# if defined( __clang__ )
+# if __has_attribute( always_inline )
+# define VULKAN_HPP_INLINE __attribute__( ( always_inline ) ) __inline__
+# else
+# define VULKAN_HPP_INLINE inline
+# endif
+# elif defined( __GNUC__ )
+# define VULKAN_HPP_INLINE __attribute__( ( always_inline ) ) __inline__
+# elif defined( _MSC_VER )
+# define VULKAN_HPP_INLINE inline
+# else
+# define VULKAN_HPP_INLINE inline
+# endif
+#endif
+
+#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
+# define VULKAN_HPP_TYPESAFE_EXPLICIT
+#else
+# define VULKAN_HPP_TYPESAFE_EXPLICIT explicit
+#endif
+
+#if defined( __cpp_constexpr )
+# define VULKAN_HPP_CONSTEXPR constexpr
+# if 201304 <= __cpp_constexpr
+# define VULKAN_HPP_CONSTEXPR_14 constexpr
+# else
+# define VULKAN_HPP_CONSTEXPR_14
+# endif
+# if ( 201907 <= __cpp_constexpr ) && ( !defined( __GNUC__ ) || ( 110400 < GCC_VERSION ) )
+# define VULKAN_HPP_CONSTEXPR_20 constexpr
+# else
+# define VULKAN_HPP_CONSTEXPR_20
+# endif
+# define VULKAN_HPP_CONST_OR_CONSTEXPR constexpr
+#else
+# define VULKAN_HPP_CONSTEXPR
+# define VULKAN_HPP_CONSTEXPR_14
+# define VULKAN_HPP_CONST_OR_CONSTEXPR const
+#endif
+
+#if !defined( VULKAN_HPP_CONSTEXPR_INLINE )
+# if 201606L <= __cpp_inline_variables
+# define VULKAN_HPP_CONSTEXPR_INLINE VULKAN_HPP_CONSTEXPR inline
+# else
+# define VULKAN_HPP_CONSTEXPR_INLINE VULKAN_HPP_CONSTEXPR
+# endif
+#endif
+
+#if !defined( VULKAN_HPP_NOEXCEPT )
+# if defined( _MSC_VER ) && ( _MSC_VER <= 1800 )
+# define VULKAN_HPP_NOEXCEPT
+# else
+# define VULKAN_HPP_NOEXCEPT noexcept
+# define VULKAN_HPP_HAS_NOEXCEPT 1
+# if defined( VULKAN_HPP_NO_EXCEPTIONS )
+# define VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS noexcept
+# else
+# define VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
+# endif
+# endif
+#endif
+
+#if 14 <= VULKAN_HPP_CPP_VERSION
+# define VULKAN_HPP_DEPRECATED( msg ) [[deprecated( msg )]]
+#else
+# define VULKAN_HPP_DEPRECATED( msg )
+#endif
+
+#if ( 17 <= VULKAN_HPP_CPP_VERSION ) && !defined( VULKAN_HPP_NO_NODISCARD_WARNINGS )
+# define VULKAN_HPP_NODISCARD [[nodiscard]]
+# if defined( VULKAN_HPP_NO_EXCEPTIONS )
+# define VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS [[nodiscard]]
+# else
+# define VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
+# endif
+#else
+# define VULKAN_HPP_NODISCARD
+# define VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
+#endif
+
+#if !defined( VULKAN_HPP_NAMESPACE )
+# define VULKAN_HPP_NAMESPACE vk
+#endif
+
+#define VULKAN_HPP_STRINGIFY2( text ) #text
+#define VULKAN_HPP_STRINGIFY( text ) VULKAN_HPP_STRINGIFY2( text )
+#define VULKAN_HPP_NAMESPACE_STRING VULKAN_HPP_STRINGIFY( VULKAN_HPP_NAMESPACE )
+
+#if !defined( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC )
+# if defined( VK_NO_PROTOTYPES )
+# define VULKAN_HPP_DISPATCH_LOADER_DYNAMIC 1
+# else
+# define VULKAN_HPP_DISPATCH_LOADER_DYNAMIC 0
+# endif
+#endif
+
+#if !defined( VULKAN_HPP_STORAGE_API )
+# if defined( VULKAN_HPP_STORAGE_SHARED )
+# if defined( _MSC_VER )
+# if defined( VULKAN_HPP_STORAGE_SHARED_EXPORT )
+# define VULKAN_HPP_STORAGE_API __declspec( dllexport )
+# else
+# define VULKAN_HPP_STORAGE_API __declspec( dllimport )
+# endif
+# elif defined( __clang__ ) || defined( __GNUC__ )
+# if defined( VULKAN_HPP_STORAGE_SHARED_EXPORT )
+# define VULKAN_HPP_STORAGE_API __attribute__( ( visibility( "default" ) ) )
+# else
+# define VULKAN_HPP_STORAGE_API
+# endif
+# else
+# define VULKAN_HPP_STORAGE_API
+# pragma warning Unknown import / export semantics
+# endif
+# else
+# define VULKAN_HPP_STORAGE_API
+# endif
+#endif
+
+namespace VULKAN_HPP_NAMESPACE
+{
+ class DispatchLoaderDynamic;
+} // namespace VULKAN_HPP_NAMESPACE
+
+#if !defined( VULKAN_HPP_DEFAULT_DISPATCHER )
+# if VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1
+# define VULKAN_HPP_DEFAULT_DISPATCHER ::VULKAN_HPP_NAMESPACE::defaultDispatchLoaderDynamic
+# define VULKAN_HPP_DEFAULT_DISPATCH_LOADER_DYNAMIC_STORAGE \
+ namespace VULKAN_HPP_NAMESPACE \
+ { \
+ VULKAN_HPP_STORAGE_API ::VULKAN_HPP_NAMESPACE::DispatchLoaderDynamic defaultDispatchLoaderDynamic; \
+ }
+namespace VULKAN_HPP_NAMESPACE
+{
+ extern VULKAN_HPP_STORAGE_API VULKAN_HPP_NAMESPACE::DispatchLoaderDynamic defaultDispatchLoaderDynamic;
+} // namespace VULKAN_HPP_NAMESPACE
+# else
+# define VULKAN_HPP_DEFAULT_DISPATCHER ::VULKAN_HPP_NAMESPACE::getDispatchLoaderStatic()
+# define VULKAN_HPP_DEFAULT_DISPATCH_LOADER_DYNAMIC_STORAGE
+# endif
+#endif
+
+#if !defined( VULKAN_HPP_DEFAULT_DISPATCHER_TYPE )
+# if VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1
+# define VULKAN_HPP_DEFAULT_DISPATCHER_TYPE ::VULKAN_HPP_NAMESPACE::DispatchLoaderDynamic
+# else
+# define VULKAN_HPP_DEFAULT_DISPATCHER_TYPE ::VULKAN_HPP_NAMESPACE::DispatchLoaderStatic
+# endif
+#endif
+
+#if defined( VULKAN_HPP_NO_DEFAULT_DISPATCHER )
+# define VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT
+# define VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT
+# define VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT
+#else
+# define VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT = {}
+# define VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT = nullptr
+# define VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT = VULKAN_HPP_DEFAULT_DISPATCHER
+#endif
+
+#endif
\ No newline at end of file
diff --git a/include/vulkan/vulkan_raii.hpp b/include/vulkan/vulkan_raii.hpp
index f065519..754f07e 100644
--- a/include/vulkan/vulkan_raii.hpp
+++ b/include/vulkan/vulkan_raii.hpp
@@ -1663,6 +1663,13 @@
vkGetDynamicRenderingTilePropertiesQCOM =
PFN_vkGetDynamicRenderingTilePropertiesQCOM( vkGetDeviceProcAddr( device, "vkGetDynamicRenderingTilePropertiesQCOM" ) );
+ //=== VK_NV_low_latency2 ===
+ vkSetLatencySleepModeNV = PFN_vkSetLatencySleepModeNV( vkGetDeviceProcAddr( device, "vkSetLatencySleepModeNV" ) );
+ vkLatencySleepNV = PFN_vkLatencySleepNV( vkGetDeviceProcAddr( device, "vkLatencySleepNV" ) );
+ vkSetLatencyMarkerNV = PFN_vkSetLatencyMarkerNV( vkGetDeviceProcAddr( device, "vkSetLatencyMarkerNV" ) );
+ vkGetLatencyTimingsNV = PFN_vkGetLatencyTimingsNV( vkGetDeviceProcAddr( device, "vkGetLatencyTimingsNV" ) );
+ vkQueueNotifyOutOfBandNV = PFN_vkQueueNotifyOutOfBandNV( vkGetDeviceProcAddr( device, "vkQueueNotifyOutOfBandNV" ) );
+
//=== VK_EXT_attachment_feedback_loop_dynamic_state ===
vkCmdSetAttachmentFeedbackLoopEnableEXT =
PFN_vkCmdSetAttachmentFeedbackLoopEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetAttachmentFeedbackLoopEnableEXT" ) );
@@ -2507,6 +2514,13 @@
PFN_vkGetFramebufferTilePropertiesQCOM vkGetFramebufferTilePropertiesQCOM = 0;
PFN_vkGetDynamicRenderingTilePropertiesQCOM vkGetDynamicRenderingTilePropertiesQCOM = 0;
+ //=== VK_NV_low_latency2 ===
+ PFN_vkSetLatencySleepModeNV vkSetLatencySleepModeNV = 0;
+ PFN_vkLatencySleepNV vkLatencySleepNV = 0;
+ PFN_vkSetLatencyMarkerNV vkSetLatencyMarkerNV = 0;
+ PFN_vkGetLatencyTimingsNV vkGetLatencyTimingsNV = 0;
+ PFN_vkQueueNotifyOutOfBandNV vkQueueNotifyOutOfBandNV = 0;
+
//=== VK_EXT_attachment_feedback_loop_dynamic_state ===
PFN_vkCmdSetAttachmentFeedbackLoopEnableEXT vkCmdSetAttachmentFeedbackLoopEnableEXT = 0;
@@ -9929,6 +9943,10 @@
VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::CheckpointData2NV> getCheckpointData2NV() const;
+ //=== VK_NV_low_latency2 ===
+
+ void notifyOutOfBandNV( VULKAN_HPP_NAMESPACE::OutOfBandQueueTypeInfoNV pQueueTypeInfo ) const VULKAN_HPP_NOEXCEPT;
+
private:
VULKAN_HPP_NAMESPACE::Queue m_queue = {};
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
@@ -11278,6 +11296,16 @@
void releaseFullScreenExclusiveModeEXT() const;
# endif /*VK_USE_PLATFORM_WIN32_KHR*/
+ //=== VK_NV_low_latency2 ===
+
+ VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::LatencySleepModeInfoNV setLatencySleepModeNV() const;
+
+ VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::LatencySleepInfoNV latencySleepNV() const;
+
+ VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::SetLatencyMarkerInfoNV setLatencyMarkerNV() const VULKAN_HPP_NOEXCEPT;
+
+ VULKAN_HPP_NODISCARD std::pair<uint32_t, VULKAN_HPP_NAMESPACE::GetLatencyMarkerInfoNV> getLatencyTimingsNV() const VULKAN_HPP_NOEXCEPT;
+
private:
VULKAN_HPP_NAMESPACE::Device m_device = {};
VULKAN_HPP_NAMESPACE::SwapchainKHR m_swapchain = {};
@@ -20639,6 +20667,66 @@
return properties;
}
+ //=== VK_NV_low_latency2 ===
+
+ VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::LatencySleepModeInfoNV SwapchainKHR::setLatencySleepModeNV() const
+ {
+ VULKAN_HPP_ASSERT( getDispatcher()->vkSetLatencySleepModeNV && "Function <vkSetLatencySleepModeNV> requires <VK_NV_low_latency2>" );
+
+ VULKAN_HPP_NAMESPACE::LatencySleepModeInfoNV sleepModeInfo;
+ VkResult result = getDispatcher()->vkSetLatencySleepModeNV(
+ static_cast<VkDevice>( m_device ), static_cast<VkSwapchainKHR>( m_swapchain ), reinterpret_cast<VkLatencySleepModeInfoNV *>( &sleepModeInfo ) );
+ resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::setLatencySleepModeNV" );
+
+ return sleepModeInfo;
+ }
+
+ VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::LatencySleepInfoNV SwapchainKHR::latencySleepNV() const
+ {
+ VULKAN_HPP_ASSERT( getDispatcher()->vkLatencySleepNV && "Function <vkLatencySleepNV> requires <VK_NV_low_latency2>" );
+
+ VULKAN_HPP_NAMESPACE::LatencySleepInfoNV sleepInfo;
+ VkResult result = getDispatcher()->vkLatencySleepNV(
+ static_cast<VkDevice>( m_device ), static_cast<VkSwapchainKHR>( m_swapchain ), reinterpret_cast<VkLatencySleepInfoNV *>( &sleepInfo ) );
+ resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::latencySleepNV" );
+
+ return sleepInfo;
+ }
+
+ VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::SetLatencyMarkerInfoNV SwapchainKHR::setLatencyMarkerNV() const VULKAN_HPP_NOEXCEPT
+ {
+ VULKAN_HPP_ASSERT( getDispatcher()->vkSetLatencyMarkerNV && "Function <vkSetLatencyMarkerNV> requires <VK_NV_low_latency2>" );
+
+ VULKAN_HPP_NAMESPACE::SetLatencyMarkerInfoNV latencyMarkerInfo;
+ getDispatcher()->vkSetLatencyMarkerNV(
+ static_cast<VkDevice>( m_device ), static_cast<VkSwapchainKHR>( m_swapchain ), reinterpret_cast<VkSetLatencyMarkerInfoNV *>( &latencyMarkerInfo ) );
+
+ return latencyMarkerInfo;
+ }
+
+ VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair<uint32_t, VULKAN_HPP_NAMESPACE::GetLatencyMarkerInfoNV>
+ SwapchainKHR::getLatencyTimingsNV() const VULKAN_HPP_NOEXCEPT
+ {
+ VULKAN_HPP_ASSERT( getDispatcher()->vkGetLatencyTimingsNV && "Function <vkGetLatencyTimingsNV> requires <VK_NV_low_latency2>" );
+
+ std::pair<uint32_t, VULKAN_HPP_NAMESPACE::GetLatencyMarkerInfoNV> data_;
+ uint32_t & timingCount = data_.first;
+ VULKAN_HPP_NAMESPACE::GetLatencyMarkerInfoNV & latencyMarkerInfo = data_.second;
+ getDispatcher()->vkGetLatencyTimingsNV( static_cast<VkDevice>( m_device ),
+ static_cast<VkSwapchainKHR>( m_swapchain ),
+ &timingCount,
+ reinterpret_cast<VkGetLatencyMarkerInfoNV *>( &latencyMarkerInfo ) );
+
+ return data_;
+ }
+
+ VULKAN_HPP_INLINE void Queue::notifyOutOfBandNV( VULKAN_HPP_NAMESPACE::OutOfBandQueueTypeInfoNV pQueueTypeInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ VULKAN_HPP_ASSERT( getDispatcher()->vkQueueNotifyOutOfBandNV && "Function <vkQueueNotifyOutOfBandNV> requires <VK_NV_low_latency2>" );
+
+ getDispatcher()->vkQueueNotifyOutOfBandNV( static_cast<VkQueue>( m_queue ), static_cast<VkOutOfBandQueueTypeInfoNV>( pQueueTypeInfo ) );
+ }
+
//=== VK_KHR_cooperative_matrix ===
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR>
diff --git a/include/vulkan/vulkan_shared.hpp b/include/vulkan/vulkan_shared.hpp
new file mode 100644
index 0000000..7b1bb23
--- /dev/null
+++ b/include/vulkan/vulkan_shared.hpp
@@ -0,0 +1,988 @@
+// Copyright 2015-2023 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_SHARED_HPP
+#define VULKAN_SHARED_HPP
+
+#include <atomic> // std::atomic_size_t
+#include <vulkan/vulkan.hpp>
+
+namespace VULKAN_HPP_NAMESPACE
+{
+#if !defined( VULKAN_HPP_NO_SMART_HANDLE )
+
+ template <typename HandleType>
+ class SharedHandleTraits;
+
+ class NoDestructor
+ {
+ };
+
+ template <typename HandleType, typename = void>
+ struct HasDestructorType : std::false_type
+ {
+ };
+
+ template <typename HandleType>
+ struct HasDestructorType<HandleType, decltype( (void)typename SharedHandleTraits<HandleType>::DestructorType() )> : std::true_type
+ {
+ };
+
+ template <typename HandleType, typename Enable = void>
+ struct GetDestructorType
+ {
+ using type = NoDestructor;
+ };
+
+ template <typename HandleType>
+ struct GetDestructorType<HandleType, typename std::enable_if<HasDestructorType<HandleType>::value>::type>
+ {
+ using type = typename SharedHandleTraits<HandleType>::DestructorType;
+ };
+
+ template <class HandleType>
+ using DestructorTypeOf = typename GetDestructorType<HandleType>::type;
+
+ template <class HandleType>
+ struct HasDestructor : std::integral_constant<bool, !std::is_same<DestructorTypeOf<HandleType>, NoDestructor>::value>
+ {
+ };
+
+ //=====================================================================================================================
+
+ template <typename HandleType>
+ class SharedHandle;
+
+ template <typename DestructorType, typename Deleter>
+ struct SharedHeader
+ {
+ SharedHeader( SharedHandle<DestructorType> parent, Deleter deleter = Deleter() ) VULKAN_HPP_NOEXCEPT
+ : parent( std::move( parent ) )
+ , deleter( std::move( deleter ) )
+ {
+ }
+
+ SharedHandle<DestructorType> parent;
+ Deleter deleter;
+ };
+
+ template <typename Deleter>
+ struct SharedHeader<NoDestructor, Deleter>
+ {
+ SharedHeader( Deleter deleter = Deleter() ) VULKAN_HPP_NOEXCEPT : deleter( std::move( deleter ) ) {}
+
+ Deleter deleter;
+ };
+
+ //=====================================================================================================================
+
+ template <typename HeaderType>
+ class ReferenceCounter
+ {
+ public:
+ template <typename... Args>
+ ReferenceCounter( Args &&... control_args ) : m_header( std::forward<Args>( control_args )... )
+ {
+ }
+ ReferenceCounter( const ReferenceCounter & ) = delete;
+ ReferenceCounter & operator=( const ReferenceCounter & ) = delete;
+
+ public:
+ size_t addRef() VULKAN_HPP_NOEXCEPT
+ {
+ // Relaxed memory order is sufficient since this does not impose any ordering on other operations
+ return m_ref_cnt.fetch_add( 1, std::memory_order_relaxed );
+ }
+
+ size_t release() VULKAN_HPP_NOEXCEPT
+ {
+ // A release memory order to ensure that all releases are ordered
+ return m_ref_cnt.fetch_sub( 1, std::memory_order_release );
+ }
+
+ public:
+ std::atomic_size_t m_ref_cnt{ 1 };
+ HeaderType m_header{};
+ };
+
+ //=====================================================================================================================
+
+ template <typename HandleType, typename HeaderType, typename ForwardType = SharedHandle<HandleType>>
+ class SharedHandleBase
+ {
+ public:
+ SharedHandleBase() = default;
+
+ template <typename... Args>
+ SharedHandleBase( HandleType handle, Args &&... control_args )
+ : m_control( new ReferenceCounter<HeaderType>( std::forward<Args>( control_args )... ) ), m_handle( handle )
+ {
+ }
+
+ SharedHandleBase( const SharedHandleBase & o ) VULKAN_HPP_NOEXCEPT
+ {
+ o.addRef();
+ m_handle = o.m_handle;
+ m_control = o.m_control;
+ }
+
+ SharedHandleBase( SharedHandleBase && o ) VULKAN_HPP_NOEXCEPT
+ : m_control( o.m_control )
+ , m_handle( o.m_handle )
+ {
+ o.m_handle = nullptr;
+ o.m_control = nullptr;
+ }
+
+ SharedHandleBase & operator=( const SharedHandleBase & o ) VULKAN_HPP_NOEXCEPT
+ {
+ SharedHandleBase( o ).swap( *this );
+ return *this;
+ }
+
+ SharedHandleBase & operator=( SharedHandleBase && o ) VULKAN_HPP_NOEXCEPT
+ {
+ SharedHandleBase( std::move( o ) ).swap( *this );
+ return *this;
+ }
+
+ ~SharedHandleBase()
+ {
+ // only this function owns the last reference to the control block
+ // the same principle is used in the default deleter of std::shared_ptr
+ if ( m_control && ( m_control->release() == 1 ) )
+ {
+ // noop in x86, but does thread synchronization in ARM
+ // it is required to ensure that last thread is getting to destroy the control block
+ // by ordering all atomic operations before this fence
+ std::atomic_thread_fence( std::memory_order_acquire );
+ ForwardType::internalDestroy( getHeader(), m_handle );
+ delete m_control;
+ }
+ }
+
+ public:
+ HandleType get() const VULKAN_HPP_NOEXCEPT
+ {
+ return m_handle;
+ }
+
+ HandleType operator*() const VULKAN_HPP_NOEXCEPT
+ {
+ return m_handle;
+ }
+
+ explicit operator bool() const VULKAN_HPP_NOEXCEPT
+ {
+ return bool( m_handle );
+ }
+
+ const HandleType * operator->() const VULKAN_HPP_NOEXCEPT
+ {
+ return &m_handle;
+ }
+
+ HandleType * operator->() VULKAN_HPP_NOEXCEPT
+ {
+ return &m_handle;
+ }
+
+ void reset() VULKAN_HPP_NOEXCEPT
+ {
+ SharedHandleBase().swap( *this );
+ }
+
+ void swap( SharedHandleBase & o ) VULKAN_HPP_NOEXCEPT
+ {
+ std::swap( m_handle, o.m_handle );
+ std::swap( m_control, o.m_control );
+ }
+
+ template <typename T = HandleType>
+ typename std::enable_if<HasDestructor<T>::value, const SharedHandle<DestructorTypeOf<HandleType>> &>::type getDestructorType() const VULKAN_HPP_NOEXCEPT
+ {
+ return getHeader().parent;
+ }
+
+ protected:
+ template <typename T = HandleType>
+ static typename std::enable_if<!HasDestructor<T>::value, void>::type internalDestroy( const HeaderType & control, HandleType handle ) VULKAN_HPP_NOEXCEPT
+ {
+ control.deleter.destroy( handle );
+ }
+
+ template <typename T = HandleType>
+ static typename std::enable_if<HasDestructor<T>::value, void>::type internalDestroy( const HeaderType & control, HandleType handle ) VULKAN_HPP_NOEXCEPT
+ {
+ control.deleter.destroy( control.parent.get(), handle );
+ }
+
+ const HeaderType & getHeader() const VULKAN_HPP_NOEXCEPT
+ {
+ return m_control->m_header;
+ }
+
+ private:
+ void addRef() const VULKAN_HPP_NOEXCEPT
+ {
+ if ( m_control )
+ m_control->addRef();
+ }
+
+ protected:
+ ReferenceCounter<HeaderType> * m_control = nullptr;
+ HandleType m_handle{};
+ };
+
+ template <typename HandleType>
+ class SharedHandle : public SharedHandleBase<HandleType, SharedHeader<DestructorTypeOf<HandleType>, typename SharedHandleTraits<HandleType>::deleter>>
+ {
+ private:
+ using BaseType = SharedHandleBase<HandleType, SharedHeader<DestructorTypeOf<HandleType>, typename SharedHandleTraits<HandleType>::deleter>>;
+ using DeleterType = typename SharedHandleTraits<HandleType>::deleter;
+ friend BaseType;
+
+ public:
+ SharedHandle() = default;
+
+ template <typename T = HandleType, typename = typename std::enable_if<HasDestructor<T>::value>::type>
+ explicit SharedHandle( HandleType handle, SharedHandle<DestructorTypeOf<HandleType>> parent, DeleterType deleter = DeleterType() ) VULKAN_HPP_NOEXCEPT
+ : BaseType( handle, std::move( parent ), std::move( deleter ) )
+ {
+ }
+
+ template <typename T = HandleType, typename = typename std::enable_if<!HasDestructor<T>::value>::type>
+ explicit SharedHandle( HandleType handle, DeleterType deleter = DeleterType() ) VULKAN_HPP_NOEXCEPT : BaseType( handle, std::move( deleter ) )
+ {
+ }
+
+ protected:
+ using BaseType::internalDestroy;
+ };
+
+ template <typename HandleType>
+ class SharedHandleTraits;
+
+// Silence the function cast warnings.
+# if defined( __GNUC__ ) && !defined( __clang__ ) && !defined( __INTEL_COMPILER )
+# pragma GCC diagnostic push
+# pragma GCC diagnostic ignored "-Wcast-function-type"
+# endif
+
+ template <typename HandleType>
+ class ObjectDestroyShared
+ {
+ public:
+ using DestructorType = typename SharedHandleTraits<HandleType>::DestructorType;
+
+ template <class Dispatcher>
+ using DestroyFunctionPointerType =
+ typename std::conditional<HasDestructor<HandleType>::value,
+ void ( DestructorType::* )( HandleType, const AllocationCallbacks *, const Dispatcher & ) const,
+ void ( HandleType::* )( const AllocationCallbacks *, const Dispatcher & ) const>::type;
+
+ using SelectorType = typename std::conditional<HasDestructor<HandleType>::value, DestructorType, HandleType>::type;
+
+ template <typename Dispatcher = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ObjectDestroyShared( Optional<const AllocationCallbacks> allocationCallbacks VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+ const Dispatcher & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT )
+ : m_destroy( reinterpret_cast<decltype( m_destroy )>( static_cast<DestroyFunctionPointerType<Dispatcher>>( &SelectorType::destroy ) ) )
+ , m_dispatch( &dispatch )
+ , m_allocationCallbacks( allocationCallbacks )
+ {
+ }
+
+ public:
+ template <typename T = HandleType>
+ typename std::enable_if<HasDestructor<T>::value, void>::type destroy( DestructorType parent, HandleType handle ) const VULKAN_HPP_NOEXCEPT
+ {
+ VULKAN_HPP_ASSERT( m_destroy && m_dispatch );
+ ( parent.*m_destroy )( handle, m_allocationCallbacks, *m_dispatch );
+ }
+
+ template <typename T = HandleType>
+ typename std::enable_if<!HasDestructor<T>::value, void>::type destroy( HandleType handle ) const VULKAN_HPP_NOEXCEPT
+ {
+ VULKAN_HPP_ASSERT( m_destroy && m_dispatch );
+ ( handle.*m_destroy )( m_allocationCallbacks, *m_dispatch );
+ }
+
+ private:
+ DestroyFunctionPointerType<DispatchLoaderBase> m_destroy = nullptr;
+ const DispatchLoaderBase * m_dispatch = nullptr;
+ Optional<const AllocationCallbacks> m_allocationCallbacks = nullptr;
+ };
+
+ template <typename HandleType>
+ class ObjectFreeShared
+ {
+ public:
+ using DestructorType = typename SharedHandleTraits<HandleType>::DestructorType;
+
+ template <class Dispatcher>
+ using DestroyFunctionPointerType = void ( DestructorType::* )( HandleType, const AllocationCallbacks *, const Dispatcher & ) const;
+
+ template <class Dispatcher = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ObjectFreeShared( Optional<const AllocationCallbacks> allocationCallbacks VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+ const Dispatcher & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT )
+ : m_destroy( reinterpret_cast<decltype( m_destroy )>( static_cast<DestroyFunctionPointerType<Dispatcher>>( &DestructorType::free ) ) )
+ , m_dispatch( &dispatch )
+ , m_allocationCallbacks( allocationCallbacks )
+ {
+ }
+
+ public:
+ void destroy( DestructorType parent, HandleType handle ) const VULKAN_HPP_NOEXCEPT
+ {
+ VULKAN_HPP_ASSERT( m_destroy && m_dispatch );
+ ( parent.*m_destroy )( handle, m_allocationCallbacks, *m_dispatch );
+ }
+
+ private:
+ DestroyFunctionPointerType<DispatchLoaderBase> m_destroy = nullptr;
+ const DispatchLoaderBase * m_dispatch = nullptr;
+ Optional<const AllocationCallbacks> m_allocationCallbacks = nullptr;
+ };
+
+ template <typename HandleType>
+ class ObjectReleaseShared
+ {
+ public:
+ using DestructorType = typename SharedHandleTraits<HandleType>::DestructorType;
+
+ template <class Dispatcher>
+ using DestroyFunctionPointerType = void ( DestructorType::* )( HandleType, const Dispatcher & ) const;
+
+ template <class Dispatcher = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ObjectReleaseShared( const Dispatcher & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT )
+ : m_destroy( reinterpret_cast<decltype( m_destroy )>( static_cast<DestroyFunctionPointerType<Dispatcher>>( &DestructorType::release ) ) )
+ , m_dispatch( &dispatch )
+ {
+ }
+
+ public:
+ void destroy( DestructorType parent, HandleType handle ) const VULKAN_HPP_NOEXCEPT
+ {
+ VULKAN_HPP_ASSERT( m_destroy && m_dispatch );
+ ( parent.*m_destroy )( handle, *m_dispatch );
+ }
+
+ private:
+ DestroyFunctionPointerType<DispatchLoaderBase> m_destroy = nullptr;
+ const DispatchLoaderBase * m_dispatch = nullptr;
+ };
+
+ template <typename HandleType, typename PoolType>
+ class PoolFreeShared
+ {
+ public:
+ using DestructorType = typename SharedHandleTraits<HandleType>::DestructorType;
+
+ template <class Dispatcher>
+ using ReturnType = decltype( std::declval<DestructorType>().free( PoolType(), 0u, nullptr, Dispatcher() ) );
+
+ template <class Dispatcher>
+ using DestroyFunctionPointerType = ReturnType<Dispatcher> ( DestructorType::* )( PoolType, uint32_t, const HandleType *, const Dispatcher & ) const;
+
+ PoolFreeShared() = default;
+
+ template <class Dispatcher = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ PoolFreeShared( SharedHandle<PoolType> pool, const Dispatcher & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT )
+ : m_destroy( reinterpret_cast<decltype( m_destroy )>( static_cast<DestroyFunctionPointerType<Dispatcher>>( &DestructorType::free ) ) )
+ , m_dispatch( &dispatch )
+ , m_pool( std::move( pool ) )
+ {
+ }
+
+ public:
+ void destroy( DestructorType parent, HandleType handle ) const VULKAN_HPP_NOEXCEPT
+ {
+ VULKAN_HPP_ASSERT( m_destroy && m_dispatch );
+ ( parent.*m_destroy )( m_pool.get(), 1u, &handle, *m_dispatch );
+ }
+
+ private:
+ DestroyFunctionPointerType<DispatchLoaderBase> m_destroy = nullptr;
+ const DispatchLoaderBase * m_dispatch = nullptr;
+ SharedHandle<PoolType> m_pool{};
+ };
+
+# if defined( __GNUC__ ) && !defined( __clang__ ) && !defined( __INTEL_COMPILER )
+# pragma GCC diagnostic pop
+# endif
+
+ //======================
+ //=== SHARED HANDLEs ===
+ //======================
+
+ //=== VK_VERSION_1_0 ===
+ template <>
+ class SharedHandleTraits<Instance>
+ {
+ public:
+ using DestructorType = NoDestructor;
+ using deleter = ObjectDestroyShared<Instance>;
+ };
+ using SharedInstance = SharedHandle<Instance>;
+ template <>
+ class SharedHandleTraits<Device>
+ {
+ public:
+ using DestructorType = NoDestructor;
+ using deleter = ObjectDestroyShared<Device>;
+ };
+ using SharedDevice = SharedHandle<Device>;
+ template <>
+ class SharedHandleTraits<DeviceMemory>
+ {
+ public:
+ using DestructorType = Device;
+ using deleter = ObjectFreeShared<DeviceMemory>;
+ };
+ using SharedDeviceMemory = SharedHandle<DeviceMemory>;
+ template <>
+ class SharedHandleTraits<Fence>
+ {
+ public:
+ using DestructorType = Device;
+ using deleter = ObjectDestroyShared<Fence>;
+ };
+ using SharedFence = SharedHandle<Fence>;
+ template <>
+ class SharedHandleTraits<Semaphore>
+ {
+ public:
+ using DestructorType = Device;
+ using deleter = ObjectDestroyShared<Semaphore>;
+ };
+ using SharedSemaphore = SharedHandle<Semaphore>;
+ template <>
+ class SharedHandleTraits<Event>
+ {
+ public:
+ using DestructorType = Device;
+ using deleter = ObjectDestroyShared<Event>;
+ };
+ using SharedEvent = SharedHandle<Event>;
+ template <>
+ class SharedHandleTraits<QueryPool>
+ {
+ public:
+ using DestructorType = Device;
+ using deleter = ObjectDestroyShared<QueryPool>;
+ };
+ using SharedQueryPool = SharedHandle<QueryPool>;
+ template <>
+ class SharedHandleTraits<Buffer>
+ {
+ public:
+ using DestructorType = Device;
+ using deleter = ObjectDestroyShared<Buffer>;
+ };
+ using SharedBuffer = SharedHandle<Buffer>;
+ template <>
+ class SharedHandleTraits<BufferView>
+ {
+ public:
+ using DestructorType = Device;
+ using deleter = ObjectDestroyShared<BufferView>;
+ };
+ using SharedBufferView = SharedHandle<BufferView>;
+ template <>
+ class SharedHandleTraits<Image>
+ {
+ public:
+ using DestructorType = Device;
+ using deleter = ObjectDestroyShared<Image>;
+ };
+ using SharedImage = SharedHandle<Image>;
+ template <>
+ class SharedHandleTraits<ImageView>
+ {
+ public:
+ using DestructorType = Device;
+ using deleter = ObjectDestroyShared<ImageView>;
+ };
+ using SharedImageView = SharedHandle<ImageView>;
+ template <>
+ class SharedHandleTraits<ShaderModule>
+ {
+ public:
+ using DestructorType = Device;
+ using deleter = ObjectDestroyShared<ShaderModule>;
+ };
+ using SharedShaderModule = SharedHandle<ShaderModule>;
+ template <>
+ class SharedHandleTraits<PipelineCache>
+ {
+ public:
+ using DestructorType = Device;
+ using deleter = ObjectDestroyShared<PipelineCache>;
+ };
+ using SharedPipelineCache = SharedHandle<PipelineCache>;
+ template <>
+ class SharedHandleTraits<Pipeline>
+ {
+ public:
+ using DestructorType = Device;
+ using deleter = ObjectDestroyShared<Pipeline>;
+ };
+ using SharedPipeline = SharedHandle<Pipeline>;
+ template <>
+ class SharedHandleTraits<PipelineLayout>
+ {
+ public:
+ using DestructorType = Device;
+ using deleter = ObjectDestroyShared<PipelineLayout>;
+ };
+ using SharedPipelineLayout = SharedHandle<PipelineLayout>;
+ template <>
+ class SharedHandleTraits<Sampler>
+ {
+ public:
+ using DestructorType = Device;
+ using deleter = ObjectDestroyShared<Sampler>;
+ };
+ using SharedSampler = SharedHandle<Sampler>;
+ template <>
+ class SharedHandleTraits<DescriptorPool>
+ {
+ public:
+ using DestructorType = Device;
+ using deleter = ObjectDestroyShared<DescriptorPool>;
+ };
+ using SharedDescriptorPool = SharedHandle<DescriptorPool>;
+ template <>
+ class SharedHandleTraits<DescriptorSet>
+ {
+ public:
+ using DestructorType = Device;
+ using deleter = PoolFreeShared<DescriptorSet, DescriptorPool>;
+ };
+ using SharedDescriptorSet = SharedHandle<DescriptorSet>;
+ template <>
+ class SharedHandleTraits<DescriptorSetLayout>
+ {
+ public:
+ using DestructorType = Device;
+ using deleter = ObjectDestroyShared<DescriptorSetLayout>;
+ };
+ using SharedDescriptorSetLayout = SharedHandle<DescriptorSetLayout>;
+ template <>
+ class SharedHandleTraits<Framebuffer>
+ {
+ public:
+ using DestructorType = Device;
+ using deleter = ObjectDestroyShared<Framebuffer>;
+ };
+ using SharedFramebuffer = SharedHandle<Framebuffer>;
+ template <>
+ class SharedHandleTraits<RenderPass>
+ {
+ public:
+ using DestructorType = Device;
+ using deleter = ObjectDestroyShared<RenderPass>;
+ };
+ using SharedRenderPass = SharedHandle<RenderPass>;
+ template <>
+ class SharedHandleTraits<CommandPool>
+ {
+ public:
+ using DestructorType = Device;
+ using deleter = ObjectDestroyShared<CommandPool>;
+ };
+ using SharedCommandPool = SharedHandle<CommandPool>;
+ template <>
+ class SharedHandleTraits<CommandBuffer>
+ {
+ public:
+ using DestructorType = Device;
+ using deleter = PoolFreeShared<CommandBuffer, CommandPool>;
+ };
+ using SharedCommandBuffer = SharedHandle<CommandBuffer>;
+
+ //=== VK_VERSION_1_1 ===
+ template <>
+ class SharedHandleTraits<SamplerYcbcrConversion>
+ {
+ public:
+ using DestructorType = Device;
+ using deleter = ObjectDestroyShared<SamplerYcbcrConversion>;
+ };
+ using SharedSamplerYcbcrConversion = SharedHandle<SamplerYcbcrConversion>;
+ using SharedSamplerYcbcrConversionKHR = SharedHandle<SamplerYcbcrConversion>;
+ template <>
+ class SharedHandleTraits<DescriptorUpdateTemplate>
+ {
+ public:
+ using DestructorType = Device;
+ using deleter = ObjectDestroyShared<DescriptorUpdateTemplate>;
+ };
+ using SharedDescriptorUpdateTemplate = SharedHandle<DescriptorUpdateTemplate>;
+ using SharedDescriptorUpdateTemplateKHR = SharedHandle<DescriptorUpdateTemplate>;
+ //=== VK_VERSION_1_3 ===
+ template <>
+ class SharedHandleTraits<PrivateDataSlot>
+ {
+ public:
+ using DestructorType = Device;
+ using deleter = ObjectDestroyShared<PrivateDataSlot>;
+ };
+ using SharedPrivateDataSlot = SharedHandle<PrivateDataSlot>;
+ using SharedPrivateDataSlotEXT = SharedHandle<PrivateDataSlot>;
+ //=== VK_KHR_surface ===
+ template <>
+ class SharedHandleTraits<SurfaceKHR>
+ {
+ public:
+ using DestructorType = Instance;
+ using deleter = ObjectDestroyShared<SurfaceKHR>;
+ };
+ using SharedSurfaceKHR = SharedHandle<SurfaceKHR>;
+
+ //=== VK_KHR_swapchain ===
+ template <>
+ class SharedHandleTraits<SwapchainKHR>
+ {
+ public:
+ using DestructorType = Device;
+ using deleter = ObjectDestroyShared<SwapchainKHR>;
+ };
+ using SharedSwapchainKHR = SharedHandle<SwapchainKHR>;
+
+ //=== VK_EXT_debug_report ===
+ template <>
+ class SharedHandleTraits<DebugReportCallbackEXT>
+ {
+ public:
+ using DestructorType = Instance;
+ using deleter = ObjectDestroyShared<DebugReportCallbackEXT>;
+ };
+ using SharedDebugReportCallbackEXT = SharedHandle<DebugReportCallbackEXT>;
+
+ //=== VK_KHR_video_queue ===
+ template <>
+ class SharedHandleTraits<VideoSessionKHR>
+ {
+ public:
+ using DestructorType = Device;
+ using deleter = ObjectDestroyShared<VideoSessionKHR>;
+ };
+ using SharedVideoSessionKHR = SharedHandle<VideoSessionKHR>;
+ template <>
+ class SharedHandleTraits<VideoSessionParametersKHR>
+ {
+ public:
+ using DestructorType = Device;
+ using deleter = ObjectDestroyShared<VideoSessionParametersKHR>;
+ };
+ using SharedVideoSessionParametersKHR = SharedHandle<VideoSessionParametersKHR>;
+
+ //=== VK_NVX_binary_import ===
+ template <>
+ class SharedHandleTraits<CuModuleNVX>
+ {
+ public:
+ using DestructorType = Device;
+ using deleter = ObjectDestroyShared<CuModuleNVX>;
+ };
+ using SharedCuModuleNVX = SharedHandle<CuModuleNVX>;
+ template <>
+ class SharedHandleTraits<CuFunctionNVX>
+ {
+ public:
+ using DestructorType = Device;
+ using deleter = ObjectDestroyShared<CuFunctionNVX>;
+ };
+ using SharedCuFunctionNVX = SharedHandle<CuFunctionNVX>;
+
+ //=== VK_EXT_debug_utils ===
+ template <>
+ class SharedHandleTraits<DebugUtilsMessengerEXT>
+ {
+ public:
+ using DestructorType = Instance;
+ using deleter = ObjectDestroyShared<DebugUtilsMessengerEXT>;
+ };
+ using SharedDebugUtilsMessengerEXT = SharedHandle<DebugUtilsMessengerEXT>;
+
+ //=== VK_KHR_acceleration_structure ===
+ template <>
+ class SharedHandleTraits<AccelerationStructureKHR>
+ {
+ public:
+ using DestructorType = Device;
+ using deleter = ObjectDestroyShared<AccelerationStructureKHR>;
+ };
+ using SharedAccelerationStructureKHR = SharedHandle<AccelerationStructureKHR>;
+
+ //=== VK_EXT_validation_cache ===
+ template <>
+ class SharedHandleTraits<ValidationCacheEXT>
+ {
+ public:
+ using DestructorType = Device;
+ using deleter = ObjectDestroyShared<ValidationCacheEXT>;
+ };
+ using SharedValidationCacheEXT = SharedHandle<ValidationCacheEXT>;
+
+ //=== VK_NV_ray_tracing ===
+ template <>
+ class SharedHandleTraits<AccelerationStructureNV>
+ {
+ public:
+ using DestructorType = Device;
+ using deleter = ObjectDestroyShared<AccelerationStructureNV>;
+ };
+ using SharedAccelerationStructureNV = SharedHandle<AccelerationStructureNV>;
+
+ //=== VK_KHR_deferred_host_operations ===
+ template <>
+ class SharedHandleTraits<DeferredOperationKHR>
+ {
+ public:
+ using DestructorType = Device;
+ using deleter = ObjectDestroyShared<DeferredOperationKHR>;
+ };
+ using SharedDeferredOperationKHR = SharedHandle<DeferredOperationKHR>;
+
+ //=== VK_NV_device_generated_commands ===
+ template <>
+ class SharedHandleTraits<IndirectCommandsLayoutNV>
+ {
+ public:
+ using DestructorType = Device;
+ using deleter = ObjectDestroyShared<IndirectCommandsLayoutNV>;
+ };
+ using SharedIndirectCommandsLayoutNV = SharedHandle<IndirectCommandsLayoutNV>;
+
+# if defined( VK_USE_PLATFORM_FUCHSIA )
+ //=== VK_FUCHSIA_buffer_collection ===
+ template <>
+ class SharedHandleTraits<BufferCollectionFUCHSIA>
+ {
+ public:
+ using DestructorType = Device;
+ using deleter = ObjectDestroyShared<BufferCollectionFUCHSIA>;
+ };
+ using SharedBufferCollectionFUCHSIA = SharedHandle<BufferCollectionFUCHSIA>;
+# endif /*VK_USE_PLATFORM_FUCHSIA*/
+
+ //=== VK_EXT_opacity_micromap ===
+ template <>
+ class SharedHandleTraits<MicromapEXT>
+ {
+ public:
+ using DestructorType = Device;
+ using deleter = ObjectDestroyShared<MicromapEXT>;
+ };
+ using SharedMicromapEXT = SharedHandle<MicromapEXT>;
+
+ //=== VK_NV_optical_flow ===
+ template <>
+ class SharedHandleTraits<OpticalFlowSessionNV>
+ {
+ public:
+ using DestructorType = Device;
+ using deleter = ObjectDestroyShared<OpticalFlowSessionNV>;
+ };
+ using SharedOpticalFlowSessionNV = SharedHandle<OpticalFlowSessionNV>;
+
+ //=== VK_EXT_shader_object ===
+ template <>
+ class SharedHandleTraits<ShaderEXT>
+ {
+ public:
+ using DestructorType = Device;
+ using deleter = ObjectDestroyShared<ShaderEXT>;
+ };
+ using SharedShaderEXT = SharedHandle<ShaderEXT>;
+
+ enum class SwapchainOwns
+ {
+ no,
+ yes,
+ };
+
+ struct ImageHeader : SharedHeader<DestructorTypeOf<VULKAN_HPP_NAMESPACE::Image>, typename SharedHandleTraits<VULKAN_HPP_NAMESPACE::Image>::deleter>
+ {
+ ImageHeader(
+ SharedHandle<DestructorTypeOf<VULKAN_HPP_NAMESPACE::Image>> parent,
+ typename SharedHandleTraits<VULKAN_HPP_NAMESPACE::Image>::deleter deleter = typename SharedHandleTraits<VULKAN_HPP_NAMESPACE::Image>::deleter(),
+ SwapchainOwns swapchainOwned = SwapchainOwns::no ) VULKAN_HPP_NOEXCEPT
+ : SharedHeader<DestructorTypeOf<VULKAN_HPP_NAMESPACE::Image>, typename SharedHandleTraits<VULKAN_HPP_NAMESPACE::Image>::deleter>( std::move( parent ),
+ std::move( deleter ) )
+ , swapchainOwned( swapchainOwned )
+ {
+ }
+
+ SwapchainOwns swapchainOwned = SwapchainOwns::no;
+ };
+
+ template <>
+ class SharedHandle<VULKAN_HPP_NAMESPACE::Image> : public SharedHandleBase<VULKAN_HPP_NAMESPACE::Image, ImageHeader>
+ {
+ using BaseType = SharedHandleBase<VULKAN_HPP_NAMESPACE::Image, ImageHeader>;
+ using DeleterType = typename SharedHandleTraits<VULKAN_HPP_NAMESPACE::Image>::deleter;
+ friend BaseType;
+
+ public:
+ SharedHandle() = default;
+
+ explicit SharedHandle( VULKAN_HPP_NAMESPACE::Image handle,
+ SharedHandle<DestructorTypeOf<VULKAN_HPP_NAMESPACE::Image>> parent,
+ SwapchainOwns swapchain_owned = SwapchainOwns::no,
+ DeleterType deleter = DeleterType() ) VULKAN_HPP_NOEXCEPT
+ : BaseType( handle, std::move( parent ), std::move( deleter ), swapchain_owned )
+ {
+ }
+
+ protected:
+ static void internalDestroy( const ImageHeader & control, VULKAN_HPP_NAMESPACE::Image handle ) VULKAN_HPP_NOEXCEPT
+ {
+ if ( control.swapchainOwned == SwapchainOwns::no )
+ {
+ control.deleter.destroy( control.parent.get(), handle );
+ }
+ }
+ };
+
+ struct SwapchainHeader
+ {
+ SwapchainHeader( SharedHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR> surface,
+ SharedHandle<DestructorTypeOf<VULKAN_HPP_NAMESPACE::SwapchainKHR>> parent,
+ typename SharedHandleTraits<VULKAN_HPP_NAMESPACE::SwapchainKHR>::deleter deleter =
+ typename SharedHandleTraits<VULKAN_HPP_NAMESPACE::SwapchainKHR>::deleter() ) VULKAN_HPP_NOEXCEPT
+ : surface( std::move( surface ) )
+ , parent( std::move( parent ) )
+ , deleter( std::move( deleter ) )
+ {
+ }
+
+ SharedHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR> surface{};
+ SharedHandle<DestructorTypeOf<VULKAN_HPP_NAMESPACE::SwapchainKHR>> parent{};
+ typename SharedHandleTraits<VULKAN_HPP_NAMESPACE::SwapchainKHR>::deleter deleter{};
+ };
+
+ template <>
+ class SharedHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR> : public SharedHandleBase<VULKAN_HPP_NAMESPACE::SwapchainKHR, SwapchainHeader>
+ {
+ using BaseType = SharedHandleBase<VULKAN_HPP_NAMESPACE::SwapchainKHR, SwapchainHeader>;
+ using DeleterType = typename SharedHandleTraits<VULKAN_HPP_NAMESPACE::SwapchainKHR>::deleter;
+ friend BaseType;
+
+ public:
+ SharedHandle() = default;
+
+ explicit SharedHandle( VULKAN_HPP_NAMESPACE::SwapchainKHR handle,
+ SharedHandle<DestructorTypeOf<VULKAN_HPP_NAMESPACE::SwapchainKHR>> parent,
+ SharedHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR> surface,
+ DeleterType deleter = DeleterType() ) VULKAN_HPP_NOEXCEPT
+ : BaseType( handle, std::move( surface ), std::move( parent ), std::move( deleter ) )
+ {
+ }
+
+ public:
+ const SharedHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR> & getSurface() const VULKAN_HPP_NOEXCEPT
+ {
+ return getHeader().surface;
+ }
+
+ protected:
+ using BaseType::internalDestroy;
+ };
+
+ template <typename HandleType, typename DestructorType>
+ class SharedHandleBaseNoDestroy : public SharedHandleBase<HandleType, DestructorType>
+ {
+ public:
+ using SharedHandleBase<HandleType, DestructorType>::SharedHandleBase;
+
+ const DestructorType & getDestructorType() const VULKAN_HPP_NOEXCEPT
+ {
+ return SharedHandleBase<HandleType, DestructorType>::getHeader();
+ }
+
+ protected:
+ static void internalDestroy( const DestructorType &, HandleType ) VULKAN_HPP_NOEXCEPT {}
+ };
+
+ //=== VK_VERSION_1_0 ===
+
+ template <>
+ class SharedHandle<PhysicalDevice> : public SharedHandleBaseNoDestroy<PhysicalDevice, SharedInstance>
+ {
+ friend SharedHandleBase<PhysicalDevice, SharedInstance>;
+
+ public:
+ SharedHandle() = default;
+ explicit SharedHandle( PhysicalDevice handle, SharedInstance parent ) noexcept
+ : SharedHandleBaseNoDestroy<PhysicalDevice, SharedInstance>( handle, std::move( parent ) )
+ {
+ }
+ };
+ using SharedPhysicalDevice = SharedHandle<PhysicalDevice>;
+
+ template <>
+ class SharedHandle<Queue> : public SharedHandleBaseNoDestroy<Queue, SharedDevice>
+ {
+ friend SharedHandleBase<Queue, SharedDevice>;
+
+ public:
+ SharedHandle() = default;
+ explicit SharedHandle( Queue handle, SharedDevice parent ) noexcept : SharedHandleBaseNoDestroy<Queue, SharedDevice>( handle, std::move( parent ) ) {}
+ };
+ using SharedQueue = SharedHandle<Queue>;
+
+ //=== VK_KHR_display ===
+
+ template <>
+ class SharedHandle<DisplayKHR> : public SharedHandleBaseNoDestroy<DisplayKHR, SharedPhysicalDevice>
+ {
+ friend SharedHandleBase<DisplayKHR, SharedPhysicalDevice>;
+
+ public:
+ SharedHandle() = default;
+ explicit SharedHandle( DisplayKHR handle, SharedPhysicalDevice parent ) noexcept
+ : SharedHandleBaseNoDestroy<DisplayKHR, SharedPhysicalDevice>( handle, std::move( parent ) )
+ {
+ }
+ };
+ using SharedDisplayKHR = SharedHandle<DisplayKHR>;
+
+ template <>
+ class SharedHandle<DisplayModeKHR> : public SharedHandleBaseNoDestroy<DisplayModeKHR, SharedDisplayKHR>
+ {
+ friend SharedHandleBase<DisplayModeKHR, SharedDisplayKHR>;
+
+ public:
+ SharedHandle() = default;
+ explicit SharedHandle( DisplayModeKHR handle, SharedDisplayKHR parent ) noexcept
+ : SharedHandleBaseNoDestroy<DisplayModeKHR, SharedDisplayKHR>( handle, std::move( parent ) )
+ {
+ }
+ };
+ using SharedDisplayModeKHR = SharedHandle<DisplayModeKHR>;
+
+ //=== VK_INTEL_performance_query ===
+
+ template <>
+ class SharedHandle<PerformanceConfigurationINTEL> : public SharedHandleBaseNoDestroy<PerformanceConfigurationINTEL, SharedDevice>
+ {
+ friend SharedHandleBase<PerformanceConfigurationINTEL, SharedDevice>;
+
+ public:
+ SharedHandle() = default;
+ explicit SharedHandle( PerformanceConfigurationINTEL handle, SharedDevice parent ) noexcept
+ : SharedHandleBaseNoDestroy<PerformanceConfigurationINTEL, SharedDevice>( handle, std::move( parent ) )
+ {
+ }
+ };
+ using SharedPerformanceConfigurationINTEL = SharedHandle<PerformanceConfigurationINTEL>;
+#endif // !VULKAN_HPP_NO_SMART_HANDLE
+} // namespace VULKAN_HPP_NAMESPACE
+#endif // VULKAN_SHARED_HPP
diff --git a/include/vulkan/vulkan_static_assertions.hpp b/include/vulkan/vulkan_static_assertions.hpp
index 2806413..c467447 100644
--- a/include/vulkan/vulkan_static_assertions.hpp
+++ b/include/vulkan/vulkan_static_assertions.hpp
@@ -5882,6 +5882,20 @@
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelinePropertiesFeaturesEXT>::value,
"PhysicalDevicePipelinePropertiesFeaturesEXT is not nothrow_move_constructible!" );
+//=== VK_EXT_frame_boundary ===
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceFrameBoundaryFeaturesEXT ) == sizeof( VkPhysicalDeviceFrameBoundaryFeaturesEXT ),
+ "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceFrameBoundaryFeaturesEXT>::value,
+ "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceFrameBoundaryFeaturesEXT>::value,
+ "PhysicalDeviceFrameBoundaryFeaturesEXT is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::FrameBoundaryEXT ) == sizeof( VkFrameBoundaryEXT ), "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::FrameBoundaryEXT>::value, "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::FrameBoundaryEXT>::value,
+ "FrameBoundaryEXT is not nothrow_move_constructible!" );
+
//=== VK_EXT_multisampled_render_to_single_sampled ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT ) ==
@@ -6613,6 +6627,34 @@
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineProtectedAccessFeaturesEXT>::value,
"PhysicalDevicePipelineProtectedAccessFeaturesEXT is not nothrow_move_constructible!" );
+#if defined( VK_USE_PLATFORM_ANDROID_KHR )
+//=== VK_ANDROID_external_format_resolve ===
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFormatResolveFeaturesANDROID ) ==
+ sizeof( VkPhysicalDeviceExternalFormatResolveFeaturesANDROID ),
+ "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFormatResolveFeaturesANDROID>::value,
+ "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFormatResolveFeaturesANDROID>::value,
+ "PhysicalDeviceExternalFormatResolveFeaturesANDROID is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFormatResolvePropertiesANDROID ) ==
+ sizeof( VkPhysicalDeviceExternalFormatResolvePropertiesANDROID ),
+ "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFormatResolvePropertiesANDROID>::value,
+ "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFormatResolvePropertiesANDROID>::value,
+ "PhysicalDeviceExternalFormatResolvePropertiesANDROID is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatResolvePropertiesANDROID ) ==
+ sizeof( VkAndroidHardwareBufferFormatResolvePropertiesANDROID ),
+ "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatResolvePropertiesANDROID>::value,
+ "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatResolvePropertiesANDROID>::value,
+ "AndroidHardwareBufferFormatResolvePropertiesANDROID is not nothrow_move_constructible!" );
+#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
+
//=== VK_KHR_maintenance5 ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance5FeaturesKHR ) == sizeof( VkPhysicalDeviceMaintenance5FeaturesKHR ),
@@ -6815,6 +6857,61 @@
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT>::value,
"PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT is not nothrow_move_constructible!" );
+//=== VK_NV_low_latency2 ===
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::LatencySleepModeInfoNV ) == sizeof( VkLatencySleepModeInfoNV ),
+ "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::LatencySleepModeInfoNV>::value, "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::LatencySleepModeInfoNV>::value,
+ "LatencySleepModeInfoNV is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::LatencySleepInfoNV ) == sizeof( VkLatencySleepInfoNV ), "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::LatencySleepInfoNV>::value, "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::LatencySleepInfoNV>::value,
+ "LatencySleepInfoNV is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SetLatencyMarkerInfoNV ) == sizeof( VkSetLatencyMarkerInfoNV ),
+ "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::SetLatencyMarkerInfoNV>::value, "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SetLatencyMarkerInfoNV>::value,
+ "SetLatencyMarkerInfoNV is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::GetLatencyMarkerInfoNV ) == sizeof( VkGetLatencyMarkerInfoNV ),
+ "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::GetLatencyMarkerInfoNV>::value, "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::GetLatencyMarkerInfoNV>::value,
+ "GetLatencyMarkerInfoNV is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::LatencyTimingsFrameReportNV ) == sizeof( VkLatencyTimingsFrameReportNV ),
+ "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::LatencyTimingsFrameReportNV>::value, "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::LatencyTimingsFrameReportNV>::value,
+ "LatencyTimingsFrameReportNV is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::LatencySubmissionPresentIdNV ) == sizeof( VkLatencySubmissionPresentIdNV ),
+ "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::LatencySubmissionPresentIdNV>::value, "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::LatencySubmissionPresentIdNV>::value,
+ "LatencySubmissionPresentIdNV is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SwapchainLatencyCreateInfoNV ) == sizeof( VkSwapchainLatencyCreateInfoNV ),
+ "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::SwapchainLatencyCreateInfoNV>::value, "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SwapchainLatencyCreateInfoNV>::value,
+ "SwapchainLatencyCreateInfoNV is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::OutOfBandQueueTypeInfoNV ) == sizeof( VkOutOfBandQueueTypeInfoNV ),
+ "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::OutOfBandQueueTypeInfoNV>::value, "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::OutOfBandQueueTypeInfoNV>::value,
+ "OutOfBandQueueTypeInfoNV is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::LatencySurfaceCapabilitiesNV ) == sizeof( VkLatencySurfaceCapabilitiesNV ),
+ "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::LatencySurfaceCapabilitiesNV>::value, "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::LatencySurfaceCapabilitiesNV>::value,
+ "LatencySurfaceCapabilitiesNV is not nothrow_move_constructible!" );
+
//=== VK_KHR_cooperative_matrix ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR ) == sizeof( VkCooperativeMatrixPropertiesKHR ),
@@ -6972,6 +7069,15 @@
"PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX is not nothrow_move_constructible!" );
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
+//=== VK_MSFT_layered_driver ===
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredDriverPropertiesMSFT ) == sizeof( VkPhysicalDeviceLayeredDriverPropertiesMSFT ),
+ "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredDriverPropertiesMSFT>::value,
+ "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredDriverPropertiesMSFT>::value,
+ "PhysicalDeviceLayeredDriverPropertiesMSFT is not nothrow_move_constructible!" );
+
//=== VK_NV_descriptor_pool_overallocation ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorPoolOverallocationFeaturesNV ) ==
diff --git a/include/vulkan/vulkan_structs.hpp b/include/vulkan/vulkan_structs.hpp
index 72fc2e6..f5bf97a 100644
--- a/include/vulkan/vulkan_structs.hpp
+++ b/include/vulkan/vulkan_structs.hpp
@@ -5098,6 +5098,94 @@
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
#if defined( VK_USE_PLATFORM_ANDROID_KHR )
+ struct AndroidHardwareBufferFormatResolvePropertiesANDROID
+ {
+ using NativeType = VkAndroidHardwareBufferFormatResolvePropertiesANDROID;
+
+ static const bool allowDuplicate = false;
+ static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAndroidHardwareBufferFormatResolvePropertiesANDROID;
+
+# if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+ VULKAN_HPP_CONSTEXPR
+ AndroidHardwareBufferFormatResolvePropertiesANDROID( VULKAN_HPP_NAMESPACE::Format colorAttachmentFormat_ = VULKAN_HPP_NAMESPACE::Format::eUndefined,
+ void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
+ : pNext( pNext_ )
+ , colorAttachmentFormat( colorAttachmentFormat_ )
+ {
+ }
+
+ VULKAN_HPP_CONSTEXPR
+ AndroidHardwareBufferFormatResolvePropertiesANDROID( AndroidHardwareBufferFormatResolvePropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+ AndroidHardwareBufferFormatResolvePropertiesANDROID( VkAndroidHardwareBufferFormatResolvePropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT
+ : AndroidHardwareBufferFormatResolvePropertiesANDROID( *reinterpret_cast<AndroidHardwareBufferFormatResolvePropertiesANDROID const *>( &rhs ) )
+ {
+ }
+
+ AndroidHardwareBufferFormatResolvePropertiesANDROID &
+ operator=( AndroidHardwareBufferFormatResolvePropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+# endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
+
+ AndroidHardwareBufferFormatResolvePropertiesANDROID & operator=( VkAndroidHardwareBufferFormatResolvePropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT
+ {
+ *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatResolvePropertiesANDROID const *>( &rhs );
+ return *this;
+ }
+
+ operator VkAndroidHardwareBufferFormatResolvePropertiesANDROID const &() const VULKAN_HPP_NOEXCEPT
+ {
+ return *reinterpret_cast<const VkAndroidHardwareBufferFormatResolvePropertiesANDROID *>( this );
+ }
+
+ operator VkAndroidHardwareBufferFormatResolvePropertiesANDROID &() VULKAN_HPP_NOEXCEPT
+ {
+ return *reinterpret_cast<VkAndroidHardwareBufferFormatResolvePropertiesANDROID *>( this );
+ }
+
+# if defined( VULKAN_HPP_USE_REFLECT )
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Format const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, colorAttachmentFormat );
+ }
+# endif
+
+# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+ auto operator<=>( AndroidHardwareBufferFormatResolvePropertiesANDROID const & ) const = default;
+# else
+ bool operator==( AndroidHardwareBufferFormatResolvePropertiesANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+# if defined( VULKAN_HPP_USE_REFLECT )
+ return this->reflect() == rhs.reflect();
+# else
+ return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( colorAttachmentFormat == rhs.colorAttachmentFormat );
+# endif
+ }
+
+ bool operator!=( AndroidHardwareBufferFormatResolvePropertiesANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return !operator==( rhs );
+ }
+# endif
+
+ public:
+ VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eAndroidHardwareBufferFormatResolvePropertiesANDROID;
+ void * pNext = {};
+ VULKAN_HPP_NAMESPACE::Format colorAttachmentFormat = VULKAN_HPP_NAMESPACE::Format::eUndefined;
+ };
+
+ template <>
+ struct CppType<StructureType, StructureType::eAndroidHardwareBufferFormatResolvePropertiesANDROID>
+ {
+ using Type = AndroidHardwareBufferFormatResolvePropertiesANDROID;
+ };
+#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
+
+#if defined( VK_USE_PLATFORM_ANDROID_KHR )
struct AndroidHardwareBufferPropertiesANDROID
{
using NativeType = VkAndroidHardwareBufferPropertiesANDROID;
@@ -36694,6 +36782,225 @@
using Type = FragmentShadingRateAttachmentInfoKHR;
};
+ struct FrameBoundaryEXT
+ {
+ using NativeType = VkFrameBoundaryEXT;
+
+ static const bool allowDuplicate = false;
+ static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eFrameBoundaryEXT;
+
+#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+ VULKAN_HPP_CONSTEXPR FrameBoundaryEXT( VULKAN_HPP_NAMESPACE::FrameBoundaryFlagsEXT flags_ = {},
+ uint64_t frameID_ = {},
+ uint32_t imageCount_ = {},
+ const VULKAN_HPP_NAMESPACE::Image * pImages_ = {},
+ uint32_t bufferCount_ = {},
+ const VULKAN_HPP_NAMESPACE::Buffer * pBuffers_ = {},
+ uint64_t tagName_ = {},
+ size_t tagSize_ = {},
+ const void * pTag_ = {},
+ const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
+ : pNext( pNext_ )
+ , flags( flags_ )
+ , frameID( frameID_ )
+ , imageCount( imageCount_ )
+ , pImages( pImages_ )
+ , bufferCount( bufferCount_ )
+ , pBuffers( pBuffers_ )
+ , tagName( tagName_ )
+ , tagSize( tagSize_ )
+ , pTag( pTag_ )
+ {
+ }
+
+ VULKAN_HPP_CONSTEXPR FrameBoundaryEXT( FrameBoundaryEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+ FrameBoundaryEXT( VkFrameBoundaryEXT const & rhs ) VULKAN_HPP_NOEXCEPT : FrameBoundaryEXT( *reinterpret_cast<FrameBoundaryEXT const *>( &rhs ) ) {}
+
+# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+ FrameBoundaryEXT( VULKAN_HPP_NAMESPACE::FrameBoundaryFlagsEXT flags_,
+ uint64_t frameID_,
+ VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::Image> const & images_,
+ VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::Buffer> const & buffers_ = {},
+ uint64_t tagName_ = {},
+ size_t tagSize_ = {},
+ const void * pTag_ = {},
+ const void * pNext_ = nullptr )
+ : pNext( pNext_ )
+ , flags( flags_ )
+ , frameID( frameID_ )
+ , imageCount( static_cast<uint32_t>( images_.size() ) )
+ , pImages( images_.data() )
+ , bufferCount( static_cast<uint32_t>( buffers_.size() ) )
+ , pBuffers( buffers_.data() )
+ , tagName( tagName_ )
+ , tagSize( tagSize_ )
+ , pTag( pTag_ )
+ {
+ }
+# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ FrameBoundaryEXT & operator=( FrameBoundaryEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
+
+ FrameBoundaryEXT & operator=( VkFrameBoundaryEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+ {
+ *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::FrameBoundaryEXT const *>( &rhs );
+ return *this;
+ }
+
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
+ VULKAN_HPP_CONSTEXPR_14 FrameBoundaryEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 FrameBoundaryEXT & setFlags( VULKAN_HPP_NAMESPACE::FrameBoundaryFlagsEXT flags_ ) VULKAN_HPP_NOEXCEPT
+ {
+ flags = flags_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 FrameBoundaryEXT & setFrameID( uint64_t frameID_ ) VULKAN_HPP_NOEXCEPT
+ {
+ frameID = frameID_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 FrameBoundaryEXT & setImageCount( uint32_t imageCount_ ) VULKAN_HPP_NOEXCEPT
+ {
+ imageCount = imageCount_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 FrameBoundaryEXT & setPImages( const VULKAN_HPP_NAMESPACE::Image * pImages_ ) VULKAN_HPP_NOEXCEPT
+ {
+ pImages = pImages_;
+ return *this;
+ }
+
+# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+ FrameBoundaryEXT & setImages( VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::Image> const & images_ ) VULKAN_HPP_NOEXCEPT
+ {
+ imageCount = static_cast<uint32_t>( images_.size() );
+ pImages = images_.data();
+ return *this;
+ }
+# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ VULKAN_HPP_CONSTEXPR_14 FrameBoundaryEXT & setBufferCount( uint32_t bufferCount_ ) VULKAN_HPP_NOEXCEPT
+ {
+ bufferCount = bufferCount_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 FrameBoundaryEXT & setPBuffers( const VULKAN_HPP_NAMESPACE::Buffer * pBuffers_ ) VULKAN_HPP_NOEXCEPT
+ {
+ pBuffers = pBuffers_;
+ return *this;
+ }
+
+# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+ FrameBoundaryEXT & setBuffers( VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::Buffer> const & buffers_ ) VULKAN_HPP_NOEXCEPT
+ {
+ bufferCount = static_cast<uint32_t>( buffers_.size() );
+ pBuffers = buffers_.data();
+ return *this;
+ }
+# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ VULKAN_HPP_CONSTEXPR_14 FrameBoundaryEXT & setTagName( uint64_t tagName_ ) VULKAN_HPP_NOEXCEPT
+ {
+ tagName = tagName_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 FrameBoundaryEXT & setTagSize( size_t tagSize_ ) VULKAN_HPP_NOEXCEPT
+ {
+ tagSize = tagSize_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 FrameBoundaryEXT & setPTag( const void * pTag_ ) VULKAN_HPP_NOEXCEPT
+ {
+ pTag = pTag_;
+ return *this;
+ }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
+
+ operator VkFrameBoundaryEXT const &() const VULKAN_HPP_NOEXCEPT
+ {
+ return *reinterpret_cast<const VkFrameBoundaryEXT *>( this );
+ }
+
+ operator VkFrameBoundaryEXT &() VULKAN_HPP_NOEXCEPT
+ {
+ return *reinterpret_cast<VkFrameBoundaryEXT *>( this );
+ }
+
+#if defined( VULKAN_HPP_USE_REFLECT )
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::FrameBoundaryFlagsEXT const &,
+ uint64_t const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::Image * const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::Buffer * const &,
+ uint64_t const &,
+ size_t const &,
+ const void * const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, flags, frameID, imageCount, pImages, bufferCount, pBuffers, tagName, tagSize, pTag );
+ }
+#endif
+
+#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+ auto operator<=>( FrameBoundaryEXT const & ) const = default;
+#else
+ bool operator==( FrameBoundaryEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+# if defined( VULKAN_HPP_USE_REFLECT )
+ return this->reflect() == rhs.reflect();
+# else
+ return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( frameID == rhs.frameID ) && ( imageCount == rhs.imageCount ) &&
+ ( pImages == rhs.pImages ) && ( bufferCount == rhs.bufferCount ) && ( pBuffers == rhs.pBuffers ) && ( tagName == rhs.tagName ) &&
+ ( tagSize == rhs.tagSize ) && ( pTag == rhs.pTag );
+# endif
+ }
+
+ bool operator!=( FrameBoundaryEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return !operator==( rhs );
+ }
+#endif
+
+ public:
+ VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eFrameBoundaryEXT;
+ const void * pNext = {};
+ VULKAN_HPP_NAMESPACE::FrameBoundaryFlagsEXT flags = {};
+ uint64_t frameID = {};
+ uint32_t imageCount = {};
+ const VULKAN_HPP_NAMESPACE::Image * pImages = {};
+ uint32_t bufferCount = {};
+ const VULKAN_HPP_NAMESPACE::Buffer * pBuffers = {};
+ uint64_t tagName = {};
+ size_t tagSize = {};
+ const void * pTag = {};
+ };
+
+ template <>
+ struct CppType<StructureType, StructureType::eFrameBoundaryEXT>
+ {
+ using Type = FrameBoundaryEXT;
+ };
+
struct FramebufferAttachmentImageInfo
{
using NativeType = VkFramebufferAttachmentImageInfo;
@@ -37811,6 +38118,352 @@
using Type = GeneratedCommandsMemoryRequirementsInfoNV;
};
+ struct LatencyTimingsFrameReportNV
+ {
+ using NativeType = VkLatencyTimingsFrameReportNV;
+
+ static const bool allowDuplicate = false;
+ static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eLatencyTimingsFrameReportNV;
+
+#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+ VULKAN_HPP_CONSTEXPR LatencyTimingsFrameReportNV( uint64_t presentID_ = {},
+ uint64_t inputSampleTimeUs_ = {},
+ uint64_t simStartTimeUs_ = {},
+ uint64_t simEndTimeUs_ = {},
+ uint64_t renderSubmitStartTimeUs_ = {},
+ uint64_t renderSubmitEndTimeUs_ = {},
+ uint64_t presentStartTimeUs_ = {},
+ uint64_t presentEndTimeUs_ = {},
+ uint64_t driverStartTimeUs_ = {},
+ uint64_t driverEndTimeUs_ = {},
+ uint64_t osRenderQueueStartTimeUs_ = {},
+ uint64_t osRenderQueueEndTimeUs_ = {},
+ uint64_t gpuRenderStartTimeUs_ = {},
+ uint64_t gpuRenderEndTimeUs_ = {},
+ const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
+ : pNext( pNext_ )
+ , presentID( presentID_ )
+ , inputSampleTimeUs( inputSampleTimeUs_ )
+ , simStartTimeUs( simStartTimeUs_ )
+ , simEndTimeUs( simEndTimeUs_ )
+ , renderSubmitStartTimeUs( renderSubmitStartTimeUs_ )
+ , renderSubmitEndTimeUs( renderSubmitEndTimeUs_ )
+ , presentStartTimeUs( presentStartTimeUs_ )
+ , presentEndTimeUs( presentEndTimeUs_ )
+ , driverStartTimeUs( driverStartTimeUs_ )
+ , driverEndTimeUs( driverEndTimeUs_ )
+ , osRenderQueueStartTimeUs( osRenderQueueStartTimeUs_ )
+ , osRenderQueueEndTimeUs( osRenderQueueEndTimeUs_ )
+ , gpuRenderStartTimeUs( gpuRenderStartTimeUs_ )
+ , gpuRenderEndTimeUs( gpuRenderEndTimeUs_ )
+ {
+ }
+
+ VULKAN_HPP_CONSTEXPR LatencyTimingsFrameReportNV( LatencyTimingsFrameReportNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+ LatencyTimingsFrameReportNV( VkLatencyTimingsFrameReportNV const & rhs ) VULKAN_HPP_NOEXCEPT
+ : LatencyTimingsFrameReportNV( *reinterpret_cast<LatencyTimingsFrameReportNV const *>( &rhs ) )
+ {
+ }
+
+ LatencyTimingsFrameReportNV & operator=( LatencyTimingsFrameReportNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
+
+ LatencyTimingsFrameReportNV & operator=( VkLatencyTimingsFrameReportNV const & rhs ) VULKAN_HPP_NOEXCEPT
+ {
+ *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::LatencyTimingsFrameReportNV const *>( &rhs );
+ return *this;
+ }
+
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
+ VULKAN_HPP_CONSTEXPR_14 LatencyTimingsFrameReportNV & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 LatencyTimingsFrameReportNV & setPresentID( uint64_t presentID_ ) VULKAN_HPP_NOEXCEPT
+ {
+ presentID = presentID_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 LatencyTimingsFrameReportNV & setInputSampleTimeUs( uint64_t inputSampleTimeUs_ ) VULKAN_HPP_NOEXCEPT
+ {
+ inputSampleTimeUs = inputSampleTimeUs_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 LatencyTimingsFrameReportNV & setSimStartTimeUs( uint64_t simStartTimeUs_ ) VULKAN_HPP_NOEXCEPT
+ {
+ simStartTimeUs = simStartTimeUs_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 LatencyTimingsFrameReportNV & setSimEndTimeUs( uint64_t simEndTimeUs_ ) VULKAN_HPP_NOEXCEPT
+ {
+ simEndTimeUs = simEndTimeUs_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 LatencyTimingsFrameReportNV & setRenderSubmitStartTimeUs( uint64_t renderSubmitStartTimeUs_ ) VULKAN_HPP_NOEXCEPT
+ {
+ renderSubmitStartTimeUs = renderSubmitStartTimeUs_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 LatencyTimingsFrameReportNV & setRenderSubmitEndTimeUs( uint64_t renderSubmitEndTimeUs_ ) VULKAN_HPP_NOEXCEPT
+ {
+ renderSubmitEndTimeUs = renderSubmitEndTimeUs_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 LatencyTimingsFrameReportNV & setPresentStartTimeUs( uint64_t presentStartTimeUs_ ) VULKAN_HPP_NOEXCEPT
+ {
+ presentStartTimeUs = presentStartTimeUs_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 LatencyTimingsFrameReportNV & setPresentEndTimeUs( uint64_t presentEndTimeUs_ ) VULKAN_HPP_NOEXCEPT
+ {
+ presentEndTimeUs = presentEndTimeUs_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 LatencyTimingsFrameReportNV & setDriverStartTimeUs( uint64_t driverStartTimeUs_ ) VULKAN_HPP_NOEXCEPT
+ {
+ driverStartTimeUs = driverStartTimeUs_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 LatencyTimingsFrameReportNV & setDriverEndTimeUs( uint64_t driverEndTimeUs_ ) VULKAN_HPP_NOEXCEPT
+ {
+ driverEndTimeUs = driverEndTimeUs_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 LatencyTimingsFrameReportNV & setOsRenderQueueStartTimeUs( uint64_t osRenderQueueStartTimeUs_ ) VULKAN_HPP_NOEXCEPT
+ {
+ osRenderQueueStartTimeUs = osRenderQueueStartTimeUs_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 LatencyTimingsFrameReportNV & setOsRenderQueueEndTimeUs( uint64_t osRenderQueueEndTimeUs_ ) VULKAN_HPP_NOEXCEPT
+ {
+ osRenderQueueEndTimeUs = osRenderQueueEndTimeUs_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 LatencyTimingsFrameReportNV & setGpuRenderStartTimeUs( uint64_t gpuRenderStartTimeUs_ ) VULKAN_HPP_NOEXCEPT
+ {
+ gpuRenderStartTimeUs = gpuRenderStartTimeUs_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 LatencyTimingsFrameReportNV & setGpuRenderEndTimeUs( uint64_t gpuRenderEndTimeUs_ ) VULKAN_HPP_NOEXCEPT
+ {
+ gpuRenderEndTimeUs = gpuRenderEndTimeUs_;
+ return *this;
+ }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
+
+ operator VkLatencyTimingsFrameReportNV const &() const VULKAN_HPP_NOEXCEPT
+ {
+ return *reinterpret_cast<const VkLatencyTimingsFrameReportNV *>( this );
+ }
+
+ operator VkLatencyTimingsFrameReportNV &() VULKAN_HPP_NOEXCEPT
+ {
+ return *reinterpret_cast<VkLatencyTimingsFrameReportNV *>( this );
+ }
+
+#if defined( VULKAN_HPP_USE_REFLECT )
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ uint64_t const &,
+ uint64_t const &,
+ uint64_t const &,
+ uint64_t const &,
+ uint64_t const &,
+ uint64_t const &,
+ uint64_t const &,
+ uint64_t const &,
+ uint64_t const &,
+ uint64_t const &,
+ uint64_t const &,
+ uint64_t const &,
+ uint64_t const &,
+ uint64_t const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ presentID,
+ inputSampleTimeUs,
+ simStartTimeUs,
+ simEndTimeUs,
+ renderSubmitStartTimeUs,
+ renderSubmitEndTimeUs,
+ presentStartTimeUs,
+ presentEndTimeUs,
+ driverStartTimeUs,
+ driverEndTimeUs,
+ osRenderQueueStartTimeUs,
+ osRenderQueueEndTimeUs,
+ gpuRenderStartTimeUs,
+ gpuRenderEndTimeUs );
+ }
+#endif
+
+#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+ auto operator<=>( LatencyTimingsFrameReportNV const & ) const = default;
+#else
+ bool operator==( LatencyTimingsFrameReportNV const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+# if defined( VULKAN_HPP_USE_REFLECT )
+ return this->reflect() == rhs.reflect();
+# else
+ return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentID == rhs.presentID ) && ( inputSampleTimeUs == rhs.inputSampleTimeUs ) &&
+ ( simStartTimeUs == rhs.simStartTimeUs ) && ( simEndTimeUs == rhs.simEndTimeUs ) && ( renderSubmitStartTimeUs == rhs.renderSubmitStartTimeUs ) &&
+ ( renderSubmitEndTimeUs == rhs.renderSubmitEndTimeUs ) && ( presentStartTimeUs == rhs.presentStartTimeUs ) &&
+ ( presentEndTimeUs == rhs.presentEndTimeUs ) && ( driverStartTimeUs == rhs.driverStartTimeUs ) && ( driverEndTimeUs == rhs.driverEndTimeUs ) &&
+ ( osRenderQueueStartTimeUs == rhs.osRenderQueueStartTimeUs ) && ( osRenderQueueEndTimeUs == rhs.osRenderQueueEndTimeUs ) &&
+ ( gpuRenderStartTimeUs == rhs.gpuRenderStartTimeUs ) && ( gpuRenderEndTimeUs == rhs.gpuRenderEndTimeUs );
+# endif
+ }
+
+ bool operator!=( LatencyTimingsFrameReportNV const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return !operator==( rhs );
+ }
+#endif
+
+ public:
+ VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eLatencyTimingsFrameReportNV;
+ const void * pNext = {};
+ uint64_t presentID = {};
+ uint64_t inputSampleTimeUs = {};
+ uint64_t simStartTimeUs = {};
+ uint64_t simEndTimeUs = {};
+ uint64_t renderSubmitStartTimeUs = {};
+ uint64_t renderSubmitEndTimeUs = {};
+ uint64_t presentStartTimeUs = {};
+ uint64_t presentEndTimeUs = {};
+ uint64_t driverStartTimeUs = {};
+ uint64_t driverEndTimeUs = {};
+ uint64_t osRenderQueueStartTimeUs = {};
+ uint64_t osRenderQueueEndTimeUs = {};
+ uint64_t gpuRenderStartTimeUs = {};
+ uint64_t gpuRenderEndTimeUs = {};
+ };
+
+ template <>
+ struct CppType<StructureType, StructureType::eLatencyTimingsFrameReportNV>
+ {
+ using Type = LatencyTimingsFrameReportNV;
+ };
+
+ struct GetLatencyMarkerInfoNV
+ {
+ using NativeType = VkGetLatencyMarkerInfoNV;
+
+ static const bool allowDuplicate = false;
+ static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eGetLatencyMarkerInfoNV;
+
+#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+ VULKAN_HPP_CONSTEXPR GetLatencyMarkerInfoNV( VULKAN_HPP_NAMESPACE::LatencyTimingsFrameReportNV * pTimings_ = {},
+ const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
+ : pNext( pNext_ )
+ , pTimings( pTimings_ )
+ {
+ }
+
+ VULKAN_HPP_CONSTEXPR GetLatencyMarkerInfoNV( GetLatencyMarkerInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+ GetLatencyMarkerInfoNV( VkGetLatencyMarkerInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
+ : GetLatencyMarkerInfoNV( *reinterpret_cast<GetLatencyMarkerInfoNV const *>( &rhs ) )
+ {
+ }
+
+ GetLatencyMarkerInfoNV & operator=( GetLatencyMarkerInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
+
+ GetLatencyMarkerInfoNV & operator=( VkGetLatencyMarkerInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
+ {
+ *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::GetLatencyMarkerInfoNV const *>( &rhs );
+ return *this;
+ }
+
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
+ VULKAN_HPP_CONSTEXPR_14 GetLatencyMarkerInfoNV & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 GetLatencyMarkerInfoNV & setPTimings( VULKAN_HPP_NAMESPACE::LatencyTimingsFrameReportNV * pTimings_ ) VULKAN_HPP_NOEXCEPT
+ {
+ pTimings = pTimings_;
+ return *this;
+ }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
+
+ operator VkGetLatencyMarkerInfoNV const &() const VULKAN_HPP_NOEXCEPT
+ {
+ return *reinterpret_cast<const VkGetLatencyMarkerInfoNV *>( this );
+ }
+
+ operator VkGetLatencyMarkerInfoNV &() VULKAN_HPP_NOEXCEPT
+ {
+ return *reinterpret_cast<VkGetLatencyMarkerInfoNV *>( this );
+ }
+
+#if defined( VULKAN_HPP_USE_REFLECT )
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, VULKAN_HPP_NAMESPACE::LatencyTimingsFrameReportNV * const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, pTimings );
+ }
+#endif
+
+#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+ auto operator<=>( GetLatencyMarkerInfoNV const & ) const = default;
+#else
+ bool operator==( GetLatencyMarkerInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+# if defined( VULKAN_HPP_USE_REFLECT )
+ return this->reflect() == rhs.reflect();
+# else
+ return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pTimings == rhs.pTimings );
+# endif
+ }
+
+ bool operator!=( GetLatencyMarkerInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return !operator==( rhs );
+ }
+#endif
+
+ public:
+ VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eGetLatencyMarkerInfoNV;
+ const void * pNext = {};
+ VULKAN_HPP_NAMESPACE::LatencyTimingsFrameReportNV * pTimings = {};
+ };
+
+ template <>
+ struct CppType<StructureType, StructureType::eGetLatencyMarkerInfoNV>
+ {
+ using Type = GetLatencyMarkerInfoNV;
+ };
+
struct VertexInputBindingDescription
{
using NativeType = VkVertexInputBindingDescription;
@@ -47696,6 +48349,448 @@
using Type = InstanceCreateInfo;
};
+ struct LatencySleepInfoNV
+ {
+ using NativeType = VkLatencySleepInfoNV;
+
+ static const bool allowDuplicate = false;
+ static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eLatencySleepInfoNV;
+
+#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+ VULKAN_HPP_CONSTEXPR
+ LatencySleepInfoNV( VULKAN_HPP_NAMESPACE::Semaphore signalSemaphore_ = {}, uint64_t value_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
+ : pNext( pNext_ )
+ , signalSemaphore( signalSemaphore_ )
+ , value( value_ )
+ {
+ }
+
+ VULKAN_HPP_CONSTEXPR LatencySleepInfoNV( LatencySleepInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+ LatencySleepInfoNV( VkLatencySleepInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT : LatencySleepInfoNV( *reinterpret_cast<LatencySleepInfoNV const *>( &rhs ) ) {}
+
+ LatencySleepInfoNV & operator=( LatencySleepInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
+
+ LatencySleepInfoNV & operator=( VkLatencySleepInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
+ {
+ *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::LatencySleepInfoNV const *>( &rhs );
+ return *this;
+ }
+
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
+ VULKAN_HPP_CONSTEXPR_14 LatencySleepInfoNV & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 LatencySleepInfoNV & setSignalSemaphore( VULKAN_HPP_NAMESPACE::Semaphore signalSemaphore_ ) VULKAN_HPP_NOEXCEPT
+ {
+ signalSemaphore = signalSemaphore_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 LatencySleepInfoNV & setValue( uint64_t value_ ) VULKAN_HPP_NOEXCEPT
+ {
+ value = value_;
+ return *this;
+ }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
+
+ operator VkLatencySleepInfoNV const &() const VULKAN_HPP_NOEXCEPT
+ {
+ return *reinterpret_cast<const VkLatencySleepInfoNV *>( this );
+ }
+
+ operator VkLatencySleepInfoNV &() VULKAN_HPP_NOEXCEPT
+ {
+ return *reinterpret_cast<VkLatencySleepInfoNV *>( this );
+ }
+
+#if defined( VULKAN_HPP_USE_REFLECT )
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, VULKAN_HPP_NAMESPACE::Semaphore const &, uint64_t const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, signalSemaphore, value );
+ }
+#endif
+
+#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+ auto operator<=>( LatencySleepInfoNV const & ) const = default;
+#else
+ bool operator==( LatencySleepInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+# if defined( VULKAN_HPP_USE_REFLECT )
+ return this->reflect() == rhs.reflect();
+# else
+ return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( signalSemaphore == rhs.signalSemaphore ) && ( value == rhs.value );
+# endif
+ }
+
+ bool operator!=( LatencySleepInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return !operator==( rhs );
+ }
+#endif
+
+ public:
+ VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eLatencySleepInfoNV;
+ const void * pNext = {};
+ VULKAN_HPP_NAMESPACE::Semaphore signalSemaphore = {};
+ uint64_t value = {};
+ };
+
+ template <>
+ struct CppType<StructureType, StructureType::eLatencySleepInfoNV>
+ {
+ using Type = LatencySleepInfoNV;
+ };
+
+ struct LatencySleepModeInfoNV
+ {
+ using NativeType = VkLatencySleepModeInfoNV;
+
+ static const bool allowDuplicate = false;
+ static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eLatencySleepModeInfoNV;
+
+#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+ VULKAN_HPP_CONSTEXPR LatencySleepModeInfoNV( VULKAN_HPP_NAMESPACE::Bool32 lowLatencyMode_ = {},
+ VULKAN_HPP_NAMESPACE::Bool32 lowLatencyBoost_ = {},
+ uint32_t minimumIntervalUs_ = {},
+ const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
+ : pNext( pNext_ )
+ , lowLatencyMode( lowLatencyMode_ )
+ , lowLatencyBoost( lowLatencyBoost_ )
+ , minimumIntervalUs( minimumIntervalUs_ )
+ {
+ }
+
+ VULKAN_HPP_CONSTEXPR LatencySleepModeInfoNV( LatencySleepModeInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+ LatencySleepModeInfoNV( VkLatencySleepModeInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
+ : LatencySleepModeInfoNV( *reinterpret_cast<LatencySleepModeInfoNV const *>( &rhs ) )
+ {
+ }
+
+ LatencySleepModeInfoNV & operator=( LatencySleepModeInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
+
+ LatencySleepModeInfoNV & operator=( VkLatencySleepModeInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
+ {
+ *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::LatencySleepModeInfoNV const *>( &rhs );
+ return *this;
+ }
+
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
+ VULKAN_HPP_CONSTEXPR_14 LatencySleepModeInfoNV & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 LatencySleepModeInfoNV & setLowLatencyMode( VULKAN_HPP_NAMESPACE::Bool32 lowLatencyMode_ ) VULKAN_HPP_NOEXCEPT
+ {
+ lowLatencyMode = lowLatencyMode_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 LatencySleepModeInfoNV & setLowLatencyBoost( VULKAN_HPP_NAMESPACE::Bool32 lowLatencyBoost_ ) VULKAN_HPP_NOEXCEPT
+ {
+ lowLatencyBoost = lowLatencyBoost_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 LatencySleepModeInfoNV & setMinimumIntervalUs( uint32_t minimumIntervalUs_ ) VULKAN_HPP_NOEXCEPT
+ {
+ minimumIntervalUs = minimumIntervalUs_;
+ return *this;
+ }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
+
+ operator VkLatencySleepModeInfoNV const &() const VULKAN_HPP_NOEXCEPT
+ {
+ return *reinterpret_cast<const VkLatencySleepModeInfoNV *>( this );
+ }
+
+ operator VkLatencySleepModeInfoNV &() VULKAN_HPP_NOEXCEPT
+ {
+ return *reinterpret_cast<VkLatencySleepModeInfoNV *>( this );
+ }
+
+#if defined( VULKAN_HPP_USE_REFLECT )
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ uint32_t const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, lowLatencyMode, lowLatencyBoost, minimumIntervalUs );
+ }
+#endif
+
+#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+ auto operator<=>( LatencySleepModeInfoNV const & ) const = default;
+#else
+ bool operator==( LatencySleepModeInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+# if defined( VULKAN_HPP_USE_REFLECT )
+ return this->reflect() == rhs.reflect();
+# else
+ return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( lowLatencyMode == rhs.lowLatencyMode ) && ( lowLatencyBoost == rhs.lowLatencyBoost ) &&
+ ( minimumIntervalUs == rhs.minimumIntervalUs );
+# endif
+ }
+
+ bool operator!=( LatencySleepModeInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return !operator==( rhs );
+ }
+#endif
+
+ public:
+ VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eLatencySleepModeInfoNV;
+ const void * pNext = {};
+ VULKAN_HPP_NAMESPACE::Bool32 lowLatencyMode = {};
+ VULKAN_HPP_NAMESPACE::Bool32 lowLatencyBoost = {};
+ uint32_t minimumIntervalUs = {};
+ };
+
+ template <>
+ struct CppType<StructureType, StructureType::eLatencySleepModeInfoNV>
+ {
+ using Type = LatencySleepModeInfoNV;
+ };
+
+ struct LatencySubmissionPresentIdNV
+ {
+ using NativeType = VkLatencySubmissionPresentIdNV;
+
+ static const bool allowDuplicate = false;
+ static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eLatencySubmissionPresentIdNV;
+
+#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+ VULKAN_HPP_CONSTEXPR LatencySubmissionPresentIdNV( uint64_t presentID_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
+ : pNext( pNext_ )
+ , presentID( presentID_ )
+ {
+ }
+
+ VULKAN_HPP_CONSTEXPR LatencySubmissionPresentIdNV( LatencySubmissionPresentIdNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+ LatencySubmissionPresentIdNV( VkLatencySubmissionPresentIdNV const & rhs ) VULKAN_HPP_NOEXCEPT
+ : LatencySubmissionPresentIdNV( *reinterpret_cast<LatencySubmissionPresentIdNV const *>( &rhs ) )
+ {
+ }
+
+ LatencySubmissionPresentIdNV & operator=( LatencySubmissionPresentIdNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
+
+ LatencySubmissionPresentIdNV & operator=( VkLatencySubmissionPresentIdNV const & rhs ) VULKAN_HPP_NOEXCEPT
+ {
+ *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::LatencySubmissionPresentIdNV const *>( &rhs );
+ return *this;
+ }
+
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
+ VULKAN_HPP_CONSTEXPR_14 LatencySubmissionPresentIdNV & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 LatencySubmissionPresentIdNV & setPresentID( uint64_t presentID_ ) VULKAN_HPP_NOEXCEPT
+ {
+ presentID = presentID_;
+ return *this;
+ }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
+
+ operator VkLatencySubmissionPresentIdNV const &() const VULKAN_HPP_NOEXCEPT
+ {
+ return *reinterpret_cast<const VkLatencySubmissionPresentIdNV *>( this );
+ }
+
+ operator VkLatencySubmissionPresentIdNV &() VULKAN_HPP_NOEXCEPT
+ {
+ return *reinterpret_cast<VkLatencySubmissionPresentIdNV *>( this );
+ }
+
+#if defined( VULKAN_HPP_USE_REFLECT )
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, uint64_t const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, presentID );
+ }
+#endif
+
+#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+ auto operator<=>( LatencySubmissionPresentIdNV const & ) const = default;
+#else
+ bool operator==( LatencySubmissionPresentIdNV const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+# if defined( VULKAN_HPP_USE_REFLECT )
+ return this->reflect() == rhs.reflect();
+# else
+ return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentID == rhs.presentID );
+# endif
+ }
+
+ bool operator!=( LatencySubmissionPresentIdNV const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return !operator==( rhs );
+ }
+#endif
+
+ public:
+ VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eLatencySubmissionPresentIdNV;
+ const void * pNext = {};
+ uint64_t presentID = {};
+ };
+
+ template <>
+ struct CppType<StructureType, StructureType::eLatencySubmissionPresentIdNV>
+ {
+ using Type = LatencySubmissionPresentIdNV;
+ };
+
+ struct LatencySurfaceCapabilitiesNV
+ {
+ using NativeType = VkLatencySurfaceCapabilitiesNV;
+
+ static const bool allowDuplicate = false;
+ static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eLatencySurfaceCapabilitiesNV;
+
+#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+ VULKAN_HPP_CONSTEXPR LatencySurfaceCapabilitiesNV( uint32_t presentModeCount_ = {},
+ VULKAN_HPP_NAMESPACE::PresentModeKHR * pPresentModes_ = {},
+ const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
+ : pNext( pNext_ )
+ , presentModeCount( presentModeCount_ )
+ , pPresentModes( pPresentModes_ )
+ {
+ }
+
+ VULKAN_HPP_CONSTEXPR LatencySurfaceCapabilitiesNV( LatencySurfaceCapabilitiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+ LatencySurfaceCapabilitiesNV( VkLatencySurfaceCapabilitiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
+ : LatencySurfaceCapabilitiesNV( *reinterpret_cast<LatencySurfaceCapabilitiesNV const *>( &rhs ) )
+ {
+ }
+
+# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+ LatencySurfaceCapabilitiesNV( VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<VULKAN_HPP_NAMESPACE::PresentModeKHR> const & presentModes_,
+ const void * pNext_ = nullptr )
+ : pNext( pNext_ ), presentModeCount( static_cast<uint32_t>( presentModes_.size() ) ), pPresentModes( presentModes_.data() )
+ {
+ }
+# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ LatencySurfaceCapabilitiesNV & operator=( LatencySurfaceCapabilitiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
+
+ LatencySurfaceCapabilitiesNV & operator=( VkLatencySurfaceCapabilitiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
+ {
+ *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::LatencySurfaceCapabilitiesNV const *>( &rhs );
+ return *this;
+ }
+
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
+ VULKAN_HPP_CONSTEXPR_14 LatencySurfaceCapabilitiesNV & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 LatencySurfaceCapabilitiesNV & setPresentModeCount( uint32_t presentModeCount_ ) VULKAN_HPP_NOEXCEPT
+ {
+ presentModeCount = presentModeCount_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 LatencySurfaceCapabilitiesNV & setPPresentModes( VULKAN_HPP_NAMESPACE::PresentModeKHR * pPresentModes_ ) VULKAN_HPP_NOEXCEPT
+ {
+ pPresentModes = pPresentModes_;
+ return *this;
+ }
+
+# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+ LatencySurfaceCapabilitiesNV &
+ setPresentModes( VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<VULKAN_HPP_NAMESPACE::PresentModeKHR> const & presentModes_ ) VULKAN_HPP_NOEXCEPT
+ {
+ presentModeCount = static_cast<uint32_t>( presentModes_.size() );
+ pPresentModes = presentModes_.data();
+ return *this;
+ }
+# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
+
+ operator VkLatencySurfaceCapabilitiesNV const &() const VULKAN_HPP_NOEXCEPT
+ {
+ return *reinterpret_cast<const VkLatencySurfaceCapabilitiesNV *>( this );
+ }
+
+ operator VkLatencySurfaceCapabilitiesNV &() VULKAN_HPP_NOEXCEPT
+ {
+ return *reinterpret_cast<VkLatencySurfaceCapabilitiesNV *>( this );
+ }
+
+#if defined( VULKAN_HPP_USE_REFLECT )
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, uint32_t const &, VULKAN_HPP_NAMESPACE::PresentModeKHR * const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, presentModeCount, pPresentModes );
+ }
+#endif
+
+#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+ auto operator<=>( LatencySurfaceCapabilitiesNV const & ) const = default;
+#else
+ bool operator==( LatencySurfaceCapabilitiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+# if defined( VULKAN_HPP_USE_REFLECT )
+ return this->reflect() == rhs.reflect();
+# else
+ return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentModeCount == rhs.presentModeCount ) && ( pPresentModes == rhs.pPresentModes );
+# endif
+ }
+
+ bool operator!=( LatencySurfaceCapabilitiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return !operator==( rhs );
+ }
+#endif
+
+ public:
+ VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eLatencySurfaceCapabilitiesNV;
+ const void * pNext = {};
+ uint32_t presentModeCount = {};
+ VULKAN_HPP_NAMESPACE::PresentModeKHR * pPresentModes = {};
+ };
+
+ template <>
+ struct CppType<StructureType, StructureType::eLatencySurfaceCapabilitiesNV>
+ {
+ using Type = LatencySurfaceCapabilitiesNV;
+ };
+
struct LayerProperties
{
using NativeType = VkLayerProperties;
@@ -52481,6 +53576,103 @@
using Type = OpticalFlowSessionCreatePrivateDataInfoNV;
};
+ struct OutOfBandQueueTypeInfoNV
+ {
+ using NativeType = VkOutOfBandQueueTypeInfoNV;
+
+ static const bool allowDuplicate = false;
+ static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eOutOfBandQueueTypeInfoNV;
+
+#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+ VULKAN_HPP_CONSTEXPR OutOfBandQueueTypeInfoNV( VULKAN_HPP_NAMESPACE::OutOfBandQueueTypeNV queueType_ = VULKAN_HPP_NAMESPACE::OutOfBandQueueTypeNV::eRender,
+ const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
+ : pNext( pNext_ )
+ , queueType( queueType_ )
+ {
+ }
+
+ VULKAN_HPP_CONSTEXPR OutOfBandQueueTypeInfoNV( OutOfBandQueueTypeInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+ OutOfBandQueueTypeInfoNV( VkOutOfBandQueueTypeInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
+ : OutOfBandQueueTypeInfoNV( *reinterpret_cast<OutOfBandQueueTypeInfoNV const *>( &rhs ) )
+ {
+ }
+
+ OutOfBandQueueTypeInfoNV & operator=( OutOfBandQueueTypeInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
+
+ OutOfBandQueueTypeInfoNV & operator=( VkOutOfBandQueueTypeInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
+ {
+ *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::OutOfBandQueueTypeInfoNV const *>( &rhs );
+ return *this;
+ }
+
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
+ VULKAN_HPP_CONSTEXPR_14 OutOfBandQueueTypeInfoNV & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 OutOfBandQueueTypeInfoNV & setQueueType( VULKAN_HPP_NAMESPACE::OutOfBandQueueTypeNV queueType_ ) VULKAN_HPP_NOEXCEPT
+ {
+ queueType = queueType_;
+ return *this;
+ }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
+
+ operator VkOutOfBandQueueTypeInfoNV const &() const VULKAN_HPP_NOEXCEPT
+ {
+ return *reinterpret_cast<const VkOutOfBandQueueTypeInfoNV *>( this );
+ }
+
+ operator VkOutOfBandQueueTypeInfoNV &() VULKAN_HPP_NOEXCEPT
+ {
+ return *reinterpret_cast<VkOutOfBandQueueTypeInfoNV *>( this );
+ }
+
+#if defined( VULKAN_HPP_USE_REFLECT )
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, VULKAN_HPP_NAMESPACE::OutOfBandQueueTypeNV const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, queueType );
+ }
+#endif
+
+#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+ auto operator<=>( OutOfBandQueueTypeInfoNV const & ) const = default;
+#else
+ bool operator==( OutOfBandQueueTypeInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+# if defined( VULKAN_HPP_USE_REFLECT )
+ return this->reflect() == rhs.reflect();
+# else
+ return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( queueType == rhs.queueType );
+# endif
+ }
+
+ bool operator!=( OutOfBandQueueTypeInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return !operator==( rhs );
+ }
+#endif
+
+ public:
+ VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eOutOfBandQueueTypeInfoNV;
+ const void * pNext = {};
+ VULKAN_HPP_NAMESPACE::OutOfBandQueueTypeNV queueType = VULKAN_HPP_NAMESPACE::OutOfBandQueueTypeNV::eRender;
+ };
+
+ template <>
+ struct CppType<StructureType, StructureType::eOutOfBandQueueTypeInfoNV>
+ {
+ using Type = OutOfBandQueueTypeInfoNV;
+ };
+
struct PastPresentationTimingGOOGLE
{
using NativeType = VkPastPresentationTimingGOOGLE;
@@ -61384,6 +62576,209 @@
};
using PhysicalDeviceExternalFenceInfoKHR = PhysicalDeviceExternalFenceInfo;
+#if defined( VK_USE_PLATFORM_ANDROID_KHR )
+ struct PhysicalDeviceExternalFormatResolveFeaturesANDROID
+ {
+ using NativeType = VkPhysicalDeviceExternalFormatResolveFeaturesANDROID;
+
+ static const bool allowDuplicate = false;
+ static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceExternalFormatResolveFeaturesANDROID;
+
+# if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalFormatResolveFeaturesANDROID( VULKAN_HPP_NAMESPACE::Bool32 externalFormatResolve_ = {},
+ void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
+ : pNext( pNext_ )
+ , externalFormatResolve( externalFormatResolve_ )
+ {
+ }
+
+ VULKAN_HPP_CONSTEXPR
+ PhysicalDeviceExternalFormatResolveFeaturesANDROID( PhysicalDeviceExternalFormatResolveFeaturesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+ PhysicalDeviceExternalFormatResolveFeaturesANDROID( VkPhysicalDeviceExternalFormatResolveFeaturesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT
+ : PhysicalDeviceExternalFormatResolveFeaturesANDROID( *reinterpret_cast<PhysicalDeviceExternalFormatResolveFeaturesANDROID const *>( &rhs ) )
+ {
+ }
+
+ PhysicalDeviceExternalFormatResolveFeaturesANDROID &
+ operator=( PhysicalDeviceExternalFormatResolveFeaturesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+# endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
+
+ PhysicalDeviceExternalFormatResolveFeaturesANDROID & operator=( VkPhysicalDeviceExternalFormatResolveFeaturesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT
+ {
+ *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFormatResolveFeaturesANDROID const *>( &rhs );
+ return *this;
+ }
+
+# if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
+ VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalFormatResolveFeaturesANDROID & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalFormatResolveFeaturesANDROID &
+ setExternalFormatResolve( VULKAN_HPP_NAMESPACE::Bool32 externalFormatResolve_ ) VULKAN_HPP_NOEXCEPT
+ {
+ externalFormatResolve = externalFormatResolve_;
+ return *this;
+ }
+# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
+
+ operator VkPhysicalDeviceExternalFormatResolveFeaturesANDROID const &() const VULKAN_HPP_NOEXCEPT
+ {
+ return *reinterpret_cast<const VkPhysicalDeviceExternalFormatResolveFeaturesANDROID *>( this );
+ }
+
+ operator VkPhysicalDeviceExternalFormatResolveFeaturesANDROID &() VULKAN_HPP_NOEXCEPT
+ {
+ return *reinterpret_cast<VkPhysicalDeviceExternalFormatResolveFeaturesANDROID *>( this );
+ }
+
+# if defined( VULKAN_HPP_USE_REFLECT )
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, externalFormatResolve );
+ }
+# endif
+
+# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+ auto operator<=>( PhysicalDeviceExternalFormatResolveFeaturesANDROID const & ) const = default;
+# else
+ bool operator==( PhysicalDeviceExternalFormatResolveFeaturesANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+# if defined( VULKAN_HPP_USE_REFLECT )
+ return this->reflect() == rhs.reflect();
+# else
+ return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( externalFormatResolve == rhs.externalFormatResolve );
+# endif
+ }
+
+ bool operator!=( PhysicalDeviceExternalFormatResolveFeaturesANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return !operator==( rhs );
+ }
+# endif
+
+ public:
+ VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceExternalFormatResolveFeaturesANDROID;
+ void * pNext = {};
+ VULKAN_HPP_NAMESPACE::Bool32 externalFormatResolve = {};
+ };
+
+ template <>
+ struct CppType<StructureType, StructureType::ePhysicalDeviceExternalFormatResolveFeaturesANDROID>
+ {
+ using Type = PhysicalDeviceExternalFormatResolveFeaturesANDROID;
+ };
+#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
+
+#if defined( VK_USE_PLATFORM_ANDROID_KHR )
+ struct PhysicalDeviceExternalFormatResolvePropertiesANDROID
+ {
+ using NativeType = VkPhysicalDeviceExternalFormatResolvePropertiesANDROID;
+
+ static const bool allowDuplicate = false;
+ static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceExternalFormatResolvePropertiesANDROID;
+
+# if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalFormatResolvePropertiesANDROID(
+ VULKAN_HPP_NAMESPACE::Bool32 nullColorAttachmentWithExternalFormatResolve_ = {},
+ VULKAN_HPP_NAMESPACE::ChromaLocation externalFormatResolveChromaOffsetX_ = VULKAN_HPP_NAMESPACE::ChromaLocation::eCositedEven,
+ VULKAN_HPP_NAMESPACE::ChromaLocation externalFormatResolveChromaOffsetY_ = VULKAN_HPP_NAMESPACE::ChromaLocation::eCositedEven,
+ void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
+ : pNext( pNext_ )
+ , nullColorAttachmentWithExternalFormatResolve( nullColorAttachmentWithExternalFormatResolve_ )
+ , externalFormatResolveChromaOffsetX( externalFormatResolveChromaOffsetX_ )
+ , externalFormatResolveChromaOffsetY( externalFormatResolveChromaOffsetY_ )
+ {
+ }
+
+ VULKAN_HPP_CONSTEXPR
+ PhysicalDeviceExternalFormatResolvePropertiesANDROID( PhysicalDeviceExternalFormatResolvePropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+ PhysicalDeviceExternalFormatResolvePropertiesANDROID( VkPhysicalDeviceExternalFormatResolvePropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT
+ : PhysicalDeviceExternalFormatResolvePropertiesANDROID( *reinterpret_cast<PhysicalDeviceExternalFormatResolvePropertiesANDROID const *>( &rhs ) )
+ {
+ }
+
+ PhysicalDeviceExternalFormatResolvePropertiesANDROID &
+ operator=( PhysicalDeviceExternalFormatResolvePropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+# endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
+
+ PhysicalDeviceExternalFormatResolvePropertiesANDROID & operator=( VkPhysicalDeviceExternalFormatResolvePropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT
+ {
+ *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFormatResolvePropertiesANDROID const *>( &rhs );
+ return *this;
+ }
+
+ operator VkPhysicalDeviceExternalFormatResolvePropertiesANDROID const &() const VULKAN_HPP_NOEXCEPT
+ {
+ return *reinterpret_cast<const VkPhysicalDeviceExternalFormatResolvePropertiesANDROID *>( this );
+ }
+
+ operator VkPhysicalDeviceExternalFormatResolvePropertiesANDROID &() VULKAN_HPP_NOEXCEPT
+ {
+ return *reinterpret_cast<VkPhysicalDeviceExternalFormatResolvePropertiesANDROID *>( this );
+ }
+
+# if defined( VULKAN_HPP_USE_REFLECT )
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::ChromaLocation const &,
+ VULKAN_HPP_NAMESPACE::ChromaLocation const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, nullColorAttachmentWithExternalFormatResolve, externalFormatResolveChromaOffsetX, externalFormatResolveChromaOffsetY );
+ }
+# endif
+
+# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+ auto operator<=>( PhysicalDeviceExternalFormatResolvePropertiesANDROID const & ) const = default;
+# else
+ bool operator==( PhysicalDeviceExternalFormatResolvePropertiesANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+# if defined( VULKAN_HPP_USE_REFLECT )
+ return this->reflect() == rhs.reflect();
+# else
+ return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+ ( nullColorAttachmentWithExternalFormatResolve == rhs.nullColorAttachmentWithExternalFormatResolve ) &&
+ ( externalFormatResolveChromaOffsetX == rhs.externalFormatResolveChromaOffsetX ) &&
+ ( externalFormatResolveChromaOffsetY == rhs.externalFormatResolveChromaOffsetY );
+# endif
+ }
+
+ bool operator!=( PhysicalDeviceExternalFormatResolvePropertiesANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return !operator==( rhs );
+ }
+# endif
+
+ public:
+ VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceExternalFormatResolvePropertiesANDROID;
+ void * pNext = {};
+ VULKAN_HPP_NAMESPACE::Bool32 nullColorAttachmentWithExternalFormatResolve = {};
+ VULKAN_HPP_NAMESPACE::ChromaLocation externalFormatResolveChromaOffsetX = VULKAN_HPP_NAMESPACE::ChromaLocation::eCositedEven;
+ VULKAN_HPP_NAMESPACE::ChromaLocation externalFormatResolveChromaOffsetY = VULKAN_HPP_NAMESPACE::ChromaLocation::eCositedEven;
+ };
+
+ template <>
+ struct CppType<StructureType, StructureType::ePhysicalDeviceExternalFormatResolvePropertiesANDROID>
+ {
+ using Type = PhysicalDeviceExternalFormatResolvePropertiesANDROID;
+ };
+#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
+
struct PhysicalDeviceExternalImageFormatInfo
{
using NativeType = VkPhysicalDeviceExternalImageFormatInfo;
@@ -63789,6 +65184,102 @@
using Type = PhysicalDeviceFragmentShadingRatePropertiesKHR;
};
+ struct PhysicalDeviceFrameBoundaryFeaturesEXT
+ {
+ using NativeType = VkPhysicalDeviceFrameBoundaryFeaturesEXT;
+
+ static const bool allowDuplicate = false;
+ static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceFrameBoundaryFeaturesEXT;
+
+#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceFrameBoundaryFeaturesEXT( VULKAN_HPP_NAMESPACE::Bool32 frameBoundary_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
+ : pNext( pNext_ )
+ , frameBoundary( frameBoundary_ )
+ {
+ }
+
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceFrameBoundaryFeaturesEXT( PhysicalDeviceFrameBoundaryFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+ PhysicalDeviceFrameBoundaryFeaturesEXT( VkPhysicalDeviceFrameBoundaryFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+ : PhysicalDeviceFrameBoundaryFeaturesEXT( *reinterpret_cast<PhysicalDeviceFrameBoundaryFeaturesEXT const *>( &rhs ) )
+ {
+ }
+
+ PhysicalDeviceFrameBoundaryFeaturesEXT & operator=( PhysicalDeviceFrameBoundaryFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
+
+ PhysicalDeviceFrameBoundaryFeaturesEXT & operator=( VkPhysicalDeviceFrameBoundaryFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+ {
+ *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PhysicalDeviceFrameBoundaryFeaturesEXT const *>( &rhs );
+ return *this;
+ }
+
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
+ VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFrameBoundaryFeaturesEXT & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFrameBoundaryFeaturesEXT & setFrameBoundary( VULKAN_HPP_NAMESPACE::Bool32 frameBoundary_ ) VULKAN_HPP_NOEXCEPT
+ {
+ frameBoundary = frameBoundary_;
+ return *this;
+ }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
+
+ operator VkPhysicalDeviceFrameBoundaryFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+ {
+ return *reinterpret_cast<const VkPhysicalDeviceFrameBoundaryFeaturesEXT *>( this );
+ }
+
+ operator VkPhysicalDeviceFrameBoundaryFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+ {
+ return *reinterpret_cast<VkPhysicalDeviceFrameBoundaryFeaturesEXT *>( this );
+ }
+
+#if defined( VULKAN_HPP_USE_REFLECT )
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, frameBoundary );
+ }
+#endif
+
+#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+ auto operator<=>( PhysicalDeviceFrameBoundaryFeaturesEXT const & ) const = default;
+#else
+ bool operator==( PhysicalDeviceFrameBoundaryFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+# if defined( VULKAN_HPP_USE_REFLECT )
+ return this->reflect() == rhs.reflect();
+# else
+ return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( frameBoundary == rhs.frameBoundary );
+# endif
+ }
+
+ bool operator!=( PhysicalDeviceFrameBoundaryFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return !operator==( rhs );
+ }
+#endif
+
+ public:
+ VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceFrameBoundaryFeaturesEXT;
+ void * pNext = {};
+ VULKAN_HPP_NAMESPACE::Bool32 frameBoundary = {};
+ };
+
+ template <>
+ struct CppType<StructureType, StructureType::ePhysicalDeviceFrameBoundaryFeaturesEXT>
+ {
+ using Type = PhysicalDeviceFrameBoundaryFeaturesEXT;
+ };
+
struct PhysicalDeviceGlobalPriorityQueryFeaturesKHR
{
using NativeType = VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR;
@@ -66696,6 +68187,90 @@
using Type = PhysicalDeviceInvocationMaskFeaturesHUAWEI;
};
+ struct PhysicalDeviceLayeredDriverPropertiesMSFT
+ {
+ using NativeType = VkPhysicalDeviceLayeredDriverPropertiesMSFT;
+
+ static const bool allowDuplicate = false;
+ static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceLayeredDriverPropertiesMSFT;
+
+#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceLayeredDriverPropertiesMSFT(
+ VULKAN_HPP_NAMESPACE::LayeredDriverUnderlyingApiMSFT underlyingAPI_ = VULKAN_HPP_NAMESPACE::LayeredDriverUnderlyingApiMSFT::eNone,
+ void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
+ : pNext( pNext_ )
+ , underlyingAPI( underlyingAPI_ )
+ {
+ }
+
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceLayeredDriverPropertiesMSFT( PhysicalDeviceLayeredDriverPropertiesMSFT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+ PhysicalDeviceLayeredDriverPropertiesMSFT( VkPhysicalDeviceLayeredDriverPropertiesMSFT const & rhs ) VULKAN_HPP_NOEXCEPT
+ : PhysicalDeviceLayeredDriverPropertiesMSFT( *reinterpret_cast<PhysicalDeviceLayeredDriverPropertiesMSFT const *>( &rhs ) )
+ {
+ }
+
+ PhysicalDeviceLayeredDriverPropertiesMSFT & operator=( PhysicalDeviceLayeredDriverPropertiesMSFT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
+
+ PhysicalDeviceLayeredDriverPropertiesMSFT & operator=( VkPhysicalDeviceLayeredDriverPropertiesMSFT const & rhs ) VULKAN_HPP_NOEXCEPT
+ {
+ *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredDriverPropertiesMSFT const *>( &rhs );
+ return *this;
+ }
+
+ operator VkPhysicalDeviceLayeredDriverPropertiesMSFT const &() const VULKAN_HPP_NOEXCEPT
+ {
+ return *reinterpret_cast<const VkPhysicalDeviceLayeredDriverPropertiesMSFT *>( this );
+ }
+
+ operator VkPhysicalDeviceLayeredDriverPropertiesMSFT &() VULKAN_HPP_NOEXCEPT
+ {
+ return *reinterpret_cast<VkPhysicalDeviceLayeredDriverPropertiesMSFT *>( this );
+ }
+
+#if defined( VULKAN_HPP_USE_REFLECT )
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::LayeredDriverUnderlyingApiMSFT const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, underlyingAPI );
+ }
+#endif
+
+#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+ auto operator<=>( PhysicalDeviceLayeredDriverPropertiesMSFT const & ) const = default;
+#else
+ bool operator==( PhysicalDeviceLayeredDriverPropertiesMSFT const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+# if defined( VULKAN_HPP_USE_REFLECT )
+ return this->reflect() == rhs.reflect();
+# else
+ return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( underlyingAPI == rhs.underlyingAPI );
+# endif
+ }
+
+ bool operator!=( PhysicalDeviceLayeredDriverPropertiesMSFT const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return !operator==( rhs );
+ }
+#endif
+
+ public:
+ VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceLayeredDriverPropertiesMSFT;
+ void * pNext = {};
+ VULKAN_HPP_NAMESPACE::LayeredDriverUnderlyingApiMSFT underlyingAPI = VULKAN_HPP_NAMESPACE::LayeredDriverUnderlyingApiMSFT::eNone;
+ };
+
+ template <>
+ struct CppType<StructureType, StructureType::ePhysicalDeviceLayeredDriverPropertiesMSFT>
+ {
+ using Type = PhysicalDeviceLayeredDriverPropertiesMSFT;
+ };
+
struct PhysicalDeviceLegacyDitheringFeaturesEXT
{
using NativeType = VkPhysicalDeviceLegacyDitheringFeaturesEXT;
@@ -93285,10 +94860,10 @@
#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR RayTracingShaderGroupCreateInfoKHR(
VULKAN_HPP_NAMESPACE::RayTracingShaderGroupTypeKHR type_ = VULKAN_HPP_NAMESPACE::RayTracingShaderGroupTypeKHR::eGeneral,
- uint32_t generalShader_ = {},
- uint32_t closestHitShader_ = {},
- uint32_t anyHitShader_ = {},
- uint32_t intersectionShader_ = {},
+ uint32_t generalShader_ = VULKAN_HPP_NAMESPACE::ShaderUnusedKHR,
+ uint32_t closestHitShader_ = VULKAN_HPP_NAMESPACE::ShaderUnusedKHR,
+ uint32_t anyHitShader_ = VULKAN_HPP_NAMESPACE::ShaderUnusedKHR,
+ uint32_t intersectionShader_ = VULKAN_HPP_NAMESPACE::ShaderUnusedKHR,
const void * pShaderGroupCaptureReplayHandle_ = {},
const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext( pNext_ )
@@ -93415,10 +94990,10 @@
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eRayTracingShaderGroupCreateInfoKHR;
const void * pNext = {};
VULKAN_HPP_NAMESPACE::RayTracingShaderGroupTypeKHR type = VULKAN_HPP_NAMESPACE::RayTracingShaderGroupTypeKHR::eGeneral;
- uint32_t generalShader = {};
- uint32_t closestHitShader = {};
- uint32_t anyHitShader = {};
- uint32_t intersectionShader = {};
+ uint32_t generalShader = VULKAN_HPP_NAMESPACE::ShaderUnusedKHR;
+ uint32_t closestHitShader = VULKAN_HPP_NAMESPACE::ShaderUnusedKHR;
+ uint32_t anyHitShader = VULKAN_HPP_NAMESPACE::ShaderUnusedKHR;
+ uint32_t intersectionShader = VULKAN_HPP_NAMESPACE::ShaderUnusedKHR;
const void * pShaderGroupCaptureReplayHandle = {};
};
@@ -93826,10 +95401,10 @@
#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR RayTracingShaderGroupCreateInfoNV(
VULKAN_HPP_NAMESPACE::RayTracingShaderGroupTypeKHR type_ = VULKAN_HPP_NAMESPACE::RayTracingShaderGroupTypeKHR::eGeneral,
- uint32_t generalShader_ = {},
- uint32_t closestHitShader_ = {},
- uint32_t anyHitShader_ = {},
- uint32_t intersectionShader_ = {},
+ uint32_t generalShader_ = VULKAN_HPP_NAMESPACE::ShaderUnusedNV,
+ uint32_t closestHitShader_ = VULKAN_HPP_NAMESPACE::ShaderUnusedNV,
+ uint32_t anyHitShader_ = VULKAN_HPP_NAMESPACE::ShaderUnusedNV,
+ uint32_t intersectionShader_ = VULKAN_HPP_NAMESPACE::ShaderUnusedNV,
const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext( pNext_ )
, type( type_ )
@@ -93945,10 +95520,10 @@
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eRayTracingShaderGroupCreateInfoNV;
const void * pNext = {};
VULKAN_HPP_NAMESPACE::RayTracingShaderGroupTypeKHR type = VULKAN_HPP_NAMESPACE::RayTracingShaderGroupTypeKHR::eGeneral;
- uint32_t generalShader = {};
- uint32_t closestHitShader = {};
- uint32_t anyHitShader = {};
- uint32_t intersectionShader = {};
+ uint32_t generalShader = VULKAN_HPP_NAMESPACE::ShaderUnusedNV;
+ uint32_t closestHitShader = VULKAN_HPP_NAMESPACE::ShaderUnusedNV;
+ uint32_t anyHitShader = VULKAN_HPP_NAMESPACE::ShaderUnusedNV;
+ uint32_t intersectionShader = VULKAN_HPP_NAMESPACE::ShaderUnusedNV;
};
template <>
@@ -100779,6 +102354,112 @@
};
using SemaphoreWaitInfoKHR = SemaphoreWaitInfo;
+ struct SetLatencyMarkerInfoNV
+ {
+ using NativeType = VkSetLatencyMarkerInfoNV;
+
+ static const bool allowDuplicate = false;
+ static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSetLatencyMarkerInfoNV;
+
+#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+ VULKAN_HPP_CONSTEXPR SetLatencyMarkerInfoNV( uint64_t presentID_ = {},
+ VULKAN_HPP_NAMESPACE::LatencyMarkerNV marker_ = VULKAN_HPP_NAMESPACE::LatencyMarkerNV::eSimulationStart,
+ const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
+ : pNext( pNext_ )
+ , presentID( presentID_ )
+ , marker( marker_ )
+ {
+ }
+
+ VULKAN_HPP_CONSTEXPR SetLatencyMarkerInfoNV( SetLatencyMarkerInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+ SetLatencyMarkerInfoNV( VkSetLatencyMarkerInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
+ : SetLatencyMarkerInfoNV( *reinterpret_cast<SetLatencyMarkerInfoNV const *>( &rhs ) )
+ {
+ }
+
+ SetLatencyMarkerInfoNV & operator=( SetLatencyMarkerInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
+
+ SetLatencyMarkerInfoNV & operator=( VkSetLatencyMarkerInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
+ {
+ *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::SetLatencyMarkerInfoNV const *>( &rhs );
+ return *this;
+ }
+
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
+ VULKAN_HPP_CONSTEXPR_14 SetLatencyMarkerInfoNV & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 SetLatencyMarkerInfoNV & setPresentID( uint64_t presentID_ ) VULKAN_HPP_NOEXCEPT
+ {
+ presentID = presentID_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 SetLatencyMarkerInfoNV & setMarker( VULKAN_HPP_NAMESPACE::LatencyMarkerNV marker_ ) VULKAN_HPP_NOEXCEPT
+ {
+ marker = marker_;
+ return *this;
+ }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
+
+ operator VkSetLatencyMarkerInfoNV const &() const VULKAN_HPP_NOEXCEPT
+ {
+ return *reinterpret_cast<const VkSetLatencyMarkerInfoNV *>( this );
+ }
+
+ operator VkSetLatencyMarkerInfoNV &() VULKAN_HPP_NOEXCEPT
+ {
+ return *reinterpret_cast<VkSetLatencyMarkerInfoNV *>( this );
+ }
+
+#if defined( VULKAN_HPP_USE_REFLECT )
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, uint64_t const &, VULKAN_HPP_NAMESPACE::LatencyMarkerNV const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, presentID, marker );
+ }
+#endif
+
+#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+ auto operator<=>( SetLatencyMarkerInfoNV const & ) const = default;
+#else
+ bool operator==( SetLatencyMarkerInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+# if defined( VULKAN_HPP_USE_REFLECT )
+ return this->reflect() == rhs.reflect();
+# else
+ return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentID == rhs.presentID ) && ( marker == rhs.marker );
+# endif
+ }
+
+ bool operator!=( SetLatencyMarkerInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return !operator==( rhs );
+ }
+#endif
+
+ public:
+ VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eSetLatencyMarkerInfoNV;
+ const void * pNext = {};
+ uint64_t presentID = {};
+ VULKAN_HPP_NAMESPACE::LatencyMarkerNV marker = VULKAN_HPP_NAMESPACE::LatencyMarkerNV::eSimulationStart;
+ };
+
+ template <>
+ struct CppType<StructureType, StructureType::eSetLatencyMarkerInfoNV>
+ {
+ using Type = SetLatencyMarkerInfoNV;
+ };
+
struct SetStateFlagsIndirectCommandNV
{
using NativeType = VkSetStateFlagsIndirectCommandNV;
@@ -105384,6 +107065,102 @@
using Type = SwapchainDisplayNativeHdrCreateInfoAMD;
};
+ struct SwapchainLatencyCreateInfoNV
+ {
+ using NativeType = VkSwapchainLatencyCreateInfoNV;
+
+ static const bool allowDuplicate = false;
+ static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSwapchainLatencyCreateInfoNV;
+
+#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+ VULKAN_HPP_CONSTEXPR SwapchainLatencyCreateInfoNV( VULKAN_HPP_NAMESPACE::Bool32 latencyModeEnable_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
+ : pNext( pNext_ )
+ , latencyModeEnable( latencyModeEnable_ )
+ {
+ }
+
+ VULKAN_HPP_CONSTEXPR SwapchainLatencyCreateInfoNV( SwapchainLatencyCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+ SwapchainLatencyCreateInfoNV( VkSwapchainLatencyCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
+ : SwapchainLatencyCreateInfoNV( *reinterpret_cast<SwapchainLatencyCreateInfoNV const *>( &rhs ) )
+ {
+ }
+
+ SwapchainLatencyCreateInfoNV & operator=( SwapchainLatencyCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
+
+ SwapchainLatencyCreateInfoNV & operator=( VkSwapchainLatencyCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
+ {
+ *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::SwapchainLatencyCreateInfoNV const *>( &rhs );
+ return *this;
+ }
+
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
+ VULKAN_HPP_CONSTEXPR_14 SwapchainLatencyCreateInfoNV & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 SwapchainLatencyCreateInfoNV & setLatencyModeEnable( VULKAN_HPP_NAMESPACE::Bool32 latencyModeEnable_ ) VULKAN_HPP_NOEXCEPT
+ {
+ latencyModeEnable = latencyModeEnable_;
+ return *this;
+ }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
+
+ operator VkSwapchainLatencyCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
+ {
+ return *reinterpret_cast<const VkSwapchainLatencyCreateInfoNV *>( this );
+ }
+
+ operator VkSwapchainLatencyCreateInfoNV &() VULKAN_HPP_NOEXCEPT
+ {
+ return *reinterpret_cast<VkSwapchainLatencyCreateInfoNV *>( this );
+ }
+
+#if defined( VULKAN_HPP_USE_REFLECT )
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, latencyModeEnable );
+ }
+#endif
+
+#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+ auto operator<=>( SwapchainLatencyCreateInfoNV const & ) const = default;
+#else
+ bool operator==( SwapchainLatencyCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+# if defined( VULKAN_HPP_USE_REFLECT )
+ return this->reflect() == rhs.reflect();
+# else
+ return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( latencyModeEnable == rhs.latencyModeEnable );
+# endif
+ }
+
+ bool operator!=( SwapchainLatencyCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return !operator==( rhs );
+ }
+#endif
+
+ public:
+ VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eSwapchainLatencyCreateInfoNV;
+ const void * pNext = {};
+ VULKAN_HPP_NAMESPACE::Bool32 latencyModeEnable = {};
+ };
+
+ template <>
+ struct CppType<StructureType, StructureType::eSwapchainLatencyCreateInfoNV>
+ {
+ using Type = SwapchainLatencyCreateInfoNV;
+ };
+
struct SwapchainPresentBarrierCreateInfoNV
{
using NativeType = VkSwapchainPresentBarrierCreateInfoNV;
diff --git a/include/vulkan/vulkan_to_string.hpp b/include/vulkan/vulkan_to_string.hpp
index 69c6d1b..09b6a9d 100644
--- a/include/vulkan/vulkan_to_string.hpp
+++ b/include/vulkan/vulkan_to_string.hpp
@@ -1460,6 +1460,10 @@
result += "Min | ";
if ( value & ResolveModeFlagBits::eMax )
result += "Max | ";
+#if defined( VK_USE_PLATFORM_ANDROID_KHR )
+ if ( value & ResolveModeFlagBits::eExternalFormatDownsampleANDROID )
+ result += "ExternalFormatDownsampleANDROID | ";
+#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
@@ -3189,6 +3193,20 @@
}
#endif /*VK_USE_PLATFORM_FUCHSIA*/
+ //=== VK_EXT_frame_boundary ===
+
+ VULKAN_HPP_INLINE std::string to_string( FrameBoundaryFlagsEXT value )
+ {
+ if ( !value )
+ return "{}";
+
+ std::string result;
+ if ( value & FrameBoundaryFlagBitsEXT::eFrameEnd )
+ result += "FrameEnd | ";
+
+ return "{ " + result.substr( 0, result.size() - 3 ) + " }";
+ }
+
#if defined( VK_USE_PLATFORM_SCREEN_QNX )
//=== VK_QNX_screen_surface ===
@@ -4318,6 +4336,8 @@
case StructureType::ePhysicalDeviceExternalMemoryRdmaFeaturesNV: return "PhysicalDeviceExternalMemoryRdmaFeaturesNV";
case StructureType::ePipelinePropertiesIdentifierEXT: return "PipelinePropertiesIdentifierEXT";
case StructureType::ePhysicalDevicePipelinePropertiesFeaturesEXT: return "PhysicalDevicePipelinePropertiesFeaturesEXT";
+ case StructureType::ePhysicalDeviceFrameBoundaryFeaturesEXT: return "PhysicalDeviceFrameBoundaryFeaturesEXT";
+ case StructureType::eFrameBoundaryEXT: return "FrameBoundaryEXT";
case StructureType::ePhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT: return "PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT";
case StructureType::eSubpassResolvePerformanceQueryEXT: return "SubpassResolvePerformanceQueryEXT";
case StructureType::eMultisampledRenderToSingleSampledInfoEXT: return "MultisampledRenderToSingleSampledInfoEXT";
@@ -4402,6 +4422,11 @@
case StructureType::eOpticalFlowSessionCreatePrivateDataInfoNV: return "OpticalFlowSessionCreatePrivateDataInfoNV";
case StructureType::ePhysicalDeviceLegacyDitheringFeaturesEXT: return "PhysicalDeviceLegacyDitheringFeaturesEXT";
case StructureType::ePhysicalDevicePipelineProtectedAccessFeaturesEXT: return "PhysicalDevicePipelineProtectedAccessFeaturesEXT";
+#if defined( VK_USE_PLATFORM_ANDROID_KHR )
+ case StructureType::ePhysicalDeviceExternalFormatResolveFeaturesANDROID: return "PhysicalDeviceExternalFormatResolveFeaturesANDROID";
+ case StructureType::ePhysicalDeviceExternalFormatResolvePropertiesANDROID: return "PhysicalDeviceExternalFormatResolvePropertiesANDROID";
+ case StructureType::eAndroidHardwareBufferFormatResolvePropertiesANDROID: return "AndroidHardwareBufferFormatResolvePropertiesANDROID";
+#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
case StructureType::ePhysicalDeviceMaintenance5FeaturesKHR: return "PhysicalDeviceMaintenance5FeaturesKHR";
case StructureType::ePhysicalDeviceMaintenance5PropertiesKHR: return "PhysicalDeviceMaintenance5PropertiesKHR";
case StructureType::eRenderingAreaInfoKHR: return "RenderingAreaInfoKHR";
@@ -4427,6 +4452,15 @@
case StructureType::ePhysicalDeviceShaderCoreBuiltinsPropertiesARM: return "PhysicalDeviceShaderCoreBuiltinsPropertiesARM";
case StructureType::ePhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT: return "PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT";
case StructureType::ePhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT: return "PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT";
+ case StructureType::eLatencySleepModeInfoNV: return "LatencySleepModeInfoNV";
+ case StructureType::eLatencySleepInfoNV: return "LatencySleepInfoNV";
+ case StructureType::eSetLatencyMarkerInfoNV: return "SetLatencyMarkerInfoNV";
+ case StructureType::eGetLatencyMarkerInfoNV: return "GetLatencyMarkerInfoNV";
+ case StructureType::eLatencyTimingsFrameReportNV: return "LatencyTimingsFrameReportNV";
+ case StructureType::eLatencySubmissionPresentIdNV: return "LatencySubmissionPresentIdNV";
+ case StructureType::eOutOfBandQueueTypeInfoNV: return "OutOfBandQueueTypeInfoNV";
+ case StructureType::eSwapchainLatencyCreateInfoNV: return "SwapchainLatencyCreateInfoNV";
+ case StructureType::eLatencySurfaceCapabilitiesNV: return "LatencySurfaceCapabilitiesNV";
case StructureType::ePhysicalDeviceCooperativeMatrixFeaturesKHR: return "PhysicalDeviceCooperativeMatrixFeaturesKHR";
case StructureType::eCooperativeMatrixPropertiesKHR: return "CooperativeMatrixPropertiesKHR";
case StructureType::ePhysicalDeviceCooperativeMatrixPropertiesKHR: return "PhysicalDeviceCooperativeMatrixPropertiesKHR";
@@ -4449,6 +4483,7 @@
case StructureType::eExternalFormatQNX: return "ExternalFormatQNX";
case StructureType::ePhysicalDeviceExternalMemoryScreenBufferFeaturesQNX: return "PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX";
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
+ case StructureType::ePhysicalDeviceLayeredDriverPropertiesMSFT: return "PhysicalDeviceLayeredDriverPropertiesMSFT";
case StructureType::ePhysicalDeviceDescriptorPoolOverallocationFeaturesNV: return "PhysicalDeviceDescriptorPoolOverallocationFeaturesNV";
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
}
@@ -6358,6 +6393,7 @@
case DriverId::eMesaDozen: return "MesaDozen";
case DriverId::eMesaNvk: return "MesaNvk";
case DriverId::eImaginationOpenSourceMESA: return "ImaginationOpenSourceMESA";
+ case DriverId::eMesaAgxv: return "MesaAgxv";
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
}
}
@@ -6394,6 +6430,9 @@
case ResolveModeFlagBits::eAverage: return "Average";
case ResolveModeFlagBits::eMin: return "Min";
case ResolveModeFlagBits::eMax: return "Max";
+#if defined( VK_USE_PLATFORM_ANDROID_KHR )
+ case ResolveModeFlagBits::eExternalFormatDownsampleANDROID: return "ExternalFormatDownsampleANDROID";
+#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
}
}
@@ -8462,6 +8501,17 @@
}
#endif /*VK_USE_PLATFORM_FUCHSIA*/
+ //=== VK_EXT_frame_boundary ===
+
+ VULKAN_HPP_INLINE std::string to_string( FrameBoundaryFlagBitsEXT value )
+ {
+ switch ( value )
+ {
+ case FrameBoundaryFlagBitsEXT::eFrameEnd: return "FrameEnd";
+ default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
+ }
+ }
+
#if defined( VK_USE_PLATFORM_SCREEN_QNX )
//=== VK_QNX_screen_surface ===
@@ -8834,6 +8884,38 @@
}
}
+ //=== VK_NV_low_latency2 ===
+
+ VULKAN_HPP_INLINE std::string to_string( LatencyMarkerNV value )
+ {
+ switch ( value )
+ {
+ case LatencyMarkerNV::eSimulationStart: return "SimulationStart";
+ case LatencyMarkerNV::eSimulationEnd: return "SimulationEnd";
+ case LatencyMarkerNV::eRendersubmitStart: return "RendersubmitStart";
+ case LatencyMarkerNV::eRendersubmitEnd: return "RendersubmitEnd";
+ case LatencyMarkerNV::ePresentStart: return "PresentStart";
+ case LatencyMarkerNV::ePresentEnd: return "PresentEnd";
+ case LatencyMarkerNV::eInputSample: return "InputSample";
+ case LatencyMarkerNV::eTriggerFlash: return "TriggerFlash";
+ case LatencyMarkerNV::eOutOfBandRendersubmitStart: return "OutOfBandRendersubmitStart";
+ case LatencyMarkerNV::eOutOfBandRendersubmitEnd: return "OutOfBandRendersubmitEnd";
+ case LatencyMarkerNV::eOutOfBandPresentStart: return "OutOfBandPresentStart";
+ case LatencyMarkerNV::eOutOfBandPresentEnd: return "OutOfBandPresentEnd";
+ default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
+ }
+ }
+
+ VULKAN_HPP_INLINE std::string to_string( OutOfBandQueueTypeNV value )
+ {
+ switch ( value )
+ {
+ case OutOfBandQueueTypeNV::eRender: return "Render";
+ case OutOfBandQueueTypeNV::ePresent: return "Present";
+ default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
+ }
+ }
+
//=== VK_KHR_cooperative_matrix ===
VULKAN_HPP_INLINE std::string to_string( ScopeKHR value )
@@ -8893,5 +8975,17 @@
}
}
+ //=== VK_MSFT_layered_driver ===
+
+ VULKAN_HPP_INLINE std::string to_string( LayeredDriverUnderlyingApiMSFT value )
+ {
+ switch ( value )
+ {
+ case LayeredDriverUnderlyingApiMSFT::eNone: return "None";
+ case LayeredDriverUnderlyingApiMSFT::eD3D12: return "D3D12";
+ default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
+ }
+ }
+
} // namespace VULKAN_HPP_NAMESPACE
#endif
