From 18569340537070c6a8b7d8a28902fe159e0a2c11 Mon Sep 17 00:00:00 2001 From: Kbz-8 Date: Sun, 20 Apr 2025 00:44:38 +0000 Subject: [PATCH] [BOT] update dependencies --- third_party/vulkan/vulkan.cppm | 23 + third_party/vulkan/vulkan.hpp | 143 ++++- third_party/vulkan/vulkan_core.h | 56 +- third_party/vulkan/vulkan_enums.hpp | 262 +++++--- .../vulkan/vulkan_extension_inspection.hpp | 42 +- third_party/vulkan/vulkan_funcs.hpp | 28 + third_party/vulkan/vulkan_handles.hpp | 20 + third_party/vulkan/vulkan_hash.hpp | 69 +++ third_party/vulkan/vulkan_hpp_macros.hpp | 4 +- third_party/vulkan/vulkan_raii.hpp | 25 + .../vulkan/vulkan_static_assertions.hpp | 34 ++ third_party/vulkan/vulkan_structs.hpp | 561 ++++++++++++++++++ third_party/vulkan/vulkan_to_string.hpp | 17 + 13 files changed, 1146 insertions(+), 138 deletions(-) diff --git a/third_party/vulkan/vulkan.cppm b/third_party/vulkan/vulkan.cppm index 2d55b3b..cca3fe1 100644 --- a/third_party/vulkan/vulkan.cppm +++ b/third_party/vulkan/vulkan.cppm @@ -2649,6 +2649,10 @@ export namespace VULKAN_HPP_NAMESPACE using VULKAN_HPP_NAMESPACE::NVDescriptorPoolOverallocationExtensionName; using VULKAN_HPP_NAMESPACE::NVDescriptorPoolOverallocationSpecVersion; + //=== VK_QCOM_tile_memory_heap === + using VULKAN_HPP_NAMESPACE::QCOMTileMemoryHeapExtensionName; + using VULKAN_HPP_NAMESPACE::QCOMTileMemoryHeapSpecVersion; + //=== VK_NV_display_stereo === using VULKAN_HPP_NAMESPACE::NVDisplayStereoExtensionName; using VULKAN_HPP_NAMESPACE::NVDisplayStereoSpecVersion; @@ -4698,6 +4702,13 @@ export namespace VULKAN_HPP_NAMESPACE //=== VK_NV_descriptor_pool_overallocation === using VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorPoolOverallocationFeaturesNV; + //=== VK_QCOM_tile_memory_heap === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceTileMemoryHeapFeaturesQCOM; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceTileMemoryHeapPropertiesQCOM; + using VULKAN_HPP_NAMESPACE::TileMemoryBindInfoQCOM; + using VULKAN_HPP_NAMESPACE::TileMemoryRequirementsQCOM; + using VULKAN_HPP_NAMESPACE::TileMemorySizeInfoQCOM; + //=== VK_NV_display_stereo === using VULKAN_HPP_NAMESPACE::DisplayModeStereoPropertiesNV; using VULKAN_HPP_NAMESPACE::DisplaySurfaceStereoCreateInfoNV; @@ -8327,6 +8338,18 @@ export namespace std template <> struct hash; + //=== VK_QCOM_tile_memory_heap === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + //=== VK_NV_display_stereo === template <> struct hash; diff --git a/third_party/vulkan/vulkan.hpp b/third_party/vulkan/vulkan.hpp index 172a45a..1dc3da0 100644 --- a/third_party/vulkan/vulkan.hpp +++ b/third_party/vulkan/vulkan.hpp @@ -15,30 +15,30 @@ import VULKAN_HPP_STD_MODULE; #else # include -# include // ArrayWrapperND +# include // ArrayWrapperND +# include # include // strnlen # include // std::string # include // std::exchange +# if 17 <= VULKAN_HPP_CPP_VERSION +# include +# endif +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) +# include // std::tie +# include // std::vector +# endif +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) +# include +# endif +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) +# include // std::is_error_code_enum +# endif +# if defined( VULKAN_HPP_SUPPORT_SPAN ) +# include +# endif #endif #include -#if 17 <= VULKAN_HPP_CPP_VERSION && !( defined( VULKAN_HPP_ENABLE_STD_MODULE ) && defined( VULKAN_HPP_STD_MODULE ) ) -# include -#endif - -#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) && !( defined( VULKAN_HPP_ENABLE_STD_MODULE ) && defined( VULKAN_HPP_STD_MODULE ) ) -# include // std::tie -# include // std::vector -#endif - -#if !defined( VULKAN_HPP_NO_EXCEPTIONS ) && !( defined( VULKAN_HPP_ENABLE_STD_MODULE ) && defined( VULKAN_HPP_STD_MODULE ) ) -# include // std::is_error_code_enum -#endif - -#if ( VULKAN_HPP_ASSERT == assert ) -# include -#endif - #if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL == 1 # if defined( __unix__ ) || defined( __APPLE__ ) || defined( __QNX__ ) || defined( __Fuchsia__ ) # include @@ -55,15 +55,7 @@ extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE h # endif #endif -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) && !( defined( VULKAN_HPP_ENABLE_STD_MODULE ) && defined( VULKAN_HPP_STD_MODULE ) ) -# include -#endif - -#if defined( VULKAN_HPP_SUPPORT_SPAN ) && !( defined( VULKAN_HPP_ENABLE_STD_MODULE ) && defined( VULKAN_HPP_STD_MODULE ) ) -# include -#endif - -static_assert( VK_HEADER_VERSION == 312, "Wrong VK_HEADER_VERSION!" ); +static_assert( VK_HEADER_VERSION == 313, "Wrong VK_HEADER_VERSION!" ); // includes through some other header // this results in major(x) being resolved to gnu_dev_major(x) @@ -6112,6 +6104,13 @@ namespace VULKAN_HPP_NAMESPACE return ::vkCmdBindDescriptorBufferEmbeddedSamplers2EXT( commandBuffer, pBindDescriptorBufferEmbeddedSamplersInfo ); } + //=== VK_QCOM_tile_memory_heap === + + void vkCmdBindTileMemoryQCOM( VkCommandBuffer commandBuffer, const VkTileMemoryBindInfoQCOM * pTileMemoryBindInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdBindTileMemoryQCOM( commandBuffer, pTileMemoryBindInfo ); + } + //=== VK_NV_external_compute_queue === VkResult vkCreateExternalComputeQueueNV( VkDevice device, @@ -8625,8 +8624,10 @@ namespace VULKAN_HPP_NAMESPACE #if defined( VK_ENABLE_BETA_EXTENSIONS ) //=== VK_NV_displacement_micromap === + VULKAN_HPP_DEPRECATED( "The VK_NV_displacement_micromap extension has been deprecated by VK_NV_cluster_acceleration_structure." ) VULKAN_HPP_CONSTEXPR_INLINE auto NVDisplacementMicromapExtensionName = VK_NV_DISPLACEMENT_MICROMAP_EXTENSION_NAME; - VULKAN_HPP_CONSTEXPR_INLINE auto NVDisplacementMicromapSpecVersion = VK_NV_DISPLACEMENT_MICROMAP_SPEC_VERSION; + VULKAN_HPP_DEPRECATED( "The VK_NV_displacement_micromap extension has been deprecated by VK_NV_cluster_acceleration_structure." ) + VULKAN_HPP_CONSTEXPR_INLINE auto NVDisplacementMicromapSpecVersion = VK_NV_DISPLACEMENT_MICROMAP_SPEC_VERSION; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ //=== VK_EXT_load_store_op_none === @@ -8933,6 +8934,10 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_CONSTEXPR_INLINE auto NVDescriptorPoolOverallocationExtensionName = VK_NV_DESCRIPTOR_POOL_OVERALLOCATION_EXTENSION_NAME; VULKAN_HPP_CONSTEXPR_INLINE auto NVDescriptorPoolOverallocationSpecVersion = VK_NV_DESCRIPTOR_POOL_OVERALLOCATION_SPEC_VERSION; + //=== VK_QCOM_tile_memory_heap === + VULKAN_HPP_CONSTEXPR_INLINE auto QCOMTileMemoryHeapExtensionName = VK_QCOM_TILE_MEMORY_HEAP_EXTENSION_NAME; + VULKAN_HPP_CONSTEXPR_INLINE auto QCOMTileMemoryHeapSpecVersion = VK_QCOM_TILE_MEMORY_HEAP_SPEC_VERSION; + //=== VK_NV_display_stereo === VULKAN_HPP_CONSTEXPR_INLINE auto NVDisplayStereoExtensionName = VK_NV_DISPLAY_STEREO_EXTENSION_NAME; VULKAN_HPP_CONSTEXPR_INLINE auto NVDisplayStereoSpecVersion = VK_NV_DISPLAY_STEREO_SPEC_VERSION; @@ -17376,6 +17381,79 @@ namespace VULKAN_HPP_NAMESPACE }; }; + //=== VK_QCOM_tile_memory_heap === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + //=== VK_NV_display_stereo === template <> struct StructExtends @@ -19484,6 +19562,9 @@ namespace VULKAN_HPP_NAMESPACE PFN_vkCmdSetDescriptorBufferOffsets2EXT vkCmdSetDescriptorBufferOffsets2EXT = 0; PFN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT vkCmdBindDescriptorBufferEmbeddedSamplers2EXT = 0; + //=== VK_QCOM_tile_memory_heap === + PFN_vkCmdBindTileMemoryQCOM vkCmdBindTileMemoryQCOM = 0; + //=== VK_NV_external_compute_queue === PFN_vkCreateExternalComputeQueueNV vkCreateExternalComputeQueueNV = 0; PFN_vkDestroyExternalComputeQueueNV vkDestroyExternalComputeQueueNV = 0; @@ -21033,6 +21114,9 @@ namespace VULKAN_HPP_NAMESPACE vkCmdBindDescriptorBufferEmbeddedSamplers2EXT = PFN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT( vkGetInstanceProcAddr( instance, "vkCmdBindDescriptorBufferEmbeddedSamplers2EXT" ) ); + //=== VK_QCOM_tile_memory_heap === + vkCmdBindTileMemoryQCOM = PFN_vkCmdBindTileMemoryQCOM( vkGetInstanceProcAddr( instance, "vkCmdBindTileMemoryQCOM" ) ); + //=== VK_NV_external_compute_queue === vkCreateExternalComputeQueueNV = PFN_vkCreateExternalComputeQueueNV( vkGetInstanceProcAddr( instance, "vkCreateExternalComputeQueueNV" ) ); vkDestroyExternalComputeQueueNV = PFN_vkDestroyExternalComputeQueueNV( vkGetInstanceProcAddr( instance, "vkDestroyExternalComputeQueueNV" ) ); @@ -22219,6 +22303,9 @@ namespace VULKAN_HPP_NAMESPACE vkCmdBindDescriptorBufferEmbeddedSamplers2EXT = PFN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT( vkGetDeviceProcAddr( device, "vkCmdBindDescriptorBufferEmbeddedSamplers2EXT" ) ); + //=== VK_QCOM_tile_memory_heap === + vkCmdBindTileMemoryQCOM = PFN_vkCmdBindTileMemoryQCOM( vkGetDeviceProcAddr( device, "vkCmdBindTileMemoryQCOM" ) ); + //=== VK_NV_external_compute_queue === vkCreateExternalComputeQueueNV = PFN_vkCreateExternalComputeQueueNV( vkGetDeviceProcAddr( device, "vkCreateExternalComputeQueueNV" ) ); vkDestroyExternalComputeQueueNV = PFN_vkDestroyExternalComputeQueueNV( vkGetDeviceProcAddr( device, "vkDestroyExternalComputeQueueNV" ) ); diff --git a/third_party/vulkan/vulkan_core.h b/third_party/vulkan/vulkan_core.h index 35e5091..b57b368 100644 --- a/third_party/vulkan/vulkan_core.h +++ b/third_party/vulkan/vulkan_core.h @@ -69,7 +69,7 @@ extern "C" { #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 312 +#define VK_HEADER_VERSION 313 // Complete version of this file #define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 4, VK_HEADER_VERSION) @@ -1168,6 +1168,11 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_SET_DESCRIPTOR_BUFFER_OFFSETS_INFO_EXT = 1000545007, VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT = 1000545008, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV = 1000546000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM = 1000547000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_PROPERTIES_QCOM = 1000547001, + VK_STRUCTURE_TYPE_TILE_MEMORY_REQUIREMENTS_QCOM = 1000547002, + VK_STRUCTURE_TYPE_TILE_MEMORY_BIND_INFO_QCOM = 1000547003, + VK_STRUCTURE_TYPE_TILE_MEMORY_SIZE_INFO_QCOM = 1000547004, VK_STRUCTURE_TYPE_DISPLAY_SURFACE_STEREO_CREATE_INFO_NV = 1000551000, VK_STRUCTURE_TYPE_DISPLAY_MODE_STEREO_PROPERTIES_NV = 1000551001, VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR = 1000553000, @@ -2565,6 +2570,7 @@ typedef enum VkImageUsageFlagBits { VK_IMAGE_USAGE_INVOCATION_MASK_BIT_HUAWEI = 0x00040000, VK_IMAGE_USAGE_SAMPLE_WEIGHT_BIT_QCOM = 0x00100000, VK_IMAGE_USAGE_SAMPLE_BLOCK_MATCH_BIT_QCOM = 0x00200000, + VK_IMAGE_USAGE_TILE_MEMORY_QCOM = 0x08000000, VK_IMAGE_USAGE_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR = 0x02000000, VK_IMAGE_USAGE_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR = 0x04000000, VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV = VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, @@ -2582,6 +2588,7 @@ typedef VkFlags VkInstanceCreateFlags; typedef enum VkMemoryHeapFlagBits { VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = 0x00000001, VK_MEMORY_HEAP_MULTI_INSTANCE_BIT = 0x00000002, + VK_MEMORY_HEAP_TILE_MEMORY_BIT_QCOM = 0x00000008, VK_MEMORY_HEAP_MULTI_INSTANCE_BIT_KHR = VK_MEMORY_HEAP_MULTI_INSTANCE_BIT, VK_MEMORY_HEAP_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF } VkMemoryHeapFlagBits; @@ -2767,6 +2774,7 @@ typedef enum VkBufferUsageFlagBits { VK_BUFFER_USAGE_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT = 0x04000000, VK_BUFFER_USAGE_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT = 0x00800000, VK_BUFFER_USAGE_MICROMAP_STORAGE_BIT_EXT = 0x01000000, + VK_BUFFER_USAGE_TILE_MEMORY_QCOM = 0x08000000, VK_BUFFER_USAGE_RAY_TRACING_BIT_NV = VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR, VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT = VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT, VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_KHR = VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT, @@ -7966,6 +7974,7 @@ static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_RESOURCE_DESCRIPTOR_BUFFER static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT = 0x04000000ULL; static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT = 0x00800000ULL; static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_MICROMAP_STORAGE_BIT_EXT = 0x01000000ULL; +static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_TILE_MEMORY_QCOM = 0x08000000ULL; static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_PREPROCESS_BUFFER_BIT_EXT = 0x80000000ULL; @@ -20633,6 +20642,51 @@ typedef struct VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV { +// VK_QCOM_tile_memory_heap is a preprocessor guard. Do not pass it to API calls. +#define VK_QCOM_tile_memory_heap 1 +#define VK_QCOM_TILE_MEMORY_HEAP_SPEC_VERSION 1 +#define VK_QCOM_TILE_MEMORY_HEAP_EXTENSION_NAME "VK_QCOM_tile_memory_heap" +typedef struct VkPhysicalDeviceTileMemoryHeapFeaturesQCOM { + VkStructureType sType; + void* pNext; + VkBool32 tileMemoryHeap; +} VkPhysicalDeviceTileMemoryHeapFeaturesQCOM; + +typedef struct VkPhysicalDeviceTileMemoryHeapPropertiesQCOM { + VkStructureType sType; + void* pNext; + VkBool32 queueSubmitBoundary; + VkBool32 tileBufferTransfers; +} VkPhysicalDeviceTileMemoryHeapPropertiesQCOM; + +typedef struct VkTileMemoryRequirementsQCOM { + VkStructureType sType; + void* pNext; + VkDeviceSize size; + VkDeviceSize alignment; +} VkTileMemoryRequirementsQCOM; + +typedef struct VkTileMemoryBindInfoQCOM { + VkStructureType sType; + const void* pNext; + VkDeviceMemory memory; +} VkTileMemoryBindInfoQCOM; + +typedef struct VkTileMemorySizeInfoQCOM { + VkStructureType sType; + const void* pNext; + VkDeviceSize size; +} VkTileMemorySizeInfoQCOM; + +typedef void (VKAPI_PTR *PFN_vkCmdBindTileMemoryQCOM)(VkCommandBuffer commandBuffer, const VkTileMemoryBindInfoQCOM* pTileMemoryBindInfo); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdBindTileMemoryQCOM( + VkCommandBuffer commandBuffer, + const VkTileMemoryBindInfoQCOM* pTileMemoryBindInfo); +#endif + + // VK_NV_display_stereo is a preprocessor guard. Do not pass it to API calls. #define VK_NV_display_stereo 1 #define VK_NV_DISPLAY_STEREO_SPEC_VERSION 1 diff --git a/third_party/vulkan/vulkan_enums.hpp b/third_party/vulkan/vulkan_enums.hpp index bb5ad5f..d315e45 100644 --- a/third_party/vulkan/vulkan_enums.hpp +++ b/third_party/vulkan/vulkan_enums.hpp @@ -23,6 +23,7 @@ namespace VULKAN_HPP_NAMESPACE class Flags { public: + using BitsType = BitType; using MaskType = typename std::underlying_type::type; // constructors @@ -1513,6 +1514,11 @@ namespace VULKAN_HPP_NAMESPACE eSetDescriptorBufferOffsetsInfoEXT = VK_STRUCTURE_TYPE_SET_DESCRIPTOR_BUFFER_OFFSETS_INFO_EXT, eBindDescriptorBufferEmbeddedSamplersInfoEXT = VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT, ePhysicalDeviceDescriptorPoolOverallocationFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV, + ePhysicalDeviceTileMemoryHeapFeaturesQCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM, + ePhysicalDeviceTileMemoryHeapPropertiesQCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_PROPERTIES_QCOM, + eTileMemoryRequirementsQCOM = VK_STRUCTURE_TYPE_TILE_MEMORY_REQUIREMENTS_QCOM, + eTileMemoryBindInfoQCOM = VK_STRUCTURE_TYPE_TILE_MEMORY_BIND_INFO_QCOM, + eTileMemorySizeInfoQCOM = VK_STRUCTURE_TYPE_TILE_MEMORY_SIZE_INFO_QCOM, eDisplaySurfaceStereoCreateInfoNV = VK_STRUCTURE_TYPE_DISPLAY_SURFACE_STEREO_CREATE_INFO_NV, eDisplayModeStereoPropertiesNV = VK_STRUCTURE_TYPE_DISPLAY_MODE_STEREO_PROPERTIES_NV, eVideoEncodeQuantizationMapCapabilitiesKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR, @@ -2059,6 +2065,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkFormatFeatureFlagBits; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR FormatFeatureFlags allFlags = FormatFeatureFlagBits::eSampledImage | FormatFeatureFlagBits::eStorageImage | FormatFeatureFlagBits::eStorageImageAtomic | @@ -2114,6 +2121,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkImageCreateFlagBits; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR ImageCreateFlags allFlags = ImageCreateFlagBits::eSparseBinding | ImageCreateFlagBits::eSparseResidency | ImageCreateFlagBits::eSparseAliased | ImageCreateFlagBits::eMutableFormat | @@ -2167,6 +2175,7 @@ namespace VULKAN_HPP_NAMESPACE eInvocationMaskHUAWEI = VK_IMAGE_USAGE_INVOCATION_MASK_BIT_HUAWEI, eSampleWeightQCOM = VK_IMAGE_USAGE_SAMPLE_WEIGHT_BIT_QCOM, eSampleBlockMatchQCOM = VK_IMAGE_USAGE_SAMPLE_BLOCK_MATCH_BIT_QCOM, + eTileMemoryQCOM = VK_IMAGE_USAGE_TILE_MEMORY_QCOM, eVideoEncodeQuantizationDeltaMapKHR = VK_IMAGE_USAGE_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR, eVideoEncodeEmphasisMapKHR = VK_IMAGE_USAGE_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR }; @@ -2177,6 +2186,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkImageUsageFlagBits; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR ImageUsageFlags allFlags = ImageUsageFlagBits::eTransferSrc | ImageUsageFlagBits::eTransferDst | ImageUsageFlagBits::eSampled | ImageUsageFlagBits::eStorage | @@ -2185,8 +2195,8 @@ namespace VULKAN_HPP_NAMESPACE ImageUsageFlagBits::eVideoDecodeSrcKHR | ImageUsageFlagBits::eVideoDecodeDpbKHR | ImageUsageFlagBits::eFragmentDensityMapEXT | ImageUsageFlagBits::eFragmentShadingRateAttachmentKHR | ImageUsageFlagBits::eVideoEncodeDstKHR | ImageUsageFlagBits::eVideoEncodeSrcKHR | ImageUsageFlagBits::eVideoEncodeDpbKHR | ImageUsageFlagBits::eAttachmentFeedbackLoopEXT | ImageUsageFlagBits::eInvocationMaskHUAWEI | - ImageUsageFlagBits::eSampleWeightQCOM | ImageUsageFlagBits::eSampleBlockMatchQCOM | ImageUsageFlagBits::eVideoEncodeQuantizationDeltaMapKHR | - ImageUsageFlagBits::eVideoEncodeEmphasisMapKHR; + ImageUsageFlagBits::eSampleWeightQCOM | ImageUsageFlagBits::eSampleBlockMatchQCOM | ImageUsageFlagBits::eTileMemoryQCOM | + ImageUsageFlagBits::eVideoEncodeQuantizationDeltaMapKHR | ImageUsageFlagBits::eVideoEncodeEmphasisMapKHR; }; // wrapper class for enum VkInstanceCreateFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkInstanceCreateFlagBits.html @@ -2201,6 +2211,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkInstanceCreateFlagBits; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR InstanceCreateFlags allFlags = InstanceCreateFlagBits::eEnumeratePortabilityKHR; }; @@ -2216,7 +2227,8 @@ namespace VULKAN_HPP_NAMESPACE { eDeviceLocal = VK_MEMORY_HEAP_DEVICE_LOCAL_BIT, eMultiInstance = VK_MEMORY_HEAP_MULTI_INSTANCE_BIT, - eMultiInstanceKHR = VK_MEMORY_HEAP_MULTI_INSTANCE_BIT_KHR + eMultiInstanceKHR = VK_MEMORY_HEAP_MULTI_INSTANCE_BIT_KHR, + eTileMemoryQCOM = VK_MEMORY_HEAP_TILE_MEMORY_BIT_QCOM }; // wrapper using for bitmask VkMemoryHeapFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryHeapFlags.html @@ -2225,8 +2237,10 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkMemoryHeapFlagBits; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR MemoryHeapFlags allFlags = MemoryHeapFlagBits::eDeviceLocal | MemoryHeapFlagBits::eMultiInstance; + static VULKAN_HPP_CONST_OR_CONSTEXPR MemoryHeapFlags allFlags = + MemoryHeapFlagBits::eDeviceLocal | MemoryHeapFlagBits::eMultiInstance | MemoryHeapFlagBits::eTileMemoryQCOM; }; // wrapper class for enum VkMemoryPropertyFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryPropertyFlagBits.html @@ -2249,6 +2263,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkMemoryPropertyFlagBits; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR MemoryPropertyFlags allFlags = MemoryPropertyFlagBits::eDeviceLocal | MemoryPropertyFlagBits::eHostVisible | MemoryPropertyFlagBits::eHostCoherent | @@ -2285,6 +2300,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkQueueFlagBits; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR QueueFlags allFlags = QueueFlagBits::eGraphics | QueueFlagBits::eCompute | QueueFlagBits::eTransfer | QueueFlagBits::eSparseBinding | QueueFlagBits::eProtected | QueueFlagBits::eVideoDecodeKHR | @@ -2309,6 +2325,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkSampleCountFlagBits; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR SampleCountFlags allFlags = SampleCountFlagBits::e1 | SampleCountFlagBits::e2 | SampleCountFlagBits::e4 | SampleCountFlagBits::e8 | SampleCountFlagBits::e16 | SampleCountFlagBits::e32 | @@ -2325,7 +2342,6 @@ namespace VULKAN_HPP_NAMESPACE eInstance = VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE }; - // wrapper class for enum VkDeviceCreateFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceCreateFlagBits.html enum class DeviceCreateFlagBits : VkDeviceCreateFlags { }; @@ -2352,6 +2368,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkDeviceQueueCreateFlagBits; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR DeviceQueueCreateFlags allFlags = DeviceQueueCreateFlagBits::eProtected; }; @@ -2401,6 +2418,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkPipelineStageFlagBits; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineStageFlags allFlags = PipelineStageFlagBits::eTopOfPipe | PipelineStageFlagBits::eDrawIndirect | PipelineStageFlagBits::eVertexInput | PipelineStageFlagBits::eVertexShader | @@ -2426,6 +2444,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkMemoryMapFlagBits; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR MemoryMapFlags allFlags = MemoryMapFlagBits::ePlacedEXT; }; @@ -2457,6 +2476,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkImageAspectFlagBits; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR ImageAspectFlags allFlags = ImageAspectFlagBits::eColor | ImageAspectFlagBits::eDepth | ImageAspectFlagBits::eStencil | ImageAspectFlagBits::eMetadata | ImageAspectFlagBits::ePlane0 | @@ -2479,6 +2499,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkSparseImageFormatFlagBits; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR SparseImageFormatFlags allFlags = SparseImageFormatFlagBits::eSingleMiptail | SparseImageFormatFlagBits::eAlignedMipSize | SparseImageFormatFlagBits::eNonstandardBlockSize; @@ -2496,6 +2517,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkSparseMemoryBindFlagBits; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR SparseMemoryBindFlags allFlags = SparseMemoryBindFlagBits::eMetadata; }; @@ -2512,11 +2534,11 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkFenceCreateFlagBits; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR FenceCreateFlags allFlags = FenceCreateFlagBits::eSignaled; }; - // wrapper class for enum VkSemaphoreCreateFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSemaphoreCreateFlagBits.html enum class SemaphoreCreateFlagBits : VkSemaphoreCreateFlags { }; @@ -2544,6 +2566,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkEventCreateFlagBits; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR EventCreateFlags allFlags = EventCreateFlagBits::eDeviceOnly; }; @@ -2574,6 +2597,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkQueryPipelineStatisticFlagBits; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR QueryPipelineStatisticFlags allFlags = QueryPipelineStatisticFlagBits::eInputAssemblyVertices | QueryPipelineStatisticFlagBits::eInputAssemblyPrimitives | @@ -2601,6 +2625,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkQueryResultFlagBits; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR QueryResultFlags allFlags = QueryResultFlagBits::e64 | QueryResultFlagBits::eWait | QueryResultFlagBits::eWithAvailability | QueryResultFlagBits::ePartial | @@ -2629,7 +2654,6 @@ namespace VULKAN_HPP_NAMESPACE eMicromapCompactedSizeEXT = VK_QUERY_TYPE_MICROMAP_COMPACTED_SIZE_EXT }; - // wrapper class for enum VkQueryPoolCreateFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueryPoolCreateFlagBits.html enum class QueryPoolCreateFlagBits : VkQueryPoolCreateFlags { }; @@ -2664,6 +2688,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkBufferCreateFlagBits; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR BufferCreateFlags allFlags = BufferCreateFlagBits::eSparseBinding | BufferCreateFlagBits::eSparseResidency | BufferCreateFlagBits::eSparseAliased | BufferCreateFlagBits::eProtected | @@ -2704,7 +2729,8 @@ namespace VULKAN_HPP_NAMESPACE eResourceDescriptorBufferEXT = VK_BUFFER_USAGE_RESOURCE_DESCRIPTOR_BUFFER_BIT_EXT, ePushDescriptorsDescriptorBufferEXT = VK_BUFFER_USAGE_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT, eMicromapBuildInputReadOnlyEXT = VK_BUFFER_USAGE_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT, - eMicromapStorageEXT = VK_BUFFER_USAGE_MICROMAP_STORAGE_BIT_EXT + eMicromapStorageEXT = VK_BUFFER_USAGE_MICROMAP_STORAGE_BIT_EXT, + eTileMemoryQCOM = VK_BUFFER_USAGE_TILE_MEMORY_QCOM }; // wrapper using for bitmask VkBufferUsageFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferUsageFlags.html @@ -2713,6 +2739,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkBufferUsageFlagBits; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR BufferUsageFlags allFlags = BufferUsageFlagBits::eTransferSrc | BufferUsageFlagBits::eTransferDst | BufferUsageFlagBits::eUniformTexelBuffer | @@ -2726,7 +2753,8 @@ namespace VULKAN_HPP_NAMESPACE | BufferUsageFlagBits::eAccelerationStructureBuildInputReadOnlyKHR | BufferUsageFlagBits::eAccelerationStructureStorageKHR | BufferUsageFlagBits::eShaderBindingTableKHR | BufferUsageFlagBits::eVideoEncodeDstKHR | BufferUsageFlagBits::eVideoEncodeSrcKHR | BufferUsageFlagBits::eSamplerDescriptorBufferEXT | BufferUsageFlagBits::eResourceDescriptorBufferEXT | - BufferUsageFlagBits::ePushDescriptorsDescriptorBufferEXT | BufferUsageFlagBits::eMicromapBuildInputReadOnlyEXT | BufferUsageFlagBits::eMicromapStorageEXT; + BufferUsageFlagBits::ePushDescriptorsDescriptorBufferEXT | BufferUsageFlagBits::eMicromapBuildInputReadOnlyEXT | + BufferUsageFlagBits::eMicromapStorageEXT | BufferUsageFlagBits::eTileMemoryQCOM; }; // wrapper class for enum VkSharingMode, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSharingMode.html @@ -2736,7 +2764,6 @@ namespace VULKAN_HPP_NAMESPACE eConcurrent = VK_SHARING_MODE_CONCURRENT }; - // wrapper class for enum VkBufferViewCreateFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferViewCreateFlagBits.html enum class BufferViewCreateFlagBits : VkBufferViewCreateFlags { }; @@ -2822,6 +2849,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkImageViewCreateFlagBits; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR ImageViewCreateFlags allFlags = ImageViewCreateFlagBits::eFragmentDensityMapDynamicEXT | ImageViewCreateFlagBits::eDescriptorBufferCaptureReplayEXT | @@ -2840,7 +2868,6 @@ namespace VULKAN_HPP_NAMESPACE eCubeArray = VK_IMAGE_VIEW_TYPE_CUBE_ARRAY }; - // wrapper class for enum VkShaderModuleCreateFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkShaderModuleCreateFlagBits.html enum class ShaderModuleCreateFlagBits : VkShaderModuleCreateFlags { }; @@ -2869,6 +2896,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkPipelineCacheCreateFlagBits; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineCacheCreateFlags allFlags = PipelineCacheCreateFlagBits::eExternallySynchronized | PipelineCacheCreateFlagBits::eInternallySynchronizedMergeKHR; @@ -2969,6 +2997,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkColorComponentFlagBits; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR ColorComponentFlags allFlags = ColorComponentFlagBits::eR | ColorComponentFlagBits::eG | ColorComponentFlagBits::eB | ColorComponentFlagBits::eA; @@ -3002,6 +3031,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkCullModeFlagBits; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR CullModeFlags allFlags = CullModeFlagBits::eNone | CullModeFlagBits::eFront | CullModeFlagBits::eBack | CullModeFlagBits::eFrontAndBack; @@ -3182,6 +3212,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkPipelineCreateFlagBits; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineCreateFlags allFlags = PipelineCreateFlagBits::eDisableOptimization | PipelineCreateFlagBits::eAllowDerivatives | PipelineCreateFlagBits::eDerivative | @@ -3220,6 +3251,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkPipelineShaderStageCreateFlagBits; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineShaderStageCreateFlags allFlags = PipelineShaderStageCreateFlagBits::eAllowVaryingSubgroupSize | PipelineShaderStageCreateFlagBits::eRequireFullSubgroups; @@ -3287,6 +3319,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkShaderStageFlagBits; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR ShaderStageFlags allFlags = ShaderStageFlagBits::eVertex | ShaderStageFlagBits::eTessellationControl | ShaderStageFlagBits::eTessellationEvaluation | ShaderStageFlagBits::eGeometry | @@ -3331,6 +3364,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkPipelineColorBlendStateCreateFlagBits; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineColorBlendStateCreateFlags allFlags = PipelineColorBlendStateCreateFlagBits::eRasterizationOrderAttachmentAccessEXT; @@ -3353,14 +3387,13 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkPipelineDepthStencilStateCreateFlagBits; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineDepthStencilStateCreateFlags allFlags = PipelineDepthStencilStateCreateFlagBits::eRasterizationOrderAttachmentDepthAccessEXT | PipelineDepthStencilStateCreateFlagBits::eRasterizationOrderAttachmentStencilAccessEXT; }; - // wrapper class for enum VkPipelineDynamicStateCreateFlagBits, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineDynamicStateCreateFlagBits.html enum class PipelineDynamicStateCreateFlagBits : VkPipelineDynamicStateCreateFlags { }; @@ -3376,8 +3409,6 @@ namespace VULKAN_HPP_NAMESPACE static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineDynamicStateCreateFlags allFlags = {}; }; - // wrapper class for enum VkPipelineInputAssemblyStateCreateFlagBits, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineInputAssemblyStateCreateFlagBits.html enum class PipelineInputAssemblyStateCreateFlagBits : VkPipelineInputAssemblyStateCreateFlags { }; @@ -3405,12 +3436,11 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkPipelineLayoutCreateFlagBits; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineLayoutCreateFlags allFlags = PipelineLayoutCreateFlagBits::eIndependentSetsEXT; }; - // wrapper class for enum VkPipelineMultisampleStateCreateFlagBits, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineMultisampleStateCreateFlagBits.html enum class PipelineMultisampleStateCreateFlagBits : VkPipelineMultisampleStateCreateFlags { }; @@ -3426,8 +3456,6 @@ namespace VULKAN_HPP_NAMESPACE static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineMultisampleStateCreateFlags allFlags = {}; }; - // wrapper class for enum VkPipelineRasterizationStateCreateFlagBits, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineRasterizationStateCreateFlagBits.html enum class PipelineRasterizationStateCreateFlagBits : VkPipelineRasterizationStateCreateFlags { }; @@ -3443,8 +3471,6 @@ namespace VULKAN_HPP_NAMESPACE static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineRasterizationStateCreateFlags allFlags = {}; }; - // wrapper class for enum VkPipelineTessellationStateCreateFlagBits, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineTessellationStateCreateFlagBits.html enum class PipelineTessellationStateCreateFlagBits : VkPipelineTessellationStateCreateFlags { }; @@ -3460,8 +3486,6 @@ namespace VULKAN_HPP_NAMESPACE static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineTessellationStateCreateFlags allFlags = {}; }; - // wrapper class for enum VkPipelineVertexInputStateCreateFlagBits, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineVertexInputStateCreateFlagBits.html enum class PipelineVertexInputStateCreateFlagBits : VkPipelineVertexInputStateCreateFlags { }; @@ -3477,8 +3501,6 @@ namespace VULKAN_HPP_NAMESPACE static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineVertexInputStateCreateFlags allFlags = {}; }; - // wrapper class for enum VkPipelineViewportStateCreateFlagBits, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineViewportStateCreateFlagBits.html enum class PipelineViewportStateCreateFlagBits : VkPipelineViewportStateCreateFlags { }; @@ -3543,6 +3565,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkSamplerCreateFlagBits; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR SamplerCreateFlags allFlags = SamplerCreateFlagBits::eSubsampledEXT | SamplerCreateFlagBits::eSubsampledCoarseReconstructionEXT | @@ -3574,6 +3597,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkDescriptorPoolCreateFlagBits; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR DescriptorPoolCreateFlags allFlags = DescriptorPoolCreateFlagBits::eFreeDescriptorSet | DescriptorPoolCreateFlagBits::eUpdateAfterBind | DescriptorPoolCreateFlagBits::eHostOnlyEXT | @@ -3603,6 +3627,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkDescriptorSetLayoutCreateFlagBits; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR DescriptorSetLayoutCreateFlags allFlags = DescriptorSetLayoutCreateFlagBits::eUpdateAfterBindPool | DescriptorSetLayoutCreateFlagBits::ePushDescriptor | @@ -3636,7 +3661,6 @@ namespace VULKAN_HPP_NAMESPACE ePartitionedAccelerationStructureNV = VK_DESCRIPTOR_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_NV }; - // wrapper class for enum VkDescriptorPoolResetFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorPoolResetFlagBits.html enum class DescriptorPoolResetFlagBits : VkDescriptorPoolResetFlags { }; @@ -3697,6 +3721,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkAccessFlagBits; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR AccessFlags allFlags = AccessFlagBits::eIndirectCommandRead | AccessFlagBits::eIndexRead | AccessFlagBits::eVertexAttributeRead | AccessFlagBits::eUniformRead | @@ -3721,6 +3746,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkAttachmentDescriptionFlagBits; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR AttachmentDescriptionFlags allFlags = AttachmentDescriptionFlagBits::eMayAlias; }; @@ -3765,6 +3791,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkDependencyFlagBits; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR DependencyFlags allFlags = DependencyFlagBits::eByRegion | DependencyFlagBits::eDeviceGroup | DependencyFlagBits::eViewLocal | DependencyFlagBits::eFeedbackLoopEXT | @@ -3784,6 +3811,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkFramebufferCreateFlagBits; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR FramebufferCreateFlags allFlags = FramebufferCreateFlagBits::eImageless; }; @@ -3813,6 +3841,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkRenderPassCreateFlagBits; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR RenderPassCreateFlags allFlags = RenderPassCreateFlagBits::eTransformQCOM; }; @@ -3840,6 +3869,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkSubpassDescriptionFlagBits; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR SubpassDescriptionFlags allFlags = SubpassDescriptionFlagBits::ePerViewAttributesNVX | SubpassDescriptionFlagBits::ePerViewPositionXOnlyNVX | @@ -3862,6 +3892,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkCommandPoolCreateFlagBits; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR CommandPoolCreateFlags allFlags = CommandPoolCreateFlagBits::eTransient | CommandPoolCreateFlagBits::eResetCommandBuffer | CommandPoolCreateFlagBits::eProtected; @@ -3879,6 +3910,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkCommandPoolResetFlagBits; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR CommandPoolResetFlags allFlags = CommandPoolResetFlagBits::eReleaseResources; }; @@ -3902,6 +3934,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkCommandBufferResetFlagBits; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR CommandBufferResetFlags allFlags = CommandBufferResetFlagBits::eReleaseResources; }; @@ -3920,6 +3953,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkCommandBufferUsageFlagBits; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR CommandBufferUsageFlags allFlags = CommandBufferUsageFlagBits::eOneTimeSubmit | CommandBufferUsageFlagBits::eRenderPassContinue | CommandBufferUsageFlagBits::eSimultaneousUse; @@ -3937,6 +3971,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkQueryControlFlagBits; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR QueryControlFlags allFlags = QueryControlFlagBits::ePrecise; }; @@ -4013,6 +4048,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkStencilFaceFlagBits; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR StencilFaceFlags allFlags = StencilFaceFlagBits::eFront | StencilFaceFlagBits::eBack | StencilFaceFlagBits::eFrontAndBack; @@ -4053,6 +4089,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkSubgroupFeatureFlagBits; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR SubgroupFeatureFlags allFlags = SubgroupFeatureFlagBits::eBasic | SubgroupFeatureFlagBits::eVote | SubgroupFeatureFlagBits::eArithmetic | SubgroupFeatureFlagBits::eBallot | @@ -4078,6 +4115,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkPeerMemoryFeatureFlagBits; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR PeerMemoryFeatureFlags allFlags = PeerMemoryFeatureFlagBits::eCopySrc | PeerMemoryFeatureFlagBits::eCopyDst | PeerMemoryFeatureFlagBits::eGenericSrc | PeerMemoryFeatureFlagBits::eGenericDst; @@ -4100,12 +4138,12 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkMemoryAllocateFlagBits; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR MemoryAllocateFlags allFlags = MemoryAllocateFlagBits::eDeviceMask | MemoryAllocateFlagBits::eDeviceAddress | MemoryAllocateFlagBits::eDeviceAddressCaptureReplay; }; - // wrapper class for enum VkCommandPoolTrimFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCommandPoolTrimFlagBits.html enum class CommandPoolTrimFlagBits : VkCommandPoolTrimFlags { }; @@ -4178,8 +4216,6 @@ namespace VULKAN_HPP_NAMESPACE using DescriptorUpdateTemplateTypeKHR = DescriptorUpdateTemplateType; - // wrapper class for enum VkDescriptorUpdateTemplateCreateFlagBits, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorUpdateTemplateCreateFlagBits.html enum class DescriptorUpdateTemplateCreateFlagBits : VkDescriptorUpdateTemplateCreateFlags { }; @@ -4237,6 +4273,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkExternalMemoryHandleTypeFlagBits; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR ExternalMemoryHandleTypeFlags allFlags = ExternalMemoryHandleTypeFlagBits::eOpaqueFd | ExternalMemoryHandleTypeFlagBits::eOpaqueWin32 | ExternalMemoryHandleTypeFlagBits::eOpaqueWin32Kmt | @@ -4276,6 +4313,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkExternalMemoryFeatureFlagBits; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR ExternalMemoryFeatureFlags allFlags = ExternalMemoryFeatureFlagBits::eDedicatedOnly | ExternalMemoryFeatureFlagBits::eExportable | ExternalMemoryFeatureFlagBits::eImportable; @@ -4300,6 +4338,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkExternalFenceHandleTypeFlagBits; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR ExternalFenceHandleTypeFlags allFlags = ExternalFenceHandleTypeFlagBits::eOpaqueFd | ExternalFenceHandleTypeFlagBits::eOpaqueWin32 | ExternalFenceHandleTypeFlagBits::eOpaqueWin32Kmt | @@ -4322,6 +4361,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkExternalFenceFeatureFlagBits; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR ExternalFenceFeatureFlags allFlags = ExternalFenceFeatureFlagBits::eExportable | ExternalFenceFeatureFlagBits::eImportable; @@ -4342,6 +4382,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkFenceImportFlagBits; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR FenceImportFlags allFlags = FenceImportFlagBits::eTemporary; }; @@ -4361,6 +4402,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkSemaphoreImportFlagBits; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR SemaphoreImportFlags allFlags = SemaphoreImportFlagBits::eTemporary; }; @@ -4390,6 +4432,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkExternalSemaphoreHandleTypeFlagBits; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR ExternalSemaphoreHandleTypeFlags allFlags = ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd | ExternalSemaphoreHandleTypeFlagBits::eOpaqueWin32 | @@ -4418,6 +4461,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkExternalSemaphoreFeatureFlagBits; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR ExternalSemaphoreFeatureFlags allFlags = ExternalSemaphoreFeatureFlagBits::eExportable | ExternalSemaphoreFeatureFlagBits::eImportable; @@ -4488,6 +4532,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkDescriptorBindingFlagBits; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR DescriptorBindingFlags allFlags = DescriptorBindingFlagBits::eUpdateAfterBind | DescriptorBindingFlagBits::eUpdateUnusedWhilePending | DescriptorBindingFlagBits::ePartiallyBound | @@ -4516,6 +4561,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkResolveModeFlagBits; 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 @@ -4560,6 +4606,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkSemaphoreWaitFlagBits; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR SemaphoreWaitFlags allFlags = SemaphoreWaitFlagBits::eAny; }; @@ -4585,6 +4632,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkPipelineCreationFeedbackFlagBits; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineCreationFeedbackFlags allFlags = PipelineCreationFeedbackFlagBits::eValid | PipelineCreationFeedbackFlagBits::eApplicationPipelineCacheHit | @@ -4612,13 +4660,13 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkToolPurposeFlagBits; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR ToolPurposeFlags allFlags = ToolPurposeFlagBits::eValidation | ToolPurposeFlagBits::eProfiling | ToolPurposeFlagBits::eTracing | ToolPurposeFlagBits::eAdditionalFeatures | ToolPurposeFlagBits::eModifyingFeatures | ToolPurposeFlagBits::eDebugReportingEXT | ToolPurposeFlagBits::eDebugMarkersEXT; }; - // wrapper class for enum VkPrivateDataSlotCreateFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPrivateDataSlotCreateFlagBits.html enum class PrivateDataSlotCreateFlagBits : VkPrivateDataSlotCreateFlags { }; @@ -4701,6 +4749,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkPipelineStageFlagBits2; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineStageFlags2 allFlags = PipelineStageFlagBits2::eNone | PipelineStageFlagBits2::eTopOfPipe | PipelineStageFlagBits2::eDrawIndirect | PipelineStageFlagBits2::eVertexInput | @@ -4783,6 +4832,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkAccessFlagBits2; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR AccessFlags2 allFlags = AccessFlagBits2::eNone | AccessFlagBits2::eIndirectCommandRead | AccessFlagBits2::eIndexRead | AccessFlagBits2::eVertexAttributeRead | @@ -4816,6 +4866,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkSubmitFlagBits; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR SubmitFlags allFlags = SubmitFlagBits::eProtected; }; @@ -4840,6 +4891,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkRenderingFlagBits; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR RenderingFlags allFlags = RenderingFlagBits::eContentsSecondaryCommandBuffers | RenderingFlagBits::eSuspending | RenderingFlagBits::eResuming | RenderingFlagBits::eEnableLegacyDitheringEXT | @@ -4909,6 +4961,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkFormatFeatureFlagBits2; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR FormatFeatureFlags2 allFlags = FormatFeatureFlagBits2::eSampledImage | FormatFeatureFlagBits2::eStorageImage | FormatFeatureFlagBits2::eStorageImageAtomic | @@ -4981,6 +5034,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkMemoryUnmapFlagBits; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR MemoryUnmapFlags allFlags = MemoryUnmapFlagBits::eReserveEXT; }; @@ -5041,6 +5095,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkPipelineCreateFlagBits2; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineCreateFlags2 allFlags = PipelineCreateFlagBits2::eDisableOptimization | PipelineCreateFlagBits2::eAllowDerivatives | PipelineCreateFlagBits2::eDerivative | @@ -5095,6 +5150,7 @@ namespace VULKAN_HPP_NAMESPACE ePushDescriptorsDescriptorBufferEXT = VK_BUFFER_USAGE_2_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT, eMicromapBuildInputReadOnlyEXT = VK_BUFFER_USAGE_2_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT, eMicromapStorageEXT = VK_BUFFER_USAGE_2_MICROMAP_STORAGE_BIT_EXT, + eTileMemoryQCOM = VK_BUFFER_USAGE_2_TILE_MEMORY_QCOM, ePreprocessBufferEXT = VK_BUFFER_USAGE_2_PREPROCESS_BUFFER_BIT_EXT }; @@ -5107,6 +5163,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkBufferUsageFlagBits2; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR BufferUsageFlags2 allFlags = BufferUsageFlagBits2::eTransferSrc | BufferUsageFlagBits2::eTransferDst | BufferUsageFlagBits2::eUniformTexelBuffer | @@ -5121,7 +5178,8 @@ namespace VULKAN_HPP_NAMESPACE BufferUsageFlagBits2::eVideoEncodeDstKHR | BufferUsageFlagBits2::eVideoEncodeSrcKHR | BufferUsageFlagBits2::eAccelerationStructureBuildInputReadOnlyKHR | BufferUsageFlagBits2::eAccelerationStructureStorageKHR | BufferUsageFlagBits2::eSamplerDescriptorBufferEXT | BufferUsageFlagBits2::eResourceDescriptorBufferEXT | BufferUsageFlagBits2::ePushDescriptorsDescriptorBufferEXT | - BufferUsageFlagBits2::eMicromapBuildInputReadOnlyEXT | BufferUsageFlagBits2::eMicromapStorageEXT | BufferUsageFlagBits2::ePreprocessBufferEXT; + BufferUsageFlagBits2::eMicromapBuildInputReadOnlyEXT | BufferUsageFlagBits2::eMicromapStorageEXT | BufferUsageFlagBits2::eTileMemoryQCOM | + BufferUsageFlagBits2::ePreprocessBufferEXT; }; // wrapper class for enum VkPipelineRobustnessBufferBehavior, see @@ -5163,6 +5221,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkHostImageCopyFlagBits; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR HostImageCopyFlags allFlags = HostImageCopyFlagBits::eMemcpy; }; @@ -5189,6 +5248,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkSurfaceTransformFlagBitsKHR; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR SurfaceTransformFlagsKHR allFlags = SurfaceTransformFlagBitsKHR::eIdentity | SurfaceTransformFlagBitsKHR::eRotate90 | SurfaceTransformFlagBitsKHR::eRotate180 | @@ -5246,6 +5306,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkCompositeAlphaFlagBitsKHR; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR CompositeAlphaFlagsKHR allFlags = CompositeAlphaFlagBitsKHR::eOpaque | CompositeAlphaFlagBitsKHR::ePreMultiplied | CompositeAlphaFlagBitsKHR::ePostMultiplied | CompositeAlphaFlagBitsKHR::eInherit; @@ -5268,6 +5329,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkSwapchainCreateFlagBitsKHR; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR SwapchainCreateFlagsKHR allFlags = SwapchainCreateFlagBitsKHR::eSplitInstanceBindRegions | SwapchainCreateFlagBitsKHR::eProtected | SwapchainCreateFlagBitsKHR::eMutableFormat | @@ -5291,6 +5353,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkDeviceGroupPresentModeFlagBitsKHR; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR DeviceGroupPresentModeFlagsKHR allFlags = DeviceGroupPresentModeFlagBitsKHR::eLocal | DeviceGroupPresentModeFlagBitsKHR::eRemote | DeviceGroupPresentModeFlagBitsKHR::eSum | @@ -5314,13 +5377,13 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkDisplayPlaneAlphaFlagBitsKHR; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR DisplayPlaneAlphaFlagsKHR allFlags = DisplayPlaneAlphaFlagBitsKHR::eOpaque | DisplayPlaneAlphaFlagBitsKHR::eGlobal | DisplayPlaneAlphaFlagBitsKHR::ePerPixel | DisplayPlaneAlphaFlagBitsKHR::ePerPixelPremultiplied; }; - // wrapper class for enum VkDisplayModeCreateFlagBitsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDisplayModeCreateFlagBitsKHR.html enum class DisplayModeCreateFlagBitsKHR : VkDisplayModeCreateFlagsKHR { }; @@ -5335,8 +5398,6 @@ namespace VULKAN_HPP_NAMESPACE static VULKAN_HPP_CONST_OR_CONSTEXPR DisplayModeCreateFlagsKHR allFlags = {}; }; - // wrapper class for enum VkDisplaySurfaceCreateFlagBitsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDisplaySurfaceCreateFlagBitsKHR.html enum class DisplaySurfaceCreateFlagBitsKHR : VkDisplaySurfaceCreateFlagsKHR { }; @@ -5354,7 +5415,6 @@ namespace VULKAN_HPP_NAMESPACE #if defined( VK_USE_PLATFORM_XLIB_KHR ) //=== VK_KHR_xlib_surface === - // wrapper class for enum VkXlibSurfaceCreateFlagBitsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkXlibSurfaceCreateFlagBitsKHR.html enum class XlibSurfaceCreateFlagBitsKHR : VkXlibSurfaceCreateFlagsKHR { }; @@ -5373,7 +5433,6 @@ namespace VULKAN_HPP_NAMESPACE #if defined( VK_USE_PLATFORM_XCB_KHR ) //=== VK_KHR_xcb_surface === - // wrapper class for enum VkXcbSurfaceCreateFlagBitsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkXcbSurfaceCreateFlagBitsKHR.html enum class XcbSurfaceCreateFlagBitsKHR : VkXcbSurfaceCreateFlagsKHR { }; @@ -5392,8 +5451,6 @@ namespace VULKAN_HPP_NAMESPACE #if defined( VK_USE_PLATFORM_WAYLAND_KHR ) //=== VK_KHR_wayland_surface === - // wrapper class for enum VkWaylandSurfaceCreateFlagBitsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkWaylandSurfaceCreateFlagBitsKHR.html enum class WaylandSurfaceCreateFlagBitsKHR : VkWaylandSurfaceCreateFlagsKHR { }; @@ -5412,8 +5469,6 @@ namespace VULKAN_HPP_NAMESPACE #if defined( VK_USE_PLATFORM_ANDROID_KHR ) //=== VK_KHR_android_surface === - // wrapper class for enum VkAndroidSurfaceCreateFlagBitsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAndroidSurfaceCreateFlagBitsKHR.html enum class AndroidSurfaceCreateFlagBitsKHR : VkAndroidSurfaceCreateFlagsKHR { }; @@ -5432,7 +5487,6 @@ namespace VULKAN_HPP_NAMESPACE #if defined( VK_USE_PLATFORM_WIN32_KHR ) //=== VK_KHR_win32_surface === - // wrapper class for enum VkWin32SurfaceCreateFlagBitsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkWin32SurfaceCreateFlagBitsKHR.html enum class Win32SurfaceCreateFlagBitsKHR : VkWin32SurfaceCreateFlagsKHR { }; @@ -5466,6 +5520,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkDebugReportFlagBitsEXT; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportFlagsEXT allFlags = DebugReportFlagBitsEXT::eInformation | DebugReportFlagBitsEXT::eWarning | DebugReportFlagBitsEXT::ePerformanceWarning | DebugReportFlagBitsEXT::eError | @@ -5556,6 +5611,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkVideoCodecOperationFlagBitsKHR; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR VideoCodecOperationFlagsKHR allFlags = VideoCodecOperationFlagBitsKHR::eNone | VideoCodecOperationFlagBitsKHR::eEncodeH264 | VideoCodecOperationFlagBitsKHR::eEncodeH265 | @@ -5581,6 +5637,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkVideoChromaSubsamplingFlagBitsKHR; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR VideoChromaSubsamplingFlagsKHR allFlags = VideoChromaSubsamplingFlagBitsKHR::eInvalid | VideoChromaSubsamplingFlagBitsKHR::eMonochrome | VideoChromaSubsamplingFlagBitsKHR::e420 | @@ -5604,6 +5661,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkVideoComponentBitDepthFlagBitsKHR; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR VideoComponentBitDepthFlagsKHR allFlags = VideoComponentBitDepthFlagBitsKHR::eInvalid | VideoComponentBitDepthFlagBitsKHR::e8 | VideoComponentBitDepthFlagBitsKHR::e10 | @@ -5623,6 +5681,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkVideoCapabilityFlagBitsKHR; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR VideoCapabilityFlagsKHR allFlags = VideoCapabilityFlagBitsKHR::eProtectedContent | VideoCapabilityFlagBitsKHR::eSeparateReferenceImages; @@ -5645,6 +5704,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkVideoSessionCreateFlagBitsKHR; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR VideoSessionCreateFlagsKHR allFlags = VideoSessionCreateFlagBitsKHR::eProtectedContent | VideoSessionCreateFlagBitsKHR::eAllowEncodeParameterOptimizations | @@ -5666,6 +5726,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkVideoCodingControlFlagBitsKHR; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR VideoCodingControlFlagsKHR allFlags = VideoCodingControlFlagBitsKHR::eReset | VideoCodingControlFlagBitsKHR::eEncodeRateControl | VideoCodingControlFlagBitsKHR::eEncodeQualityLevel; @@ -5694,11 +5755,11 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkVideoSessionParametersCreateFlagBitsKHR; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR VideoSessionParametersCreateFlagsKHR allFlags = VideoSessionParametersCreateFlagBitsKHR::eQuantizationMapCompatible; }; - // wrapper class for enum VkVideoBeginCodingFlagBitsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoBeginCodingFlagBitsKHR.html enum class VideoBeginCodingFlagBitsKHR : VkVideoBeginCodingFlagsKHR { }; @@ -5713,7 +5774,6 @@ namespace VULKAN_HPP_NAMESPACE static VULKAN_HPP_CONST_OR_CONSTEXPR VideoBeginCodingFlagsKHR allFlags = {}; }; - // wrapper class for enum VkVideoEndCodingFlagBitsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEndCodingFlagBitsKHR.html enum class VideoEndCodingFlagBitsKHR : VkVideoEndCodingFlagsKHR { }; @@ -5745,6 +5805,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkVideoDecodeCapabilityFlagBitsKHR; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR VideoDecodeCapabilityFlagsKHR allFlags = VideoDecodeCapabilityFlagBitsKHR::eDpbAndOutputCoincide | VideoDecodeCapabilityFlagBitsKHR::eDpbAndOutputDistinct; @@ -5765,12 +5826,12 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkVideoDecodeUsageFlagBitsKHR; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR VideoDecodeUsageFlagsKHR allFlags = VideoDecodeUsageFlagBitsKHR::eDefault | VideoDecodeUsageFlagBitsKHR::eTranscoding | VideoDecodeUsageFlagBitsKHR::eOffline | VideoDecodeUsageFlagBitsKHR::eStreaming; }; - // wrapper class for enum VkVideoDecodeFlagBitsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoDecodeFlagBitsKHR.html enum class VideoDecodeFlagBitsKHR : VkVideoDecodeFlagsKHR { }; @@ -5787,8 +5848,6 @@ namespace VULKAN_HPP_NAMESPACE //=== VK_EXT_transform_feedback === - // wrapper class for enum VkPipelineRasterizationStateStreamCreateFlagBitsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineRasterizationStateStreamCreateFlagBitsEXT.html enum class PipelineRasterizationStateStreamCreateFlagBitsEXT : VkPipelineRasterizationStateStreamCreateFlagsEXT { }; @@ -5829,6 +5888,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkVideoEncodeH264CapabilityFlagBitsKHR; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeH264CapabilityFlagsKHR allFlags = VideoEncodeH264CapabilityFlagBitsKHR::eHrdCompliance | VideoEncodeH264CapabilityFlagBitsKHR::ePredictionWeightTableGenerated | @@ -5869,6 +5929,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkVideoEncodeH264StdFlagBitsKHR; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeH264StdFlagsKHR allFlags = VideoEncodeH264StdFlagBitsKHR::eSeparateColorPlaneFlagSet | VideoEncodeH264StdFlagBitsKHR::eQpprimeYZeroTransformBypassFlagSet | @@ -5901,6 +5962,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkVideoEncodeH264RateControlFlagBitsKHR; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeH264RateControlFlagsKHR allFlags = VideoEncodeH264RateControlFlagBitsKHR::eAttemptHrdCompliance | VideoEncodeH264RateControlFlagBitsKHR::eRegularGop | @@ -5934,6 +5996,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkVideoEncodeH265CapabilityFlagBitsKHR; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeH265CapabilityFlagsKHR allFlags = VideoEncodeH265CapabilityFlagBitsKHR::eHrdCompliance | VideoEncodeH265CapabilityFlagBitsKHR::ePredictionWeightTableGenerated | @@ -5976,6 +6039,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkVideoEncodeH265StdFlagBitsKHR; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeH265StdFlagsKHR allFlags = VideoEncodeH265StdFlagBitsKHR::eSeparateColorPlaneFlagSet | VideoEncodeH265StdFlagBitsKHR::eSampleAdaptiveOffsetEnabledFlagSet | @@ -6007,6 +6071,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkVideoEncodeH265CtbSizeFlagBitsKHR; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeH265CtbSizeFlagsKHR allFlags = VideoEncodeH265CtbSizeFlagBitsKHR::e16 | VideoEncodeH265CtbSizeFlagBitsKHR::e32 | VideoEncodeH265CtbSizeFlagBitsKHR::e64; @@ -6029,6 +6094,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkVideoEncodeH265TransformBlockSizeFlagBitsKHR; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeH265TransformBlockSizeFlagsKHR allFlags = VideoEncodeH265TransformBlockSizeFlagBitsKHR::e4 | VideoEncodeH265TransformBlockSizeFlagBitsKHR::e8 | VideoEncodeH265TransformBlockSizeFlagBitsKHR::e16 | @@ -6053,6 +6119,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkVideoEncodeH265RateControlFlagBitsKHR; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeH265RateControlFlagsKHR allFlags = VideoEncodeH265RateControlFlagBitsKHR::eAttemptHrdCompliance | VideoEncodeH265RateControlFlagBitsKHR::eRegularGop | @@ -6078,6 +6145,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkVideoDecodeH264PictureLayoutFlagBitsKHR; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR VideoDecodeH264PictureLayoutFlagsKHR allFlags = VideoDecodeH264PictureLayoutFlagBitsKHR::eProgressive | VideoDecodeH264PictureLayoutFlagBitsKHR::eInterlacedInterleavedLines | @@ -6097,8 +6165,6 @@ namespace VULKAN_HPP_NAMESPACE #if defined( VK_USE_PLATFORM_GGP ) //=== VK_GGP_stream_descriptor_surface === - // wrapper class for enum VkStreamDescriptorSurfaceCreateFlagBitsGGP, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkStreamDescriptorSurfaceCreateFlagBitsGGP.html enum class StreamDescriptorSurfaceCreateFlagBitsGGP : VkStreamDescriptorSurfaceCreateFlagsGGP { }; @@ -6134,6 +6200,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkExternalMemoryHandleTypeFlagBitsNV; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR ExternalMemoryHandleTypeFlagsNV allFlags = ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32 | ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32Kmt | ExternalMemoryHandleTypeFlagBitsNV::eD3D11Image | @@ -6155,6 +6222,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkExternalMemoryFeatureFlagBitsNV; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR ExternalMemoryFeatureFlagsNV allFlags = ExternalMemoryFeatureFlagBitsNV::eDedicatedOnly | ExternalMemoryFeatureFlagBitsNV::eExportable | ExternalMemoryFeatureFlagBitsNV::eImportable; @@ -6172,7 +6240,6 @@ namespace VULKAN_HPP_NAMESPACE #if defined( VK_USE_PLATFORM_VI_NN ) //=== VK_NN_vi_surface === - // wrapper class for enum VkViSurfaceCreateFlagBitsNN, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkViSurfaceCreateFlagBitsNN.html enum class ViSurfaceCreateFlagBitsNN : VkViSurfaceCreateFlagsNN { }; @@ -6203,6 +6270,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkConditionalRenderingFlagBitsEXT; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR ConditionalRenderingFlagsEXT allFlags = ConditionalRenderingFlagBitsEXT::eInverted; }; @@ -6221,6 +6289,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkSurfaceCounterFlagBitsEXT; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR SurfaceCounterFlagsEXT allFlags = SurfaceCounterFlagBitsEXT::eVblank; }; @@ -6262,8 +6331,6 @@ namespace VULKAN_HPP_NAMESPACE eNegativeW = VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV }; - // wrapper class for enum VkPipelineViewportSwizzleStateCreateFlagBitsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineViewportSwizzleStateCreateFlagBitsNV.html enum class PipelineViewportSwizzleStateCreateFlagBitsNV : VkPipelineViewportSwizzleStateCreateFlagsNV { }; @@ -6288,8 +6355,6 @@ namespace VULKAN_HPP_NAMESPACE eExclusive = VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT }; - // wrapper class for enum VkPipelineDiscardRectangleStateCreateFlagBitsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineDiscardRectangleStateCreateFlagBitsEXT.html enum class PipelineDiscardRectangleStateCreateFlagBitsEXT : VkPipelineDiscardRectangleStateCreateFlagsEXT { }; @@ -6316,8 +6381,6 @@ namespace VULKAN_HPP_NAMESPACE eUnderestimate = VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT }; - // wrapper class for enum VkPipelineRasterizationConservativeStateCreateFlagBitsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineRasterizationConservativeStateCreateFlagBitsEXT.html enum class PipelineRasterizationConservativeStateCreateFlagBitsEXT : VkPipelineRasterizationConservativeStateCreateFlagsEXT { }; @@ -6335,8 +6398,6 @@ namespace VULKAN_HPP_NAMESPACE //=== VK_EXT_depth_clip_enable === - // wrapper class for enum VkPipelineRasterizationDepthClipStateCreateFlagBitsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineRasterizationDepthClipStateCreateFlagBitsEXT.html enum class PipelineRasterizationDepthClipStateCreateFlagBitsEXT : VkPipelineRasterizationDepthClipStateCreateFlagsEXT { }; @@ -6369,6 +6430,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkPerformanceCounterDescriptionFlagBitsKHR; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR PerformanceCounterDescriptionFlagsKHR allFlags = PerformanceCounterDescriptionFlagBitsKHR::ePerformanceImpacting | PerformanceCounterDescriptionFlagBitsKHR::eConcurrentlyImpacted; @@ -6412,8 +6474,6 @@ namespace VULKAN_HPP_NAMESPACE eCycles = VK_PERFORMANCE_COUNTER_UNIT_CYCLES_KHR }; - // wrapper class for enum VkAcquireProfilingLockFlagBitsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAcquireProfilingLockFlagBitsKHR.html enum class AcquireProfilingLockFlagBitsKHR : VkAcquireProfilingLockFlagsKHR { }; @@ -6431,7 +6491,6 @@ namespace VULKAN_HPP_NAMESPACE #if defined( VK_USE_PLATFORM_IOS_MVK ) //=== VK_MVK_ios_surface === - // wrapper class for enum VkIOSSurfaceCreateFlagBitsMVK, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkIOSSurfaceCreateFlagBitsMVK.html enum class IOSSurfaceCreateFlagBitsMVK : VkIOSSurfaceCreateFlagsMVK { }; @@ -6450,7 +6509,6 @@ namespace VULKAN_HPP_NAMESPACE #if defined( VK_USE_PLATFORM_MACOS_MVK ) //=== VK_MVK_macos_surface === - // wrapper class for enum VkMacOSSurfaceCreateFlagBitsMVK, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMacOSSurfaceCreateFlagBitsMVK.html enum class MacOSSurfaceCreateFlagBitsMVK : VkMacOSSurfaceCreateFlagsMVK { }; @@ -6485,6 +6543,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkDebugUtilsMessageSeverityFlagBitsEXT; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR DebugUtilsMessageSeverityFlagsEXT allFlags = DebugUtilsMessageSeverityFlagBitsEXT::eVerbose | DebugUtilsMessageSeverityFlagBitsEXT::eInfo | DebugUtilsMessageSeverityFlagBitsEXT::eWarning | @@ -6508,14 +6567,13 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkDebugUtilsMessageTypeFlagBitsEXT; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR DebugUtilsMessageTypeFlagsEXT allFlags = DebugUtilsMessageTypeFlagBitsEXT::eGeneral | DebugUtilsMessageTypeFlagBitsEXT::eValidation | DebugUtilsMessageTypeFlagBitsEXT::ePerformance | DebugUtilsMessageTypeFlagBitsEXT::eDeviceAddressBinding; }; - // wrapper class for enum VkDebugUtilsMessengerCallbackDataFlagBitsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDebugUtilsMessengerCallbackDataFlagBitsEXT.html enum class DebugUtilsMessengerCallbackDataFlagBitsEXT : VkDebugUtilsMessengerCallbackDataFlagsEXT { }; @@ -6531,8 +6589,6 @@ namespace VULKAN_HPP_NAMESPACE static VULKAN_HPP_CONST_OR_CONSTEXPR DebugUtilsMessengerCallbackDataFlagsEXT allFlags = {}; }; - // wrapper class for enum VkDebugUtilsMessengerCreateFlagBitsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDebugUtilsMessengerCreateFlagBitsEXT.html enum class DebugUtilsMessengerCreateFlagBitsEXT : VkDebugUtilsMessengerCreateFlagsEXT { }; @@ -6560,8 +6616,6 @@ namespace VULKAN_HPP_NAMESPACE //=== VK_NV_fragment_coverage_to_color === - // wrapper class for enum VkPipelineCoverageToColorStateCreateFlagBitsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCoverageToColorStateCreateFlagBitsNV.html enum class PipelineCoverageToColorStateCreateFlagBitsNV : VkPipelineCoverageToColorStateCreateFlagsNV { }; @@ -6614,6 +6668,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkGeometryFlagBitsKHR; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR GeometryFlagsKHR allFlags = GeometryFlagBitsKHR::eOpaque | GeometryFlagBitsKHR::eNoDuplicateAnyHitInvocation; }; @@ -6640,6 +6695,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkGeometryInstanceFlagBitsKHR; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR GeometryInstanceFlagsKHR allFlags = GeometryInstanceFlagBitsKHR::eTriangleFacingCullDisable | GeometryInstanceFlagBitsKHR::eTriangleFlipFacing | GeometryInstanceFlagBitsKHR::eForceOpaque | @@ -6676,6 +6732,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkBuildAccelerationStructureFlagBitsKHR; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR BuildAccelerationStructureFlagsKHR allFlags = BuildAccelerationStructureFlagBitsKHR::eAllowUpdate | BuildAccelerationStructureFlagBitsKHR::eAllowCompaction | @@ -6737,6 +6794,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkAccelerationStructureCreateFlagBitsKHR; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR AccelerationStructureCreateFlagsKHR allFlags = AccelerationStructureCreateFlagBitsKHR::eDeviceAddressCaptureReplay | AccelerationStructureCreateFlagBitsKHR::eDescriptorBufferCaptureReplayEXT | @@ -6783,8 +6841,6 @@ namespace VULKAN_HPP_NAMESPACE eRgba = VK_COVERAGE_MODULATION_MODE_RGBA_NV }; - // wrapper class for enum VkPipelineCoverageModulationStateCreateFlagBitsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCoverageModulationStateCreateFlagBitsNV.html enum class PipelineCoverageModulationStateCreateFlagBitsNV : VkPipelineCoverageModulationStateCreateFlagsNV { }; @@ -6809,8 +6865,6 @@ namespace VULKAN_HPP_NAMESPACE eOne = VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT }; - // wrapper class for enum VkValidationCacheCreateFlagBitsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkValidationCacheCreateFlagBitsEXT.html enum class ValidationCacheCreateFlagBitsEXT : VkValidationCacheCreateFlagsEXT { }; @@ -6867,8 +6921,6 @@ namespace VULKAN_HPP_NAMESPACE //=== VK_AMD_pipeline_compiler_control === - // wrapper class for enum VkPipelineCompilerControlFlagBitsAMD, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCompilerControlFlagBitsAMD.html enum class PipelineCompilerControlFlagBitsAMD : VkPipelineCompilerControlFlagsAMD { }; @@ -6937,8 +6989,6 @@ namespace VULKAN_HPP_NAMESPACE #if defined( VK_USE_PLATFORM_FUCHSIA ) //=== VK_FUCHSIA_imagepipe_surface === - // wrapper class for enum VkImagePipeSurfaceCreateFlagBitsFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkImagePipeSurfaceCreateFlagBitsFUCHSIA.html enum class ImagePipeSurfaceCreateFlagBitsFUCHSIA : VkImagePipeSurfaceCreateFlagsFUCHSIA { }; @@ -6958,7 +7008,6 @@ namespace VULKAN_HPP_NAMESPACE #if defined( VK_USE_PLATFORM_METAL_EXT ) //=== VK_EXT_metal_surface === - // wrapper class for enum VkMetalSurfaceCreateFlagBitsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMetalSurfaceCreateFlagBitsEXT.html enum class MetalSurfaceCreateFlagBitsEXT : VkMetalSurfaceCreateFlagsEXT { }; @@ -6989,8 +7038,6 @@ namespace VULKAN_HPP_NAMESPACE //=== VK_AMD_shader_core_properties2 === - // wrapper class for enum VkShaderCorePropertiesFlagBitsAMD, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkShaderCorePropertiesFlagBitsAMD.html enum class ShaderCorePropertiesFlagBitsAMD : VkShaderCorePropertiesFlagsAMD { }; @@ -7039,8 +7086,6 @@ namespace VULKAN_HPP_NAMESPACE eTruncate = VK_COVERAGE_REDUCTION_MODE_TRUNCATE_NV }; - // wrapper class for enum VkPipelineCoverageReductionStateCreateFlagBitsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCoverageReductionStateCreateFlagBitsNV.html enum class PipelineCoverageReductionStateCreateFlagBitsNV : VkPipelineCoverageReductionStateCreateFlagsNV { }; @@ -7081,8 +7126,6 @@ namespace VULKAN_HPP_NAMESPACE //=== VK_EXT_headless_surface === - // wrapper class for enum VkHeadlessSurfaceCreateFlagBitsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkHeadlessSurfaceCreateFlagBitsEXT.html enum class HeadlessSurfaceCreateFlagBitsEXT : VkHeadlessSurfaceCreateFlagsEXT { }; @@ -7126,6 +7169,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkPresentScalingFlagBitsEXT; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR PresentScalingFlagsEXT allFlags = PresentScalingFlagBitsEXT::eOneToOne | PresentScalingFlagBitsEXT::eAspectRatioStretch | PresentScalingFlagBitsEXT::eStretch; @@ -7145,6 +7189,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkPresentGravityFlagBitsEXT; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR PresentGravityFlagsEXT allFlags = PresentGravityFlagBitsEXT::eMin | PresentGravityFlagBitsEXT::eMax | PresentGravityFlagBitsEXT::eCentered; @@ -7164,6 +7209,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkIndirectStateFlagBitsNV; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR IndirectStateFlagsNV allFlags = IndirectStateFlagBitsNV::eFlagFrontface; }; @@ -7200,6 +7246,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkIndirectCommandsLayoutUsageFlagBitsNV; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR IndirectCommandsLayoutUsageFlagsNV allFlags = IndirectCommandsLayoutUsageFlagBitsNV::eExplicitPreprocess | IndirectCommandsLayoutUsageFlagBitsNV::eIndexedSequences | @@ -7229,7 +7276,6 @@ namespace VULKAN_HPP_NAMESPACE eAllocationFailed = VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATION_FAILED_EXT }; - // wrapper class for enum VkDeviceMemoryReportFlagBitsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceMemoryReportFlagBitsEXT.html enum class DeviceMemoryReportFlagBitsEXT : VkDeviceMemoryReportFlagsEXT { }; @@ -7263,6 +7309,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkVideoEncodeCapabilityFlagBitsKHR; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeCapabilityFlagsKHR allFlags = VideoEncodeCapabilityFlagBitsKHR::ePrecedingExternallyEncodedBytes | VideoEncodeCapabilityFlagBitsKHR::eInsufficientBitstreamBufferRangeDetection | @@ -7284,6 +7331,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkVideoEncodeFeedbackFlagBitsKHR; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeFeedbackFlagsKHR allFlags = VideoEncodeFeedbackFlagBitsKHR::eBitstreamBufferOffset | VideoEncodeFeedbackFlagBitsKHR::eBitstreamBytesWritten | @@ -7306,6 +7354,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkVideoEncodeUsageFlagBitsKHR; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeUsageFlagsKHR allFlags = VideoEncodeUsageFlagBitsKHR::eDefault | VideoEncodeUsageFlagBitsKHR::eTranscoding | VideoEncodeUsageFlagBitsKHR::eStreaming | VideoEncodeUsageFlagBitsKHR::eRecording | @@ -7327,6 +7376,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkVideoEncodeContentFlagBitsKHR; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeContentFlagsKHR allFlags = VideoEncodeContentFlagBitsKHR::eDefault | VideoEncodeContentFlagBitsKHR::eCamera | VideoEncodeContentFlagBitsKHR::eDesktop | @@ -7360,6 +7410,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkVideoEncodeRateControlModeFlagBitsKHR; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeRateControlModeFlagsKHR allFlags = VideoEncodeRateControlModeFlagBitsKHR::eDefault | VideoEncodeRateControlModeFlagBitsKHR::eDisabled | VideoEncodeRateControlModeFlagBitsKHR::eCbr | @@ -7379,13 +7430,12 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkVideoEncodeFlagBitsKHR; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeFlagsKHR allFlags = VideoEncodeFlagBitsKHR::eWithQuantizationDeltaMap | VideoEncodeFlagBitsKHR::eWithEmphasisMap; }; - // wrapper class for enum VkVideoEncodeRateControlFlagBitsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeRateControlFlagBitsKHR.html enum class VideoEncodeRateControlFlagBitsKHR : VkVideoEncodeRateControlFlagsKHR { }; @@ -7420,6 +7470,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkDeviceDiagnosticsConfigFlagBitsNV; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR DeviceDiagnosticsConfigFlagsNV allFlags = DeviceDiagnosticsConfigFlagBitsNV::eEnableShaderDebugInfo | DeviceDiagnosticsConfigFlagBitsNV::eEnableResourceTracking | @@ -7443,6 +7494,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkTileShadingRenderPassFlagBitsQCOM; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR TileShadingRenderPassFlagsQCOM allFlags = TileShadingRenderPassFlagBitsQCOM::eEnable | TileShadingRenderPassFlagBitsQCOM::ePerTileExecution; @@ -7470,6 +7522,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkExportMetalObjectTypeFlagBitsEXT; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR ExportMetalObjectTypeFlagsEXT allFlags = ExportMetalObjectTypeFlagBitsEXT::eMetalDevice | ExportMetalObjectTypeFlagBitsEXT::eMetalCommandQueue | ExportMetalObjectTypeFlagBitsEXT::eMetalBuffer | @@ -7496,6 +7549,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkGraphicsPipelineLibraryFlagBitsEXT; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR GraphicsPipelineLibraryFlagsEXT allFlags = GraphicsPipelineLibraryFlagBitsEXT::eVertexInputInterface | GraphicsPipelineLibraryFlagBitsEXT::ePreRasterizationShaders | @@ -7539,8 +7593,6 @@ namespace VULKAN_HPP_NAMESPACE eSrtMotion = VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_SRT_MOTION_NV }; - // wrapper class for enum VkAccelerationStructureMotionInfoFlagBitsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureMotionInfoFlagBitsNV.html enum class AccelerationStructureMotionInfoFlagBitsNV : VkAccelerationStructureMotionInfoFlagsNV { }; @@ -7556,8 +7608,6 @@ namespace VULKAN_HPP_NAMESPACE static VULKAN_HPP_CONST_OR_CONSTEXPR AccelerationStructureMotionInfoFlagsNV allFlags = {}; }; - // wrapper class for enum VkAccelerationStructureMotionInstanceFlagBitsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureMotionInstanceFlagBitsNV.html enum class AccelerationStructureMotionInstanceFlagBitsNV : VkAccelerationStructureMotionInstanceFlagsNV { }; @@ -7590,6 +7640,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkImageCompressionFlagBitsEXT; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR ImageCompressionFlagsEXT allFlags = ImageCompressionFlagBitsEXT::eDefault | ImageCompressionFlagBitsEXT::eFixedRateDefault | ImageCompressionFlagBitsEXT::eFixedRateExplicit | @@ -7634,6 +7685,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkImageCompressionFixedRateFlagBitsEXT; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR ImageCompressionFixedRateFlagsEXT allFlags = ImageCompressionFixedRateFlagBitsEXT::eNone | ImageCompressionFixedRateFlagBitsEXT::e1Bpc | ImageCompressionFixedRateFlagBitsEXT::e2Bpc | @@ -7671,8 +7723,6 @@ namespace VULKAN_HPP_NAMESPACE #if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) //=== VK_EXT_directfb_surface === - // wrapper class for enum VkDirectFBSurfaceCreateFlagBitsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDirectFBSurfaceCreateFlagBitsEXT.html enum class DirectFBSurfaceCreateFlagBitsEXT : VkDirectFBSurfaceCreateFlagsEXT { }; @@ -7704,6 +7754,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkDeviceAddressBindingFlagBitsEXT; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR DeviceAddressBindingFlagsEXT allFlags = DeviceAddressBindingFlagBitsEXT::eInternalObject; }; @@ -7736,6 +7787,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkImageConstraintsInfoFlagBitsFUCHSIA; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR ImageConstraintsInfoFlagsFUCHSIA allFlags = ImageConstraintsInfoFlagBitsFUCHSIA::eCpuReadRarely | ImageConstraintsInfoFlagBitsFUCHSIA::eCpuReadOften | @@ -7743,8 +7795,6 @@ namespace VULKAN_HPP_NAMESPACE ImageConstraintsInfoFlagBitsFUCHSIA::eProtectedOptional; }; - // wrapper class for enum VkImageFormatConstraintsFlagBitsFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageFormatConstraintsFlagBitsFUCHSIA.html enum class ImageFormatConstraintsFlagBitsFUCHSIA : VkImageFormatConstraintsFlagsFUCHSIA { }; @@ -7775,6 +7825,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkFrameBoundaryFlagBitsEXT; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR FrameBoundaryFlagsEXT allFlags = FrameBoundaryFlagBitsEXT::eFrameEnd; }; @@ -7782,8 +7833,6 @@ namespace VULKAN_HPP_NAMESPACE #if defined( VK_USE_PLATFORM_SCREEN_QNX ) //=== VK_QNX_screen_surface === - // wrapper class for enum VkScreenSurfaceCreateFlagBitsQNX, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkScreenSurfaceCreateFlagBitsQNX.html enum class ScreenSurfaceCreateFlagBitsQNX : VkScreenSurfaceCreateFlagsQNX { }; @@ -7824,6 +7873,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkBuildMicromapFlagBitsEXT; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR BuildMicromapFlagsEXT allFlags = BuildMicromapFlagBitsEXT::ePreferFastTrace | BuildMicromapFlagBitsEXT::ePreferFastBuild | BuildMicromapFlagBitsEXT::eAllowCompaction; @@ -7850,6 +7900,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkMicromapCreateFlagBitsEXT; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR MicromapCreateFlagsEXT allFlags = MicromapCreateFlagBitsEXT::eDeviceAddressCaptureReplay; }; @@ -7907,6 +7958,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkPhysicalDeviceSchedulingControlsFlagBitsARM; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR PhysicalDeviceSchedulingControlsFlagsARM allFlags = PhysicalDeviceSchedulingControlsFlagBitsARM::eShaderCoreCount; }; @@ -7927,6 +7979,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkMemoryDecompressionMethodFlagBitsNV; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR MemoryDecompressionMethodFlagsNV allFlags = MemoryDecompressionMethodFlagBitsNV::eGdeflate10; }; @@ -7978,8 +8031,6 @@ namespace VULKAN_HPP_NAMESPACE eInclusive = VK_DIRECT_DRIVER_LOADING_MODE_INCLUSIVE_LUNARG }; - // wrapper class for enum VkDirectDriverLoadingFlagBitsLUNARG, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDirectDriverLoadingFlagBitsLUNARG.html enum class DirectDriverLoadingFlagBitsLUNARG : VkDirectDriverLoadingFlagsLUNARG { }; @@ -8014,6 +8065,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkOpticalFlowUsageFlagBitsNV; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR OpticalFlowUsageFlagsNV allFlags = OpticalFlowUsageFlagBitsNV::eUnknown | OpticalFlowUsageFlagBitsNV::eInput | OpticalFlowUsageFlagBitsNV::eOutput | OpticalFlowUsageFlagBitsNV::eHint | @@ -8036,6 +8088,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkOpticalFlowGridSizeFlagBitsNV; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR OpticalFlowGridSizeFlagsNV allFlags = OpticalFlowGridSizeFlagBitsNV::eUnknown | OpticalFlowGridSizeFlagBitsNV::e1X1 | OpticalFlowGridSizeFlagBitsNV::e2X2 | OpticalFlowGridSizeFlagBitsNV::e4X4 | @@ -8084,6 +8137,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkOpticalFlowSessionCreateFlagBitsNV; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR OpticalFlowSessionCreateFlagsNV allFlags = OpticalFlowSessionCreateFlagBitsNV::eEnableHint | OpticalFlowSessionCreateFlagBitsNV::eEnableCost | @@ -8103,6 +8157,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkOpticalFlowExecuteFlagBitsNV; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR OpticalFlowExecuteFlagsNV allFlags = OpticalFlowExecuteFlagBitsNV::eDisableTemporalHints; }; @@ -8145,6 +8200,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkShaderCreateFlagBitsEXT; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR ShaderCreateFlagsEXT allFlags = ShaderCreateFlagBitsEXT::eLinkStage | ShaderCreateFlagBitsEXT::eAllowVaryingSubgroupSize | ShaderCreateFlagBitsEXT::eRequireFullSubgroups | @@ -8366,6 +8422,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkVideoEncodeAV1CapabilityFlagBitsKHR; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeAV1CapabilityFlagsKHR allFlags = VideoEncodeAV1CapabilityFlagBitsKHR::ePerRateControlGroupMinMaxQIndex | VideoEncodeAV1CapabilityFlagBitsKHR::eGenerateObuExtensionHeader | @@ -8388,6 +8445,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkVideoEncodeAV1StdFlagBitsKHR; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeAV1StdFlagsKHR allFlags = VideoEncodeAV1StdFlagBitsKHR::eUniformTileSpacingFlagSet | VideoEncodeAV1StdFlagBitsKHR::eSkipModePresentUnset | @@ -8409,6 +8467,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkVideoEncodeAV1SuperblockSizeFlagBitsKHR; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeAV1SuperblockSizeFlagsKHR allFlags = VideoEncodeAV1SuperblockSizeFlagBitsKHR::e64 | VideoEncodeAV1SuperblockSizeFlagBitsKHR::e128; @@ -8431,6 +8490,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkVideoEncodeAV1RateControlFlagBitsKHR; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeAV1RateControlFlagsKHR allFlags = VideoEncodeAV1RateControlFlagBitsKHR::eRegularGop | VideoEncodeAV1RateControlFlagBitsKHR::eTemporalLayerPatternDyadic | @@ -8520,6 +8580,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkClusterAccelerationStructureClusterFlagBitsNV; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR ClusterAccelerationStructureClusterFlagsNV allFlags = ClusterAccelerationStructureClusterFlagBitsNV::eAllowDisableOpacityMicromaps; @@ -8541,6 +8602,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkClusterAccelerationStructureGeometryFlagBitsNV; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR ClusterAccelerationStructureGeometryFlagsNV allFlags = ClusterAccelerationStructureGeometryFlagBitsNV::eCullDisable | ClusterAccelerationStructureGeometryFlagBitsNV::eNoDuplicateAnyhitInvocation | @@ -8566,6 +8628,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkClusterAccelerationStructureAddressResolutionFlagBitsNV; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR ClusterAccelerationStructureAddressResolutionFlagsNV allFlags = ClusterAccelerationStructureAddressResolutionFlagBitsNV::eIndirectedDstImplicitData | @@ -8592,6 +8655,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkClusterAccelerationStructureIndexFormatFlagBitsNV; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR ClusterAccelerationStructureIndexFormatFlagsNV allFlags = ClusterAccelerationStructureIndexFormatFlagBitsNV::e8 | ClusterAccelerationStructureIndexFormatFlagBitsNV::e16 | @@ -8656,6 +8720,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkPartitionedAccelerationStructureInstanceFlagBitsNV; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR PartitionedAccelerationStructureInstanceFlagsNV allFlags = PartitionedAccelerationStructureInstanceFlagBitsNV::eFlagTriangleFacingCullDisable | @@ -8709,6 +8774,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkIndirectCommandsLayoutUsageFlagBitsEXT; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR IndirectCommandsLayoutUsageFlagsEXT allFlags = IndirectCommandsLayoutUsageFlagBitsEXT::eExplicitPreprocess | IndirectCommandsLayoutUsageFlagBitsEXT::eUnorderedSequences; @@ -8729,6 +8795,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkIndirectCommandsInputModeFlagBitsEXT; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR IndirectCommandsInputModeFlagsEXT allFlags = IndirectCommandsInputModeFlagBitsEXT::eVulkanIndexBuffer | IndirectCommandsInputModeFlagBitsEXT::eDxgiIndexBuffer; @@ -8748,6 +8815,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct FlagTraits { + using WrappedType = VkAccessFlagBits3KHR; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR AccessFlags3KHR allFlags = AccessFlagBits3KHR::eNone; }; diff --git a/third_party/vulkan/vulkan_extension_inspection.hpp b/third_party/vulkan/vulkan_extension_inspection.hpp index dc82470..2f901e9 100644 --- a/third_party/vulkan/vulkan_extension_inspection.hpp +++ b/third_party/vulkan/vulkan_extension_inspection.hpp @@ -69,7 +69,10 @@ namespace VULKAN_HPP_NAMESPACE { "VK_AMD_gpu_shader_int16", "VK_KHR_shader_float16_int8" }, { "VK_NV_ray_tracing", "VK_KHR_ray_tracing_pipeline" }, { "VK_EXT_buffer_device_address", "VK_KHR_buffer_device_address" }, - { "VK_EXT_validation_features", "VK_EXT_layer_settings" } + { "VK_EXT_validation_features", "VK_EXT_layer_settings" }, +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + { "VK_NV_displacement_micromap", "VK_NV_cluster_acceleration_structure" } +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ }; return deprecatedExtensions; } @@ -449,6 +452,7 @@ namespace VULKAN_HPP_NAMESPACE "VK_KHR_shader_expect_assume", "VK_KHR_maintenance6", "VK_NV_descriptor_pool_overallocation", + "VK_QCOM_tile_memory_heap", "VK_KHR_video_encode_quantization_map", "VK_NV_raw_access_chains", "VK_NV_external_compute_queue", @@ -2470,6 +2474,13 @@ namespace VULKAN_HPP_NAMESPACE { "VK_VERSION_1_1", { {} } } } }, { "VK_KHR_maintenance6", { { "VK_VERSION_1_1", { {} } } } }, { "VK_NV_descriptor_pool_overallocation", { { "VK_VERSION_1_1", { {} } } } }, + { "VK_QCOM_tile_memory_heap", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_memory_requirements2", + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, { "VK_NV_display_stereo", { { "VK_VERSION_1_0", { { @@ -2818,6 +2829,13 @@ namespace VULKAN_HPP_NAMESPACE { return "VK_EXT_layer_settings"; } +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + if ( extension == "VK_NV_displacement_micromap" ) + { + return "VK_NV_cluster_acceleration_structure"; + } +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + return ""; } @@ -3261,7 +3279,11 @@ namespace VULKAN_HPP_NAMESPACE ( extension == "VK_MVK_macos_surface" ) || #endif /*VK_USE_PLATFORM_MACOS_MVK*/ ( extension == "VK_AMD_gpu_shader_int16" ) || ( extension == "VK_NV_ray_tracing" ) || ( extension == "VK_EXT_buffer_device_address" ) || - ( extension == "VK_EXT_validation_features" ); + ( extension == "VK_EXT_validation_features" ) || +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + ( extension == "VK_NV_displacement_micromap" ) || +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + false; } VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 bool isDeviceExtension( std::string const & extension ) @@ -3456,14 +3478,14 @@ namespace VULKAN_HPP_NAMESPACE #endif /*VK_USE_PLATFORM_SCREEN_QNX*/ || ( extension == "VK_MSFT_layered_driver" ) || ( extension == "VK_KHR_index_type_uint8" ) || ( extension == "VK_KHR_line_rasterization" ) || ( extension == "VK_KHR_calibrated_timestamps" ) || ( extension == "VK_KHR_shader_expect_assume" ) || ( extension == "VK_KHR_maintenance6" ) || - ( extension == "VK_NV_descriptor_pool_overallocation" ) || ( extension == "VK_KHR_video_encode_quantization_map" ) || - ( extension == "VK_NV_raw_access_chains" ) || ( extension == "VK_NV_external_compute_queue" ) || - ( extension == "VK_KHR_shader_relaxed_extended_instruction" ) || ( extension == "VK_NV_command_buffer_inheritance" ) || - ( extension == "VK_KHR_maintenance7" ) || ( extension == "VK_NV_shader_atomic_float16_vector" ) || - ( extension == "VK_EXT_shader_replicated_composites" ) || ( extension == "VK_NV_ray_tracing_validation" ) || - ( extension == "VK_NV_cluster_acceleration_structure" ) || ( extension == "VK_NV_partitioned_acceleration_structure" ) || - ( extension == "VK_EXT_device_generated_commands" ) || ( extension == "VK_KHR_maintenance8" ) || - ( extension == "VK_MESA_image_alignment_control" ) || ( extension == "VK_EXT_depth_clamp_control" ) || + ( extension == "VK_NV_descriptor_pool_overallocation" ) || ( extension == "VK_QCOM_tile_memory_heap" ) || + ( extension == "VK_KHR_video_encode_quantization_map" ) || ( extension == "VK_NV_raw_access_chains" ) || + ( extension == "VK_NV_external_compute_queue" ) || ( extension == "VK_KHR_shader_relaxed_extended_instruction" ) || + ( extension == "VK_NV_command_buffer_inheritance" ) || ( extension == "VK_KHR_maintenance7" ) || + ( extension == "VK_NV_shader_atomic_float16_vector" ) || ( extension == "VK_EXT_shader_replicated_composites" ) || + ( extension == "VK_NV_ray_tracing_validation" ) || ( extension == "VK_NV_cluster_acceleration_structure" ) || + ( extension == "VK_NV_partitioned_acceleration_structure" ) || ( extension == "VK_EXT_device_generated_commands" ) || + ( extension == "VK_KHR_maintenance8" ) || ( extension == "VK_MESA_image_alignment_control" ) || ( extension == "VK_EXT_depth_clamp_control" ) || ( extension == "VK_KHR_video_maintenance2" ) || ( extension == "VK_HUAWEI_hdr_vivid" ) || ( extension == "VK_NV_cooperative_matrix2" ) || ( extension == "VK_ARM_pipeline_opacity_micromap" ) #if defined( VK_USE_PLATFORM_METAL_EXT ) diff --git a/third_party/vulkan/vulkan_funcs.hpp b/third_party/vulkan/vulkan_funcs.hpp index bc34c7f..e033d3b 100644 --- a/third_party/vulkan/vulkan_funcs.hpp +++ b/third_party/vulkan/vulkan_funcs.hpp @@ -30777,6 +30777,34 @@ namespace VULKAN_HPP_NAMESPACE } #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + //=== VK_QCOM_tile_memory_heap === + + // wrapper function for command vkCmdBindTileMemoryQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindTileMemoryQCOM.html + template + VULKAN_HPP_INLINE void CommandBuffer::bindTileMemoryQCOM( const VULKAN_HPP_NAMESPACE::TileMemoryBindInfoQCOM * pTileMemoryBindInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdBindTileMemoryQCOM( static_cast( m_commandBuffer ), reinterpret_cast( pTileMemoryBindInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBindTileMemoryQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindTileMemoryQCOM.html + template + VULKAN_HPP_INLINE void CommandBuffer::bindTileMemoryQCOM( Optional tileMemoryBindInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdBindTileMemoryQCOM && "Function requires " ); +# endif + + d.vkCmdBindTileMemoryQCOM( + m_commandBuffer, + reinterpret_cast( static_cast( tileMemoryBindInfo ) ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + //=== VK_NV_external_compute_queue === // wrapper function for command vkCreateExternalComputeQueueNV, see diff --git a/third_party/vulkan/vulkan_handles.hpp b/third_party/vulkan/vulkan_handles.hpp index 880948d..a08b8bb 100644 --- a/third_party/vulkan/vulkan_handles.hpp +++ b/third_party/vulkan/vulkan_handles.hpp @@ -1904,6 +1904,13 @@ namespace VULKAN_HPP_NAMESPACE //=== VK_NV_descriptor_pool_overallocation === struct PhysicalDeviceDescriptorPoolOverallocationFeaturesNV; + //=== VK_QCOM_tile_memory_heap === + struct PhysicalDeviceTileMemoryHeapFeaturesQCOM; + struct PhysicalDeviceTileMemoryHeapPropertiesQCOM; + struct TileMemoryRequirementsQCOM; + struct TileMemoryBindInfoQCOM; + struct TileMemorySizeInfoQCOM; + //=== VK_NV_display_stereo === struct DisplaySurfaceStereoCreateInfoNV; struct DisplayModeStereoPropertiesNV; @@ -7801,6 +7808,19 @@ namespace VULKAN_HPP_NAMESPACE Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + //=== VK_QCOM_tile_memory_heap === + + // wrapper function for command vkCmdBindTileMemoryQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindTileMemoryQCOM.html + template + void bindTileMemoryQCOM( const VULKAN_HPP_NAMESPACE::TileMemoryBindInfoQCOM * pTileMemoryBindInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBindTileMemoryQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindTileMemoryQCOM.html + template + void bindTileMemoryQCOM( Optional tileMemoryBindInfo VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + //=== VK_NV_cluster_acceleration_structure === // wrapper function for command vkCmdBuildClusterAccelerationStructureIndirectNV, see diff --git a/third_party/vulkan/vulkan_hash.hpp b/third_party/vulkan/vulkan_hash.hpp index 0b23f6a..ff23902 100644 --- a/third_party/vulkan/vulkan_hash.hpp +++ b/third_party/vulkan/vulkan_hash.hpp @@ -13283,6 +13283,35 @@ namespace std } }; + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTileMemoryHeapFeaturesQCOM const & physicalDeviceTileMemoryHeapFeaturesQCOM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileMemoryHeapFeaturesQCOM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileMemoryHeapFeaturesQCOM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileMemoryHeapFeaturesQCOM.tileMemoryHeap ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTileMemoryHeapPropertiesQCOM const & physicalDeviceTileMemoryHeapPropertiesQCOM ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileMemoryHeapPropertiesQCOM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileMemoryHeapPropertiesQCOM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileMemoryHeapPropertiesQCOM.queueSubmitBoundary ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileMemoryHeapPropertiesQCOM.tileBufferTransfers ); + return seed; + } + }; + template <> struct hash { @@ -17013,6 +17042,46 @@ namespace std } }; + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::TileMemoryBindInfoQCOM const & tileMemoryBindInfoQCOM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, tileMemoryBindInfoQCOM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, tileMemoryBindInfoQCOM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, tileMemoryBindInfoQCOM.memory ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::TileMemoryRequirementsQCOM const & tileMemoryRequirementsQCOM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, tileMemoryRequirementsQCOM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, tileMemoryRequirementsQCOM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, tileMemoryRequirementsQCOM.size ); + VULKAN_HPP_HASH_COMBINE( seed, tileMemoryRequirementsQCOM.alignment ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::TileMemorySizeInfoQCOM const & tileMemorySizeInfoQCOM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, tileMemorySizeInfoQCOM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, tileMemorySizeInfoQCOM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, tileMemorySizeInfoQCOM.size ); + return seed; + } + }; + template <> struct hash { diff --git a/third_party/vulkan/vulkan_hpp_macros.hpp b/third_party/vulkan/vulkan_hpp_macros.hpp index a218f72..eb7869b 100644 --- a/third_party/vulkan/vulkan_hpp_macros.hpp +++ b/third_party/vulkan/vulkan_hpp_macros.hpp @@ -79,11 +79,11 @@ # define __has_include( x ) false #endif -#if ( 201907 <= __cpp_lib_three_way_comparison ) && __has_include( ) && !defined( VULKAN_HPP_NO_SPACESHIP_OPERATOR ) +#if defined( __cpp_lib_three_way_comparison ) && ( 201907 <= __cpp_lib_three_way_comparison ) && __has_include( ) && !defined( VULKAN_HPP_NO_SPACESHIP_OPERATOR ) # define VULKAN_HPP_HAS_SPACESHIP_OPERATOR #endif -#if ( 201803 <= __cpp_lib_span ) +#if defined( __cpp_lib_span ) && ( 201803 <= __cpp_lib_span ) # define VULKAN_HPP_SUPPORT_SPAN #endif diff --git a/third_party/vulkan/vulkan_raii.hpp b/third_party/vulkan/vulkan_raii.hpp index 8b57e77..8fdaa85 100644 --- a/third_party/vulkan/vulkan_raii.hpp +++ b/third_party/vulkan/vulkan_raii.hpp @@ -1817,6 +1817,9 @@ namespace VULKAN_HPP_NAMESPACE vkCmdBindDescriptorBufferEmbeddedSamplers2EXT = PFN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT( vkGetDeviceProcAddr( device, "vkCmdBindDescriptorBufferEmbeddedSamplers2EXT" ) ); + //=== VK_QCOM_tile_memory_heap === + vkCmdBindTileMemoryQCOM = PFN_vkCmdBindTileMemoryQCOM( vkGetDeviceProcAddr( device, "vkCmdBindTileMemoryQCOM" ) ); + //=== VK_NV_external_compute_queue === vkCreateExternalComputeQueueNV = PFN_vkCreateExternalComputeQueueNV( vkGetDeviceProcAddr( device, "vkCreateExternalComputeQueueNV" ) ); vkDestroyExternalComputeQueueNV = PFN_vkDestroyExternalComputeQueueNV( vkGetDeviceProcAddr( device, "vkDestroyExternalComputeQueueNV" ) ); @@ -2781,6 +2784,9 @@ namespace VULKAN_HPP_NAMESPACE PFN_vkCmdSetDescriptorBufferOffsets2EXT vkCmdSetDescriptorBufferOffsets2EXT = 0; PFN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT vkCmdBindDescriptorBufferEmbeddedSamplers2EXT = 0; + //=== VK_QCOM_tile_memory_heap === + PFN_vkCmdBindTileMemoryQCOM vkCmdBindTileMemoryQCOM = 0; + //=== VK_NV_external_compute_queue === PFN_vkCreateExternalComputeQueueNV vkCreateExternalComputeQueueNV = 0; PFN_vkDestroyExternalComputeQueueNV vkDestroyExternalComputeQueueNV = 0; @@ -7879,6 +7885,12 @@ namespace VULKAN_HPP_NAMESPACE void bindDescriptorBufferEmbeddedSamplers2EXT( const VULKAN_HPP_NAMESPACE::BindDescriptorBufferEmbeddedSamplersInfoEXT & bindDescriptorBufferEmbeddedSamplersInfo ) const VULKAN_HPP_NOEXCEPT; + //=== VK_QCOM_tile_memory_heap === + + // wrapper function for command vkCmdBindTileMemoryQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindTileMemoryQCOM.html + void bindTileMemoryQCOM( Optional tileMemoryBindInfo + VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + //=== VK_NV_cluster_acceleration_structure === // wrapper function for command vkCmdBuildClusterAccelerationStructureIndirectNV, see @@ -27170,6 +27182,19 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &bindDescriptorBufferEmbeddedSamplersInfo ) ); } + //=== VK_QCOM_tile_memory_heap === + + // wrapper function for command vkCmdBindTileMemoryQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindTileMemoryQCOM.html + VULKAN_HPP_INLINE void + CommandBuffer::bindTileMemoryQCOM( Optional tileMemoryBindInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindTileMemoryQCOM && "Function requires " ); + + getDispatcher()->vkCmdBindTileMemoryQCOM( + static_cast( m_commandBuffer ), + reinterpret_cast( static_cast( tileMemoryBindInfo ) ) ); + } + //=== VK_NV_external_compute_queue === // wrapper function for command vkCreateExternalComputeQueueNV, see diff --git a/third_party/vulkan/vulkan_static_assertions.hpp b/third_party/vulkan/vulkan_static_assertions.hpp index bec94a3..ebfc9bf 100644 --- a/third_party/vulkan/vulkan_static_assertions.hpp +++ b/third_party/vulkan/vulkan_static_assertions.hpp @@ -7803,6 +7803,40 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "PhysicalDeviceDescriptorPoolOverallocationFeaturesNV is not nothrow_move_constructible!" ); +//=== VK_QCOM_tile_memory_heap === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceTileMemoryHeapFeaturesQCOM ) == sizeof( VkPhysicalDeviceTileMemoryHeapFeaturesQCOM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceTileMemoryHeapFeaturesQCOM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceTileMemoryHeapPropertiesQCOM ) == sizeof( VkPhysicalDeviceTileMemoryHeapPropertiesQCOM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceTileMemoryHeapPropertiesQCOM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::TileMemoryRequirementsQCOM ) == sizeof( VkTileMemoryRequirementsQCOM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "TileMemoryRequirementsQCOM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::TileMemoryBindInfoQCOM ) == sizeof( VkTileMemoryBindInfoQCOM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "TileMemoryBindInfoQCOM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::TileMemorySizeInfoQCOM ) == sizeof( VkTileMemorySizeInfoQCOM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "TileMemorySizeInfoQCOM is not nothrow_move_constructible!" ); + //=== VK_NV_display_stereo === VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DisplaySurfaceStereoCreateInfoNV ) == sizeof( VkDisplaySurfaceStereoCreateInfoNV ), diff --git a/third_party/vulkan/vulkan_structs.hpp b/third_party/vulkan/vulkan_structs.hpp index d58643a..6181aad 100644 --- a/third_party/vulkan/vulkan_structs.hpp +++ b/third_party/vulkan/vulkan_structs.hpp @@ -107826,6 +107826,236 @@ namespace VULKAN_HPP_NAMESPACE using PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT = PhysicalDeviceTextureCompressionASTCHDRFeatures; + // wrapper struct for struct VkPhysicalDeviceTileMemoryHeapFeaturesQCOM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceTileMemoryHeapFeaturesQCOM.html + struct PhysicalDeviceTileMemoryHeapFeaturesQCOM + { + using NativeType = VkPhysicalDeviceTileMemoryHeapFeaturesQCOM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceTileMemoryHeapFeaturesQCOM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceTileMemoryHeapFeaturesQCOM( VULKAN_HPP_NAMESPACE::Bool32 tileMemoryHeap_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , tileMemoryHeap{ tileMemoryHeap_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceTileMemoryHeapFeaturesQCOM( PhysicalDeviceTileMemoryHeapFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceTileMemoryHeapFeaturesQCOM( VkPhysicalDeviceTileMemoryHeapFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceTileMemoryHeapFeaturesQCOM( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceTileMemoryHeapFeaturesQCOM & operator=( PhysicalDeviceTileMemoryHeapFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceTileMemoryHeapFeaturesQCOM & operator=( VkPhysicalDeviceTileMemoryHeapFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileMemoryHeapFeaturesQCOM & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileMemoryHeapFeaturesQCOM & setTileMemoryHeap( VULKAN_HPP_NAMESPACE::Bool32 tileMemoryHeap_ ) VULKAN_HPP_NOEXCEPT + { + tileMemoryHeap = tileMemoryHeap_; + return *this; + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceTileMemoryHeapFeaturesQCOM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceTileMemoryHeapFeaturesQCOM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceTileMemoryHeapFeaturesQCOM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceTileMemoryHeapFeaturesQCOM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, tileMemoryHeap ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceTileMemoryHeapFeaturesQCOM const & ) const = default; +#else + bool operator==( PhysicalDeviceTileMemoryHeapFeaturesQCOM 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 ) && ( tileMemoryHeap == rhs.tileMemoryHeap ); +# endif + } + + bool operator!=( PhysicalDeviceTileMemoryHeapFeaturesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceTileMemoryHeapFeaturesQCOM; + void * pNext = {}; + VULKAN_HPP_NAMESPACE::Bool32 tileMemoryHeap = {}; + }; + + template <> + struct CppType + { + using Type = PhysicalDeviceTileMemoryHeapFeaturesQCOM; + }; + + // wrapper struct for struct VkPhysicalDeviceTileMemoryHeapPropertiesQCOM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceTileMemoryHeapPropertiesQCOM.html + struct PhysicalDeviceTileMemoryHeapPropertiesQCOM + { + using NativeType = VkPhysicalDeviceTileMemoryHeapPropertiesQCOM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceTileMemoryHeapPropertiesQCOM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceTileMemoryHeapPropertiesQCOM( VULKAN_HPP_NAMESPACE::Bool32 queueSubmitBoundary_ = {}, + VULKAN_HPP_NAMESPACE::Bool32 tileBufferTransfers_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , queueSubmitBoundary{ queueSubmitBoundary_ } + , tileBufferTransfers{ tileBufferTransfers_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceTileMemoryHeapPropertiesQCOM( PhysicalDeviceTileMemoryHeapPropertiesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceTileMemoryHeapPropertiesQCOM( VkPhysicalDeviceTileMemoryHeapPropertiesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceTileMemoryHeapPropertiesQCOM( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceTileMemoryHeapPropertiesQCOM & operator=( PhysicalDeviceTileMemoryHeapPropertiesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceTileMemoryHeapPropertiesQCOM & operator=( VkPhysicalDeviceTileMemoryHeapPropertiesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileMemoryHeapPropertiesQCOM & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileMemoryHeapPropertiesQCOM & + setQueueSubmitBoundary( VULKAN_HPP_NAMESPACE::Bool32 queueSubmitBoundary_ ) VULKAN_HPP_NOEXCEPT + { + queueSubmitBoundary = queueSubmitBoundary_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileMemoryHeapPropertiesQCOM & + setTileBufferTransfers( VULKAN_HPP_NAMESPACE::Bool32 tileBufferTransfers_ ) VULKAN_HPP_NOEXCEPT + { + tileBufferTransfers = tileBufferTransfers_; + return *this; + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceTileMemoryHeapPropertiesQCOM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceTileMemoryHeapPropertiesQCOM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceTileMemoryHeapPropertiesQCOM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceTileMemoryHeapPropertiesQCOM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, queueSubmitBoundary, tileBufferTransfers ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceTileMemoryHeapPropertiesQCOM const & ) const = default; +#else + bool operator==( PhysicalDeviceTileMemoryHeapPropertiesQCOM 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 ) && ( queueSubmitBoundary == rhs.queueSubmitBoundary ) && + ( tileBufferTransfers == rhs.tileBufferTransfers ); +# endif + } + + bool operator!=( PhysicalDeviceTileMemoryHeapPropertiesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceTileMemoryHeapPropertiesQCOM; + void * pNext = {}; + VULKAN_HPP_NAMESPACE::Bool32 queueSubmitBoundary = {}; + VULKAN_HPP_NAMESPACE::Bool32 tileBufferTransfers = {}; + }; + + template <> + struct CppType + { + using Type = PhysicalDeviceTileMemoryHeapPropertiesQCOM; + }; + // wrapper struct for struct VkPhysicalDeviceTilePropertiesFeaturesQCOM, see // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceTilePropertiesFeaturesQCOM.html struct PhysicalDeviceTilePropertiesFeaturesQCOM @@ -140262,6 +140492,337 @@ namespace VULKAN_HPP_NAMESPACE using Type = TextureLODGatherFormatPropertiesAMD; }; + // wrapper struct for struct VkTileMemoryBindInfoQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkTileMemoryBindInfoQCOM.html + struct TileMemoryBindInfoQCOM + { + using NativeType = VkTileMemoryBindInfoQCOM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eTileMemoryBindInfoQCOM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR TileMemoryBindInfoQCOM( VULKAN_HPP_NAMESPACE::DeviceMemory memory_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , memory{ memory_ } + { + } + + VULKAN_HPP_CONSTEXPR TileMemoryBindInfoQCOM( TileMemoryBindInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + TileMemoryBindInfoQCOM( VkTileMemoryBindInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + : TileMemoryBindInfoQCOM( *reinterpret_cast( &rhs ) ) + { + } + + TileMemoryBindInfoQCOM & operator=( TileMemoryBindInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + TileMemoryBindInfoQCOM & operator=( VkTileMemoryBindInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 TileMemoryBindInfoQCOM & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 TileMemoryBindInfoQCOM & setMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory_ ) VULKAN_HPP_NOEXCEPT + { + memory = memory_; + return *this; + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkTileMemoryBindInfoQCOM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkTileMemoryBindInfoQCOM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkTileMemoryBindInfoQCOM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkTileMemoryBindInfoQCOM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, memory ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( TileMemoryBindInfoQCOM const & ) const = default; +#else + bool operator==( TileMemoryBindInfoQCOM 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 ) && ( memory == rhs.memory ); +# endif + } + + bool operator!=( TileMemoryBindInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eTileMemoryBindInfoQCOM; + const void * pNext = {}; + VULKAN_HPP_NAMESPACE::DeviceMemory memory = {}; + }; + + template <> + struct CppType + { + using Type = TileMemoryBindInfoQCOM; + }; + + // wrapper struct for struct VkTileMemoryRequirementsQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkTileMemoryRequirementsQCOM.html + struct TileMemoryRequirementsQCOM + { + using NativeType = VkTileMemoryRequirementsQCOM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eTileMemoryRequirementsQCOM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR TileMemoryRequirementsQCOM( VULKAN_HPP_NAMESPACE::DeviceSize size_ = {}, + VULKAN_HPP_NAMESPACE::DeviceSize alignment_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , size{ size_ } + , alignment{ alignment_ } + { + } + + VULKAN_HPP_CONSTEXPR TileMemoryRequirementsQCOM( TileMemoryRequirementsQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + TileMemoryRequirementsQCOM( VkTileMemoryRequirementsQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + : TileMemoryRequirementsQCOM( *reinterpret_cast( &rhs ) ) + { + } + + TileMemoryRequirementsQCOM & operator=( TileMemoryRequirementsQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + TileMemoryRequirementsQCOM & operator=( VkTileMemoryRequirementsQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 TileMemoryRequirementsQCOM & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 TileMemoryRequirementsQCOM & setSize( VULKAN_HPP_NAMESPACE::DeviceSize size_ ) VULKAN_HPP_NOEXCEPT + { + size = size_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 TileMemoryRequirementsQCOM & setAlignment( VULKAN_HPP_NAMESPACE::DeviceSize alignment_ ) VULKAN_HPP_NOEXCEPT + { + alignment = alignment_; + return *this; + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkTileMemoryRequirementsQCOM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkTileMemoryRequirementsQCOM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkTileMemoryRequirementsQCOM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkTileMemoryRequirementsQCOM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, size, alignment ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( TileMemoryRequirementsQCOM const & ) const = default; +#else + bool operator==( TileMemoryRequirementsQCOM 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 ) && ( size == rhs.size ) && ( alignment == rhs.alignment ); +# endif + } + + bool operator!=( TileMemoryRequirementsQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eTileMemoryRequirementsQCOM; + void * pNext = {}; + VULKAN_HPP_NAMESPACE::DeviceSize size = {}; + VULKAN_HPP_NAMESPACE::DeviceSize alignment = {}; + }; + + template <> + struct CppType + { + using Type = TileMemoryRequirementsQCOM; + }; + + // wrapper struct for struct VkTileMemorySizeInfoQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkTileMemorySizeInfoQCOM.html + struct TileMemorySizeInfoQCOM + { + using NativeType = VkTileMemorySizeInfoQCOM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eTileMemorySizeInfoQCOM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR TileMemorySizeInfoQCOM( VULKAN_HPP_NAMESPACE::DeviceSize size_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , size{ size_ } + { + } + + VULKAN_HPP_CONSTEXPR TileMemorySizeInfoQCOM( TileMemorySizeInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + TileMemorySizeInfoQCOM( VkTileMemorySizeInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + : TileMemorySizeInfoQCOM( *reinterpret_cast( &rhs ) ) + { + } + + TileMemorySizeInfoQCOM & operator=( TileMemorySizeInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + TileMemorySizeInfoQCOM & operator=( VkTileMemorySizeInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 TileMemorySizeInfoQCOM & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 TileMemorySizeInfoQCOM & setSize( VULKAN_HPP_NAMESPACE::DeviceSize size_ ) VULKAN_HPP_NOEXCEPT + { + size = size_; + return *this; + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkTileMemorySizeInfoQCOM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkTileMemorySizeInfoQCOM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkTileMemorySizeInfoQCOM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkTileMemorySizeInfoQCOM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, size ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( TileMemorySizeInfoQCOM const & ) const = default; +#else + bool operator==( TileMemorySizeInfoQCOM 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 ) && ( size == rhs.size ); +# endif + } + + bool operator!=( TileMemorySizeInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eTileMemorySizeInfoQCOM; + const void * pNext = {}; + VULKAN_HPP_NAMESPACE::DeviceSize size = {}; + }; + + template <> + struct CppType + { + using Type = TileMemorySizeInfoQCOM; + }; + // wrapper struct for struct VkTilePropertiesQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkTilePropertiesQCOM.html struct TilePropertiesQCOM { diff --git a/third_party/vulkan/vulkan_to_string.hpp b/third_party/vulkan/vulkan_to_string.hpp index bf99a45..8042739 100644 --- a/third_party/vulkan/vulkan_to_string.hpp +++ b/third_party/vulkan/vulkan_to_string.hpp @@ -207,6 +207,8 @@ namespace VULKAN_HPP_NAMESPACE result += " SampleWeightQCOM |"; if ( value & ImageUsageFlagBits::eSampleBlockMatchQCOM ) result += " SampleBlockMatchQCOM |"; + if ( value & ImageUsageFlagBits::eTileMemoryQCOM ) + result += " TileMemoryQCOM |"; if ( value & ImageUsageFlagBits::eVideoEncodeQuantizationDeltaMapKHR ) result += " VideoEncodeQuantizationDeltaMapKHR |"; if ( value & ImageUsageFlagBits::eVideoEncodeEmphasisMapKHR ) @@ -239,6 +241,8 @@ namespace VULKAN_HPP_NAMESPACE result += " DeviceLocal |"; if ( value & MemoryHeapFlagBits::eMultiInstance ) result += " MultiInstance |"; + if ( value & MemoryHeapFlagBits::eTileMemoryQCOM ) + result += " TileMemoryQCOM |"; if ( result.size() > 1 ) result.back() = '}'; @@ -663,6 +667,8 @@ namespace VULKAN_HPP_NAMESPACE result += " MicromapBuildInputReadOnlyEXT |"; if ( value & BufferUsageFlagBits::eMicromapStorageEXT ) result += " MicromapStorageEXT |"; + if ( value & BufferUsageFlagBits::eTileMemoryQCOM ) + result += " TileMemoryQCOM |"; if ( result.size() > 1 ) result.back() = '}'; @@ -2119,6 +2125,8 @@ namespace VULKAN_HPP_NAMESPACE result += " MicromapBuildInputReadOnlyEXT |"; if ( value & BufferUsageFlagBits2::eMicromapStorageEXT ) result += " MicromapStorageEXT |"; + if ( value & BufferUsageFlagBits2::eTileMemoryQCOM ) + result += " TileMemoryQCOM |"; if ( value & BufferUsageFlagBits2::ePreprocessBufferEXT ) result += " PreprocessBufferEXT |"; @@ -5038,6 +5046,11 @@ namespace VULKAN_HPP_NAMESPACE case StructureType::eSetDescriptorBufferOffsetsInfoEXT: return "SetDescriptorBufferOffsetsInfoEXT"; case StructureType::eBindDescriptorBufferEmbeddedSamplersInfoEXT: return "BindDescriptorBufferEmbeddedSamplersInfoEXT"; case StructureType::ePhysicalDeviceDescriptorPoolOverallocationFeaturesNV: return "PhysicalDeviceDescriptorPoolOverallocationFeaturesNV"; + case StructureType::ePhysicalDeviceTileMemoryHeapFeaturesQCOM: return "PhysicalDeviceTileMemoryHeapFeaturesQCOM"; + case StructureType::ePhysicalDeviceTileMemoryHeapPropertiesQCOM: return "PhysicalDeviceTileMemoryHeapPropertiesQCOM"; + case StructureType::eTileMemoryRequirementsQCOM: return "TileMemoryRequirementsQCOM"; + case StructureType::eTileMemoryBindInfoQCOM: return "TileMemoryBindInfoQCOM"; + case StructureType::eTileMemorySizeInfoQCOM: return "TileMemorySizeInfoQCOM"; case StructureType::eDisplaySurfaceStereoCreateInfoNV: return "DisplaySurfaceStereoCreateInfoNV"; case StructureType::eDisplayModeStereoPropertiesNV: return "DisplayModeStereoPropertiesNV"; case StructureType::eVideoEncodeQuantizationMapCapabilitiesKHR: return "VideoEncodeQuantizationMapCapabilitiesKHR"; @@ -5594,6 +5607,7 @@ namespace VULKAN_HPP_NAMESPACE case ImageUsageFlagBits::eInvocationMaskHUAWEI: return "InvocationMaskHUAWEI"; case ImageUsageFlagBits::eSampleWeightQCOM: return "SampleWeightQCOM"; case ImageUsageFlagBits::eSampleBlockMatchQCOM: return "SampleBlockMatchQCOM"; + case ImageUsageFlagBits::eTileMemoryQCOM: return "TileMemoryQCOM"; case ImageUsageFlagBits::eVideoEncodeQuantizationDeltaMapKHR: return "VideoEncodeQuantizationDeltaMapKHR"; case ImageUsageFlagBits::eVideoEncodeEmphasisMapKHR: return "VideoEncodeEmphasisMapKHR"; default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast( value ) ) + " )"; @@ -5624,6 +5638,7 @@ namespace VULKAN_HPP_NAMESPACE { case MemoryHeapFlagBits::eDeviceLocal: return "DeviceLocal"; case MemoryHeapFlagBits::eMultiInstance: return "MultiInstance"; + case MemoryHeapFlagBits::eTileMemoryQCOM: return "TileMemoryQCOM"; default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast( value ) ) + " )"; } } @@ -5935,6 +5950,7 @@ namespace VULKAN_HPP_NAMESPACE case BufferUsageFlagBits::ePushDescriptorsDescriptorBufferEXT: return "PushDescriptorsDescriptorBufferEXT"; case BufferUsageFlagBits::eMicromapBuildInputReadOnlyEXT: return "MicromapBuildInputReadOnlyEXT"; case BufferUsageFlagBits::eMicromapStorageEXT: return "MicromapStorageEXT"; + case BufferUsageFlagBits::eTileMemoryQCOM: return "TileMemoryQCOM"; default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast( value ) ) + " )"; } } @@ -7495,6 +7511,7 @@ namespace VULKAN_HPP_NAMESPACE case BufferUsageFlagBits2::ePushDescriptorsDescriptorBufferEXT: return "PushDescriptorsDescriptorBufferEXT"; case BufferUsageFlagBits2::eMicromapBuildInputReadOnlyEXT: return "MicromapBuildInputReadOnlyEXT"; case BufferUsageFlagBits2::eMicromapStorageEXT: return "MicromapStorageEXT"; + case BufferUsageFlagBits2::eTileMemoryQCOM: return "TileMemoryQCOM"; case BufferUsageFlagBits2::ePreprocessBufferEXT: return "PreprocessBufferEXT"; default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast( value ) ) + " )"; }