1 // Copyright 2015-2023 The Khronos Group Inc. 2 // 3 // SPDX-License-Identifier: Apache-2.0 OR MIT 4 // 5 6 // This header is generated from the Khronos Vulkan XML API Registry. 7 8 #ifndef VULKAN_ENUMS_HPP 9 # define VULKAN_ENUMS_HPP 10 11 namespace VULKAN_HPP_NAMESPACE 12 { 13 template <typename FlagBitsType> 14 struct FlagTraits 15 { 16 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = false; 17 }; 18 19 template <typename BitType> 20 class Flags 21 { 22 public: 23 using MaskType = typename std::underlying_type<BitType>::type; 24 25 // constructors Flags()26 VULKAN_HPP_CONSTEXPR Flags() VULKAN_HPP_NOEXCEPT 27 : m_mask( 0 ) 28 {} 29 Flags(BitType bit)30 VULKAN_HPP_CONSTEXPR Flags( BitType bit ) VULKAN_HPP_NOEXCEPT 31 : m_mask( static_cast<MaskType>( bit ) ) 32 {} 33 34 VULKAN_HPP_CONSTEXPR Flags( Flags<BitType> const & rhs ) VULKAN_HPP_NOEXCEPT = default; 35 Flags(MaskType flags)36 VULKAN_HPP_CONSTEXPR explicit Flags( MaskType flags ) VULKAN_HPP_NOEXCEPT 37 : m_mask( flags ) 38 {} 39 40 // relational operators 41 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) 42 auto operator<=>( Flags<BitType> const & ) const = default; 43 #else operator <(Flags<BitType> const & rhs) const44 VULKAN_HPP_CONSTEXPR bool operator<( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT 45 { 46 return m_mask < rhs.m_mask; 47 } 48 operator <=(Flags<BitType> const & rhs) const49 VULKAN_HPP_CONSTEXPR bool operator<=( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT 50 { 51 return m_mask <= rhs.m_mask; 52 } 53 operator >(Flags<BitType> const & rhs) const54 VULKAN_HPP_CONSTEXPR bool operator>( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT 55 { 56 return m_mask > rhs.m_mask; 57 } 58 operator >=(Flags<BitType> const & rhs) const59 VULKAN_HPP_CONSTEXPR bool operator>=( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT 60 { 61 return m_mask >= rhs.m_mask; 62 } 63 operator ==(Flags<BitType> const & rhs) const64 VULKAN_HPP_CONSTEXPR bool operator==( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT 65 { 66 return m_mask == rhs.m_mask; 67 } 68 operator !=(Flags<BitType> const & rhs) const69 VULKAN_HPP_CONSTEXPR bool operator!=( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT 70 { 71 return m_mask != rhs.m_mask; 72 } 73 #endif 74 75 // logical operator operator !() const76 VULKAN_HPP_CONSTEXPR bool operator!() const VULKAN_HPP_NOEXCEPT 77 { 78 return !m_mask; 79 } 80 81 // bitwise operators operator &(Flags<BitType> const & rhs) const82 VULKAN_HPP_CONSTEXPR Flags<BitType> operator&( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT 83 { 84 return Flags<BitType>( m_mask & rhs.m_mask ); 85 } 86 operator |(Flags<BitType> const & rhs) const87 VULKAN_HPP_CONSTEXPR Flags<BitType> operator|( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT 88 { 89 return Flags<BitType>( m_mask | rhs.m_mask ); 90 } 91 operator ^(Flags<BitType> const & rhs) const92 VULKAN_HPP_CONSTEXPR Flags<BitType> operator^( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT 93 { 94 return Flags<BitType>( m_mask ^ rhs.m_mask ); 95 } 96 operator ~() const97 VULKAN_HPP_CONSTEXPR Flags<BitType> operator~() const VULKAN_HPP_NOEXCEPT 98 { 99 return Flags<BitType>( m_mask ^ FlagTraits<BitType>::allFlags.m_mask ); 100 } 101 102 // assignment operators 103 VULKAN_HPP_CONSTEXPR_14 Flags<BitType> & operator=( Flags<BitType> const & rhs ) VULKAN_HPP_NOEXCEPT = default; 104 operator |=(Flags<BitType> const & rhs)105 VULKAN_HPP_CONSTEXPR_14 Flags<BitType> & operator|=( Flags<BitType> const & rhs ) VULKAN_HPP_NOEXCEPT 106 { 107 m_mask |= rhs.m_mask; 108 return *this; 109 } 110 operator &=(Flags<BitType> const & rhs)111 VULKAN_HPP_CONSTEXPR_14 Flags<BitType> & operator&=( Flags<BitType> const & rhs ) VULKAN_HPP_NOEXCEPT 112 { 113 m_mask &= rhs.m_mask; 114 return *this; 115 } 116 operator ^=(Flags<BitType> const & rhs)117 VULKAN_HPP_CONSTEXPR_14 Flags<BitType> & operator^=( Flags<BitType> const & rhs ) VULKAN_HPP_NOEXCEPT 118 { 119 m_mask ^= rhs.m_mask; 120 return *this; 121 } 122 123 // cast operators operator bool() const124 explicit VULKAN_HPP_CONSTEXPR operator bool() const VULKAN_HPP_NOEXCEPT 125 { 126 return !!m_mask; 127 } 128 operator MaskType() const129 explicit VULKAN_HPP_CONSTEXPR operator MaskType() const VULKAN_HPP_NOEXCEPT 130 { 131 return m_mask; 132 } 133 134 #if defined( VULKAN_HPP_FLAGS_MASK_TYPE_AS_PUBLIC ) 135 public: 136 #else 137 private: 138 #endif 139 MaskType m_mask; 140 }; 141 142 #if !defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) 143 // relational operators only needed for pre C++20 144 template <typename BitType> operator <(BitType bit,Flags<BitType> const & flags)145 VULKAN_HPP_CONSTEXPR bool operator<( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT 146 { 147 return flags.operator>( bit ); 148 } 149 150 template <typename BitType> operator <=(BitType bit,Flags<BitType> const & flags)151 VULKAN_HPP_CONSTEXPR bool operator<=( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT 152 { 153 return flags.operator>=( bit ); 154 } 155 156 template <typename BitType> operator >(BitType bit,Flags<BitType> const & flags)157 VULKAN_HPP_CONSTEXPR bool operator>( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT 158 { 159 return flags.operator<( bit ); 160 } 161 162 template <typename BitType> operator >=(BitType bit,Flags<BitType> const & flags)163 VULKAN_HPP_CONSTEXPR bool operator>=( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT 164 { 165 return flags.operator<=( bit ); 166 } 167 168 template <typename BitType> operator ==(BitType bit,Flags<BitType> const & flags)169 VULKAN_HPP_CONSTEXPR bool operator==( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT 170 { 171 return flags.operator==( bit ); 172 } 173 174 template <typename BitType> operator !=(BitType bit,Flags<BitType> const & flags)175 VULKAN_HPP_CONSTEXPR bool operator!=( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT 176 { 177 return flags.operator!=( bit ); 178 } 179 #endif 180 181 // bitwise operators 182 template <typename BitType> operator &(BitType bit,Flags<BitType> const & flags)183 VULKAN_HPP_CONSTEXPR Flags<BitType> operator&( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT 184 { 185 return flags.operator&( bit ); 186 } 187 188 template <typename BitType> operator |(BitType bit,Flags<BitType> const & flags)189 VULKAN_HPP_CONSTEXPR Flags<BitType> operator|( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT 190 { 191 return flags.operator|( bit ); 192 } 193 194 template <typename BitType> operator ^(BitType bit,Flags<BitType> const & flags)195 VULKAN_HPP_CONSTEXPR Flags<BitType> operator^( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT 196 { 197 return flags.operator^( bit ); 198 } 199 200 // bitwise operators on BitType 201 template <typename BitType, typename std::enable_if<FlagTraits<BitType>::isBitmask, bool>::type = true> operator &(BitType lhs,BitType rhs)202 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR Flags<BitType> operator&(BitType lhs, BitType rhs) VULKAN_HPP_NOEXCEPT 203 { 204 return Flags<BitType>( lhs ) & rhs; 205 } 206 207 template <typename BitType, typename std::enable_if<FlagTraits<BitType>::isBitmask, bool>::type = true> operator |(BitType lhs,BitType rhs)208 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR Flags<BitType> operator|(BitType lhs, BitType rhs) VULKAN_HPP_NOEXCEPT 209 { 210 return Flags<BitType>( lhs ) | rhs; 211 } 212 213 template <typename BitType, typename std::enable_if<FlagTraits<BitType>::isBitmask, bool>::type = true> operator ^(BitType lhs,BitType rhs)214 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR Flags<BitType> operator^(BitType lhs, BitType rhs) VULKAN_HPP_NOEXCEPT 215 { 216 return Flags<BitType>( lhs ) ^ rhs; 217 } 218 219 template <typename BitType, typename std::enable_if<FlagTraits<BitType>::isBitmask, bool>::type = true> operator ~(BitType bit)220 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR Flags<BitType> operator~( BitType bit ) VULKAN_HPP_NOEXCEPT 221 { 222 return ~( Flags<BitType>( bit ) ); 223 } 224 225 226 227 template <typename EnumType, EnumType value> 228 struct CppType 229 {}; 230 231 //============= 232 //=== ENUMs === 233 //============= 234 235 236 //=== VK_VERSION_1_0 === 237 238 enum class Result 239 { 240 eSuccess = VK_SUCCESS, 241 eNotReady = VK_NOT_READY, 242 eTimeout = VK_TIMEOUT, 243 eEventSet = VK_EVENT_SET, 244 eEventReset = VK_EVENT_RESET, 245 eIncomplete = VK_INCOMPLETE, 246 eErrorOutOfHostMemory = VK_ERROR_OUT_OF_HOST_MEMORY, 247 eErrorOutOfDeviceMemory = VK_ERROR_OUT_OF_DEVICE_MEMORY, 248 eErrorInitializationFailed = VK_ERROR_INITIALIZATION_FAILED, 249 eErrorDeviceLost = VK_ERROR_DEVICE_LOST, 250 eErrorMemoryMapFailed = VK_ERROR_MEMORY_MAP_FAILED, 251 eErrorLayerNotPresent = VK_ERROR_LAYER_NOT_PRESENT, 252 eErrorExtensionNotPresent = VK_ERROR_EXTENSION_NOT_PRESENT, 253 eErrorFeatureNotPresent = VK_ERROR_FEATURE_NOT_PRESENT, 254 eErrorIncompatibleDriver = VK_ERROR_INCOMPATIBLE_DRIVER, 255 eErrorTooManyObjects = VK_ERROR_TOO_MANY_OBJECTS, 256 eErrorFormatNotSupported = VK_ERROR_FORMAT_NOT_SUPPORTED, 257 eErrorFragmentedPool = VK_ERROR_FRAGMENTED_POOL, 258 eErrorUnknown = VK_ERROR_UNKNOWN, 259 eErrorOutOfPoolMemory = VK_ERROR_OUT_OF_POOL_MEMORY, 260 eErrorInvalidExternalHandle = VK_ERROR_INVALID_EXTERNAL_HANDLE, 261 eErrorFragmentation = VK_ERROR_FRAGMENTATION, 262 eErrorInvalidOpaqueCaptureAddress = VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS, 263 ePipelineCompileRequired = VK_PIPELINE_COMPILE_REQUIRED, 264 eErrorValidationFailed = VK_ERROR_VALIDATION_FAILED, 265 eErrorInvalidPipelineCacheData = VK_ERROR_INVALID_PIPELINE_CACHE_DATA, 266 eErrorNoPipelineMatch = VK_ERROR_NO_PIPELINE_MATCH, 267 eErrorSurfaceLostKHR = VK_ERROR_SURFACE_LOST_KHR, 268 eErrorNativeWindowInUseKHR = VK_ERROR_NATIVE_WINDOW_IN_USE_KHR, 269 eSuboptimalKHR = VK_SUBOPTIMAL_KHR, 270 eErrorOutOfDateKHR = VK_ERROR_OUT_OF_DATE_KHR, 271 eErrorIncompatibleDisplayKHR = VK_ERROR_INCOMPATIBLE_DISPLAY_KHR, 272 eErrorInvalidDrmFormatModifierPlaneLayoutEXT = VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT, 273 eErrorNotPermittedEXT = VK_ERROR_NOT_PERMITTED_EXT 274 }; 275 276 enum class StructureType 277 { 278 eApplicationInfo = VK_STRUCTURE_TYPE_APPLICATION_INFO, 279 eInstanceCreateInfo = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, 280 eDeviceQueueCreateInfo = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, 281 eDeviceCreateInfo = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, 282 eSubmitInfo = VK_STRUCTURE_TYPE_SUBMIT_INFO, 283 eMemoryAllocateInfo = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO, 284 eMappedMemoryRange = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE, 285 eFenceCreateInfo = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, 286 eSemaphoreCreateInfo = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO, 287 eEventCreateInfo = VK_STRUCTURE_TYPE_EVENT_CREATE_INFO, 288 eQueryPoolCreateInfo = VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO, 289 eBufferCreateInfo = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, 290 eBufferViewCreateInfo = VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO, 291 eImageCreateInfo = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, 292 eImageViewCreateInfo = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, 293 ePipelineCacheCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO, 294 ePipelineShaderStageCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, 295 ePipelineVertexInputStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, 296 ePipelineInputAssemblyStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, 297 ePipelineTessellationStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO, 298 ePipelineViewportStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO, 299 ePipelineRasterizationStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO, 300 ePipelineMultisampleStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, 301 ePipelineDepthStencilStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO, 302 ePipelineColorBlendStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, 303 ePipelineDynamicStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO, 304 eGraphicsPipelineCreateInfo = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO, 305 eComputePipelineCreateInfo = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO, 306 ePipelineLayoutCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, 307 eSamplerCreateInfo = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO, 308 eDescriptorSetLayoutCreateInfo = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO, 309 eDescriptorPoolCreateInfo = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO, 310 eDescriptorSetAllocateInfo = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO, 311 eWriteDescriptorSet = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, 312 eCopyDescriptorSet = VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET, 313 eFramebufferCreateInfo = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, 314 eRenderPassCreateInfo = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, 315 eCommandPoolCreateInfo = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO, 316 eCommandBufferAllocateInfo = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, 317 eCommandBufferInheritanceInfo = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO, 318 eCommandBufferBeginInfo = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, 319 eRenderPassBeginInfo = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, 320 eBufferMemoryBarrier = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, 321 eImageMemoryBarrier = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, 322 eMemoryBarrier = VK_STRUCTURE_TYPE_MEMORY_BARRIER, 323 eLoaderInstanceCreateInfo = VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO, 324 eLoaderDeviceCreateInfo = VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO, 325 ePhysicalDeviceSubgroupProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES, 326 eBindBufferMemoryInfo = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO, 327 eBindImageMemoryInfo = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO, 328 ePhysicalDevice16BitStorageFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES, 329 eMemoryDedicatedRequirements = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS, 330 eMemoryDedicatedAllocateInfo = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO, 331 eMemoryAllocateFlagsInfo = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO, 332 eDeviceGroupRenderPassBeginInfo = VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO, 333 eDeviceGroupCommandBufferBeginInfo = VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO, 334 eDeviceGroupSubmitInfo = VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO, 335 eBindBufferMemoryDeviceGroupInfo = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO, 336 eBindImageMemoryDeviceGroupInfo = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO, 337 ePhysicalDeviceGroupProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES, 338 eDeviceGroupDeviceCreateInfo = VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO, 339 eBufferMemoryRequirementsInfo2 = VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2, 340 eImageMemoryRequirementsInfo2 = VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2, 341 eMemoryRequirements2 = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2, 342 ePhysicalDeviceFeatures2 = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2, 343 ePhysicalDeviceProperties2 = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2, 344 eFormatProperties2 = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2, 345 eImageFormatProperties2 = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2, 346 ePhysicalDeviceImageFormatInfo2 = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2, 347 eQueueFamilyProperties2 = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2, 348 ePhysicalDeviceMemoryProperties2 = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2, 349 ePhysicalDevicePointClippingProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES, 350 eRenderPassInputAttachmentAspectCreateInfo = VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO, 351 eImageViewUsageCreateInfo = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO, 352 ePipelineTessellationDomainOriginStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO, 353 eRenderPassMultiviewCreateInfo = VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO, 354 ePhysicalDeviceMultiviewFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES, 355 ePhysicalDeviceMultiviewProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES, 356 ePhysicalDeviceVariablePointersFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES, 357 eProtectedSubmitInfo = VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO, 358 ePhysicalDeviceProtectedMemoryFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES, 359 ePhysicalDeviceProtectedMemoryProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES, 360 eDeviceQueueInfo2 = VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2, 361 eSamplerYcbcrConversionCreateInfo = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO, 362 eSamplerYcbcrConversionInfo = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO, 363 eBindImagePlaneMemoryInfo = VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO, 364 eImagePlaneMemoryRequirementsInfo = VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO, 365 ePhysicalDeviceSamplerYcbcrConversionFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES, 366 eSamplerYcbcrConversionImageFormatProperties = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES, 367 ePhysicalDeviceExternalImageFormatInfo = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO, 368 eExternalImageFormatProperties = VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES, 369 ePhysicalDeviceExternalBufferInfo = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO, 370 eExternalBufferProperties = VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES, 371 ePhysicalDeviceIdProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES, 372 eExternalMemoryBufferCreateInfo = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO, 373 eExternalMemoryImageCreateInfo = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO, 374 eExportMemoryAllocateInfo = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO, 375 ePhysicalDeviceExternalFenceInfo = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO, 376 eExternalFenceProperties = VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES, 377 eExportFenceCreateInfo = VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO, 378 eExportSemaphoreCreateInfo = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO, 379 ePhysicalDeviceExternalSemaphoreInfo = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO, 380 eExternalSemaphoreProperties = VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES, 381 ePhysicalDeviceMaintenance3Properties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES, 382 eDescriptorSetLayoutSupport = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT, 383 ePhysicalDeviceShaderDrawParametersFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES, 384 ePhysicalDeviceVulkan11Features = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES, 385 ePhysicalDeviceVulkan11Properties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES, 386 ePhysicalDeviceVulkan12Features = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, 387 ePhysicalDeviceVulkan12Properties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES, 388 eImageFormatListCreateInfo = VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO, 389 eAttachmentDescription2 = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2, 390 eAttachmentReference2 = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2, 391 eSubpassDescription2 = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2, 392 eSubpassDependency2 = VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2, 393 eRenderPassCreateInfo2 = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2, 394 eSubpassBeginInfo = VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO, 395 eSubpassEndInfo = VK_STRUCTURE_TYPE_SUBPASS_END_INFO, 396 ePhysicalDevice8BitStorageFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES, 397 ePhysicalDeviceDriverProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES, 398 ePhysicalDeviceShaderAtomicInt64Features = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES, 399 ePhysicalDeviceShaderFloat16Int8Features = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES, 400 ePhysicalDeviceFloatControlsProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES, 401 eDescriptorSetLayoutBindingFlagsCreateInfo = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO, 402 ePhysicalDeviceDescriptorIndexingFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES, 403 ePhysicalDeviceDescriptorIndexingProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES, 404 eDescriptorSetVariableDescriptorCountAllocateInfo = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO, 405 eDescriptorSetVariableDescriptorCountLayoutSupport = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT, 406 ePhysicalDeviceDepthStencilResolveProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES, 407 eSubpassDescriptionDepthStencilResolve = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE, 408 ePhysicalDeviceScalarBlockLayoutFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES, 409 eImageStencilUsageCreateInfo = VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO, 410 ePhysicalDeviceSamplerFilterMinmaxProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES, 411 eSamplerReductionModeCreateInfo = VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO, 412 ePhysicalDeviceVulkanMemoryModelFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES, 413 ePhysicalDeviceImagelessFramebufferFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES, 414 eFramebufferAttachmentsCreateInfo = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO, 415 eFramebufferAttachmentImageInfo = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO, 416 eRenderPassAttachmentBeginInfo = VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO, 417 ePhysicalDeviceUniformBufferStandardLayoutFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES, 418 ePhysicalDeviceShaderSubgroupExtendedTypesFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES, 419 ePhysicalDeviceSeparateDepthStencilLayoutsFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES, 420 eAttachmentReferenceStencilLayout = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT, 421 eAttachmentDescriptionStencilLayout = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT, 422 ePhysicalDeviceHostQueryResetFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES, 423 ePhysicalDeviceTimelineSemaphoreFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES, 424 ePhysicalDeviceTimelineSemaphoreProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES, 425 eSemaphoreTypeCreateInfo = VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO, 426 eTimelineSemaphoreSubmitInfo = VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO, 427 eSemaphoreWaitInfo = VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO, 428 eSemaphoreSignalInfo = VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO, 429 ePhysicalDeviceBufferDeviceAddressFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES, 430 eBufferDeviceAddressInfo = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO, 431 eBufferOpaqueCaptureAddressCreateInfo = VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO, 432 eMemoryOpaqueCaptureAddressAllocateInfo = VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO, 433 eDeviceMemoryOpaqueCaptureAddressInfo = VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO, 434 ePhysicalDeviceVulkan13Features = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES, 435 ePhysicalDeviceVulkan13Properties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES, 436 ePipelineCreationFeedbackCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO, 437 ePhysicalDeviceShaderTerminateInvocationFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES, 438 ePhysicalDeviceToolProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES, 439 ePhysicalDeviceShaderDemoteToHelperInvocationFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES, 440 ePhysicalDevicePrivateDataFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES, 441 eDevicePrivateDataCreateInfo = VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO, 442 ePrivateDataSlotCreateInfo = VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO, 443 ePhysicalDevicePipelineCreationCacheControlFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES, 444 eMemoryBarrier2 = VK_STRUCTURE_TYPE_MEMORY_BARRIER_2, 445 eBufferMemoryBarrier2 = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2, 446 eImageMemoryBarrier2 = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2, 447 eDependencyInfo = VK_STRUCTURE_TYPE_DEPENDENCY_INFO, 448 eSubmitInfo2 = VK_STRUCTURE_TYPE_SUBMIT_INFO_2, 449 eSemaphoreSubmitInfo = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO, 450 eCommandBufferSubmitInfo = VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO, 451 ePhysicalDeviceSynchronization2Features = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES, 452 ePhysicalDeviceZeroInitializeWorkgroupMemoryFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES, 453 ePhysicalDeviceImageRobustnessFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES, 454 eCopyBufferInfo2 = VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2, 455 eCopyImageInfo2 = VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2, 456 eCopyBufferToImageInfo2 = VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2, 457 eCopyImageToBufferInfo2 = VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2, 458 eBlitImageInfo2 = VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2, 459 eResolveImageInfo2 = VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2, 460 eBufferCopy2 = VK_STRUCTURE_TYPE_BUFFER_COPY_2, 461 eImageCopy2 = VK_STRUCTURE_TYPE_IMAGE_COPY_2, 462 eImageBlit2 = VK_STRUCTURE_TYPE_IMAGE_BLIT_2, 463 eBufferImageCopy2 = VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2, 464 eImageResolve2 = VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2, 465 ePhysicalDeviceSubgroupSizeControlProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES, 466 ePipelineShaderStageRequiredSubgroupSizeCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO, 467 ePhysicalDeviceSubgroupSizeControlFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES, 468 ePhysicalDeviceInlineUniformBlockFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES, 469 ePhysicalDeviceInlineUniformBlockProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES, 470 eWriteDescriptorSetInlineUniformBlock = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK, 471 eDescriptorPoolInlineUniformBlockCreateInfo = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO, 472 ePhysicalDeviceTextureCompressionAstcHdrFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES, 473 eRenderingInfo = VK_STRUCTURE_TYPE_RENDERING_INFO, 474 eRenderingAttachmentInfo = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO, 475 ePipelineRenderingCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO, 476 ePhysicalDeviceDynamicRenderingFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES, 477 eCommandBufferInheritanceRenderingInfo = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO, 478 ePhysicalDeviceShaderIntegerDotProductFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES, 479 ePhysicalDeviceShaderIntegerDotProductProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES, 480 ePhysicalDeviceTexelBufferAlignmentProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES, 481 eFormatProperties3 = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3, 482 ePhysicalDeviceMaintenance4Features = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES, 483 ePhysicalDeviceMaintenance4Properties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES, 484 eDeviceBufferMemoryRequirements = VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS, 485 eDeviceImageMemoryRequirements = VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS, 486 ePhysicalDeviceVulkanSc10Features = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_SC_1_0_FEATURES, 487 ePhysicalDeviceVulkanSc10Properties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_SC_1_0_PROPERTIES, 488 eDeviceObjectReservationCreateInfo = VK_STRUCTURE_TYPE_DEVICE_OBJECT_RESERVATION_CREATE_INFO, 489 eCommandPoolMemoryReservationCreateInfo = VK_STRUCTURE_TYPE_COMMAND_POOL_MEMORY_RESERVATION_CREATE_INFO, 490 eCommandPoolMemoryConsumption = VK_STRUCTURE_TYPE_COMMAND_POOL_MEMORY_CONSUMPTION, 491 ePipelinePoolSize = VK_STRUCTURE_TYPE_PIPELINE_POOL_SIZE, 492 eFaultData = VK_STRUCTURE_TYPE_FAULT_DATA, 493 eFaultCallbackInfo = VK_STRUCTURE_TYPE_FAULT_CALLBACK_INFO, 494 ePipelineOfflineCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_OFFLINE_CREATE_INFO, 495 eSwapchainCreateInfoKHR = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR, 496 ePresentInfoKHR = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR, 497 eDeviceGroupPresentCapabilitiesKHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR, 498 eImageSwapchainCreateInfoKHR = VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR, 499 eBindImageMemorySwapchainInfoKHR = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR, 500 eAcquireNextImageInfoKHR = VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR, 501 eDeviceGroupPresentInfoKHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR, 502 eDeviceGroupSwapchainCreateInfoKHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR, 503 eDisplayModeCreateInfoKHR = VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR, 504 eDisplaySurfaceCreateInfoKHR = VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR, 505 eDisplayPresentInfoKHR = VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR, 506 ePrivateVendorInfoPlaceholderOffset0NV = VK_STRUCTURE_TYPE_PRIVATE_VENDOR_INFO_PLACEHOLDER_OFFSET_0_NV, 507 ePhysicalDeviceTextureCompressionAstcHdrFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT, 508 eImageViewAstcDecodeModeEXT = VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT, 509 ePhysicalDeviceAstcDecodeFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT, 510 eImportMemoryFdInfoKHR = VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR, 511 eMemoryFdPropertiesKHR = VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR, 512 eMemoryGetFdInfoKHR = VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR, 513 eImportSemaphoreFdInfoKHR = VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR, 514 eSemaphoreGetFdInfoKHR = VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR, 515 ePresentRegionsKHR = VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR, 516 eSurfaceCapabilities2EXT = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT, 517 eDisplayPowerInfoEXT = VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT, 518 eDeviceEventInfoEXT = VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT, 519 eDisplayEventInfoEXT = VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT, 520 eSwapchainCounterCreateInfoEXT = VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT, 521 ePhysicalDeviceDiscardRectanglePropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT, 522 ePipelineDiscardRectangleStateCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT, 523 ePhysicalDeviceConservativeRasterizationPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT, 524 ePipelineRasterizationConservativeStateCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT, 525 ePhysicalDeviceDepthClipEnableFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT, 526 ePipelineRasterizationDepthClipStateCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT, 527 eHdrMetadataEXT = VK_STRUCTURE_TYPE_HDR_METADATA_EXT, 528 eSharedPresentSurfaceCapabilitiesKHR = VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR, 529 eImportFenceFdInfoKHR = VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR, 530 eFenceGetFdInfoKHR = VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR, 531 ePhysicalDevicePerformanceQueryFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR, 532 ePhysicalDevicePerformanceQueryPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR, 533 eQueryPoolPerformanceCreateInfoKHR = VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR, 534 ePerformanceQuerySubmitInfoKHR = VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR, 535 eAcquireProfilingLockInfoKHR = VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR, 536 ePerformanceCounterKHR = VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR, 537 ePerformanceCounterDescriptionKHR = VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR, 538 ePerformanceQueryReservationInfoKHR = VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_RESERVATION_INFO_KHR, 539 ePhysicalDeviceSurfaceInfo2KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR, 540 eSurfaceCapabilities2KHR = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR, 541 eSurfaceFormat2KHR = VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR, 542 eDisplayProperties2KHR = VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR, 543 eDisplayPlaneProperties2KHR = VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR, 544 eDisplayModeProperties2KHR = VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR, 545 eDisplayPlaneInfo2KHR = VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR, 546 eDisplayPlaneCapabilities2KHR = VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR, 547 eDebugUtilsObjectNameInfoEXT = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT, 548 eDebugUtilsObjectTagInfoEXT = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT, 549 eDebugUtilsLabelEXT = VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT, 550 eDebugUtilsMessengerCallbackDataEXT = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT, 551 eDebugUtilsMessengerCreateInfoEXT = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT, 552 eSampleLocationsInfoEXT = VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT, 553 eRenderPassSampleLocationsBeginInfoEXT = VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT, 554 ePipelineSampleLocationsStateCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT, 555 ePhysicalDeviceSampleLocationsPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT, 556 eMultisamplePropertiesEXT = VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT, 557 ePhysicalDeviceBlendOperationAdvancedFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT, 558 ePhysicalDeviceBlendOperationAdvancedPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT, 559 ePipelineColorBlendAdvancedStateCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT, 560 eDrmFormatModifierPropertiesListEXT = VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT, 561 ePhysicalDeviceImageDrmFormatModifierInfoEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT, 562 eImageDrmFormatModifierListCreateInfoEXT = VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT, 563 eImageDrmFormatModifierExplicitCreateInfoEXT = VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT, 564 eImageDrmFormatModifierPropertiesEXT = VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT, 565 eDrmFormatModifierPropertiesList2EXT = VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT, 566 ePhysicalDeviceImageViewImageFormatInfoEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT, 567 eFilterCubicImageViewImageFormatPropertiesEXT = VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT, 568 eDeviceQueueGlobalPriorityCreateInfoEXT = VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT, 569 eImportMemoryHostPointerInfoEXT = VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT, 570 eMemoryHostPointerPropertiesEXT = VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT, 571 ePhysicalDeviceExternalMemoryHostPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT, 572 ePhysicalDeviceShaderClockFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR, 573 eCalibratedTimestampInfoEXT = VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT, 574 ePhysicalDeviceVertexAttributeDivisorPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT, 575 ePipelineVertexInputDivisorStateCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT, 576 ePhysicalDeviceVertexAttributeDivisorFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT, 577 ePhysicalDevicePciBusInfoPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT, 578 ePhysicalDeviceShaderTerminateInvocationFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR, 579 ePhysicalDeviceSubgroupSizeControlPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT, 580 ePipelineShaderStageRequiredSubgroupSizeCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT, 581 ePhysicalDeviceSubgroupSizeControlFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT, 582 eFragmentShadingRateAttachmentInfoKHR = VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR, 583 ePipelineFragmentShadingRateStateCreateInfoKHR = VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR, 584 ePhysicalDeviceFragmentShadingRatePropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR, 585 ePhysicalDeviceFragmentShadingRateFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR, 586 ePhysicalDeviceFragmentShadingRateKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR, 587 ePhysicalDeviceShaderImageAtomicInt64FeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT, 588 ePhysicalDeviceMemoryBudgetPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT, 589 eValidationFeaturesEXT = VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT, 590 ePhysicalDeviceFragmentShaderInterlockFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT, 591 ePhysicalDeviceYcbcrImageArraysFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT, 592 eHeadlessSurfaceCreateInfoEXT = VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT, 593 ePhysicalDeviceLineRasterizationFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT, 594 ePipelineRasterizationLineStateCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT, 595 ePhysicalDeviceLineRasterizationPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT, 596 ePhysicalDeviceShaderAtomicFloatFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT, 597 ePhysicalDeviceIndexTypeUint8FeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT, 598 ePhysicalDeviceExtendedDynamicStateFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT, 599 ePhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT, 600 ePhysicalDeviceTexelBufferAlignmentFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT, 601 ePhysicalDeviceTexelBufferAlignmentPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT, 602 ePhysicalDeviceRobustness2FeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT, 603 ePhysicalDeviceRobustness2PropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT, 604 eSamplerCustomBorderColorCreateInfoEXT = VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT, 605 ePhysicalDeviceCustomBorderColorPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT, 606 ePhysicalDeviceCustomBorderColorFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT, 607 eRefreshObjectListKHR = VK_STRUCTURE_TYPE_REFRESH_OBJECT_LIST_KHR, 608 eMemoryBarrier2KHR = VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR, 609 eBufferMemoryBarrier2KHR = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2_KHR, 610 eImageMemoryBarrier2KHR = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2_KHR, 611 eDependencyInfoKHR = VK_STRUCTURE_TYPE_DEPENDENCY_INFO_KHR, 612 eSubmitInfo2KHR = VK_STRUCTURE_TYPE_SUBMIT_INFO_2_KHR, 613 eSemaphoreSubmitInfoKHR = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO_KHR, 614 eCommandBufferSubmitInfoKHR = VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO_KHR, 615 ePhysicalDeviceSynchronization2FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR, 616 eQueueFamilyCheckpointProperties2NV = VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV, 617 eCheckpointData2NV = VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV, 618 ePhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT, 619 ePhysicalDeviceImageRobustnessFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT, 620 eCopyBufferInfo2KHR = VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2_KHR, 621 eCopyImageInfo2KHR = VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2_KHR, 622 eCopyBufferToImageInfo2KHR = VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2_KHR, 623 eCopyImageToBufferInfo2KHR = VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2_KHR, 624 eBlitImageInfo2KHR = VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2_KHR, 625 eResolveImageInfo2KHR = VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2_KHR, 626 eBufferCopy2KHR = VK_STRUCTURE_TYPE_BUFFER_COPY_2_KHR, 627 eImageCopy2KHR = VK_STRUCTURE_TYPE_IMAGE_COPY_2_KHR, 628 eImageBlit2KHR = VK_STRUCTURE_TYPE_IMAGE_BLIT_2_KHR, 629 eBufferImageCopy2KHR = VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2_KHR, 630 eImageResolve2KHR = VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2_KHR, 631 ePhysicalDevice4444FormatsFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT, 632 ePhysicalDeviceVertexInputDynamicStateFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT, 633 eVertexInputBindingDescription2EXT = VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT, 634 eVertexInputAttributeDescription2EXT = VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT, 635 #if defined( VK_USE_PLATFORM_SCI ) 636 eImportFenceSciSyncInfoNV = VK_STRUCTURE_TYPE_IMPORT_FENCE_SCI_SYNC_INFO_NV, 637 eExportFenceSciSyncInfoNV = VK_STRUCTURE_TYPE_EXPORT_FENCE_SCI_SYNC_INFO_NV, 638 eFenceGetSciSyncInfoNV = VK_STRUCTURE_TYPE_FENCE_GET_SCI_SYNC_INFO_NV, 639 eSciSyncAttributesInfoNV = VK_STRUCTURE_TYPE_SCI_SYNC_ATTRIBUTES_INFO_NV, 640 eImportSemaphoreSciSyncInfoNV = VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_SCI_SYNC_INFO_NV, 641 eExportSemaphoreSciSyncInfoNV = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_SCI_SYNC_INFO_NV, 642 eSemaphoreGetSciSyncInfoNV = VK_STRUCTURE_TYPE_SEMAPHORE_GET_SCI_SYNC_INFO_NV, 643 ePhysicalDeviceExternalSciSyncFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SCI_SYNC_FEATURES_NV, 644 eImportMemorySciBufInfoNV = VK_STRUCTURE_TYPE_IMPORT_MEMORY_SCI_BUF_INFO_NV, 645 eExportMemorySciBufInfoNV = VK_STRUCTURE_TYPE_EXPORT_MEMORY_SCI_BUF_INFO_NV, 646 eMemoryGetSciBufInfoNV = VK_STRUCTURE_TYPE_MEMORY_GET_SCI_BUF_INFO_NV, 647 eMemorySciBufPropertiesNV = VK_STRUCTURE_TYPE_MEMORY_SCI_BUF_PROPERTIES_NV, 648 ePhysicalDeviceExternalMemorySciBufFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCI_BUF_FEATURES_NV, 649 ePhysicalDeviceExternalSciBufFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SCI_BUF_FEATURES_NV, 650 #endif /*VK_USE_PLATFORM_SCI*/ 651 ePhysicalDeviceExtendedDynamicState2FeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT, 652 ePhysicalDeviceColorWriteEnableFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT, 653 ePipelineColorWriteCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT, 654 eApplicationParametersEXT = VK_STRUCTURE_TYPE_APPLICATION_PARAMETERS_EXT, 655 #if defined( VK_USE_PLATFORM_SCI ) 656 eSemaphoreSciSyncPoolCreateInfoNV = VK_STRUCTURE_TYPE_SEMAPHORE_SCI_SYNC_POOL_CREATE_INFO_NV, 657 eSemaphoreSciSyncCreateInfoNV = VK_STRUCTURE_TYPE_SEMAPHORE_SCI_SYNC_CREATE_INFO_NV, 658 ePhysicalDeviceExternalSciSync2FeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SCI_SYNC_2_FEATURES_NV, 659 eDeviceSemaphoreSciSyncPoolReservationCreateInfoNV = VK_STRUCTURE_TYPE_DEVICE_SEMAPHORE_SCI_SYNC_POOL_RESERVATION_CREATE_INFO_NV, 660 #endif /*VK_USE_PLATFORM_SCI*/ 661 #if defined( VK_USE_PLATFORM_SCREEN_QNX ) 662 eScreenBufferPropertiesQNX = VK_STRUCTURE_TYPE_SCREEN_BUFFER_PROPERTIES_QNX, 663 eScreenBufferFormatPropertiesQNX = VK_STRUCTURE_TYPE_SCREEN_BUFFER_FORMAT_PROPERTIES_QNX, 664 eImportScreenBufferInfoQNX = VK_STRUCTURE_TYPE_IMPORT_SCREEN_BUFFER_INFO_QNX, 665 eExternalFormatQNX = VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_QNX, 666 ePhysicalDeviceExternalMemoryScreenBufferFeaturesQNX = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX 667 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/ 668 }; 669 670 enum class PipelineCacheHeaderVersion 671 { 672 eOne = VK_PIPELINE_CACHE_HEADER_VERSION_ONE, 673 eSafetyCriticalOne = VK_PIPELINE_CACHE_HEADER_VERSION_SAFETY_CRITICAL_ONE 674 }; 675 676 enum class ObjectType 677 { 678 eUnknown = VK_OBJECT_TYPE_UNKNOWN, 679 eInstance = VK_OBJECT_TYPE_INSTANCE, 680 ePhysicalDevice = VK_OBJECT_TYPE_PHYSICAL_DEVICE, 681 eDevice = VK_OBJECT_TYPE_DEVICE, 682 eQueue = VK_OBJECT_TYPE_QUEUE, 683 eSemaphore = VK_OBJECT_TYPE_SEMAPHORE, 684 eCommandBuffer = VK_OBJECT_TYPE_COMMAND_BUFFER, 685 eFence = VK_OBJECT_TYPE_FENCE, 686 eDeviceMemory = VK_OBJECT_TYPE_DEVICE_MEMORY, 687 eBuffer = VK_OBJECT_TYPE_BUFFER, 688 eImage = VK_OBJECT_TYPE_IMAGE, 689 eEvent = VK_OBJECT_TYPE_EVENT, 690 eQueryPool = VK_OBJECT_TYPE_QUERY_POOL, 691 eBufferView = VK_OBJECT_TYPE_BUFFER_VIEW, 692 eImageView = VK_OBJECT_TYPE_IMAGE_VIEW, 693 eShaderModule = VK_OBJECT_TYPE_SHADER_MODULE, 694 ePipelineCache = VK_OBJECT_TYPE_PIPELINE_CACHE, 695 ePipelineLayout = VK_OBJECT_TYPE_PIPELINE_LAYOUT, 696 eRenderPass = VK_OBJECT_TYPE_RENDER_PASS, 697 ePipeline = VK_OBJECT_TYPE_PIPELINE, 698 eDescriptorSetLayout = VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT, 699 eSampler = VK_OBJECT_TYPE_SAMPLER, 700 eDescriptorPool = VK_OBJECT_TYPE_DESCRIPTOR_POOL, 701 eDescriptorSet = VK_OBJECT_TYPE_DESCRIPTOR_SET, 702 eFramebuffer = VK_OBJECT_TYPE_FRAMEBUFFER, 703 eCommandPool = VK_OBJECT_TYPE_COMMAND_POOL, 704 eSamplerYcbcrConversion = VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION, 705 ePrivateDataSlot = VK_OBJECT_TYPE_PRIVATE_DATA_SLOT, 706 eSurfaceKHR = VK_OBJECT_TYPE_SURFACE_KHR, 707 eSwapchainKHR = VK_OBJECT_TYPE_SWAPCHAIN_KHR, 708 eDisplayKHR = VK_OBJECT_TYPE_DISPLAY_KHR, 709 eDisplayModeKHR = VK_OBJECT_TYPE_DISPLAY_MODE_KHR, 710 eDebugUtilsMessengerEXT = VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT, 711 #if defined( VK_USE_PLATFORM_SCI ) 712 eSemaphoreSciSyncPoolNV = VK_OBJECT_TYPE_SEMAPHORE_SCI_SYNC_POOL_NV 713 #endif /*VK_USE_PLATFORM_SCI*/ 714 }; 715 716 enum class VendorId 717 { 718 eVIV = VK_VENDOR_ID_VIV, 719 eVSI = VK_VENDOR_ID_VSI, 720 eKazan = VK_VENDOR_ID_KAZAN, 721 eCodeplay = VK_VENDOR_ID_CODEPLAY, 722 eMESA = VK_VENDOR_ID_MESA, 723 ePocl = VK_VENDOR_ID_POCL, 724 eMobileye = VK_VENDOR_ID_MOBILEYE 725 }; 726 727 enum class Format 728 { 729 eUndefined = VK_FORMAT_UNDEFINED, 730 eR4G4UnormPack8 = VK_FORMAT_R4G4_UNORM_PACK8, 731 eR4G4B4A4UnormPack16 = VK_FORMAT_R4G4B4A4_UNORM_PACK16, 732 eB4G4R4A4UnormPack16 = VK_FORMAT_B4G4R4A4_UNORM_PACK16, 733 eR5G6B5UnormPack16 = VK_FORMAT_R5G6B5_UNORM_PACK16, 734 eB5G6R5UnormPack16 = VK_FORMAT_B5G6R5_UNORM_PACK16, 735 eR5G5B5A1UnormPack16 = VK_FORMAT_R5G5B5A1_UNORM_PACK16, 736 eB5G5R5A1UnormPack16 = VK_FORMAT_B5G5R5A1_UNORM_PACK16, 737 eA1R5G5B5UnormPack16 = VK_FORMAT_A1R5G5B5_UNORM_PACK16, 738 eR8Unorm = VK_FORMAT_R8_UNORM, 739 eR8Snorm = VK_FORMAT_R8_SNORM, 740 eR8Uscaled = VK_FORMAT_R8_USCALED, 741 eR8Sscaled = VK_FORMAT_R8_SSCALED, 742 eR8Uint = VK_FORMAT_R8_UINT, 743 eR8Sint = VK_FORMAT_R8_SINT, 744 eR8Srgb = VK_FORMAT_R8_SRGB, 745 eR8G8Unorm = VK_FORMAT_R8G8_UNORM, 746 eR8G8Snorm = VK_FORMAT_R8G8_SNORM, 747 eR8G8Uscaled = VK_FORMAT_R8G8_USCALED, 748 eR8G8Sscaled = VK_FORMAT_R8G8_SSCALED, 749 eR8G8Uint = VK_FORMAT_R8G8_UINT, 750 eR8G8Sint = VK_FORMAT_R8G8_SINT, 751 eR8G8Srgb = VK_FORMAT_R8G8_SRGB, 752 eR8G8B8Unorm = VK_FORMAT_R8G8B8_UNORM, 753 eR8G8B8Snorm = VK_FORMAT_R8G8B8_SNORM, 754 eR8G8B8Uscaled = VK_FORMAT_R8G8B8_USCALED, 755 eR8G8B8Sscaled = VK_FORMAT_R8G8B8_SSCALED, 756 eR8G8B8Uint = VK_FORMAT_R8G8B8_UINT, 757 eR8G8B8Sint = VK_FORMAT_R8G8B8_SINT, 758 eR8G8B8Srgb = VK_FORMAT_R8G8B8_SRGB, 759 eB8G8R8Unorm = VK_FORMAT_B8G8R8_UNORM, 760 eB8G8R8Snorm = VK_FORMAT_B8G8R8_SNORM, 761 eB8G8R8Uscaled = VK_FORMAT_B8G8R8_USCALED, 762 eB8G8R8Sscaled = VK_FORMAT_B8G8R8_SSCALED, 763 eB8G8R8Uint = VK_FORMAT_B8G8R8_UINT, 764 eB8G8R8Sint = VK_FORMAT_B8G8R8_SINT, 765 eB8G8R8Srgb = VK_FORMAT_B8G8R8_SRGB, 766 eR8G8B8A8Unorm = VK_FORMAT_R8G8B8A8_UNORM, 767 eR8G8B8A8Snorm = VK_FORMAT_R8G8B8A8_SNORM, 768 eR8G8B8A8Uscaled = VK_FORMAT_R8G8B8A8_USCALED, 769 eR8G8B8A8Sscaled = VK_FORMAT_R8G8B8A8_SSCALED, 770 eR8G8B8A8Uint = VK_FORMAT_R8G8B8A8_UINT, 771 eR8G8B8A8Sint = VK_FORMAT_R8G8B8A8_SINT, 772 eR8G8B8A8Srgb = VK_FORMAT_R8G8B8A8_SRGB, 773 eB8G8R8A8Unorm = VK_FORMAT_B8G8R8A8_UNORM, 774 eB8G8R8A8Snorm = VK_FORMAT_B8G8R8A8_SNORM, 775 eB8G8R8A8Uscaled = VK_FORMAT_B8G8R8A8_USCALED, 776 eB8G8R8A8Sscaled = VK_FORMAT_B8G8R8A8_SSCALED, 777 eB8G8R8A8Uint = VK_FORMAT_B8G8R8A8_UINT, 778 eB8G8R8A8Sint = VK_FORMAT_B8G8R8A8_SINT, 779 eB8G8R8A8Srgb = VK_FORMAT_B8G8R8A8_SRGB, 780 eA8B8G8R8UnormPack32 = VK_FORMAT_A8B8G8R8_UNORM_PACK32, 781 eA8B8G8R8SnormPack32 = VK_FORMAT_A8B8G8R8_SNORM_PACK32, 782 eA8B8G8R8UscaledPack32 = VK_FORMAT_A8B8G8R8_USCALED_PACK32, 783 eA8B8G8R8SscaledPack32 = VK_FORMAT_A8B8G8R8_SSCALED_PACK32, 784 eA8B8G8R8UintPack32 = VK_FORMAT_A8B8G8R8_UINT_PACK32, 785 eA8B8G8R8SintPack32 = VK_FORMAT_A8B8G8R8_SINT_PACK32, 786 eA8B8G8R8SrgbPack32 = VK_FORMAT_A8B8G8R8_SRGB_PACK32, 787 eA2R10G10B10UnormPack32 = VK_FORMAT_A2R10G10B10_UNORM_PACK32, 788 eA2R10G10B10SnormPack32 = VK_FORMAT_A2R10G10B10_SNORM_PACK32, 789 eA2R10G10B10UscaledPack32 = VK_FORMAT_A2R10G10B10_USCALED_PACK32, 790 eA2R10G10B10SscaledPack32 = VK_FORMAT_A2R10G10B10_SSCALED_PACK32, 791 eA2R10G10B10UintPack32 = VK_FORMAT_A2R10G10B10_UINT_PACK32, 792 eA2R10G10B10SintPack32 = VK_FORMAT_A2R10G10B10_SINT_PACK32, 793 eA2B10G10R10UnormPack32 = VK_FORMAT_A2B10G10R10_UNORM_PACK32, 794 eA2B10G10R10SnormPack32 = VK_FORMAT_A2B10G10R10_SNORM_PACK32, 795 eA2B10G10R10UscaledPack32 = VK_FORMAT_A2B10G10R10_USCALED_PACK32, 796 eA2B10G10R10SscaledPack32 = VK_FORMAT_A2B10G10R10_SSCALED_PACK32, 797 eA2B10G10R10UintPack32 = VK_FORMAT_A2B10G10R10_UINT_PACK32, 798 eA2B10G10R10SintPack32 = VK_FORMAT_A2B10G10R10_SINT_PACK32, 799 eR16Unorm = VK_FORMAT_R16_UNORM, 800 eR16Snorm = VK_FORMAT_R16_SNORM, 801 eR16Uscaled = VK_FORMAT_R16_USCALED, 802 eR16Sscaled = VK_FORMAT_R16_SSCALED, 803 eR16Uint = VK_FORMAT_R16_UINT, 804 eR16Sint = VK_FORMAT_R16_SINT, 805 eR16Sfloat = VK_FORMAT_R16_SFLOAT, 806 eR16G16Unorm = VK_FORMAT_R16G16_UNORM, 807 eR16G16Snorm = VK_FORMAT_R16G16_SNORM, 808 eR16G16Uscaled = VK_FORMAT_R16G16_USCALED, 809 eR16G16Sscaled = VK_FORMAT_R16G16_SSCALED, 810 eR16G16Uint = VK_FORMAT_R16G16_UINT, 811 eR16G16Sint = VK_FORMAT_R16G16_SINT, 812 eR16G16Sfloat = VK_FORMAT_R16G16_SFLOAT, 813 eR16G16B16Unorm = VK_FORMAT_R16G16B16_UNORM, 814 eR16G16B16Snorm = VK_FORMAT_R16G16B16_SNORM, 815 eR16G16B16Uscaled = VK_FORMAT_R16G16B16_USCALED, 816 eR16G16B16Sscaled = VK_FORMAT_R16G16B16_SSCALED, 817 eR16G16B16Uint = VK_FORMAT_R16G16B16_UINT, 818 eR16G16B16Sint = VK_FORMAT_R16G16B16_SINT, 819 eR16G16B16Sfloat = VK_FORMAT_R16G16B16_SFLOAT, 820 eR16G16B16A16Unorm = VK_FORMAT_R16G16B16A16_UNORM, 821 eR16G16B16A16Snorm = VK_FORMAT_R16G16B16A16_SNORM, 822 eR16G16B16A16Uscaled = VK_FORMAT_R16G16B16A16_USCALED, 823 eR16G16B16A16Sscaled = VK_FORMAT_R16G16B16A16_SSCALED, 824 eR16G16B16A16Uint = VK_FORMAT_R16G16B16A16_UINT, 825 eR16G16B16A16Sint = VK_FORMAT_R16G16B16A16_SINT, 826 eR16G16B16A16Sfloat = VK_FORMAT_R16G16B16A16_SFLOAT, 827 eR32Uint = VK_FORMAT_R32_UINT, 828 eR32Sint = VK_FORMAT_R32_SINT, 829 eR32Sfloat = VK_FORMAT_R32_SFLOAT, 830 eR32G32Uint = VK_FORMAT_R32G32_UINT, 831 eR32G32Sint = VK_FORMAT_R32G32_SINT, 832 eR32G32Sfloat = VK_FORMAT_R32G32_SFLOAT, 833 eR32G32B32Uint = VK_FORMAT_R32G32B32_UINT, 834 eR32G32B32Sint = VK_FORMAT_R32G32B32_SINT, 835 eR32G32B32Sfloat = VK_FORMAT_R32G32B32_SFLOAT, 836 eR32G32B32A32Uint = VK_FORMAT_R32G32B32A32_UINT, 837 eR32G32B32A32Sint = VK_FORMAT_R32G32B32A32_SINT, 838 eR32G32B32A32Sfloat = VK_FORMAT_R32G32B32A32_SFLOAT, 839 eR64Uint = VK_FORMAT_R64_UINT, 840 eR64Sint = VK_FORMAT_R64_SINT, 841 eR64Sfloat = VK_FORMAT_R64_SFLOAT, 842 eR64G64Uint = VK_FORMAT_R64G64_UINT, 843 eR64G64Sint = VK_FORMAT_R64G64_SINT, 844 eR64G64Sfloat = VK_FORMAT_R64G64_SFLOAT, 845 eR64G64B64Uint = VK_FORMAT_R64G64B64_UINT, 846 eR64G64B64Sint = VK_FORMAT_R64G64B64_SINT, 847 eR64G64B64Sfloat = VK_FORMAT_R64G64B64_SFLOAT, 848 eR64G64B64A64Uint = VK_FORMAT_R64G64B64A64_UINT, 849 eR64G64B64A64Sint = VK_FORMAT_R64G64B64A64_SINT, 850 eR64G64B64A64Sfloat = VK_FORMAT_R64G64B64A64_SFLOAT, 851 eB10G11R11UfloatPack32 = VK_FORMAT_B10G11R11_UFLOAT_PACK32, 852 eE5B9G9R9UfloatPack32 = VK_FORMAT_E5B9G9R9_UFLOAT_PACK32, 853 eD16Unorm = VK_FORMAT_D16_UNORM, 854 eX8D24UnormPack32 = VK_FORMAT_X8_D24_UNORM_PACK32, 855 eD32Sfloat = VK_FORMAT_D32_SFLOAT, 856 eS8Uint = VK_FORMAT_S8_UINT, 857 eD16UnormS8Uint = VK_FORMAT_D16_UNORM_S8_UINT, 858 eD24UnormS8Uint = VK_FORMAT_D24_UNORM_S8_UINT, 859 eD32SfloatS8Uint = VK_FORMAT_D32_SFLOAT_S8_UINT, 860 eBc1RgbUnormBlock = VK_FORMAT_BC1_RGB_UNORM_BLOCK, 861 eBc1RgbSrgbBlock = VK_FORMAT_BC1_RGB_SRGB_BLOCK, 862 eBc1RgbaUnormBlock = VK_FORMAT_BC1_RGBA_UNORM_BLOCK, 863 eBc1RgbaSrgbBlock = VK_FORMAT_BC1_RGBA_SRGB_BLOCK, 864 eBc2UnormBlock = VK_FORMAT_BC2_UNORM_BLOCK, 865 eBc2SrgbBlock = VK_FORMAT_BC2_SRGB_BLOCK, 866 eBc3UnormBlock = VK_FORMAT_BC3_UNORM_BLOCK, 867 eBc3SrgbBlock = VK_FORMAT_BC3_SRGB_BLOCK, 868 eBc4UnormBlock = VK_FORMAT_BC4_UNORM_BLOCK, 869 eBc4SnormBlock = VK_FORMAT_BC4_SNORM_BLOCK, 870 eBc5UnormBlock = VK_FORMAT_BC5_UNORM_BLOCK, 871 eBc5SnormBlock = VK_FORMAT_BC5_SNORM_BLOCK, 872 eBc6HUfloatBlock = VK_FORMAT_BC6H_UFLOAT_BLOCK, 873 eBc6HSfloatBlock = VK_FORMAT_BC6H_SFLOAT_BLOCK, 874 eBc7UnormBlock = VK_FORMAT_BC7_UNORM_BLOCK, 875 eBc7SrgbBlock = VK_FORMAT_BC7_SRGB_BLOCK, 876 eEtc2R8G8B8UnormBlock = VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK, 877 eEtc2R8G8B8SrgbBlock = VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK, 878 eEtc2R8G8B8A1UnormBlock = VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK, 879 eEtc2R8G8B8A1SrgbBlock = VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK, 880 eEtc2R8G8B8A8UnormBlock = VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK, 881 eEtc2R8G8B8A8SrgbBlock = VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK, 882 eEacR11UnormBlock = VK_FORMAT_EAC_R11_UNORM_BLOCK, 883 eEacR11SnormBlock = VK_FORMAT_EAC_R11_SNORM_BLOCK, 884 eEacR11G11UnormBlock = VK_FORMAT_EAC_R11G11_UNORM_BLOCK, 885 eEacR11G11SnormBlock = VK_FORMAT_EAC_R11G11_SNORM_BLOCK, 886 eAstc4x4UnormBlock = VK_FORMAT_ASTC_4x4_UNORM_BLOCK, 887 eAstc4x4SrgbBlock = VK_FORMAT_ASTC_4x4_SRGB_BLOCK, 888 eAstc5x4UnormBlock = VK_FORMAT_ASTC_5x4_UNORM_BLOCK, 889 eAstc5x4SrgbBlock = VK_FORMAT_ASTC_5x4_SRGB_BLOCK, 890 eAstc5x5UnormBlock = VK_FORMAT_ASTC_5x5_UNORM_BLOCK, 891 eAstc5x5SrgbBlock = VK_FORMAT_ASTC_5x5_SRGB_BLOCK, 892 eAstc6x5UnormBlock = VK_FORMAT_ASTC_6x5_UNORM_BLOCK, 893 eAstc6x5SrgbBlock = VK_FORMAT_ASTC_6x5_SRGB_BLOCK, 894 eAstc6x6UnormBlock = VK_FORMAT_ASTC_6x6_UNORM_BLOCK, 895 eAstc6x6SrgbBlock = VK_FORMAT_ASTC_6x6_SRGB_BLOCK, 896 eAstc8x5UnormBlock = VK_FORMAT_ASTC_8x5_UNORM_BLOCK, 897 eAstc8x5SrgbBlock = VK_FORMAT_ASTC_8x5_SRGB_BLOCK, 898 eAstc8x6UnormBlock = VK_FORMAT_ASTC_8x6_UNORM_BLOCK, 899 eAstc8x6SrgbBlock = VK_FORMAT_ASTC_8x6_SRGB_BLOCK, 900 eAstc8x8UnormBlock = VK_FORMAT_ASTC_8x8_UNORM_BLOCK, 901 eAstc8x8SrgbBlock = VK_FORMAT_ASTC_8x8_SRGB_BLOCK, 902 eAstc10x5UnormBlock = VK_FORMAT_ASTC_10x5_UNORM_BLOCK, 903 eAstc10x5SrgbBlock = VK_FORMAT_ASTC_10x5_SRGB_BLOCK, 904 eAstc10x6UnormBlock = VK_FORMAT_ASTC_10x6_UNORM_BLOCK, 905 eAstc10x6SrgbBlock = VK_FORMAT_ASTC_10x6_SRGB_BLOCK, 906 eAstc10x8UnormBlock = VK_FORMAT_ASTC_10x8_UNORM_BLOCK, 907 eAstc10x8SrgbBlock = VK_FORMAT_ASTC_10x8_SRGB_BLOCK, 908 eAstc10x10UnormBlock = VK_FORMAT_ASTC_10x10_UNORM_BLOCK, 909 eAstc10x10SrgbBlock = VK_FORMAT_ASTC_10x10_SRGB_BLOCK, 910 eAstc12x10UnormBlock = VK_FORMAT_ASTC_12x10_UNORM_BLOCK, 911 eAstc12x10SrgbBlock = VK_FORMAT_ASTC_12x10_SRGB_BLOCK, 912 eAstc12x12UnormBlock = VK_FORMAT_ASTC_12x12_UNORM_BLOCK, 913 eAstc12x12SrgbBlock = VK_FORMAT_ASTC_12x12_SRGB_BLOCK, 914 eG8B8G8R8422Unorm = VK_FORMAT_G8B8G8R8_422_UNORM, 915 eB8G8R8G8422Unorm = VK_FORMAT_B8G8R8G8_422_UNORM, 916 eG8B8R83Plane420Unorm = VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM, 917 eG8B8R82Plane420Unorm = VK_FORMAT_G8_B8R8_2PLANE_420_UNORM, 918 eG8B8R83Plane422Unorm = VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM, 919 eG8B8R82Plane422Unorm = VK_FORMAT_G8_B8R8_2PLANE_422_UNORM, 920 eG8B8R83Plane444Unorm = VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM, 921 eR10X6UnormPack16 = VK_FORMAT_R10X6_UNORM_PACK16, 922 eR10X6G10X6Unorm2Pack16 = VK_FORMAT_R10X6G10X6_UNORM_2PACK16, 923 eR10X6G10X6B10X6A10X6Unorm4Pack16 = VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16, 924 eG10X6B10X6G10X6R10X6422Unorm4Pack16 = VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16, 925 eB10X6G10X6R10X6G10X6422Unorm4Pack16 = VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16, 926 eG10X6B10X6R10X63Plane420Unorm3Pack16 = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16, 927 eG10X6B10X6R10X62Plane420Unorm3Pack16 = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16, 928 eG10X6B10X6R10X63Plane422Unorm3Pack16 = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16, 929 eG10X6B10X6R10X62Plane422Unorm3Pack16 = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16, 930 eG10X6B10X6R10X63Plane444Unorm3Pack16 = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16, 931 eR12X4UnormPack16 = VK_FORMAT_R12X4_UNORM_PACK16, 932 eR12X4G12X4Unorm2Pack16 = VK_FORMAT_R12X4G12X4_UNORM_2PACK16, 933 eR12X4G12X4B12X4A12X4Unorm4Pack16 = VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16, 934 eG12X4B12X4G12X4R12X4422Unorm4Pack16 = VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16, 935 eB12X4G12X4R12X4G12X4422Unorm4Pack16 = VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16, 936 eG12X4B12X4R12X43Plane420Unorm3Pack16 = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16, 937 eG12X4B12X4R12X42Plane420Unorm3Pack16 = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16, 938 eG12X4B12X4R12X43Plane422Unorm3Pack16 = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16, 939 eG12X4B12X4R12X42Plane422Unorm3Pack16 = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16, 940 eG12X4B12X4R12X43Plane444Unorm3Pack16 = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16, 941 eG16B16G16R16422Unorm = VK_FORMAT_G16B16G16R16_422_UNORM, 942 eB16G16R16G16422Unorm = VK_FORMAT_B16G16R16G16_422_UNORM, 943 eG16B16R163Plane420Unorm = VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM, 944 eG16B16R162Plane420Unorm = VK_FORMAT_G16_B16R16_2PLANE_420_UNORM, 945 eG16B16R163Plane422Unorm = VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM, 946 eG16B16R162Plane422Unorm = VK_FORMAT_G16_B16R16_2PLANE_422_UNORM, 947 eG16B16R163Plane444Unorm = VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM, 948 eG8B8R82Plane444Unorm = VK_FORMAT_G8_B8R8_2PLANE_444_UNORM, 949 eG10X6B10X6R10X62Plane444Unorm3Pack16 = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16, 950 eG12X4B12X4R12X42Plane444Unorm3Pack16 = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16, 951 eG16B16R162Plane444Unorm = VK_FORMAT_G16_B16R16_2PLANE_444_UNORM, 952 eA4R4G4B4UnormPack16 = VK_FORMAT_A4R4G4B4_UNORM_PACK16, 953 eA4B4G4R4UnormPack16 = VK_FORMAT_A4B4G4R4_UNORM_PACK16, 954 eAstc4x4SfloatBlock = VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK, 955 eAstc5x4SfloatBlock = VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK, 956 eAstc5x5SfloatBlock = VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK, 957 eAstc6x5SfloatBlock = VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK, 958 eAstc6x6SfloatBlock = VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK, 959 eAstc8x5SfloatBlock = VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK, 960 eAstc8x6SfloatBlock = VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK, 961 eAstc8x8SfloatBlock = VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK, 962 eAstc10x5SfloatBlock = VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK, 963 eAstc10x6SfloatBlock = VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK, 964 eAstc10x8SfloatBlock = VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK, 965 eAstc10x10SfloatBlock = VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK, 966 eAstc12x10SfloatBlock = VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK, 967 eAstc12x12SfloatBlock = VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK, 968 eAstc4x4SfloatBlockEXT = VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK_EXT, 969 eAstc5x4SfloatBlockEXT = VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK_EXT, 970 eAstc5x5SfloatBlockEXT = VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK_EXT, 971 eAstc6x5SfloatBlockEXT = VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK_EXT, 972 eAstc6x6SfloatBlockEXT = VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK_EXT, 973 eAstc8x5SfloatBlockEXT = VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK_EXT, 974 eAstc8x6SfloatBlockEXT = VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK_EXT, 975 eAstc8x8SfloatBlockEXT = VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK_EXT, 976 eAstc10x5SfloatBlockEXT = VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK_EXT, 977 eAstc10x6SfloatBlockEXT = VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK_EXT, 978 eAstc10x8SfloatBlockEXT = VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK_EXT, 979 eAstc10x10SfloatBlockEXT = VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK_EXT, 980 eAstc12x10SfloatBlockEXT = VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK_EXT, 981 eAstc12x12SfloatBlockEXT = VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK_EXT, 982 eG8B8R82Plane444UnormEXT = VK_FORMAT_G8_B8R8_2PLANE_444_UNORM_EXT, 983 eG10X6B10X6R10X62Plane444Unorm3Pack16EXT = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16_EXT, 984 eG12X4B12X4R12X42Plane444Unorm3Pack16EXT = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16_EXT, 985 eG16B16R162Plane444UnormEXT = VK_FORMAT_G16_B16R16_2PLANE_444_UNORM_EXT, 986 eA4R4G4B4UnormPack16EXT = VK_FORMAT_A4R4G4B4_UNORM_PACK16_EXT, 987 eA4B4G4R4UnormPack16EXT = VK_FORMAT_A4B4G4R4_UNORM_PACK16_EXT 988 }; 989 990 enum class FormatFeatureFlagBits : VkFormatFeatureFlags 991 { 992 eSampledImage = VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT, 993 eStorageImage = VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT, 994 eStorageImageAtomic = VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT, 995 eUniformTexelBuffer = VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT, 996 eStorageTexelBuffer = VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT, 997 eStorageTexelBufferAtomic = VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT, 998 eVertexBuffer = VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT, 999 eColorAttachment = VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT, 1000 eColorAttachmentBlend = VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT, 1001 eDepthStencilAttachment = VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT, 1002 eBlitSrc = VK_FORMAT_FEATURE_BLIT_SRC_BIT, 1003 eBlitDst = VK_FORMAT_FEATURE_BLIT_DST_BIT, 1004 eSampledImageFilterLinear = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT, 1005 eTransferSrc = VK_FORMAT_FEATURE_TRANSFER_SRC_BIT, 1006 eTransferDst = VK_FORMAT_FEATURE_TRANSFER_DST_BIT, 1007 eMidpointChromaSamples = VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT, 1008 eSampledImageYcbcrConversionLinearFilter = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT, 1009 eSampledImageYcbcrConversionSeparateReconstructionFilter = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT, 1010 eSampledImageYcbcrConversionChromaReconstructionExplicit = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT, 1011 eSampledImageYcbcrConversionChromaReconstructionExplicitForceable = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT, 1012 eDisjoint = VK_FORMAT_FEATURE_DISJOINT_BIT, 1013 eCositedChromaSamples = VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT, 1014 eSampledImageFilterMinmax = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT, 1015 eSampledImageFilterCubicEXT = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT, 1016 eFragmentShadingRateAttachmentKHR = VK_FORMAT_FEATURE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR 1017 }; 1018 1019 using FormatFeatureFlags = Flags<FormatFeatureFlagBits>; 1020 1021 1022 template <> struct FlagTraits<FormatFeatureFlagBits> 1023 { 1024 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 1025 static VULKAN_HPP_CONST_OR_CONSTEXPR FormatFeatureFlags allFlags = 1026 FormatFeatureFlagBits::eSampledImage 1027 | FormatFeatureFlagBits::eStorageImage 1028 | FormatFeatureFlagBits::eStorageImageAtomic 1029 | FormatFeatureFlagBits::eUniformTexelBuffer 1030 | FormatFeatureFlagBits::eStorageTexelBuffer 1031 | FormatFeatureFlagBits::eStorageTexelBufferAtomic 1032 | FormatFeatureFlagBits::eVertexBuffer 1033 | FormatFeatureFlagBits::eColorAttachment 1034 | FormatFeatureFlagBits::eColorAttachmentBlend 1035 | FormatFeatureFlagBits::eDepthStencilAttachment 1036 | FormatFeatureFlagBits::eBlitSrc 1037 | FormatFeatureFlagBits::eBlitDst 1038 | FormatFeatureFlagBits::eSampledImageFilterLinear 1039 | FormatFeatureFlagBits::eTransferSrc 1040 | FormatFeatureFlagBits::eTransferDst 1041 | FormatFeatureFlagBits::eMidpointChromaSamples 1042 | FormatFeatureFlagBits::eSampledImageYcbcrConversionLinearFilter 1043 | FormatFeatureFlagBits::eSampledImageYcbcrConversionSeparateReconstructionFilter 1044 | FormatFeatureFlagBits::eSampledImageYcbcrConversionChromaReconstructionExplicit 1045 | FormatFeatureFlagBits::eSampledImageYcbcrConversionChromaReconstructionExplicitForceable 1046 | FormatFeatureFlagBits::eDisjoint 1047 | FormatFeatureFlagBits::eCositedChromaSamples 1048 | FormatFeatureFlagBits::eSampledImageFilterMinmax 1049 | FormatFeatureFlagBits::eSampledImageFilterCubicEXT 1050 | FormatFeatureFlagBits::eFragmentShadingRateAttachmentKHR; 1051 }; 1052 1053 enum class ImageCreateFlagBits : VkImageCreateFlags 1054 { 1055 eSparseBinding = VK_IMAGE_CREATE_SPARSE_BINDING_BIT, 1056 eSparseResidency = VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT, 1057 eSparseAliased = VK_IMAGE_CREATE_SPARSE_ALIASED_BIT, 1058 eMutableFormat = VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT, 1059 eCubeCompatible = VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT, 1060 eAlias = VK_IMAGE_CREATE_ALIAS_BIT, 1061 eSplitInstanceBindRegions = VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT, 1062 e2DArrayCompatible = VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT, 1063 eBlockTexelViewCompatible = VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT, 1064 eExtendedUsage = VK_IMAGE_CREATE_EXTENDED_USAGE_BIT, 1065 eProtected = VK_IMAGE_CREATE_PROTECTED_BIT, 1066 eDisjoint = VK_IMAGE_CREATE_DISJOINT_BIT, 1067 eSampleLocationsCompatibleDepthEXT = VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT 1068 }; 1069 1070 using ImageCreateFlags = Flags<ImageCreateFlagBits>; 1071 1072 1073 template <> struct FlagTraits<ImageCreateFlagBits> 1074 { 1075 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 1076 static VULKAN_HPP_CONST_OR_CONSTEXPR ImageCreateFlags allFlags = 1077 ImageCreateFlagBits::eSparseBinding 1078 | ImageCreateFlagBits::eSparseResidency 1079 | ImageCreateFlagBits::eSparseAliased 1080 | ImageCreateFlagBits::eMutableFormat 1081 | ImageCreateFlagBits::eCubeCompatible 1082 | ImageCreateFlagBits::eAlias 1083 | ImageCreateFlagBits::eSplitInstanceBindRegions 1084 | ImageCreateFlagBits::e2DArrayCompatible 1085 | ImageCreateFlagBits::eBlockTexelViewCompatible 1086 | ImageCreateFlagBits::eExtendedUsage 1087 | ImageCreateFlagBits::eProtected 1088 | ImageCreateFlagBits::eDisjoint 1089 | ImageCreateFlagBits::eSampleLocationsCompatibleDepthEXT; 1090 }; 1091 1092 enum class ImageTiling 1093 { 1094 eOptimal = VK_IMAGE_TILING_OPTIMAL, 1095 eLinear = VK_IMAGE_TILING_LINEAR, 1096 eDrmFormatModifierEXT = VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT 1097 }; 1098 1099 enum class ImageType 1100 { 1101 e1D = VK_IMAGE_TYPE_1D, 1102 e2D = VK_IMAGE_TYPE_2D, 1103 e3D = VK_IMAGE_TYPE_3D 1104 }; 1105 1106 enum class ImageUsageFlagBits : VkImageUsageFlags 1107 { 1108 eTransferSrc = VK_IMAGE_USAGE_TRANSFER_SRC_BIT, 1109 eTransferDst = VK_IMAGE_USAGE_TRANSFER_DST_BIT, 1110 eSampled = VK_IMAGE_USAGE_SAMPLED_BIT, 1111 eStorage = VK_IMAGE_USAGE_STORAGE_BIT, 1112 eColorAttachment = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, 1113 eDepthStencilAttachment = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, 1114 eTransientAttachment = VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT, 1115 eInputAttachment = VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT, 1116 eFragmentShadingRateAttachmentKHR = VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR 1117 }; 1118 1119 using ImageUsageFlags = Flags<ImageUsageFlagBits>; 1120 1121 1122 template <> struct FlagTraits<ImageUsageFlagBits> 1123 { 1124 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 1125 static VULKAN_HPP_CONST_OR_CONSTEXPR ImageUsageFlags allFlags = 1126 ImageUsageFlagBits::eTransferSrc 1127 | ImageUsageFlagBits::eTransferDst 1128 | ImageUsageFlagBits::eSampled 1129 | ImageUsageFlagBits::eStorage 1130 | ImageUsageFlagBits::eColorAttachment 1131 | ImageUsageFlagBits::eDepthStencilAttachment 1132 | ImageUsageFlagBits::eTransientAttachment 1133 | ImageUsageFlagBits::eInputAttachment 1134 | ImageUsageFlagBits::eFragmentShadingRateAttachmentKHR; 1135 }; 1136 1137 enum class InstanceCreateFlagBits : VkInstanceCreateFlags 1138 {}; 1139 1140 using InstanceCreateFlags = Flags<InstanceCreateFlagBits>; 1141 1142 1143 template <> struct FlagTraits<InstanceCreateFlagBits> 1144 { 1145 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 1146 static VULKAN_HPP_CONST_OR_CONSTEXPR InstanceCreateFlags allFlags = {}; 1147 }; 1148 1149 enum class InternalAllocationType 1150 { 1151 eExecutable = VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE 1152 }; 1153 1154 enum class MemoryHeapFlagBits : VkMemoryHeapFlags 1155 { 1156 eDeviceLocal = VK_MEMORY_HEAP_DEVICE_LOCAL_BIT, 1157 eMultiInstance = VK_MEMORY_HEAP_MULTI_INSTANCE_BIT, 1158 eSeuSafe = VK_MEMORY_HEAP_SEU_SAFE_BIT 1159 }; 1160 1161 using MemoryHeapFlags = Flags<MemoryHeapFlagBits>; 1162 1163 1164 template <> struct FlagTraits<MemoryHeapFlagBits> 1165 { 1166 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 1167 static VULKAN_HPP_CONST_OR_CONSTEXPR MemoryHeapFlags allFlags = 1168 MemoryHeapFlagBits::eDeviceLocal 1169 | MemoryHeapFlagBits::eMultiInstance 1170 | MemoryHeapFlagBits::eSeuSafe; 1171 }; 1172 1173 enum class MemoryPropertyFlagBits : VkMemoryPropertyFlags 1174 { 1175 eDeviceLocal = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, 1176 eHostVisible = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, 1177 eHostCoherent = VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, 1178 eHostCached = VK_MEMORY_PROPERTY_HOST_CACHED_BIT, 1179 eLazilyAllocated = VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT, 1180 eProtected = VK_MEMORY_PROPERTY_PROTECTED_BIT 1181 }; 1182 1183 using MemoryPropertyFlags = Flags<MemoryPropertyFlagBits>; 1184 1185 1186 template <> struct FlagTraits<MemoryPropertyFlagBits> 1187 { 1188 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 1189 static VULKAN_HPP_CONST_OR_CONSTEXPR MemoryPropertyFlags allFlags = 1190 MemoryPropertyFlagBits::eDeviceLocal 1191 | MemoryPropertyFlagBits::eHostVisible 1192 | MemoryPropertyFlagBits::eHostCoherent 1193 | MemoryPropertyFlagBits::eHostCached 1194 | MemoryPropertyFlagBits::eLazilyAllocated 1195 | MemoryPropertyFlagBits::eProtected; 1196 }; 1197 1198 enum class PhysicalDeviceType 1199 { 1200 eOther = VK_PHYSICAL_DEVICE_TYPE_OTHER, 1201 eIntegratedGpu = VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU, 1202 eDiscreteGpu = VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU, 1203 eVirtualGpu = VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU, 1204 eCpu = VK_PHYSICAL_DEVICE_TYPE_CPU 1205 }; 1206 1207 enum class QueueFlagBits : VkQueueFlags 1208 { 1209 eGraphics = VK_QUEUE_GRAPHICS_BIT, 1210 eCompute = VK_QUEUE_COMPUTE_BIT, 1211 eTransfer = VK_QUEUE_TRANSFER_BIT, 1212 eProtected = VK_QUEUE_PROTECTED_BIT 1213 }; 1214 1215 using QueueFlags = Flags<QueueFlagBits>; 1216 1217 1218 template <> struct FlagTraits<QueueFlagBits> 1219 { 1220 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 1221 static VULKAN_HPP_CONST_OR_CONSTEXPR QueueFlags allFlags = 1222 QueueFlagBits::eGraphics 1223 | QueueFlagBits::eCompute 1224 | QueueFlagBits::eTransfer 1225 | QueueFlagBits::eProtected; 1226 }; 1227 1228 enum class SampleCountFlagBits : VkSampleCountFlags 1229 { 1230 e1 = VK_SAMPLE_COUNT_1_BIT, 1231 e2 = VK_SAMPLE_COUNT_2_BIT, 1232 e4 = VK_SAMPLE_COUNT_4_BIT, 1233 e8 = VK_SAMPLE_COUNT_8_BIT, 1234 e16 = VK_SAMPLE_COUNT_16_BIT, 1235 e32 = VK_SAMPLE_COUNT_32_BIT, 1236 e64 = VK_SAMPLE_COUNT_64_BIT 1237 }; 1238 1239 using SampleCountFlags = Flags<SampleCountFlagBits>; 1240 1241 1242 template <> struct FlagTraits<SampleCountFlagBits> 1243 { 1244 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 1245 static VULKAN_HPP_CONST_OR_CONSTEXPR SampleCountFlags allFlags = 1246 SampleCountFlagBits::e1 1247 | SampleCountFlagBits::e2 1248 | SampleCountFlagBits::e4 1249 | SampleCountFlagBits::e8 1250 | SampleCountFlagBits::e16 1251 | SampleCountFlagBits::e32 1252 | SampleCountFlagBits::e64; 1253 }; 1254 1255 enum class SystemAllocationScope 1256 { 1257 eCommand = VK_SYSTEM_ALLOCATION_SCOPE_COMMAND, 1258 eObject = VK_SYSTEM_ALLOCATION_SCOPE_OBJECT, 1259 eCache = VK_SYSTEM_ALLOCATION_SCOPE_CACHE, 1260 eDevice = VK_SYSTEM_ALLOCATION_SCOPE_DEVICE, 1261 eInstance = VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE 1262 }; 1263 1264 enum class DeviceCreateFlagBits : VkDeviceCreateFlags 1265 {}; 1266 1267 using DeviceCreateFlags = Flags<DeviceCreateFlagBits>; 1268 1269 1270 template <> struct FlagTraits<DeviceCreateFlagBits> 1271 { 1272 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 1273 static VULKAN_HPP_CONST_OR_CONSTEXPR DeviceCreateFlags allFlags = {}; 1274 }; 1275 1276 enum class DeviceQueueCreateFlagBits : VkDeviceQueueCreateFlags 1277 { 1278 eProtected = VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT 1279 }; 1280 1281 using DeviceQueueCreateFlags = Flags<DeviceQueueCreateFlagBits>; 1282 1283 1284 template <> struct FlagTraits<DeviceQueueCreateFlagBits> 1285 { 1286 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 1287 static VULKAN_HPP_CONST_OR_CONSTEXPR DeviceQueueCreateFlags allFlags = 1288 DeviceQueueCreateFlagBits::eProtected; 1289 }; 1290 1291 enum class PipelineStageFlagBits : VkPipelineStageFlags 1292 { 1293 eTopOfPipe = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, 1294 eDrawIndirect = VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT, 1295 eVertexInput = VK_PIPELINE_STAGE_VERTEX_INPUT_BIT, 1296 eVertexShader = VK_PIPELINE_STAGE_VERTEX_SHADER_BIT, 1297 eTessellationControlShader = VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT, 1298 eTessellationEvaluationShader = VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT, 1299 eGeometryShader = VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT, 1300 eFragmentShader = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, 1301 eEarlyFragmentTests = VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT, 1302 eLateFragmentTests = VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT, 1303 eColorAttachmentOutput = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, 1304 eComputeShader = VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, 1305 eTransfer = VK_PIPELINE_STAGE_TRANSFER_BIT, 1306 eBottomOfPipe = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, 1307 eHost = VK_PIPELINE_STAGE_HOST_BIT, 1308 eAllGraphics = VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, 1309 eAllCommands = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 1310 eNone = VK_PIPELINE_STAGE_NONE, 1311 eFragmentShadingRateAttachmentKHR = VK_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, 1312 eNoneKHR = VK_PIPELINE_STAGE_NONE_KHR 1313 }; 1314 1315 using PipelineStageFlags = Flags<PipelineStageFlagBits>; 1316 1317 1318 template <> struct FlagTraits<PipelineStageFlagBits> 1319 { 1320 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 1321 static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineStageFlags allFlags = 1322 PipelineStageFlagBits::eTopOfPipe 1323 | PipelineStageFlagBits::eDrawIndirect 1324 | PipelineStageFlagBits::eVertexInput 1325 | PipelineStageFlagBits::eVertexShader 1326 | PipelineStageFlagBits::eTessellationControlShader 1327 | PipelineStageFlagBits::eTessellationEvaluationShader 1328 | PipelineStageFlagBits::eGeometryShader 1329 | PipelineStageFlagBits::eFragmentShader 1330 | PipelineStageFlagBits::eEarlyFragmentTests 1331 | PipelineStageFlagBits::eLateFragmentTests 1332 | PipelineStageFlagBits::eColorAttachmentOutput 1333 | PipelineStageFlagBits::eComputeShader 1334 | PipelineStageFlagBits::eTransfer 1335 | PipelineStageFlagBits::eBottomOfPipe 1336 | PipelineStageFlagBits::eHost 1337 | PipelineStageFlagBits::eAllGraphics 1338 | PipelineStageFlagBits::eAllCommands 1339 | PipelineStageFlagBits::eNone 1340 | PipelineStageFlagBits::eFragmentShadingRateAttachmentKHR; 1341 }; 1342 1343 enum class MemoryMapFlagBits : VkMemoryMapFlags 1344 {}; 1345 1346 using MemoryMapFlags = Flags<MemoryMapFlagBits>; 1347 1348 1349 template <> struct FlagTraits<MemoryMapFlagBits> 1350 { 1351 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 1352 static VULKAN_HPP_CONST_OR_CONSTEXPR MemoryMapFlags allFlags = {}; 1353 }; 1354 1355 enum class ImageAspectFlagBits : VkImageAspectFlags 1356 { 1357 eColor = VK_IMAGE_ASPECT_COLOR_BIT, 1358 eDepth = VK_IMAGE_ASPECT_DEPTH_BIT, 1359 eStencil = VK_IMAGE_ASPECT_STENCIL_BIT, 1360 eMetadata = VK_IMAGE_ASPECT_METADATA_BIT, 1361 ePlane0 = VK_IMAGE_ASPECT_PLANE_0_BIT, 1362 ePlane1 = VK_IMAGE_ASPECT_PLANE_1_BIT, 1363 ePlane2 = VK_IMAGE_ASPECT_PLANE_2_BIT, 1364 eNone = VK_IMAGE_ASPECT_NONE, 1365 eMemoryPlane0EXT = VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT, 1366 eMemoryPlane1EXT = VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT, 1367 eMemoryPlane2EXT = VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT, 1368 eMemoryPlane3EXT = VK_IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT 1369 }; 1370 1371 using ImageAspectFlags = Flags<ImageAspectFlagBits>; 1372 1373 1374 template <> struct FlagTraits<ImageAspectFlagBits> 1375 { 1376 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 1377 static VULKAN_HPP_CONST_OR_CONSTEXPR ImageAspectFlags allFlags = 1378 ImageAspectFlagBits::eColor 1379 | ImageAspectFlagBits::eDepth 1380 | ImageAspectFlagBits::eStencil 1381 | ImageAspectFlagBits::eMetadata 1382 | ImageAspectFlagBits::ePlane0 1383 | ImageAspectFlagBits::ePlane1 1384 | ImageAspectFlagBits::ePlane2 1385 | ImageAspectFlagBits::eNone 1386 | ImageAspectFlagBits::eMemoryPlane0EXT 1387 | ImageAspectFlagBits::eMemoryPlane1EXT 1388 | ImageAspectFlagBits::eMemoryPlane2EXT 1389 | ImageAspectFlagBits::eMemoryPlane3EXT; 1390 }; 1391 1392 enum class FenceCreateFlagBits : VkFenceCreateFlags 1393 { 1394 eSignaled = VK_FENCE_CREATE_SIGNALED_BIT 1395 }; 1396 1397 using FenceCreateFlags = Flags<FenceCreateFlagBits>; 1398 1399 1400 template <> struct FlagTraits<FenceCreateFlagBits> 1401 { 1402 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 1403 static VULKAN_HPP_CONST_OR_CONSTEXPR FenceCreateFlags allFlags = 1404 FenceCreateFlagBits::eSignaled; 1405 }; 1406 1407 enum class SemaphoreCreateFlagBits : VkSemaphoreCreateFlags 1408 {}; 1409 1410 using SemaphoreCreateFlags = Flags<SemaphoreCreateFlagBits>; 1411 1412 1413 template <> struct FlagTraits<SemaphoreCreateFlagBits> 1414 { 1415 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 1416 static VULKAN_HPP_CONST_OR_CONSTEXPR SemaphoreCreateFlags allFlags = {}; 1417 }; 1418 1419 enum class EventCreateFlagBits : VkEventCreateFlags 1420 { 1421 eDeviceOnly = VK_EVENT_CREATE_DEVICE_ONLY_BIT, 1422 eDeviceOnlyKHR = VK_EVENT_CREATE_DEVICE_ONLY_BIT_KHR 1423 }; 1424 1425 using EventCreateFlags = Flags<EventCreateFlagBits>; 1426 1427 1428 template <> struct FlagTraits<EventCreateFlagBits> 1429 { 1430 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 1431 static VULKAN_HPP_CONST_OR_CONSTEXPR EventCreateFlags allFlags = 1432 EventCreateFlagBits::eDeviceOnly; 1433 }; 1434 1435 enum class QueryPipelineStatisticFlagBits : VkQueryPipelineStatisticFlags 1436 { 1437 eInputAssemblyVertices = VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT, 1438 eInputAssemblyPrimitives = VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT, 1439 eVertexShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT, 1440 eGeometryShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT, 1441 eGeometryShaderPrimitives = VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT, 1442 eClippingInvocations = VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT, 1443 eClippingPrimitives = VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT, 1444 eFragmentShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT, 1445 eTessellationControlShaderPatches = VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT, 1446 eTessellationEvaluationShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT, 1447 eComputeShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT 1448 }; 1449 1450 using QueryPipelineStatisticFlags = Flags<QueryPipelineStatisticFlagBits>; 1451 1452 1453 template <> struct FlagTraits<QueryPipelineStatisticFlagBits> 1454 { 1455 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 1456 static VULKAN_HPP_CONST_OR_CONSTEXPR QueryPipelineStatisticFlags allFlags = 1457 QueryPipelineStatisticFlagBits::eInputAssemblyVertices 1458 | QueryPipelineStatisticFlagBits::eInputAssemblyPrimitives 1459 | QueryPipelineStatisticFlagBits::eVertexShaderInvocations 1460 | QueryPipelineStatisticFlagBits::eGeometryShaderInvocations 1461 | QueryPipelineStatisticFlagBits::eGeometryShaderPrimitives 1462 | QueryPipelineStatisticFlagBits::eClippingInvocations 1463 | QueryPipelineStatisticFlagBits::eClippingPrimitives 1464 | QueryPipelineStatisticFlagBits::eFragmentShaderInvocations 1465 | QueryPipelineStatisticFlagBits::eTessellationControlShaderPatches 1466 | QueryPipelineStatisticFlagBits::eTessellationEvaluationShaderInvocations 1467 | QueryPipelineStatisticFlagBits::eComputeShaderInvocations; 1468 }; 1469 1470 enum class QueryResultFlagBits : VkQueryResultFlags 1471 { 1472 e64 = VK_QUERY_RESULT_64_BIT, 1473 eWait = VK_QUERY_RESULT_WAIT_BIT, 1474 eWithAvailability = VK_QUERY_RESULT_WITH_AVAILABILITY_BIT, 1475 ePartial = VK_QUERY_RESULT_PARTIAL_BIT 1476 }; 1477 1478 using QueryResultFlags = Flags<QueryResultFlagBits>; 1479 1480 1481 template <> struct FlagTraits<QueryResultFlagBits> 1482 { 1483 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 1484 static VULKAN_HPP_CONST_OR_CONSTEXPR QueryResultFlags allFlags = 1485 QueryResultFlagBits::e64 1486 | QueryResultFlagBits::eWait 1487 | QueryResultFlagBits::eWithAvailability 1488 | QueryResultFlagBits::ePartial; 1489 }; 1490 1491 enum class QueryType 1492 { 1493 eOcclusion = VK_QUERY_TYPE_OCCLUSION, 1494 ePipelineStatistics = VK_QUERY_TYPE_PIPELINE_STATISTICS, 1495 eTimestamp = VK_QUERY_TYPE_TIMESTAMP, 1496 ePerformanceQueryKHR = VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR 1497 }; 1498 1499 enum class QueryPoolCreateFlagBits : VkQueryPoolCreateFlags 1500 {}; 1501 1502 using QueryPoolCreateFlags = Flags<QueryPoolCreateFlagBits>; 1503 1504 1505 template <> struct FlagTraits<QueryPoolCreateFlagBits> 1506 { 1507 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 1508 static VULKAN_HPP_CONST_OR_CONSTEXPR QueryPoolCreateFlags allFlags = {}; 1509 }; 1510 1511 enum class BufferCreateFlagBits : VkBufferCreateFlags 1512 { 1513 eSparseBinding = VK_BUFFER_CREATE_SPARSE_BINDING_BIT, 1514 eSparseResidency = VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT, 1515 eSparseAliased = VK_BUFFER_CREATE_SPARSE_ALIASED_BIT, 1516 eProtected = VK_BUFFER_CREATE_PROTECTED_BIT, 1517 eDeviceAddressCaptureReplay = VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT 1518 }; 1519 1520 using BufferCreateFlags = Flags<BufferCreateFlagBits>; 1521 1522 1523 template <> struct FlagTraits<BufferCreateFlagBits> 1524 { 1525 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 1526 static VULKAN_HPP_CONST_OR_CONSTEXPR BufferCreateFlags allFlags = 1527 BufferCreateFlagBits::eSparseBinding 1528 | BufferCreateFlagBits::eSparseResidency 1529 | BufferCreateFlagBits::eSparseAliased 1530 | BufferCreateFlagBits::eProtected 1531 | BufferCreateFlagBits::eDeviceAddressCaptureReplay; 1532 }; 1533 1534 enum class BufferUsageFlagBits : VkBufferUsageFlags 1535 { 1536 eTransferSrc = VK_BUFFER_USAGE_TRANSFER_SRC_BIT, 1537 eTransferDst = VK_BUFFER_USAGE_TRANSFER_DST_BIT, 1538 eUniformTexelBuffer = VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT, 1539 eStorageTexelBuffer = VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT, 1540 eUniformBuffer = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, 1541 eStorageBuffer = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, 1542 eIndexBuffer = VK_BUFFER_USAGE_INDEX_BUFFER_BIT, 1543 eVertexBuffer = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, 1544 eIndirectBuffer = VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT, 1545 eShaderDeviceAddress = VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT 1546 }; 1547 1548 using BufferUsageFlags = Flags<BufferUsageFlagBits>; 1549 1550 1551 template <> struct FlagTraits<BufferUsageFlagBits> 1552 { 1553 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 1554 static VULKAN_HPP_CONST_OR_CONSTEXPR BufferUsageFlags allFlags = 1555 BufferUsageFlagBits::eTransferSrc 1556 | BufferUsageFlagBits::eTransferDst 1557 | BufferUsageFlagBits::eUniformTexelBuffer 1558 | BufferUsageFlagBits::eStorageTexelBuffer 1559 | BufferUsageFlagBits::eUniformBuffer 1560 | BufferUsageFlagBits::eStorageBuffer 1561 | BufferUsageFlagBits::eIndexBuffer 1562 | BufferUsageFlagBits::eVertexBuffer 1563 | BufferUsageFlagBits::eIndirectBuffer 1564 | BufferUsageFlagBits::eShaderDeviceAddress; 1565 }; 1566 1567 enum class SharingMode 1568 { 1569 eExclusive = VK_SHARING_MODE_EXCLUSIVE, 1570 eConcurrent = VK_SHARING_MODE_CONCURRENT 1571 }; 1572 1573 enum class BufferViewCreateFlagBits : VkBufferViewCreateFlags 1574 {}; 1575 1576 using BufferViewCreateFlags = Flags<BufferViewCreateFlagBits>; 1577 1578 1579 template <> struct FlagTraits<BufferViewCreateFlagBits> 1580 { 1581 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 1582 static VULKAN_HPP_CONST_OR_CONSTEXPR BufferViewCreateFlags allFlags = {}; 1583 }; 1584 1585 enum class ImageLayout 1586 { 1587 eUndefined = VK_IMAGE_LAYOUT_UNDEFINED, 1588 eGeneral = VK_IMAGE_LAYOUT_GENERAL, 1589 eColorAttachmentOptimal = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, 1590 eDepthStencilAttachmentOptimal = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, 1591 eDepthStencilReadOnlyOptimal = VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, 1592 eShaderReadOnlyOptimal = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, 1593 eTransferSrcOptimal = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, 1594 eTransferDstOptimal = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1595 ePreinitialized = VK_IMAGE_LAYOUT_PREINITIALIZED, 1596 eDepthReadOnlyStencilAttachmentOptimal = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL, 1597 eDepthAttachmentStencilReadOnlyOptimal = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, 1598 eDepthAttachmentOptimal = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, 1599 eDepthReadOnlyOptimal = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, 1600 eStencilAttachmentOptimal = VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL, 1601 eStencilReadOnlyOptimal = VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL, 1602 eReadOnlyOptimal = VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL, 1603 eAttachmentOptimal = VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL, 1604 ePresentSrcKHR = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR, 1605 eSharedPresentKHR = VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR, 1606 eFragmentShadingRateAttachmentOptimalKHR = VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR, 1607 eReadOnlyOptimalKHR = VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL_KHR, 1608 eAttachmentOptimalKHR = VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL_KHR 1609 }; 1610 1611 enum class ComponentSwizzle 1612 { 1613 eIdentity = VK_COMPONENT_SWIZZLE_IDENTITY, 1614 eZero = VK_COMPONENT_SWIZZLE_ZERO, 1615 eOne = VK_COMPONENT_SWIZZLE_ONE, 1616 eR = VK_COMPONENT_SWIZZLE_R, 1617 eG = VK_COMPONENT_SWIZZLE_G, 1618 eB = VK_COMPONENT_SWIZZLE_B, 1619 eA = VK_COMPONENT_SWIZZLE_A 1620 }; 1621 1622 enum class ImageViewCreateFlagBits : VkImageViewCreateFlags 1623 {}; 1624 1625 using ImageViewCreateFlags = Flags<ImageViewCreateFlagBits>; 1626 1627 1628 template <> struct FlagTraits<ImageViewCreateFlagBits> 1629 { 1630 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 1631 static VULKAN_HPP_CONST_OR_CONSTEXPR ImageViewCreateFlags allFlags = {}; 1632 }; 1633 1634 enum class ImageViewType 1635 { 1636 e1D = VK_IMAGE_VIEW_TYPE_1D, 1637 e2D = VK_IMAGE_VIEW_TYPE_2D, 1638 e3D = VK_IMAGE_VIEW_TYPE_3D, 1639 eCube = VK_IMAGE_VIEW_TYPE_CUBE, 1640 e1DArray = VK_IMAGE_VIEW_TYPE_1D_ARRAY, 1641 e2DArray = VK_IMAGE_VIEW_TYPE_2D_ARRAY, 1642 eCubeArray = VK_IMAGE_VIEW_TYPE_CUBE_ARRAY 1643 }; 1644 1645 enum class PipelineCacheCreateFlagBits : VkPipelineCacheCreateFlags 1646 { 1647 eExternallySynchronized = VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT, 1648 eReadOnly = VK_PIPELINE_CACHE_CREATE_READ_ONLY_BIT, 1649 eUseApplicationStorage = VK_PIPELINE_CACHE_CREATE_USE_APPLICATION_STORAGE_BIT 1650 }; 1651 1652 using PipelineCacheCreateFlags = Flags<PipelineCacheCreateFlagBits>; 1653 1654 1655 template <> struct FlagTraits<PipelineCacheCreateFlagBits> 1656 { 1657 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 1658 static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineCacheCreateFlags allFlags = 1659 PipelineCacheCreateFlagBits::eExternallySynchronized 1660 | PipelineCacheCreateFlagBits::eReadOnly 1661 | PipelineCacheCreateFlagBits::eUseApplicationStorage; 1662 }; 1663 1664 enum class BlendFactor 1665 { 1666 eZero = VK_BLEND_FACTOR_ZERO, 1667 eOne = VK_BLEND_FACTOR_ONE, 1668 eSrcColor = VK_BLEND_FACTOR_SRC_COLOR, 1669 eOneMinusSrcColor = VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR, 1670 eDstColor = VK_BLEND_FACTOR_DST_COLOR, 1671 eOneMinusDstColor = VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR, 1672 eSrcAlpha = VK_BLEND_FACTOR_SRC_ALPHA, 1673 eOneMinusSrcAlpha = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA, 1674 eDstAlpha = VK_BLEND_FACTOR_DST_ALPHA, 1675 eOneMinusDstAlpha = VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA, 1676 eConstantColor = VK_BLEND_FACTOR_CONSTANT_COLOR, 1677 eOneMinusConstantColor = VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR, 1678 eConstantAlpha = VK_BLEND_FACTOR_CONSTANT_ALPHA, 1679 eOneMinusConstantAlpha = VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA, 1680 eSrcAlphaSaturate = VK_BLEND_FACTOR_SRC_ALPHA_SATURATE, 1681 eSrc1Color = VK_BLEND_FACTOR_SRC1_COLOR, 1682 eOneMinusSrc1Color = VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR, 1683 eSrc1Alpha = VK_BLEND_FACTOR_SRC1_ALPHA, 1684 eOneMinusSrc1Alpha = VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA 1685 }; 1686 1687 enum class BlendOp 1688 { 1689 eAdd = VK_BLEND_OP_ADD, 1690 eSubtract = VK_BLEND_OP_SUBTRACT, 1691 eReverseSubtract = VK_BLEND_OP_REVERSE_SUBTRACT, 1692 eMin = VK_BLEND_OP_MIN, 1693 eMax = VK_BLEND_OP_MAX, 1694 eZeroEXT = VK_BLEND_OP_ZERO_EXT, 1695 eSrcEXT = VK_BLEND_OP_SRC_EXT, 1696 eDstEXT = VK_BLEND_OP_DST_EXT, 1697 eSrcOverEXT = VK_BLEND_OP_SRC_OVER_EXT, 1698 eDstOverEXT = VK_BLEND_OP_DST_OVER_EXT, 1699 eSrcInEXT = VK_BLEND_OP_SRC_IN_EXT, 1700 eDstInEXT = VK_BLEND_OP_DST_IN_EXT, 1701 eSrcOutEXT = VK_BLEND_OP_SRC_OUT_EXT, 1702 eDstOutEXT = VK_BLEND_OP_DST_OUT_EXT, 1703 eSrcAtopEXT = VK_BLEND_OP_SRC_ATOP_EXT, 1704 eDstAtopEXT = VK_BLEND_OP_DST_ATOP_EXT, 1705 eXorEXT = VK_BLEND_OP_XOR_EXT, 1706 eMultiplyEXT = VK_BLEND_OP_MULTIPLY_EXT, 1707 eScreenEXT = VK_BLEND_OP_SCREEN_EXT, 1708 eOverlayEXT = VK_BLEND_OP_OVERLAY_EXT, 1709 eDarkenEXT = VK_BLEND_OP_DARKEN_EXT, 1710 eLightenEXT = VK_BLEND_OP_LIGHTEN_EXT, 1711 eColordodgeEXT = VK_BLEND_OP_COLORDODGE_EXT, 1712 eColorburnEXT = VK_BLEND_OP_COLORBURN_EXT, 1713 eHardlightEXT = VK_BLEND_OP_HARDLIGHT_EXT, 1714 eSoftlightEXT = VK_BLEND_OP_SOFTLIGHT_EXT, 1715 eDifferenceEXT = VK_BLEND_OP_DIFFERENCE_EXT, 1716 eExclusionEXT = VK_BLEND_OP_EXCLUSION_EXT, 1717 eInvertEXT = VK_BLEND_OP_INVERT_EXT, 1718 eInvertRgbEXT = VK_BLEND_OP_INVERT_RGB_EXT, 1719 eLineardodgeEXT = VK_BLEND_OP_LINEARDODGE_EXT, 1720 eLinearburnEXT = VK_BLEND_OP_LINEARBURN_EXT, 1721 eVividlightEXT = VK_BLEND_OP_VIVIDLIGHT_EXT, 1722 eLinearlightEXT = VK_BLEND_OP_LINEARLIGHT_EXT, 1723 ePinlightEXT = VK_BLEND_OP_PINLIGHT_EXT, 1724 eHardmixEXT = VK_BLEND_OP_HARDMIX_EXT, 1725 eHslHueEXT = VK_BLEND_OP_HSL_HUE_EXT, 1726 eHslSaturationEXT = VK_BLEND_OP_HSL_SATURATION_EXT, 1727 eHslColorEXT = VK_BLEND_OP_HSL_COLOR_EXT, 1728 eHslLuminosityEXT = VK_BLEND_OP_HSL_LUMINOSITY_EXT, 1729 ePlusEXT = VK_BLEND_OP_PLUS_EXT, 1730 ePlusClampedEXT = VK_BLEND_OP_PLUS_CLAMPED_EXT, 1731 ePlusClampedAlphaEXT = VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT, 1732 ePlusDarkerEXT = VK_BLEND_OP_PLUS_DARKER_EXT, 1733 eMinusEXT = VK_BLEND_OP_MINUS_EXT, 1734 eMinusClampedEXT = VK_BLEND_OP_MINUS_CLAMPED_EXT, 1735 eContrastEXT = VK_BLEND_OP_CONTRAST_EXT, 1736 eInvertOvgEXT = VK_BLEND_OP_INVERT_OVG_EXT, 1737 eRedEXT = VK_BLEND_OP_RED_EXT, 1738 eGreenEXT = VK_BLEND_OP_GREEN_EXT, 1739 eBlueEXT = VK_BLEND_OP_BLUE_EXT 1740 }; 1741 1742 enum class ColorComponentFlagBits : VkColorComponentFlags 1743 { 1744 eR = VK_COLOR_COMPONENT_R_BIT, 1745 eG = VK_COLOR_COMPONENT_G_BIT, 1746 eB = VK_COLOR_COMPONENT_B_BIT, 1747 eA = VK_COLOR_COMPONENT_A_BIT 1748 }; 1749 1750 using ColorComponentFlags = Flags<ColorComponentFlagBits>; 1751 1752 1753 template <> struct FlagTraits<ColorComponentFlagBits> 1754 { 1755 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 1756 static VULKAN_HPP_CONST_OR_CONSTEXPR ColorComponentFlags allFlags = 1757 ColorComponentFlagBits::eR 1758 | ColorComponentFlagBits::eG 1759 | ColorComponentFlagBits::eB 1760 | ColorComponentFlagBits::eA; 1761 }; 1762 1763 enum class CompareOp 1764 { 1765 eNever = VK_COMPARE_OP_NEVER, 1766 eLess = VK_COMPARE_OP_LESS, 1767 eEqual = VK_COMPARE_OP_EQUAL, 1768 eLessOrEqual = VK_COMPARE_OP_LESS_OR_EQUAL, 1769 eGreater = VK_COMPARE_OP_GREATER, 1770 eNotEqual = VK_COMPARE_OP_NOT_EQUAL, 1771 eGreaterOrEqual = VK_COMPARE_OP_GREATER_OR_EQUAL, 1772 eAlways = VK_COMPARE_OP_ALWAYS 1773 }; 1774 1775 enum class CullModeFlagBits : VkCullModeFlags 1776 { 1777 eNone = VK_CULL_MODE_NONE, 1778 eFront = VK_CULL_MODE_FRONT_BIT, 1779 eBack = VK_CULL_MODE_BACK_BIT, 1780 eFrontAndBack = VK_CULL_MODE_FRONT_AND_BACK 1781 }; 1782 1783 using CullModeFlags = Flags<CullModeFlagBits>; 1784 1785 1786 template <> struct FlagTraits<CullModeFlagBits> 1787 { 1788 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 1789 static VULKAN_HPP_CONST_OR_CONSTEXPR CullModeFlags allFlags = 1790 CullModeFlagBits::eNone 1791 | CullModeFlagBits::eFront 1792 | CullModeFlagBits::eBack 1793 | CullModeFlagBits::eFrontAndBack; 1794 }; 1795 1796 enum class DynamicState 1797 { 1798 eViewport = VK_DYNAMIC_STATE_VIEWPORT, 1799 eScissor = VK_DYNAMIC_STATE_SCISSOR, 1800 eLineWidth = VK_DYNAMIC_STATE_LINE_WIDTH, 1801 eDepthBias = VK_DYNAMIC_STATE_DEPTH_BIAS, 1802 eBlendConstants = VK_DYNAMIC_STATE_BLEND_CONSTANTS, 1803 eDepthBounds = VK_DYNAMIC_STATE_DEPTH_BOUNDS, 1804 eStencilCompareMask = VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK, 1805 eStencilWriteMask = VK_DYNAMIC_STATE_STENCIL_WRITE_MASK, 1806 eStencilReference = VK_DYNAMIC_STATE_STENCIL_REFERENCE, 1807 eCullMode = VK_DYNAMIC_STATE_CULL_MODE, 1808 eFrontFace = VK_DYNAMIC_STATE_FRONT_FACE, 1809 ePrimitiveTopology = VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY, 1810 eViewportWithCount = VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT, 1811 eScissorWithCount = VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT, 1812 eVertexInputBindingStride = VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE, 1813 eDepthTestEnable = VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE, 1814 eDepthWriteEnable = VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE, 1815 eDepthCompareOp = VK_DYNAMIC_STATE_DEPTH_COMPARE_OP, 1816 eDepthBoundsTestEnable = VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE, 1817 eStencilTestEnable = VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE, 1818 eStencilOp = VK_DYNAMIC_STATE_STENCIL_OP, 1819 eRasterizerDiscardEnable = VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE, 1820 eDepthBiasEnable = VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE, 1821 ePrimitiveRestartEnable = VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE, 1822 eDiscardRectangleEXT = VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT, 1823 eDiscardRectangleEnableEXT = VK_DYNAMIC_STATE_DISCARD_RECTANGLE_ENABLE_EXT, 1824 eDiscardRectangleModeEXT = VK_DYNAMIC_STATE_DISCARD_RECTANGLE_MODE_EXT, 1825 eSampleLocationsEXT = VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT, 1826 eFragmentShadingRateKHR = VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR, 1827 eLineStippleEXT = VK_DYNAMIC_STATE_LINE_STIPPLE_EXT, 1828 eCullModeEXT = VK_DYNAMIC_STATE_CULL_MODE_EXT, 1829 eFrontFaceEXT = VK_DYNAMIC_STATE_FRONT_FACE_EXT, 1830 ePrimitiveTopologyEXT = VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY_EXT, 1831 eViewportWithCountEXT = VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT, 1832 eScissorWithCountEXT = VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT, 1833 eVertexInputBindingStrideEXT = VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT, 1834 eDepthTestEnableEXT = VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE_EXT, 1835 eDepthWriteEnableEXT = VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE_EXT, 1836 eDepthCompareOpEXT = VK_DYNAMIC_STATE_DEPTH_COMPARE_OP_EXT, 1837 eDepthBoundsTestEnableEXT = VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE_EXT, 1838 eStencilTestEnableEXT = VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE_EXT, 1839 eStencilOpEXT = VK_DYNAMIC_STATE_STENCIL_OP_EXT, 1840 eVertexInputEXT = VK_DYNAMIC_STATE_VERTEX_INPUT_EXT, 1841 ePatchControlPointsEXT = VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT, 1842 eRasterizerDiscardEnableEXT = VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT, 1843 eDepthBiasEnableEXT = VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE_EXT, 1844 eLogicOpEXT = VK_DYNAMIC_STATE_LOGIC_OP_EXT, 1845 ePrimitiveRestartEnableEXT = VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE_EXT, 1846 eColorWriteEnableEXT = VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT 1847 }; 1848 1849 enum class FrontFace 1850 { 1851 eCounterClockwise = VK_FRONT_FACE_COUNTER_CLOCKWISE, 1852 eClockwise = VK_FRONT_FACE_CLOCKWISE 1853 }; 1854 1855 enum class LogicOp 1856 { 1857 eClear = VK_LOGIC_OP_CLEAR, 1858 eAnd = VK_LOGIC_OP_AND, 1859 eAndReverse = VK_LOGIC_OP_AND_REVERSE, 1860 eCopy = VK_LOGIC_OP_COPY, 1861 eAndInverted = VK_LOGIC_OP_AND_INVERTED, 1862 eNoOp = VK_LOGIC_OP_NO_OP, 1863 eXor = VK_LOGIC_OP_XOR, 1864 eOr = VK_LOGIC_OP_OR, 1865 eNor = VK_LOGIC_OP_NOR, 1866 eEquivalent = VK_LOGIC_OP_EQUIVALENT, 1867 eInvert = VK_LOGIC_OP_INVERT, 1868 eOrReverse = VK_LOGIC_OP_OR_REVERSE, 1869 eCopyInverted = VK_LOGIC_OP_COPY_INVERTED, 1870 eOrInverted = VK_LOGIC_OP_OR_INVERTED, 1871 eNand = VK_LOGIC_OP_NAND, 1872 eSet = VK_LOGIC_OP_SET 1873 }; 1874 1875 enum class PipelineCreateFlagBits : VkPipelineCreateFlags 1876 { 1877 eDisableOptimization = VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT, 1878 eViewIndexFromDeviceIndex = VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT, 1879 eDispatchBase = VK_PIPELINE_CREATE_DISPATCH_BASE_BIT, 1880 eFailOnPipelineCompileRequired = VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT, 1881 eEarlyReturnOnFailure = VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT 1882 }; 1883 1884 using PipelineCreateFlags = Flags<PipelineCreateFlagBits>; 1885 1886 1887 template <> struct FlagTraits<PipelineCreateFlagBits> 1888 { 1889 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 1890 static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineCreateFlags allFlags = 1891 PipelineCreateFlagBits::eDisableOptimization 1892 | PipelineCreateFlagBits::eViewIndexFromDeviceIndex 1893 | PipelineCreateFlagBits::eDispatchBase 1894 | PipelineCreateFlagBits::eFailOnPipelineCompileRequired 1895 | PipelineCreateFlagBits::eEarlyReturnOnFailure; 1896 }; 1897 1898 enum class PipelineShaderStageCreateFlagBits : VkPipelineShaderStageCreateFlags 1899 { 1900 eAllowVaryingSubgroupSize = VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT, 1901 eRequireFullSubgroups = VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT, 1902 eAllowVaryingSubgroupSizeEXT = VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT, 1903 eRequireFullSubgroupsEXT = VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT 1904 }; 1905 1906 using PipelineShaderStageCreateFlags = Flags<PipelineShaderStageCreateFlagBits>; 1907 1908 1909 template <> struct FlagTraits<PipelineShaderStageCreateFlagBits> 1910 { 1911 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 1912 static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineShaderStageCreateFlags allFlags = 1913 PipelineShaderStageCreateFlagBits::eAllowVaryingSubgroupSize 1914 | PipelineShaderStageCreateFlagBits::eRequireFullSubgroups; 1915 }; 1916 1917 enum class PolygonMode 1918 { 1919 eFill = VK_POLYGON_MODE_FILL, 1920 eLine = VK_POLYGON_MODE_LINE, 1921 ePoint = VK_POLYGON_MODE_POINT 1922 }; 1923 1924 enum class PrimitiveTopology 1925 { 1926 ePointList = VK_PRIMITIVE_TOPOLOGY_POINT_LIST, 1927 eLineList = VK_PRIMITIVE_TOPOLOGY_LINE_LIST, 1928 eLineStrip = VK_PRIMITIVE_TOPOLOGY_LINE_STRIP, 1929 eTriangleList = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, 1930 eTriangleStrip = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, 1931 eTriangleFan = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN, 1932 eLineListWithAdjacency = VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY, 1933 eLineStripWithAdjacency = VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY, 1934 eTriangleListWithAdjacency = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY, 1935 eTriangleStripWithAdjacency = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY, 1936 ePatchList = VK_PRIMITIVE_TOPOLOGY_PATCH_LIST 1937 }; 1938 1939 enum class ShaderStageFlagBits : VkShaderStageFlags 1940 { 1941 eVertex = VK_SHADER_STAGE_VERTEX_BIT, 1942 eTessellationControl = VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT, 1943 eTessellationEvaluation = VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT, 1944 eGeometry = VK_SHADER_STAGE_GEOMETRY_BIT, 1945 eFragment = VK_SHADER_STAGE_FRAGMENT_BIT, 1946 eCompute = VK_SHADER_STAGE_COMPUTE_BIT, 1947 eAllGraphics = VK_SHADER_STAGE_ALL_GRAPHICS, 1948 eAll = VK_SHADER_STAGE_ALL 1949 }; 1950 1951 using ShaderStageFlags = Flags<ShaderStageFlagBits>; 1952 1953 1954 template <> struct FlagTraits<ShaderStageFlagBits> 1955 { 1956 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 1957 static VULKAN_HPP_CONST_OR_CONSTEXPR ShaderStageFlags allFlags = 1958 ShaderStageFlagBits::eVertex 1959 | ShaderStageFlagBits::eTessellationControl 1960 | ShaderStageFlagBits::eTessellationEvaluation 1961 | ShaderStageFlagBits::eGeometry 1962 | ShaderStageFlagBits::eFragment 1963 | ShaderStageFlagBits::eCompute 1964 | ShaderStageFlagBits::eAllGraphics 1965 | ShaderStageFlagBits::eAll; 1966 }; 1967 1968 enum class StencilOp 1969 { 1970 eKeep = VK_STENCIL_OP_KEEP, 1971 eZero = VK_STENCIL_OP_ZERO, 1972 eReplace = VK_STENCIL_OP_REPLACE, 1973 eIncrementAndClamp = VK_STENCIL_OP_INCREMENT_AND_CLAMP, 1974 eDecrementAndClamp = VK_STENCIL_OP_DECREMENT_AND_CLAMP, 1975 eInvert = VK_STENCIL_OP_INVERT, 1976 eIncrementAndWrap = VK_STENCIL_OP_INCREMENT_AND_WRAP, 1977 eDecrementAndWrap = VK_STENCIL_OP_DECREMENT_AND_WRAP 1978 }; 1979 1980 enum class VertexInputRate 1981 { 1982 eVertex = VK_VERTEX_INPUT_RATE_VERTEX, 1983 eInstance = VK_VERTEX_INPUT_RATE_INSTANCE 1984 }; 1985 1986 enum class PipelineColorBlendStateCreateFlagBits : VkPipelineColorBlendStateCreateFlags 1987 {}; 1988 1989 using PipelineColorBlendStateCreateFlags = Flags<PipelineColorBlendStateCreateFlagBits>; 1990 1991 1992 template <> struct FlagTraits<PipelineColorBlendStateCreateFlagBits> 1993 { 1994 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 1995 static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineColorBlendStateCreateFlags allFlags = {}; 1996 }; 1997 1998 enum class PipelineDepthStencilStateCreateFlagBits : VkPipelineDepthStencilStateCreateFlags 1999 {}; 2000 2001 using PipelineDepthStencilStateCreateFlags = Flags<PipelineDepthStencilStateCreateFlagBits>; 2002 2003 2004 template <> struct FlagTraits<PipelineDepthStencilStateCreateFlagBits> 2005 { 2006 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 2007 static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineDepthStencilStateCreateFlags allFlags = {}; 2008 }; 2009 2010 enum class PipelineDynamicStateCreateFlagBits : VkPipelineDynamicStateCreateFlags 2011 {}; 2012 2013 using PipelineDynamicStateCreateFlags = Flags<PipelineDynamicStateCreateFlagBits>; 2014 2015 2016 template <> struct FlagTraits<PipelineDynamicStateCreateFlagBits> 2017 { 2018 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 2019 static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineDynamicStateCreateFlags allFlags = {}; 2020 }; 2021 2022 enum class PipelineInputAssemblyStateCreateFlagBits : VkPipelineInputAssemblyStateCreateFlags 2023 {}; 2024 2025 using PipelineInputAssemblyStateCreateFlags = Flags<PipelineInputAssemblyStateCreateFlagBits>; 2026 2027 2028 template <> struct FlagTraits<PipelineInputAssemblyStateCreateFlagBits> 2029 { 2030 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 2031 static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineInputAssemblyStateCreateFlags allFlags = {}; 2032 }; 2033 2034 enum class PipelineLayoutCreateFlagBits : VkPipelineLayoutCreateFlags 2035 {}; 2036 2037 using PipelineLayoutCreateFlags = Flags<PipelineLayoutCreateFlagBits>; 2038 2039 2040 template <> struct FlagTraits<PipelineLayoutCreateFlagBits> 2041 { 2042 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 2043 static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineLayoutCreateFlags allFlags = {}; 2044 }; 2045 2046 enum class PipelineMultisampleStateCreateFlagBits : VkPipelineMultisampleStateCreateFlags 2047 {}; 2048 2049 using PipelineMultisampleStateCreateFlags = Flags<PipelineMultisampleStateCreateFlagBits>; 2050 2051 2052 template <> struct FlagTraits<PipelineMultisampleStateCreateFlagBits> 2053 { 2054 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 2055 static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineMultisampleStateCreateFlags allFlags = {}; 2056 }; 2057 2058 enum class PipelineRasterizationStateCreateFlagBits : VkPipelineRasterizationStateCreateFlags 2059 {}; 2060 2061 using PipelineRasterizationStateCreateFlags = Flags<PipelineRasterizationStateCreateFlagBits>; 2062 2063 2064 template <> struct FlagTraits<PipelineRasterizationStateCreateFlagBits> 2065 { 2066 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 2067 static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineRasterizationStateCreateFlags allFlags = {}; 2068 }; 2069 2070 enum class PipelineTessellationStateCreateFlagBits : VkPipelineTessellationStateCreateFlags 2071 {}; 2072 2073 using PipelineTessellationStateCreateFlags = Flags<PipelineTessellationStateCreateFlagBits>; 2074 2075 2076 template <> struct FlagTraits<PipelineTessellationStateCreateFlagBits> 2077 { 2078 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 2079 static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineTessellationStateCreateFlags allFlags = {}; 2080 }; 2081 2082 enum class PipelineVertexInputStateCreateFlagBits : VkPipelineVertexInputStateCreateFlags 2083 {}; 2084 2085 using PipelineVertexInputStateCreateFlags = Flags<PipelineVertexInputStateCreateFlagBits>; 2086 2087 2088 template <> struct FlagTraits<PipelineVertexInputStateCreateFlagBits> 2089 { 2090 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 2091 static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineVertexInputStateCreateFlags allFlags = {}; 2092 }; 2093 2094 enum class PipelineViewportStateCreateFlagBits : VkPipelineViewportStateCreateFlags 2095 {}; 2096 2097 using PipelineViewportStateCreateFlags = Flags<PipelineViewportStateCreateFlagBits>; 2098 2099 2100 template <> struct FlagTraits<PipelineViewportStateCreateFlagBits> 2101 { 2102 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 2103 static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineViewportStateCreateFlags allFlags = {}; 2104 }; 2105 2106 enum class BorderColor 2107 { 2108 eFloatTransparentBlack = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK, 2109 eIntTransparentBlack = VK_BORDER_COLOR_INT_TRANSPARENT_BLACK, 2110 eFloatOpaqueBlack = VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK, 2111 eIntOpaqueBlack = VK_BORDER_COLOR_INT_OPAQUE_BLACK, 2112 eFloatOpaqueWhite = VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE, 2113 eIntOpaqueWhite = VK_BORDER_COLOR_INT_OPAQUE_WHITE, 2114 eFloatCustomEXT = VK_BORDER_COLOR_FLOAT_CUSTOM_EXT, 2115 eIntCustomEXT = VK_BORDER_COLOR_INT_CUSTOM_EXT 2116 }; 2117 2118 enum class Filter 2119 { 2120 eNearest = VK_FILTER_NEAREST, 2121 eLinear = VK_FILTER_LINEAR, 2122 eCubicEXT = VK_FILTER_CUBIC_EXT 2123 }; 2124 2125 enum class SamplerAddressMode 2126 { 2127 eRepeat = VK_SAMPLER_ADDRESS_MODE_REPEAT, 2128 eMirroredRepeat = VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT, 2129 eClampToEdge = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, 2130 eClampToBorder = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER, 2131 eMirrorClampToEdge = VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE 2132 }; 2133 2134 enum class SamplerCreateFlagBits : VkSamplerCreateFlags 2135 {}; 2136 2137 using SamplerCreateFlags = Flags<SamplerCreateFlagBits>; 2138 2139 2140 template <> struct FlagTraits<SamplerCreateFlagBits> 2141 { 2142 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 2143 static VULKAN_HPP_CONST_OR_CONSTEXPR SamplerCreateFlags allFlags = {}; 2144 }; 2145 2146 enum class SamplerMipmapMode 2147 { 2148 eNearest = VK_SAMPLER_MIPMAP_MODE_NEAREST, 2149 eLinear = VK_SAMPLER_MIPMAP_MODE_LINEAR 2150 }; 2151 2152 enum class DescriptorPoolCreateFlagBits : VkDescriptorPoolCreateFlags 2153 { 2154 eFreeDescriptorSet = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 2155 eUpdateAfterBind = VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT 2156 }; 2157 2158 using DescriptorPoolCreateFlags = Flags<DescriptorPoolCreateFlagBits>; 2159 2160 2161 template <> struct FlagTraits<DescriptorPoolCreateFlagBits> 2162 { 2163 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 2164 static VULKAN_HPP_CONST_OR_CONSTEXPR DescriptorPoolCreateFlags allFlags = 2165 DescriptorPoolCreateFlagBits::eFreeDescriptorSet 2166 | DescriptorPoolCreateFlagBits::eUpdateAfterBind; 2167 }; 2168 2169 enum class DescriptorSetLayoutCreateFlagBits : VkDescriptorSetLayoutCreateFlags 2170 { 2171 eUpdateAfterBindPool = VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT 2172 }; 2173 2174 using DescriptorSetLayoutCreateFlags = Flags<DescriptorSetLayoutCreateFlagBits>; 2175 2176 2177 template <> struct FlagTraits<DescriptorSetLayoutCreateFlagBits> 2178 { 2179 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 2180 static VULKAN_HPP_CONST_OR_CONSTEXPR DescriptorSetLayoutCreateFlags allFlags = 2181 DescriptorSetLayoutCreateFlagBits::eUpdateAfterBindPool; 2182 }; 2183 2184 enum class DescriptorType 2185 { 2186 eSampler = VK_DESCRIPTOR_TYPE_SAMPLER, 2187 eCombinedImageSampler = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 2188 eSampledImage = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, 2189 eStorageImage = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, 2190 eUniformTexelBuffer = VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER, 2191 eStorageTexelBuffer = VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, 2192 eUniformBuffer = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 2193 eStorageBuffer = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 2194 eUniformBufferDynamic = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, 2195 eStorageBufferDynamic = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, 2196 eInputAttachment = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, 2197 eInlineUniformBlock = VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK 2198 }; 2199 2200 enum class DescriptorPoolResetFlagBits : VkDescriptorPoolResetFlags 2201 {}; 2202 2203 using DescriptorPoolResetFlags = Flags<DescriptorPoolResetFlagBits>; 2204 2205 2206 template <> struct FlagTraits<DescriptorPoolResetFlagBits> 2207 { 2208 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 2209 static VULKAN_HPP_CONST_OR_CONSTEXPR DescriptorPoolResetFlags allFlags = {}; 2210 }; 2211 2212 enum class AccessFlagBits : VkAccessFlags 2213 { 2214 eIndirectCommandRead = VK_ACCESS_INDIRECT_COMMAND_READ_BIT, 2215 eIndexRead = VK_ACCESS_INDEX_READ_BIT, 2216 eVertexAttributeRead = VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT, 2217 eUniformRead = VK_ACCESS_UNIFORM_READ_BIT, 2218 eInputAttachmentRead = VK_ACCESS_INPUT_ATTACHMENT_READ_BIT, 2219 eShaderRead = VK_ACCESS_SHADER_READ_BIT, 2220 eShaderWrite = VK_ACCESS_SHADER_WRITE_BIT, 2221 eColorAttachmentRead = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT, 2222 eColorAttachmentWrite = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, 2223 eDepthStencilAttachmentRead = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT, 2224 eDepthStencilAttachmentWrite = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT, 2225 eTransferRead = VK_ACCESS_TRANSFER_READ_BIT, 2226 eTransferWrite = VK_ACCESS_TRANSFER_WRITE_BIT, 2227 eHostRead = VK_ACCESS_HOST_READ_BIT, 2228 eHostWrite = VK_ACCESS_HOST_WRITE_BIT, 2229 eMemoryRead = VK_ACCESS_MEMORY_READ_BIT, 2230 eMemoryWrite = VK_ACCESS_MEMORY_WRITE_BIT, 2231 eNone = VK_ACCESS_NONE, 2232 eColorAttachmentReadNoncoherentEXT = VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT, 2233 eFragmentShadingRateAttachmentReadKHR = VK_ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR, 2234 eNoneKHR = VK_ACCESS_NONE_KHR 2235 }; 2236 2237 using AccessFlags = Flags<AccessFlagBits>; 2238 2239 2240 template <> struct FlagTraits<AccessFlagBits> 2241 { 2242 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 2243 static VULKAN_HPP_CONST_OR_CONSTEXPR AccessFlags allFlags = 2244 AccessFlagBits::eIndirectCommandRead 2245 | AccessFlagBits::eIndexRead 2246 | AccessFlagBits::eVertexAttributeRead 2247 | AccessFlagBits::eUniformRead 2248 | AccessFlagBits::eInputAttachmentRead 2249 | AccessFlagBits::eShaderRead 2250 | AccessFlagBits::eShaderWrite 2251 | AccessFlagBits::eColorAttachmentRead 2252 | AccessFlagBits::eColorAttachmentWrite 2253 | AccessFlagBits::eDepthStencilAttachmentRead 2254 | AccessFlagBits::eDepthStencilAttachmentWrite 2255 | AccessFlagBits::eTransferRead 2256 | AccessFlagBits::eTransferWrite 2257 | AccessFlagBits::eHostRead 2258 | AccessFlagBits::eHostWrite 2259 | AccessFlagBits::eMemoryRead 2260 | AccessFlagBits::eMemoryWrite 2261 | AccessFlagBits::eNone 2262 | AccessFlagBits::eColorAttachmentReadNoncoherentEXT 2263 | AccessFlagBits::eFragmentShadingRateAttachmentReadKHR; 2264 }; 2265 2266 enum class AttachmentDescriptionFlagBits : VkAttachmentDescriptionFlags 2267 { 2268 eMayAlias = VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT 2269 }; 2270 2271 using AttachmentDescriptionFlags = Flags<AttachmentDescriptionFlagBits>; 2272 2273 2274 template <> struct FlagTraits<AttachmentDescriptionFlagBits> 2275 { 2276 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 2277 static VULKAN_HPP_CONST_OR_CONSTEXPR AttachmentDescriptionFlags allFlags = 2278 AttachmentDescriptionFlagBits::eMayAlias; 2279 }; 2280 2281 enum class AttachmentLoadOp 2282 { 2283 eLoad = VK_ATTACHMENT_LOAD_OP_LOAD, 2284 eClear = VK_ATTACHMENT_LOAD_OP_CLEAR, 2285 eDontCare = VK_ATTACHMENT_LOAD_OP_DONT_CARE 2286 }; 2287 2288 enum class AttachmentStoreOp 2289 { 2290 eStore = VK_ATTACHMENT_STORE_OP_STORE, 2291 eDontCare = VK_ATTACHMENT_STORE_OP_DONT_CARE, 2292 eNone = VK_ATTACHMENT_STORE_OP_NONE 2293 }; 2294 2295 enum class DependencyFlagBits : VkDependencyFlags 2296 { 2297 eByRegion = VK_DEPENDENCY_BY_REGION_BIT, 2298 eDeviceGroup = VK_DEPENDENCY_DEVICE_GROUP_BIT, 2299 eViewLocal = VK_DEPENDENCY_VIEW_LOCAL_BIT 2300 }; 2301 2302 using DependencyFlags = Flags<DependencyFlagBits>; 2303 2304 2305 template <> struct FlagTraits<DependencyFlagBits> 2306 { 2307 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 2308 static VULKAN_HPP_CONST_OR_CONSTEXPR DependencyFlags allFlags = 2309 DependencyFlagBits::eByRegion 2310 | DependencyFlagBits::eDeviceGroup 2311 | DependencyFlagBits::eViewLocal; 2312 }; 2313 2314 enum class FramebufferCreateFlagBits : VkFramebufferCreateFlags 2315 { 2316 eImageless = VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT 2317 }; 2318 2319 using FramebufferCreateFlags = Flags<FramebufferCreateFlagBits>; 2320 2321 2322 template <> struct FlagTraits<FramebufferCreateFlagBits> 2323 { 2324 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 2325 static VULKAN_HPP_CONST_OR_CONSTEXPR FramebufferCreateFlags allFlags = 2326 FramebufferCreateFlagBits::eImageless; 2327 }; 2328 2329 enum class PipelineBindPoint 2330 { 2331 eGraphics = VK_PIPELINE_BIND_POINT_GRAPHICS, 2332 eCompute = VK_PIPELINE_BIND_POINT_COMPUTE 2333 }; 2334 2335 enum class RenderPassCreateFlagBits : VkRenderPassCreateFlags 2336 {}; 2337 2338 using RenderPassCreateFlags = Flags<RenderPassCreateFlagBits>; 2339 2340 2341 template <> struct FlagTraits<RenderPassCreateFlagBits> 2342 { 2343 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 2344 static VULKAN_HPP_CONST_OR_CONSTEXPR RenderPassCreateFlags allFlags = {}; 2345 }; 2346 2347 enum class SubpassDescriptionFlagBits : VkSubpassDescriptionFlags 2348 {}; 2349 2350 using SubpassDescriptionFlags = Flags<SubpassDescriptionFlagBits>; 2351 2352 2353 template <> struct FlagTraits<SubpassDescriptionFlagBits> 2354 { 2355 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 2356 static VULKAN_HPP_CONST_OR_CONSTEXPR SubpassDescriptionFlags allFlags = {}; 2357 }; 2358 2359 enum class CommandPoolCreateFlagBits : VkCommandPoolCreateFlags 2360 { 2361 eTransient = VK_COMMAND_POOL_CREATE_TRANSIENT_BIT, 2362 eResetCommandBuffer = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, 2363 eProtected = VK_COMMAND_POOL_CREATE_PROTECTED_BIT 2364 }; 2365 2366 using CommandPoolCreateFlags = Flags<CommandPoolCreateFlagBits>; 2367 2368 2369 template <> struct FlagTraits<CommandPoolCreateFlagBits> 2370 { 2371 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 2372 static VULKAN_HPP_CONST_OR_CONSTEXPR CommandPoolCreateFlags allFlags = 2373 CommandPoolCreateFlagBits::eTransient 2374 | CommandPoolCreateFlagBits::eResetCommandBuffer 2375 | CommandPoolCreateFlagBits::eProtected; 2376 }; 2377 2378 enum class CommandPoolResetFlagBits : VkCommandPoolResetFlags 2379 {}; 2380 2381 using CommandPoolResetFlags = Flags<CommandPoolResetFlagBits>; 2382 2383 2384 template <> struct FlagTraits<CommandPoolResetFlagBits> 2385 { 2386 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 2387 static VULKAN_HPP_CONST_OR_CONSTEXPR CommandPoolResetFlags allFlags = {}; 2388 }; 2389 2390 enum class CommandBufferLevel 2391 { 2392 ePrimary = VK_COMMAND_BUFFER_LEVEL_PRIMARY, 2393 eSecondary = VK_COMMAND_BUFFER_LEVEL_SECONDARY 2394 }; 2395 2396 enum class CommandBufferResetFlagBits : VkCommandBufferResetFlags 2397 { 2398 eReleaseResources = VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT 2399 }; 2400 2401 using CommandBufferResetFlags = Flags<CommandBufferResetFlagBits>; 2402 2403 2404 template <> struct FlagTraits<CommandBufferResetFlagBits> 2405 { 2406 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 2407 static VULKAN_HPP_CONST_OR_CONSTEXPR CommandBufferResetFlags allFlags = 2408 CommandBufferResetFlagBits::eReleaseResources; 2409 }; 2410 2411 enum class CommandBufferUsageFlagBits : VkCommandBufferUsageFlags 2412 { 2413 eOneTimeSubmit = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, 2414 eRenderPassContinue = VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT, 2415 eSimultaneousUse = VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT 2416 }; 2417 2418 using CommandBufferUsageFlags = Flags<CommandBufferUsageFlagBits>; 2419 2420 2421 template <> struct FlagTraits<CommandBufferUsageFlagBits> 2422 { 2423 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 2424 static VULKAN_HPP_CONST_OR_CONSTEXPR CommandBufferUsageFlags allFlags = 2425 CommandBufferUsageFlagBits::eOneTimeSubmit 2426 | CommandBufferUsageFlagBits::eRenderPassContinue 2427 | CommandBufferUsageFlagBits::eSimultaneousUse; 2428 }; 2429 2430 enum class QueryControlFlagBits : VkQueryControlFlags 2431 { 2432 ePrecise = VK_QUERY_CONTROL_PRECISE_BIT 2433 }; 2434 2435 using QueryControlFlags = Flags<QueryControlFlagBits>; 2436 2437 2438 template <> struct FlagTraits<QueryControlFlagBits> 2439 { 2440 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 2441 static VULKAN_HPP_CONST_OR_CONSTEXPR QueryControlFlags allFlags = 2442 QueryControlFlagBits::ePrecise; 2443 }; 2444 2445 enum class IndexType 2446 { 2447 eUint16 = VK_INDEX_TYPE_UINT16, 2448 eUint32 = VK_INDEX_TYPE_UINT32, 2449 eUint8EXT = VK_INDEX_TYPE_UINT8_EXT 2450 }; 2451 2452 enum class StencilFaceFlagBits : VkStencilFaceFlags 2453 { 2454 eFront = VK_STENCIL_FACE_FRONT_BIT, 2455 eBack = VK_STENCIL_FACE_BACK_BIT, 2456 eFrontAndBack = VK_STENCIL_FACE_FRONT_AND_BACK 2457 }; 2458 2459 using StencilFaceFlags = Flags<StencilFaceFlagBits>; 2460 2461 2462 template <> struct FlagTraits<StencilFaceFlagBits> 2463 { 2464 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 2465 static VULKAN_HPP_CONST_OR_CONSTEXPR StencilFaceFlags allFlags = 2466 StencilFaceFlagBits::eFront 2467 | StencilFaceFlagBits::eBack 2468 | StencilFaceFlagBits::eFrontAndBack; 2469 }; 2470 2471 enum class SubpassContents 2472 { 2473 eInline = VK_SUBPASS_CONTENTS_INLINE, 2474 eSecondaryCommandBuffers = VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS 2475 }; 2476 2477 //=== VK_VERSION_1_1 === 2478 2479 enum class SubgroupFeatureFlagBits : VkSubgroupFeatureFlags 2480 { 2481 eBasic = VK_SUBGROUP_FEATURE_BASIC_BIT, 2482 eVote = VK_SUBGROUP_FEATURE_VOTE_BIT, 2483 eArithmetic = VK_SUBGROUP_FEATURE_ARITHMETIC_BIT, 2484 eBallot = VK_SUBGROUP_FEATURE_BALLOT_BIT, 2485 eShuffle = VK_SUBGROUP_FEATURE_SHUFFLE_BIT, 2486 eShuffleRelative = VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT, 2487 eClustered = VK_SUBGROUP_FEATURE_CLUSTERED_BIT, 2488 eQuad = VK_SUBGROUP_FEATURE_QUAD_BIT 2489 }; 2490 2491 using SubgroupFeatureFlags = Flags<SubgroupFeatureFlagBits>; 2492 2493 2494 template <> struct FlagTraits<SubgroupFeatureFlagBits> 2495 { 2496 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 2497 static VULKAN_HPP_CONST_OR_CONSTEXPR SubgroupFeatureFlags allFlags = 2498 SubgroupFeatureFlagBits::eBasic 2499 | SubgroupFeatureFlagBits::eVote 2500 | SubgroupFeatureFlagBits::eArithmetic 2501 | SubgroupFeatureFlagBits::eBallot 2502 | SubgroupFeatureFlagBits::eShuffle 2503 | SubgroupFeatureFlagBits::eShuffleRelative 2504 | SubgroupFeatureFlagBits::eClustered 2505 | SubgroupFeatureFlagBits::eQuad; 2506 }; 2507 2508 enum class PeerMemoryFeatureFlagBits : VkPeerMemoryFeatureFlags 2509 { 2510 eCopySrc = VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT, 2511 eCopyDst = VK_PEER_MEMORY_FEATURE_COPY_DST_BIT, 2512 eGenericSrc = VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT, 2513 eGenericDst = VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT 2514 }; 2515 using PeerMemoryFeatureFlagBitsKHR = PeerMemoryFeatureFlagBits; 2516 2517 using PeerMemoryFeatureFlags = Flags<PeerMemoryFeatureFlagBits>; 2518 using PeerMemoryFeatureFlagsKHR = PeerMemoryFeatureFlags; 2519 2520 2521 template <> struct FlagTraits<PeerMemoryFeatureFlagBits> 2522 { 2523 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 2524 static VULKAN_HPP_CONST_OR_CONSTEXPR PeerMemoryFeatureFlags allFlags = 2525 PeerMemoryFeatureFlagBits::eCopySrc 2526 | PeerMemoryFeatureFlagBits::eCopyDst 2527 | PeerMemoryFeatureFlagBits::eGenericSrc 2528 | PeerMemoryFeatureFlagBits::eGenericDst; 2529 }; 2530 2531 enum class MemoryAllocateFlagBits : VkMemoryAllocateFlags 2532 { 2533 eDeviceMask = VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT, 2534 eDeviceAddress = VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT, 2535 eDeviceAddressCaptureReplay = VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT 2536 }; 2537 using MemoryAllocateFlagBitsKHR = MemoryAllocateFlagBits; 2538 2539 using MemoryAllocateFlags = Flags<MemoryAllocateFlagBits>; 2540 using MemoryAllocateFlagsKHR = MemoryAllocateFlags; 2541 2542 2543 template <> struct FlagTraits<MemoryAllocateFlagBits> 2544 { 2545 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 2546 static VULKAN_HPP_CONST_OR_CONSTEXPR MemoryAllocateFlags allFlags = 2547 MemoryAllocateFlagBits::eDeviceMask 2548 | MemoryAllocateFlagBits::eDeviceAddress 2549 | MemoryAllocateFlagBits::eDeviceAddressCaptureReplay; 2550 }; 2551 2552 enum class PointClippingBehavior 2553 { 2554 eAllClipPlanes = VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES, 2555 eUserClipPlanesOnly = VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY 2556 }; 2557 using PointClippingBehaviorKHR = PointClippingBehavior; 2558 2559 enum class TessellationDomainOrigin 2560 { 2561 eUpperLeft = VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT, 2562 eLowerLeft = VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT 2563 }; 2564 using TessellationDomainOriginKHR = TessellationDomainOrigin; 2565 2566 enum class SamplerYcbcrModelConversion 2567 { 2568 eRgbIdentity = VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY, 2569 eYcbcrIdentity = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY, 2570 eYcbcr709 = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709, 2571 eYcbcr601 = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601, 2572 eYcbcr2020 = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020 2573 }; 2574 using SamplerYcbcrModelConversionKHR = SamplerYcbcrModelConversion; 2575 2576 enum class SamplerYcbcrRange 2577 { 2578 eItuFull = VK_SAMPLER_YCBCR_RANGE_ITU_FULL, 2579 eItuNarrow = VK_SAMPLER_YCBCR_RANGE_ITU_NARROW 2580 }; 2581 using SamplerYcbcrRangeKHR = SamplerYcbcrRange; 2582 2583 enum class ChromaLocation 2584 { 2585 eCositedEven = VK_CHROMA_LOCATION_COSITED_EVEN, 2586 eMidpoint = VK_CHROMA_LOCATION_MIDPOINT 2587 }; 2588 using ChromaLocationKHR = ChromaLocation; 2589 2590 enum class ExternalMemoryHandleTypeFlagBits : VkExternalMemoryHandleTypeFlags 2591 { 2592 eOpaqueFd = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT, 2593 eOpaqueWin32 = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT, 2594 eOpaqueWin32Kmt = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, 2595 eD3D11Texture = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT, 2596 eD3D11TextureKmt = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT, 2597 eD3D12Heap = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT, 2598 eD3D12Resource = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT, 2599 eDmaBufEXT = VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT, 2600 eHostAllocationEXT = VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT, 2601 eHostMappedForeignMemoryEXT = VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT, 2602 #if defined( VK_USE_PLATFORM_SCI ) 2603 eSciBufNV = VK_EXTERNAL_MEMORY_HANDLE_TYPE_SCI_BUF_BIT_NV, 2604 #endif /*VK_USE_PLATFORM_SCI*/ 2605 #if defined( VK_USE_PLATFORM_SCREEN_QNX ) 2606 eScreenBufferQNX = VK_EXTERNAL_MEMORY_HANDLE_TYPE_SCREEN_BUFFER_BIT_QNX 2607 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/ 2608 }; 2609 using ExternalMemoryHandleTypeFlagBitsKHR = ExternalMemoryHandleTypeFlagBits; 2610 2611 using ExternalMemoryHandleTypeFlags = Flags<ExternalMemoryHandleTypeFlagBits>; 2612 using ExternalMemoryHandleTypeFlagsKHR = ExternalMemoryHandleTypeFlags; 2613 2614 2615 template <> struct FlagTraits<ExternalMemoryHandleTypeFlagBits> 2616 { 2617 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 2618 static VULKAN_HPP_CONST_OR_CONSTEXPR ExternalMemoryHandleTypeFlags allFlags = 2619 ExternalMemoryHandleTypeFlagBits::eOpaqueFd 2620 | ExternalMemoryHandleTypeFlagBits::eOpaqueWin32 2621 | ExternalMemoryHandleTypeFlagBits::eOpaqueWin32Kmt 2622 | ExternalMemoryHandleTypeFlagBits::eD3D11Texture 2623 | ExternalMemoryHandleTypeFlagBits::eD3D11TextureKmt 2624 | ExternalMemoryHandleTypeFlagBits::eD3D12Heap 2625 | ExternalMemoryHandleTypeFlagBits::eD3D12Resource 2626 | ExternalMemoryHandleTypeFlagBits::eDmaBufEXT 2627 | ExternalMemoryHandleTypeFlagBits::eHostAllocationEXT 2628 | ExternalMemoryHandleTypeFlagBits::eHostMappedForeignMemoryEXT 2629 #if defined( VK_USE_PLATFORM_SCI ) 2630 | ExternalMemoryHandleTypeFlagBits::eSciBufNV 2631 #endif /*VK_USE_PLATFORM_SCI*/ 2632 #if defined( VK_USE_PLATFORM_SCREEN_QNX ) 2633 | ExternalMemoryHandleTypeFlagBits::eScreenBufferQNX 2634 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/ 2635 ; 2636 }; 2637 2638 enum class ExternalMemoryFeatureFlagBits : VkExternalMemoryFeatureFlags 2639 { 2640 eDedicatedOnly = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT, 2641 eExportable = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT, 2642 eImportable = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT 2643 }; 2644 using ExternalMemoryFeatureFlagBitsKHR = ExternalMemoryFeatureFlagBits; 2645 2646 using ExternalMemoryFeatureFlags = Flags<ExternalMemoryFeatureFlagBits>; 2647 using ExternalMemoryFeatureFlagsKHR = ExternalMemoryFeatureFlags; 2648 2649 2650 template <> struct FlagTraits<ExternalMemoryFeatureFlagBits> 2651 { 2652 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 2653 static VULKAN_HPP_CONST_OR_CONSTEXPR ExternalMemoryFeatureFlags allFlags = 2654 ExternalMemoryFeatureFlagBits::eDedicatedOnly 2655 | ExternalMemoryFeatureFlagBits::eExportable 2656 | ExternalMemoryFeatureFlagBits::eImportable; 2657 }; 2658 2659 enum class ExternalFenceHandleTypeFlagBits : VkExternalFenceHandleTypeFlags 2660 { 2661 eOpaqueFd = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT, 2662 eOpaqueWin32 = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT, 2663 eOpaqueWin32Kmt = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, 2664 eSyncFd = VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT, 2665 #if defined( VK_USE_PLATFORM_SCI ) 2666 eSciSyncObjNV = VK_EXTERNAL_FENCE_HANDLE_TYPE_SCI_SYNC_OBJ_BIT_NV, 2667 eSciSyncFenceNV = VK_EXTERNAL_FENCE_HANDLE_TYPE_SCI_SYNC_FENCE_BIT_NV 2668 #endif /*VK_USE_PLATFORM_SCI*/ 2669 }; 2670 using ExternalFenceHandleTypeFlagBitsKHR = ExternalFenceHandleTypeFlagBits; 2671 2672 using ExternalFenceHandleTypeFlags = Flags<ExternalFenceHandleTypeFlagBits>; 2673 using ExternalFenceHandleTypeFlagsKHR = ExternalFenceHandleTypeFlags; 2674 2675 2676 template <> struct FlagTraits<ExternalFenceHandleTypeFlagBits> 2677 { 2678 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 2679 static VULKAN_HPP_CONST_OR_CONSTEXPR ExternalFenceHandleTypeFlags allFlags = 2680 ExternalFenceHandleTypeFlagBits::eOpaqueFd 2681 | ExternalFenceHandleTypeFlagBits::eOpaqueWin32 2682 | ExternalFenceHandleTypeFlagBits::eOpaqueWin32Kmt 2683 | ExternalFenceHandleTypeFlagBits::eSyncFd 2684 #if defined( VK_USE_PLATFORM_SCI ) 2685 | ExternalFenceHandleTypeFlagBits::eSciSyncObjNV 2686 | ExternalFenceHandleTypeFlagBits::eSciSyncFenceNV 2687 #endif /*VK_USE_PLATFORM_SCI*/ 2688 ; 2689 }; 2690 2691 enum class ExternalFenceFeatureFlagBits : VkExternalFenceFeatureFlags 2692 { 2693 eExportable = VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT, 2694 eImportable = VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT 2695 }; 2696 using ExternalFenceFeatureFlagBitsKHR = ExternalFenceFeatureFlagBits; 2697 2698 using ExternalFenceFeatureFlags = Flags<ExternalFenceFeatureFlagBits>; 2699 using ExternalFenceFeatureFlagsKHR = ExternalFenceFeatureFlags; 2700 2701 2702 template <> struct FlagTraits<ExternalFenceFeatureFlagBits> 2703 { 2704 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 2705 static VULKAN_HPP_CONST_OR_CONSTEXPR ExternalFenceFeatureFlags allFlags = 2706 ExternalFenceFeatureFlagBits::eExportable 2707 | ExternalFenceFeatureFlagBits::eImportable; 2708 }; 2709 2710 enum class FenceImportFlagBits : VkFenceImportFlags 2711 { 2712 eTemporary = VK_FENCE_IMPORT_TEMPORARY_BIT 2713 }; 2714 using FenceImportFlagBitsKHR = FenceImportFlagBits; 2715 2716 using FenceImportFlags = Flags<FenceImportFlagBits>; 2717 using FenceImportFlagsKHR = FenceImportFlags; 2718 2719 2720 template <> struct FlagTraits<FenceImportFlagBits> 2721 { 2722 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 2723 static VULKAN_HPP_CONST_OR_CONSTEXPR FenceImportFlags allFlags = 2724 FenceImportFlagBits::eTemporary; 2725 }; 2726 2727 enum class SemaphoreImportFlagBits : VkSemaphoreImportFlags 2728 { 2729 eTemporary = VK_SEMAPHORE_IMPORT_TEMPORARY_BIT 2730 }; 2731 using SemaphoreImportFlagBitsKHR = SemaphoreImportFlagBits; 2732 2733 using SemaphoreImportFlags = Flags<SemaphoreImportFlagBits>; 2734 using SemaphoreImportFlagsKHR = SemaphoreImportFlags; 2735 2736 2737 template <> struct FlagTraits<SemaphoreImportFlagBits> 2738 { 2739 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 2740 static VULKAN_HPP_CONST_OR_CONSTEXPR SemaphoreImportFlags allFlags = 2741 SemaphoreImportFlagBits::eTemporary; 2742 }; 2743 2744 enum class ExternalSemaphoreHandleTypeFlagBits : VkExternalSemaphoreHandleTypeFlags 2745 { 2746 eOpaqueFd = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT, 2747 eOpaqueWin32 = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT, 2748 eOpaqueWin32Kmt = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, 2749 eD3D12Fence = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT, 2750 eD3D11Fence = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_FENCE_BIT, 2751 eSyncFd = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT, 2752 #if defined( VK_USE_PLATFORM_SCI ) 2753 eSciSyncObjNV = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SCI_SYNC_OBJ_BIT_NV 2754 #endif /*VK_USE_PLATFORM_SCI*/ 2755 }; 2756 using ExternalSemaphoreHandleTypeFlagBitsKHR = ExternalSemaphoreHandleTypeFlagBits; 2757 2758 using ExternalSemaphoreHandleTypeFlags = Flags<ExternalSemaphoreHandleTypeFlagBits>; 2759 using ExternalSemaphoreHandleTypeFlagsKHR = ExternalSemaphoreHandleTypeFlags; 2760 2761 2762 template <> struct FlagTraits<ExternalSemaphoreHandleTypeFlagBits> 2763 { 2764 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 2765 static VULKAN_HPP_CONST_OR_CONSTEXPR ExternalSemaphoreHandleTypeFlags allFlags = 2766 ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd 2767 | ExternalSemaphoreHandleTypeFlagBits::eOpaqueWin32 2768 | ExternalSemaphoreHandleTypeFlagBits::eOpaqueWin32Kmt 2769 | ExternalSemaphoreHandleTypeFlagBits::eD3D12Fence 2770 | ExternalSemaphoreHandleTypeFlagBits::eSyncFd 2771 #if defined( VK_USE_PLATFORM_SCI ) 2772 | ExternalSemaphoreHandleTypeFlagBits::eSciSyncObjNV 2773 #endif /*VK_USE_PLATFORM_SCI*/ 2774 ; 2775 }; 2776 2777 enum class ExternalSemaphoreFeatureFlagBits : VkExternalSemaphoreFeatureFlags 2778 { 2779 eExportable = VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT, 2780 eImportable = VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT 2781 }; 2782 using ExternalSemaphoreFeatureFlagBitsKHR = ExternalSemaphoreFeatureFlagBits; 2783 2784 using ExternalSemaphoreFeatureFlags = Flags<ExternalSemaphoreFeatureFlagBits>; 2785 using ExternalSemaphoreFeatureFlagsKHR = ExternalSemaphoreFeatureFlags; 2786 2787 2788 template <> struct FlagTraits<ExternalSemaphoreFeatureFlagBits> 2789 { 2790 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 2791 static VULKAN_HPP_CONST_OR_CONSTEXPR ExternalSemaphoreFeatureFlags allFlags = 2792 ExternalSemaphoreFeatureFlagBits::eExportable 2793 | ExternalSemaphoreFeatureFlagBits::eImportable; 2794 }; 2795 2796 //=== VK_VERSION_1_2 === 2797 2798 enum class DriverId 2799 { 2800 eAmdProprietary = VK_DRIVER_ID_AMD_PROPRIETARY, 2801 eAmdOpenSource = VK_DRIVER_ID_AMD_OPEN_SOURCE, 2802 eMesaRadv = VK_DRIVER_ID_MESA_RADV, 2803 eNvidiaProprietary = VK_DRIVER_ID_NVIDIA_PROPRIETARY, 2804 eIntelProprietaryWindows = VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS, 2805 eIntelOpenSourceMESA = VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA, 2806 eImaginationProprietary = VK_DRIVER_ID_IMAGINATION_PROPRIETARY, 2807 eQualcommProprietary = VK_DRIVER_ID_QUALCOMM_PROPRIETARY, 2808 eArmProprietary = VK_DRIVER_ID_ARM_PROPRIETARY, 2809 eGoogleSwiftshader = VK_DRIVER_ID_GOOGLE_SWIFTSHADER, 2810 eGgpProprietary = VK_DRIVER_ID_GGP_PROPRIETARY, 2811 eBroadcomProprietary = VK_DRIVER_ID_BROADCOM_PROPRIETARY, 2812 eMesaLlvmpipe = VK_DRIVER_ID_MESA_LLVMPIPE, 2813 eMoltenvk = VK_DRIVER_ID_MOLTENVK, 2814 eCoreaviProprietary = VK_DRIVER_ID_COREAVI_PROPRIETARY, 2815 eJuiceProprietary = VK_DRIVER_ID_JUICE_PROPRIETARY, 2816 eVerisiliconProprietary = VK_DRIVER_ID_VERISILICON_PROPRIETARY, 2817 eMesaTurnip = VK_DRIVER_ID_MESA_TURNIP, 2818 eMesaV3Dv = VK_DRIVER_ID_MESA_V3DV, 2819 eMesaPanvk = VK_DRIVER_ID_MESA_PANVK, 2820 eSamsungProprietary = VK_DRIVER_ID_SAMSUNG_PROPRIETARY, 2821 eMesaVenus = VK_DRIVER_ID_MESA_VENUS, 2822 eMesaDozen = VK_DRIVER_ID_MESA_DOZEN, 2823 eMesaNvk = VK_DRIVER_ID_MESA_NVK, 2824 eImaginationOpenSourceMESA = VK_DRIVER_ID_IMAGINATION_OPEN_SOURCE_MESA, 2825 eMesaAgxv = VK_DRIVER_ID_MESA_AGXV 2826 }; 2827 using DriverIdKHR = DriverId; 2828 2829 enum class ShaderFloatControlsIndependence 2830 { 2831 e32BitOnly = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY, 2832 eAll = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL, 2833 eNone = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE 2834 }; 2835 using ShaderFloatControlsIndependenceKHR = ShaderFloatControlsIndependence; 2836 2837 enum class DescriptorBindingFlagBits : VkDescriptorBindingFlags 2838 { 2839 eUpdateAfterBind = VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT, 2840 eUpdateUnusedWhilePending = VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT, 2841 ePartiallyBound = VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT, 2842 eVariableDescriptorCount = VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT 2843 }; 2844 using DescriptorBindingFlagBitsEXT = DescriptorBindingFlagBits; 2845 2846 using DescriptorBindingFlags = Flags<DescriptorBindingFlagBits>; 2847 using DescriptorBindingFlagsEXT = DescriptorBindingFlags; 2848 2849 2850 template <> struct FlagTraits<DescriptorBindingFlagBits> 2851 { 2852 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 2853 static VULKAN_HPP_CONST_OR_CONSTEXPR DescriptorBindingFlags allFlags = 2854 DescriptorBindingFlagBits::eUpdateAfterBind 2855 | DescriptorBindingFlagBits::eUpdateUnusedWhilePending 2856 | DescriptorBindingFlagBits::ePartiallyBound 2857 | DescriptorBindingFlagBits::eVariableDescriptorCount; 2858 }; 2859 2860 enum class ResolveModeFlagBits : VkResolveModeFlags 2861 { 2862 eNone = VK_RESOLVE_MODE_NONE, 2863 eSampleZero = VK_RESOLVE_MODE_SAMPLE_ZERO_BIT, 2864 eAverage = VK_RESOLVE_MODE_AVERAGE_BIT, 2865 eMin = VK_RESOLVE_MODE_MIN_BIT, 2866 eMax = VK_RESOLVE_MODE_MAX_BIT 2867 }; 2868 using ResolveModeFlagBitsKHR = ResolveModeFlagBits; 2869 2870 using ResolveModeFlags = Flags<ResolveModeFlagBits>; 2871 using ResolveModeFlagsKHR = ResolveModeFlags; 2872 2873 2874 template <> struct FlagTraits<ResolveModeFlagBits> 2875 { 2876 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 2877 static VULKAN_HPP_CONST_OR_CONSTEXPR ResolveModeFlags allFlags = 2878 ResolveModeFlagBits::eNone 2879 | ResolveModeFlagBits::eSampleZero 2880 | ResolveModeFlagBits::eAverage 2881 | ResolveModeFlagBits::eMin 2882 | ResolveModeFlagBits::eMax; 2883 }; 2884 2885 enum class SamplerReductionMode 2886 { 2887 eWeightedAverage = VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE, 2888 eMin = VK_SAMPLER_REDUCTION_MODE_MIN, 2889 eMax = VK_SAMPLER_REDUCTION_MODE_MAX 2890 }; 2891 using SamplerReductionModeEXT = SamplerReductionMode; 2892 2893 enum class SemaphoreType 2894 { 2895 eBinary = VK_SEMAPHORE_TYPE_BINARY, 2896 eTimeline = VK_SEMAPHORE_TYPE_TIMELINE 2897 }; 2898 using SemaphoreTypeKHR = SemaphoreType; 2899 2900 enum class SemaphoreWaitFlagBits : VkSemaphoreWaitFlags 2901 { 2902 eAny = VK_SEMAPHORE_WAIT_ANY_BIT 2903 }; 2904 using SemaphoreWaitFlagBitsKHR = SemaphoreWaitFlagBits; 2905 2906 using SemaphoreWaitFlags = Flags<SemaphoreWaitFlagBits>; 2907 using SemaphoreWaitFlagsKHR = SemaphoreWaitFlags; 2908 2909 2910 template <> struct FlagTraits<SemaphoreWaitFlagBits> 2911 { 2912 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 2913 static VULKAN_HPP_CONST_OR_CONSTEXPR SemaphoreWaitFlags allFlags = 2914 SemaphoreWaitFlagBits::eAny; 2915 }; 2916 2917 //=== VK_VERSION_1_3 === 2918 2919 enum class PipelineCreationFeedbackFlagBits : VkPipelineCreationFeedbackFlags 2920 { 2921 eValid = VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT, 2922 eApplicationPipelineCacheHit = VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT, 2923 eBasePipelineAcceleration = VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT 2924 }; 2925 using PipelineCreationFeedbackFlagBitsEXT = PipelineCreationFeedbackFlagBits; 2926 2927 using PipelineCreationFeedbackFlags = Flags<PipelineCreationFeedbackFlagBits>; 2928 using PipelineCreationFeedbackFlagsEXT = PipelineCreationFeedbackFlags; 2929 2930 2931 template <> struct FlagTraits<PipelineCreationFeedbackFlagBits> 2932 { 2933 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 2934 static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineCreationFeedbackFlags allFlags = 2935 PipelineCreationFeedbackFlagBits::eValid 2936 | PipelineCreationFeedbackFlagBits::eApplicationPipelineCacheHit 2937 | PipelineCreationFeedbackFlagBits::eBasePipelineAcceleration; 2938 }; 2939 2940 enum class ToolPurposeFlagBits : VkToolPurposeFlags 2941 { 2942 eValidation = VK_TOOL_PURPOSE_VALIDATION_BIT, 2943 eProfiling = VK_TOOL_PURPOSE_PROFILING_BIT, 2944 eTracing = VK_TOOL_PURPOSE_TRACING_BIT, 2945 eAdditionalFeatures = VK_TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT, 2946 eModifyingFeatures = VK_TOOL_PURPOSE_MODIFYING_FEATURES_BIT 2947 }; 2948 using ToolPurposeFlagBitsEXT = ToolPurposeFlagBits; 2949 2950 using ToolPurposeFlags = Flags<ToolPurposeFlagBits>; 2951 using ToolPurposeFlagsEXT = ToolPurposeFlags; 2952 2953 2954 template <> struct FlagTraits<ToolPurposeFlagBits> 2955 { 2956 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 2957 static VULKAN_HPP_CONST_OR_CONSTEXPR ToolPurposeFlags allFlags = 2958 ToolPurposeFlagBits::eValidation 2959 | ToolPurposeFlagBits::eProfiling 2960 | ToolPurposeFlagBits::eTracing 2961 | ToolPurposeFlagBits::eAdditionalFeatures 2962 | ToolPurposeFlagBits::eModifyingFeatures; 2963 }; 2964 2965 enum class PrivateDataSlotCreateFlagBits : VkPrivateDataSlotCreateFlags 2966 {}; 2967 using PrivateDataSlotCreateFlagBitsEXT = PrivateDataSlotCreateFlagBits; 2968 2969 using PrivateDataSlotCreateFlags = Flags<PrivateDataSlotCreateFlagBits>; 2970 using PrivateDataSlotCreateFlagsEXT = PrivateDataSlotCreateFlags; 2971 2972 2973 template <> struct FlagTraits<PrivateDataSlotCreateFlagBits> 2974 { 2975 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 2976 static VULKAN_HPP_CONST_OR_CONSTEXPR PrivateDataSlotCreateFlags allFlags = {}; 2977 }; 2978 2979 enum class PipelineStageFlagBits2 : VkPipelineStageFlags2 2980 { 2981 eNone = VK_PIPELINE_STAGE_2_NONE, 2982 eTopOfPipe = VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT, 2983 eDrawIndirect = VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT, 2984 eVertexInput = VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT, 2985 eVertexShader = VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT, 2986 eTessellationControlShader = VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT, 2987 eTessellationEvaluationShader = VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT, 2988 eGeometryShader = VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT, 2989 eFragmentShader = VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT, 2990 eEarlyFragmentTests = VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT, 2991 eLateFragmentTests = VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT, 2992 eColorAttachmentOutput = VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT, 2993 eComputeShader = VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT, 2994 eAllTransfer = VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT, 2995 eTransfer = VK_PIPELINE_STAGE_2_TRANSFER_BIT, 2996 eBottomOfPipe = VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT, 2997 eHost = VK_PIPELINE_STAGE_2_HOST_BIT, 2998 eAllGraphics = VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT, 2999 eAllCommands = VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT, 3000 eCopy = VK_PIPELINE_STAGE_2_COPY_BIT, 3001 eResolve = VK_PIPELINE_STAGE_2_RESOLVE_BIT, 3002 eBlit = VK_PIPELINE_STAGE_2_BLIT_BIT, 3003 eClear = VK_PIPELINE_STAGE_2_CLEAR_BIT, 3004 eIndexInput = VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT, 3005 eVertexAttributeInput = VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT, 3006 ePreRasterizationShaders = VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT, 3007 eTransformFeedbackEXT = VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT, 3008 eConditionalRenderingEXT = VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT, 3009 eCommandPreprocessNV = VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_NV, 3010 eFragmentShadingRateAttachmentKHR = VK_PIPELINE_STAGE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, 3011 eShadingRateImageNV = VK_PIPELINE_STAGE_2_SHADING_RATE_IMAGE_BIT_NV, 3012 eAccelerationStructureBuildKHR = VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR, 3013 eRayTracingShaderKHR = VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_KHR, 3014 eRayTracingShaderNV = VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_NV, 3015 eAccelerationStructureBuildNV = VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_NV, 3016 eFragmentDensityProcessEXT = VK_PIPELINE_STAGE_2_FRAGMENT_DENSITY_PROCESS_BIT_EXT, 3017 eTaskShaderNV = VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_NV, 3018 eMeshShaderNV = VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_NV, 3019 eTaskShaderEXT = VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_EXT, 3020 eMeshShaderEXT = VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_EXT 3021 }; 3022 using PipelineStageFlagBits2KHR = PipelineStageFlagBits2; 3023 3024 using PipelineStageFlags2 = Flags<PipelineStageFlagBits2>; 3025 using PipelineStageFlags2KHR = PipelineStageFlags2; 3026 3027 3028 template <> struct FlagTraits<PipelineStageFlagBits2> 3029 { 3030 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 3031 static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineStageFlags2 allFlags = 3032 PipelineStageFlagBits2::eNone 3033 | PipelineStageFlagBits2::eTopOfPipe 3034 | PipelineStageFlagBits2::eDrawIndirect 3035 | PipelineStageFlagBits2::eVertexInput 3036 | PipelineStageFlagBits2::eVertexShader 3037 | PipelineStageFlagBits2::eTessellationControlShader 3038 | PipelineStageFlagBits2::eTessellationEvaluationShader 3039 | PipelineStageFlagBits2::eGeometryShader 3040 | PipelineStageFlagBits2::eFragmentShader 3041 | PipelineStageFlagBits2::eEarlyFragmentTests 3042 | PipelineStageFlagBits2::eLateFragmentTests 3043 | PipelineStageFlagBits2::eColorAttachmentOutput 3044 | PipelineStageFlagBits2::eComputeShader 3045 | PipelineStageFlagBits2::eAllTransfer 3046 | PipelineStageFlagBits2::eBottomOfPipe 3047 | PipelineStageFlagBits2::eHost 3048 | PipelineStageFlagBits2::eAllGraphics 3049 | PipelineStageFlagBits2::eAllCommands 3050 | PipelineStageFlagBits2::eCopy 3051 | PipelineStageFlagBits2::eResolve 3052 | PipelineStageFlagBits2::eBlit 3053 | PipelineStageFlagBits2::eClear 3054 | PipelineStageFlagBits2::eIndexInput 3055 | PipelineStageFlagBits2::eVertexAttributeInput 3056 | PipelineStageFlagBits2::ePreRasterizationShaders 3057 | PipelineStageFlagBits2::eTransformFeedbackEXT 3058 | PipelineStageFlagBits2::eConditionalRenderingEXT 3059 | PipelineStageFlagBits2::eCommandPreprocessNV 3060 | PipelineStageFlagBits2::eFragmentShadingRateAttachmentKHR 3061 | PipelineStageFlagBits2::eAccelerationStructureBuildKHR 3062 | PipelineStageFlagBits2::eRayTracingShaderKHR 3063 | PipelineStageFlagBits2::eFragmentDensityProcessEXT 3064 | PipelineStageFlagBits2::eTaskShaderEXT 3065 | PipelineStageFlagBits2::eMeshShaderEXT; 3066 }; 3067 3068 enum class AccessFlagBits2 : VkAccessFlags2 3069 { 3070 eNone = VK_ACCESS_2_NONE, 3071 eIndirectCommandRead = VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT, 3072 eIndexRead = VK_ACCESS_2_INDEX_READ_BIT, 3073 eVertexAttributeRead = VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT, 3074 eUniformRead = VK_ACCESS_2_UNIFORM_READ_BIT, 3075 eInputAttachmentRead = VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT, 3076 eShaderRead = VK_ACCESS_2_SHADER_READ_BIT, 3077 eShaderWrite = VK_ACCESS_2_SHADER_WRITE_BIT, 3078 eColorAttachmentRead = VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT, 3079 eColorAttachmentWrite = VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT, 3080 eDepthStencilAttachmentRead = VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT, 3081 eDepthStencilAttachmentWrite = VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT, 3082 eTransferRead = VK_ACCESS_2_TRANSFER_READ_BIT, 3083 eTransferWrite = VK_ACCESS_2_TRANSFER_WRITE_BIT, 3084 eHostRead = VK_ACCESS_2_HOST_READ_BIT, 3085 eHostWrite = VK_ACCESS_2_HOST_WRITE_BIT, 3086 eMemoryRead = VK_ACCESS_2_MEMORY_READ_BIT, 3087 eMemoryWrite = VK_ACCESS_2_MEMORY_WRITE_BIT, 3088 eShaderSampledRead = VK_ACCESS_2_SHADER_SAMPLED_READ_BIT, 3089 eShaderStorageRead = VK_ACCESS_2_SHADER_STORAGE_READ_BIT, 3090 eShaderStorageWrite = VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT, 3091 eTransformFeedbackWriteEXT = VK_ACCESS_2_TRANSFORM_FEEDBACK_WRITE_BIT_EXT, 3092 eTransformFeedbackCounterReadEXT = VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT, 3093 eTransformFeedbackCounterWriteEXT = VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT, 3094 eConditionalRenderingReadEXT = VK_ACCESS_2_CONDITIONAL_RENDERING_READ_BIT_EXT, 3095 eCommandPreprocessReadNV = VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_NV, 3096 eCommandPreprocessWriteNV = VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_NV, 3097 eFragmentShadingRateAttachmentReadKHR = VK_ACCESS_2_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR, 3098 eShadingRateImageReadNV = VK_ACCESS_2_SHADING_RATE_IMAGE_READ_BIT_NV, 3099 eAccelerationStructureReadKHR = VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR, 3100 eAccelerationStructureWriteKHR = VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_KHR, 3101 eAccelerationStructureReadNV = VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_NV, 3102 eAccelerationStructureWriteNV = VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_NV, 3103 eFragmentDensityMapReadEXT = VK_ACCESS_2_FRAGMENT_DENSITY_MAP_READ_BIT_EXT, 3104 eColorAttachmentReadNoncoherentEXT = VK_ACCESS_2_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT 3105 }; 3106 using AccessFlagBits2KHR = AccessFlagBits2; 3107 3108 using AccessFlags2 = Flags<AccessFlagBits2>; 3109 using AccessFlags2KHR = AccessFlags2; 3110 3111 3112 template <> struct FlagTraits<AccessFlagBits2> 3113 { 3114 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 3115 static VULKAN_HPP_CONST_OR_CONSTEXPR AccessFlags2 allFlags = 3116 AccessFlagBits2::eNone 3117 | AccessFlagBits2::eIndirectCommandRead 3118 | AccessFlagBits2::eIndexRead 3119 | AccessFlagBits2::eVertexAttributeRead 3120 | AccessFlagBits2::eUniformRead 3121 | AccessFlagBits2::eInputAttachmentRead 3122 | AccessFlagBits2::eShaderRead 3123 | AccessFlagBits2::eShaderWrite 3124 | AccessFlagBits2::eColorAttachmentRead 3125 | AccessFlagBits2::eColorAttachmentWrite 3126 | AccessFlagBits2::eDepthStencilAttachmentRead 3127 | AccessFlagBits2::eDepthStencilAttachmentWrite 3128 | AccessFlagBits2::eTransferRead 3129 | AccessFlagBits2::eTransferWrite 3130 | AccessFlagBits2::eHostRead 3131 | AccessFlagBits2::eHostWrite 3132 | AccessFlagBits2::eMemoryRead 3133 | AccessFlagBits2::eMemoryWrite 3134 | AccessFlagBits2::eShaderSampledRead 3135 | AccessFlagBits2::eShaderStorageRead 3136 | AccessFlagBits2::eShaderStorageWrite 3137 | AccessFlagBits2::eTransformFeedbackWriteEXT 3138 | AccessFlagBits2::eTransformFeedbackCounterReadEXT 3139 | AccessFlagBits2::eTransformFeedbackCounterWriteEXT 3140 | AccessFlagBits2::eConditionalRenderingReadEXT 3141 | AccessFlagBits2::eCommandPreprocessReadNV 3142 | AccessFlagBits2::eCommandPreprocessWriteNV 3143 | AccessFlagBits2::eFragmentShadingRateAttachmentReadKHR 3144 | AccessFlagBits2::eAccelerationStructureReadKHR 3145 | AccessFlagBits2::eAccelerationStructureWriteKHR 3146 | AccessFlagBits2::eFragmentDensityMapReadEXT 3147 | AccessFlagBits2::eColorAttachmentReadNoncoherentEXT; 3148 }; 3149 3150 enum class SubmitFlagBits : VkSubmitFlags 3151 { 3152 eProtected = VK_SUBMIT_PROTECTED_BIT 3153 }; 3154 using SubmitFlagBitsKHR = SubmitFlagBits; 3155 3156 using SubmitFlags = Flags<SubmitFlagBits>; 3157 using SubmitFlagsKHR = SubmitFlags; 3158 3159 3160 template <> struct FlagTraits<SubmitFlagBits> 3161 { 3162 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 3163 static VULKAN_HPP_CONST_OR_CONSTEXPR SubmitFlags allFlags = 3164 SubmitFlagBits::eProtected; 3165 }; 3166 3167 enum class RenderingFlagBits : VkRenderingFlags 3168 { 3169 eContentsSecondaryCommandBuffers = VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT, 3170 eSuspending = VK_RENDERING_SUSPENDING_BIT, 3171 eResuming = VK_RENDERING_RESUMING_BIT 3172 }; 3173 using RenderingFlagBitsKHR = RenderingFlagBits; 3174 3175 using RenderingFlags = Flags<RenderingFlagBits>; 3176 using RenderingFlagsKHR = RenderingFlags; 3177 3178 3179 template <> struct FlagTraits<RenderingFlagBits> 3180 { 3181 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 3182 static VULKAN_HPP_CONST_OR_CONSTEXPR RenderingFlags allFlags = 3183 RenderingFlagBits::eContentsSecondaryCommandBuffers 3184 | RenderingFlagBits::eSuspending 3185 | RenderingFlagBits::eResuming; 3186 }; 3187 3188 enum class FormatFeatureFlagBits2 : VkFormatFeatureFlags2 3189 { 3190 eSampledImage = VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT, 3191 eStorageImage = VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT, 3192 eStorageImageAtomic = VK_FORMAT_FEATURE_2_STORAGE_IMAGE_ATOMIC_BIT, 3193 eUniformTexelBuffer = VK_FORMAT_FEATURE_2_UNIFORM_TEXEL_BUFFER_BIT, 3194 eStorageTexelBuffer = VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT, 3195 eStorageTexelBufferAtomic = VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_ATOMIC_BIT, 3196 eVertexBuffer = VK_FORMAT_FEATURE_2_VERTEX_BUFFER_BIT, 3197 eColorAttachment = VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT, 3198 eColorAttachmentBlend = VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BLEND_BIT, 3199 eDepthStencilAttachment = VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT, 3200 eBlitSrc = VK_FORMAT_FEATURE_2_BLIT_SRC_BIT, 3201 eBlitDst = VK_FORMAT_FEATURE_2_BLIT_DST_BIT, 3202 eSampledImageFilterLinear = VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT, 3203 eSampledImageFilterCubic = VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT, 3204 eSampledImageFilterCubicEXT = VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT, 3205 eTransferSrc = VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT, 3206 eTransferDst = VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT, 3207 eSampledImageFilterMinmax = VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT, 3208 eMidpointChromaSamples = VK_FORMAT_FEATURE_2_MIDPOINT_CHROMA_SAMPLES_BIT, 3209 eSampledImageYcbcrConversionLinearFilter = VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT, 3210 eSampledImageYcbcrConversionSeparateReconstructionFilter = VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT, 3211 eSampledImageYcbcrConversionChromaReconstructionExplicit = VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT, 3212 eSampledImageYcbcrConversionChromaReconstructionExplicitForceable = VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT, 3213 eDisjoint = VK_FORMAT_FEATURE_2_DISJOINT_BIT, 3214 eCositedChromaSamples = VK_FORMAT_FEATURE_2_COSITED_CHROMA_SAMPLES_BIT, 3215 eStorageReadWithoutFormat = VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT, 3216 eStorageWriteWithoutFormat = VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT, 3217 eSampledImageDepthComparison = VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT, 3218 eFragmentShadingRateAttachmentKHR = VK_FORMAT_FEATURE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR 3219 }; 3220 using FormatFeatureFlagBits2KHR = FormatFeatureFlagBits2; 3221 3222 using FormatFeatureFlags2 = Flags<FormatFeatureFlagBits2>; 3223 using FormatFeatureFlags2KHR = FormatFeatureFlags2; 3224 3225 3226 template <> struct FlagTraits<FormatFeatureFlagBits2> 3227 { 3228 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 3229 static VULKAN_HPP_CONST_OR_CONSTEXPR FormatFeatureFlags2 allFlags = 3230 FormatFeatureFlagBits2::eSampledImage 3231 | FormatFeatureFlagBits2::eStorageImage 3232 | FormatFeatureFlagBits2::eStorageImageAtomic 3233 | FormatFeatureFlagBits2::eUniformTexelBuffer 3234 | FormatFeatureFlagBits2::eStorageTexelBuffer 3235 | FormatFeatureFlagBits2::eStorageTexelBufferAtomic 3236 | FormatFeatureFlagBits2::eVertexBuffer 3237 | FormatFeatureFlagBits2::eColorAttachment 3238 | FormatFeatureFlagBits2::eColorAttachmentBlend 3239 | FormatFeatureFlagBits2::eDepthStencilAttachment 3240 | FormatFeatureFlagBits2::eBlitSrc 3241 | FormatFeatureFlagBits2::eBlitDst 3242 | FormatFeatureFlagBits2::eSampledImageFilterLinear 3243 | FormatFeatureFlagBits2::eSampledImageFilterCubic 3244 | FormatFeatureFlagBits2::eTransferSrc 3245 | FormatFeatureFlagBits2::eTransferDst 3246 | FormatFeatureFlagBits2::eSampledImageFilterMinmax 3247 | FormatFeatureFlagBits2::eMidpointChromaSamples 3248 | FormatFeatureFlagBits2::eSampledImageYcbcrConversionLinearFilter 3249 | FormatFeatureFlagBits2::eSampledImageYcbcrConversionSeparateReconstructionFilter 3250 | FormatFeatureFlagBits2::eSampledImageYcbcrConversionChromaReconstructionExplicit 3251 | FormatFeatureFlagBits2::eSampledImageYcbcrConversionChromaReconstructionExplicitForceable 3252 | FormatFeatureFlagBits2::eDisjoint 3253 | FormatFeatureFlagBits2::eCositedChromaSamples 3254 | FormatFeatureFlagBits2::eStorageReadWithoutFormat 3255 | FormatFeatureFlagBits2::eStorageWriteWithoutFormat 3256 | FormatFeatureFlagBits2::eSampledImageDepthComparison 3257 | FormatFeatureFlagBits2::eFragmentShadingRateAttachmentKHR; 3258 }; 3259 3260 //=== VKSC_VERSION_1_0 === 3261 3262 enum class FaultLevel 3263 { 3264 eUnassigned = VK_FAULT_LEVEL_UNASSIGNED, 3265 eCritical = VK_FAULT_LEVEL_CRITICAL, 3266 eRecoverable = VK_FAULT_LEVEL_RECOVERABLE, 3267 eWarning = VK_FAULT_LEVEL_WARNING 3268 }; 3269 3270 enum class FaultType 3271 { 3272 eInvalid = VK_FAULT_TYPE_INVALID, 3273 eUnassigned = VK_FAULT_TYPE_UNASSIGNED, 3274 eImplementation = VK_FAULT_TYPE_IMPLEMENTATION, 3275 eSystem = VK_FAULT_TYPE_SYSTEM, 3276 ePhysicalDevice = VK_FAULT_TYPE_PHYSICAL_DEVICE, 3277 eCommandBufferFull = VK_FAULT_TYPE_COMMAND_BUFFER_FULL, 3278 eInvalidApiUsage = VK_FAULT_TYPE_INVALID_API_USAGE 3279 }; 3280 3281 enum class FaultQueryBehavior 3282 { 3283 eGetAndClearAllFaults = VK_FAULT_QUERY_BEHAVIOR_GET_AND_CLEAR_ALL_FAULTS 3284 }; 3285 3286 enum class PipelineMatchControl 3287 { 3288 eApplicationUuidExactMatch = VK_PIPELINE_MATCH_CONTROL_APPLICATION_UUID_EXACT_MATCH 3289 }; 3290 3291 enum class PipelineCacheValidationVersion 3292 { 3293 eSafetyCriticalOne = VK_PIPELINE_CACHE_VALIDATION_VERSION_SAFETY_CRITICAL_ONE 3294 }; 3295 3296 //=== VK_KHR_surface === 3297 3298 enum class SurfaceTransformFlagBitsKHR : VkSurfaceTransformFlagsKHR 3299 { 3300 eIdentity = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR, 3301 eRotate90 = VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR, 3302 eRotate180 = VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR, 3303 eRotate270 = VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR, 3304 eHorizontalMirror = VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR, 3305 eHorizontalMirrorRotate90 = VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR, 3306 eHorizontalMirrorRotate180 = VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR, 3307 eHorizontalMirrorRotate270 = VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR, 3308 eInherit = VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR 3309 }; 3310 3311 using SurfaceTransformFlagsKHR = Flags<SurfaceTransformFlagBitsKHR>; 3312 3313 3314 template <> struct FlagTraits<SurfaceTransformFlagBitsKHR> 3315 { 3316 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 3317 static VULKAN_HPP_CONST_OR_CONSTEXPR SurfaceTransformFlagsKHR allFlags = 3318 SurfaceTransformFlagBitsKHR::eIdentity 3319 | SurfaceTransformFlagBitsKHR::eRotate90 3320 | SurfaceTransformFlagBitsKHR::eRotate180 3321 | SurfaceTransformFlagBitsKHR::eRotate270 3322 | SurfaceTransformFlagBitsKHR::eHorizontalMirror 3323 | SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate90 3324 | SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate180 3325 | SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate270 3326 | SurfaceTransformFlagBitsKHR::eInherit; 3327 }; 3328 3329 enum class PresentModeKHR 3330 { 3331 eImmediate = VK_PRESENT_MODE_IMMEDIATE_KHR, 3332 eMailbox = VK_PRESENT_MODE_MAILBOX_KHR, 3333 eFifo = VK_PRESENT_MODE_FIFO_KHR, 3334 eFifoRelaxed = VK_PRESENT_MODE_FIFO_RELAXED_KHR, 3335 eSharedDemandRefresh = VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR, 3336 eSharedContinuousRefresh = VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR 3337 }; 3338 3339 enum class ColorSpaceKHR 3340 { 3341 eSrgbNonlinear = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR, 3342 eDisplayP3NonlinearEXT = VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT, 3343 eExtendedSrgbLinearEXT = VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT, 3344 eDisplayP3LinearEXT = VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT, 3345 eDciP3NonlinearEXT = VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT, 3346 eBt709LinearEXT = VK_COLOR_SPACE_BT709_LINEAR_EXT, 3347 eBt709NonlinearEXT = VK_COLOR_SPACE_BT709_NONLINEAR_EXT, 3348 eBt2020LinearEXT = VK_COLOR_SPACE_BT2020_LINEAR_EXT, 3349 eHdr10St2084EXT = VK_COLOR_SPACE_HDR10_ST2084_EXT, 3350 eDolbyvisionEXT = VK_COLOR_SPACE_DOLBYVISION_EXT, 3351 eHdr10HlgEXT = VK_COLOR_SPACE_HDR10_HLG_EXT, 3352 eAdobergbLinearEXT = VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT, 3353 eAdobergbNonlinearEXT = VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT, 3354 ePassThroughEXT = VK_COLOR_SPACE_PASS_THROUGH_EXT, 3355 eExtendedSrgbNonlinearEXT = VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT 3356 }; 3357 3358 enum class CompositeAlphaFlagBitsKHR : VkCompositeAlphaFlagsKHR 3359 { 3360 eOpaque = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR, 3361 ePreMultiplied = VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR, 3362 ePostMultiplied = VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR, 3363 eInherit = VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR 3364 }; 3365 3366 using CompositeAlphaFlagsKHR = Flags<CompositeAlphaFlagBitsKHR>; 3367 3368 3369 template <> struct FlagTraits<CompositeAlphaFlagBitsKHR> 3370 { 3371 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 3372 static VULKAN_HPP_CONST_OR_CONSTEXPR CompositeAlphaFlagsKHR allFlags = 3373 CompositeAlphaFlagBitsKHR::eOpaque 3374 | CompositeAlphaFlagBitsKHR::ePreMultiplied 3375 | CompositeAlphaFlagBitsKHR::ePostMultiplied 3376 | CompositeAlphaFlagBitsKHR::eInherit; 3377 }; 3378 3379 //=== VK_KHR_swapchain === 3380 3381 enum class SwapchainCreateFlagBitsKHR : VkSwapchainCreateFlagsKHR 3382 { 3383 eSplitInstanceBindRegions = VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR, 3384 eProtected = VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR, 3385 eMutableFormat = VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR 3386 }; 3387 3388 using SwapchainCreateFlagsKHR = Flags<SwapchainCreateFlagBitsKHR>; 3389 3390 3391 template <> struct FlagTraits<SwapchainCreateFlagBitsKHR> 3392 { 3393 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 3394 static VULKAN_HPP_CONST_OR_CONSTEXPR SwapchainCreateFlagsKHR allFlags = 3395 SwapchainCreateFlagBitsKHR::eSplitInstanceBindRegions 3396 | SwapchainCreateFlagBitsKHR::eProtected 3397 | SwapchainCreateFlagBitsKHR::eMutableFormat; 3398 }; 3399 3400 enum class DeviceGroupPresentModeFlagBitsKHR : VkDeviceGroupPresentModeFlagsKHR 3401 { 3402 eLocal = VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR, 3403 eRemote = VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR, 3404 eSum = VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR, 3405 eLocalMultiDevice = VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR 3406 }; 3407 3408 using DeviceGroupPresentModeFlagsKHR = Flags<DeviceGroupPresentModeFlagBitsKHR>; 3409 3410 3411 template <> struct FlagTraits<DeviceGroupPresentModeFlagBitsKHR> 3412 { 3413 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 3414 static VULKAN_HPP_CONST_OR_CONSTEXPR DeviceGroupPresentModeFlagsKHR allFlags = 3415 DeviceGroupPresentModeFlagBitsKHR::eLocal 3416 | DeviceGroupPresentModeFlagBitsKHR::eRemote 3417 | DeviceGroupPresentModeFlagBitsKHR::eSum 3418 | DeviceGroupPresentModeFlagBitsKHR::eLocalMultiDevice; 3419 }; 3420 3421 //=== VK_KHR_display === 3422 3423 enum class DisplayPlaneAlphaFlagBitsKHR : VkDisplayPlaneAlphaFlagsKHR 3424 { 3425 eOpaque = VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR, 3426 eGlobal = VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR, 3427 ePerPixel = VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR, 3428 ePerPixelPremultiplied = VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR 3429 }; 3430 3431 using DisplayPlaneAlphaFlagsKHR = Flags<DisplayPlaneAlphaFlagBitsKHR>; 3432 3433 3434 template <> struct FlagTraits<DisplayPlaneAlphaFlagBitsKHR> 3435 { 3436 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 3437 static VULKAN_HPP_CONST_OR_CONSTEXPR DisplayPlaneAlphaFlagsKHR allFlags = 3438 DisplayPlaneAlphaFlagBitsKHR::eOpaque 3439 | DisplayPlaneAlphaFlagBitsKHR::eGlobal 3440 | DisplayPlaneAlphaFlagBitsKHR::ePerPixel 3441 | DisplayPlaneAlphaFlagBitsKHR::ePerPixelPremultiplied; 3442 }; 3443 3444 enum class DisplayModeCreateFlagBitsKHR : VkDisplayModeCreateFlagsKHR 3445 {}; 3446 3447 using DisplayModeCreateFlagsKHR = Flags<DisplayModeCreateFlagBitsKHR>; 3448 3449 3450 template <> struct FlagTraits<DisplayModeCreateFlagBitsKHR> 3451 { 3452 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 3453 static VULKAN_HPP_CONST_OR_CONSTEXPR DisplayModeCreateFlagsKHR allFlags = {}; 3454 }; 3455 3456 enum class DisplaySurfaceCreateFlagBitsKHR : VkDisplaySurfaceCreateFlagsKHR 3457 {}; 3458 3459 using DisplaySurfaceCreateFlagsKHR = Flags<DisplaySurfaceCreateFlagBitsKHR>; 3460 3461 3462 template <> struct FlagTraits<DisplaySurfaceCreateFlagBitsKHR> 3463 { 3464 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 3465 static VULKAN_HPP_CONST_OR_CONSTEXPR DisplaySurfaceCreateFlagsKHR allFlags = {}; 3466 }; 3467 3468 //=== VK_EXT_display_surface_counter === 3469 3470 enum class SurfaceCounterFlagBitsEXT : VkSurfaceCounterFlagsEXT 3471 { 3472 eVblank = VK_SURFACE_COUNTER_VBLANK_BIT_EXT 3473 }; 3474 3475 using SurfaceCounterFlagsEXT = Flags<SurfaceCounterFlagBitsEXT>; 3476 3477 3478 template <> struct FlagTraits<SurfaceCounterFlagBitsEXT> 3479 { 3480 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 3481 static VULKAN_HPP_CONST_OR_CONSTEXPR SurfaceCounterFlagsEXT allFlags = 3482 SurfaceCounterFlagBitsEXT::eVblank; 3483 }; 3484 3485 //=== VK_EXT_display_control === 3486 3487 enum class DisplayPowerStateEXT 3488 { 3489 eOff = VK_DISPLAY_POWER_STATE_OFF_EXT, 3490 eSuspend = VK_DISPLAY_POWER_STATE_SUSPEND_EXT, 3491 eOn = VK_DISPLAY_POWER_STATE_ON_EXT 3492 }; 3493 3494 enum class DeviceEventTypeEXT 3495 { 3496 eDisplayHotplug = VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT 3497 }; 3498 3499 enum class DisplayEventTypeEXT 3500 { 3501 eFirstPixelOut = VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT 3502 }; 3503 3504 //=== VK_EXT_discard_rectangles === 3505 3506 enum class DiscardRectangleModeEXT 3507 { 3508 eInclusive = VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT, 3509 eExclusive = VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT 3510 }; 3511 3512 enum class PipelineDiscardRectangleStateCreateFlagBitsEXT : VkPipelineDiscardRectangleStateCreateFlagsEXT 3513 {}; 3514 3515 using PipelineDiscardRectangleStateCreateFlagsEXT = Flags<PipelineDiscardRectangleStateCreateFlagBitsEXT>; 3516 3517 3518 template <> struct FlagTraits<PipelineDiscardRectangleStateCreateFlagBitsEXT> 3519 { 3520 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 3521 static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineDiscardRectangleStateCreateFlagsEXT allFlags = {}; 3522 }; 3523 3524 //=== VK_EXT_conservative_rasterization === 3525 3526 enum class ConservativeRasterizationModeEXT 3527 { 3528 eDisabled = VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT, 3529 eOverestimate = VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT, 3530 eUnderestimate = VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT 3531 }; 3532 3533 enum class PipelineRasterizationConservativeStateCreateFlagBitsEXT : VkPipelineRasterizationConservativeStateCreateFlagsEXT 3534 {}; 3535 3536 using PipelineRasterizationConservativeStateCreateFlagsEXT = Flags<PipelineRasterizationConservativeStateCreateFlagBitsEXT>; 3537 3538 3539 template <> struct FlagTraits<PipelineRasterizationConservativeStateCreateFlagBitsEXT> 3540 { 3541 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 3542 static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineRasterizationConservativeStateCreateFlagsEXT allFlags = {}; 3543 }; 3544 3545 //=== VK_EXT_depth_clip_enable === 3546 3547 enum class PipelineRasterizationDepthClipStateCreateFlagBitsEXT : VkPipelineRasterizationDepthClipStateCreateFlagsEXT 3548 {}; 3549 3550 using PipelineRasterizationDepthClipStateCreateFlagsEXT = Flags<PipelineRasterizationDepthClipStateCreateFlagBitsEXT>; 3551 3552 3553 template <> struct FlagTraits<PipelineRasterizationDepthClipStateCreateFlagBitsEXT> 3554 { 3555 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 3556 static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineRasterizationDepthClipStateCreateFlagsEXT allFlags = {}; 3557 }; 3558 3559 //=== VK_KHR_performance_query === 3560 3561 enum class PerformanceCounterDescriptionFlagBitsKHR : VkPerformanceCounterDescriptionFlagsKHR 3562 { 3563 ePerformanceImpacting = VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_BIT_KHR, 3564 eConcurrentlyImpacted = VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_BIT_KHR 3565 }; 3566 3567 using PerformanceCounterDescriptionFlagsKHR = Flags<PerformanceCounterDescriptionFlagBitsKHR>; 3568 3569 3570 template <> struct FlagTraits<PerformanceCounterDescriptionFlagBitsKHR> 3571 { 3572 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 3573 static VULKAN_HPP_CONST_OR_CONSTEXPR PerformanceCounterDescriptionFlagsKHR allFlags = 3574 PerformanceCounterDescriptionFlagBitsKHR::ePerformanceImpacting 3575 | PerformanceCounterDescriptionFlagBitsKHR::eConcurrentlyImpacted; 3576 }; 3577 3578 enum class PerformanceCounterScopeKHR 3579 { 3580 eCommandBuffer = VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR, 3581 eRenderPass = VK_PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR, 3582 eCommand = VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_KHR, 3583 eVkQueryScopeCommandBuffer = VK_QUERY_SCOPE_COMMAND_BUFFER_KHR, 3584 eVkQueryScopeRenderPass = VK_QUERY_SCOPE_RENDER_PASS_KHR, 3585 eVkQueryScopeCommand = VK_QUERY_SCOPE_COMMAND_KHR 3586 }; 3587 3588 enum class PerformanceCounterStorageKHR 3589 { 3590 eInt32 = VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR, 3591 eInt64 = VK_PERFORMANCE_COUNTER_STORAGE_INT64_KHR, 3592 eUint32 = VK_PERFORMANCE_COUNTER_STORAGE_UINT32_KHR, 3593 eUint64 = VK_PERFORMANCE_COUNTER_STORAGE_UINT64_KHR, 3594 eFloat32 = VK_PERFORMANCE_COUNTER_STORAGE_FLOAT32_KHR, 3595 eFloat64 = VK_PERFORMANCE_COUNTER_STORAGE_FLOAT64_KHR 3596 }; 3597 3598 enum class PerformanceCounterUnitKHR 3599 { 3600 eGeneric = VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR, 3601 ePercentage = VK_PERFORMANCE_COUNTER_UNIT_PERCENTAGE_KHR, 3602 eNanoseconds = VK_PERFORMANCE_COUNTER_UNIT_NANOSECONDS_KHR, 3603 eBytes = VK_PERFORMANCE_COUNTER_UNIT_BYTES_KHR, 3604 eBytesPerSecond = VK_PERFORMANCE_COUNTER_UNIT_BYTES_PER_SECOND_KHR, 3605 eKelvin = VK_PERFORMANCE_COUNTER_UNIT_KELVIN_KHR, 3606 eWatts = VK_PERFORMANCE_COUNTER_UNIT_WATTS_KHR, 3607 eVolts = VK_PERFORMANCE_COUNTER_UNIT_VOLTS_KHR, 3608 eAmps = VK_PERFORMANCE_COUNTER_UNIT_AMPS_KHR, 3609 eHertz = VK_PERFORMANCE_COUNTER_UNIT_HERTZ_KHR, 3610 eCycles = VK_PERFORMANCE_COUNTER_UNIT_CYCLES_KHR 3611 }; 3612 3613 enum class AcquireProfilingLockFlagBitsKHR : VkAcquireProfilingLockFlagsKHR 3614 {}; 3615 3616 using AcquireProfilingLockFlagsKHR = Flags<AcquireProfilingLockFlagBitsKHR>; 3617 3618 3619 template <> struct FlagTraits<AcquireProfilingLockFlagBitsKHR> 3620 { 3621 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 3622 static VULKAN_HPP_CONST_OR_CONSTEXPR AcquireProfilingLockFlagsKHR allFlags = {}; 3623 }; 3624 3625 //=== VK_EXT_debug_utils === 3626 3627 enum class DebugUtilsMessageSeverityFlagBitsEXT : VkDebugUtilsMessageSeverityFlagsEXT 3628 { 3629 eVerbose = VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT, 3630 eInfo = VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT, 3631 eWarning = VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT, 3632 eError = VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT 3633 }; 3634 3635 using DebugUtilsMessageSeverityFlagsEXT = Flags<DebugUtilsMessageSeverityFlagBitsEXT>; 3636 3637 3638 template <> struct FlagTraits<DebugUtilsMessageSeverityFlagBitsEXT> 3639 { 3640 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 3641 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugUtilsMessageSeverityFlagsEXT allFlags = 3642 DebugUtilsMessageSeverityFlagBitsEXT::eVerbose 3643 | DebugUtilsMessageSeverityFlagBitsEXT::eInfo 3644 | DebugUtilsMessageSeverityFlagBitsEXT::eWarning 3645 | DebugUtilsMessageSeverityFlagBitsEXT::eError; 3646 }; 3647 3648 enum class DebugUtilsMessageTypeFlagBitsEXT : VkDebugUtilsMessageTypeFlagsEXT 3649 { 3650 eGeneral = VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT, 3651 eValidation = VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT, 3652 ePerformance = VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT 3653 }; 3654 3655 using DebugUtilsMessageTypeFlagsEXT = Flags<DebugUtilsMessageTypeFlagBitsEXT>; 3656 3657 3658 template <> struct FlagTraits<DebugUtilsMessageTypeFlagBitsEXT> 3659 { 3660 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 3661 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugUtilsMessageTypeFlagsEXT allFlags = 3662 DebugUtilsMessageTypeFlagBitsEXT::eGeneral 3663 | DebugUtilsMessageTypeFlagBitsEXT::eValidation 3664 | DebugUtilsMessageTypeFlagBitsEXT::ePerformance; 3665 }; 3666 3667 enum class DebugUtilsMessengerCallbackDataFlagBitsEXT : VkDebugUtilsMessengerCallbackDataFlagsEXT 3668 {}; 3669 3670 using DebugUtilsMessengerCallbackDataFlagsEXT = Flags<DebugUtilsMessengerCallbackDataFlagBitsEXT>; 3671 3672 3673 template <> struct FlagTraits<DebugUtilsMessengerCallbackDataFlagBitsEXT> 3674 { 3675 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 3676 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugUtilsMessengerCallbackDataFlagsEXT allFlags = {}; 3677 }; 3678 3679 enum class DebugUtilsMessengerCreateFlagBitsEXT : VkDebugUtilsMessengerCreateFlagsEXT 3680 {}; 3681 3682 using DebugUtilsMessengerCreateFlagsEXT = Flags<DebugUtilsMessengerCreateFlagBitsEXT>; 3683 3684 3685 template <> struct FlagTraits<DebugUtilsMessengerCreateFlagBitsEXT> 3686 { 3687 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 3688 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugUtilsMessengerCreateFlagsEXT allFlags = {}; 3689 }; 3690 3691 //=== VK_EXT_blend_operation_advanced === 3692 3693 enum class BlendOverlapEXT 3694 { 3695 eUncorrelated = VK_BLEND_OVERLAP_UNCORRELATED_EXT, 3696 eDisjoint = VK_BLEND_OVERLAP_DISJOINT_EXT, 3697 eConjoint = VK_BLEND_OVERLAP_CONJOINT_EXT 3698 }; 3699 3700 //=== VK_EXT_calibrated_timestamps === 3701 3702 enum class TimeDomainEXT 3703 { 3704 eDevice = VK_TIME_DOMAIN_DEVICE_EXT, 3705 eClockMonotonic = VK_TIME_DOMAIN_CLOCK_MONOTONIC_EXT, 3706 eClockMonotonicRaw = VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_EXT, 3707 eQueryPerformanceCounter = VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_EXT 3708 }; 3709 3710 //=== VK_KHR_fragment_shading_rate === 3711 3712 enum class FragmentShadingRateCombinerOpKHR 3713 { 3714 eKeep = VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR, 3715 eReplace = VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR, 3716 eMin = VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MIN_KHR, 3717 eMax = VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MAX_KHR, 3718 eMul = VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MUL_KHR 3719 }; 3720 3721 //=== VK_EXT_validation_features === 3722 3723 enum class ValidationFeatureEnableEXT 3724 { 3725 eGpuAssisted = VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT, 3726 eGpuAssistedReserveBindingSlot = VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT, 3727 eBestPractices = VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES_EXT, 3728 eDebugPrintf = VK_VALIDATION_FEATURE_ENABLE_DEBUG_PRINTF_EXT, 3729 eSynchronizationValidation = VK_VALIDATION_FEATURE_ENABLE_SYNCHRONIZATION_VALIDATION_EXT 3730 }; 3731 3732 enum class ValidationFeatureDisableEXT 3733 { 3734 eAll = VK_VALIDATION_FEATURE_DISABLE_ALL_EXT, 3735 eShaders = VK_VALIDATION_FEATURE_DISABLE_SHADERS_EXT, 3736 eThreadSafety = VK_VALIDATION_FEATURE_DISABLE_THREAD_SAFETY_EXT, 3737 eApiParameters = VK_VALIDATION_FEATURE_DISABLE_API_PARAMETERS_EXT, 3738 eObjectLifetimes = VK_VALIDATION_FEATURE_DISABLE_OBJECT_LIFETIMES_EXT, 3739 eCoreChecks = VK_VALIDATION_FEATURE_DISABLE_CORE_CHECKS_EXT, 3740 eUniqueHandles = VK_VALIDATION_FEATURE_DISABLE_UNIQUE_HANDLES_EXT, 3741 eShaderValidationCache = VK_VALIDATION_FEATURE_DISABLE_SHADER_VALIDATION_CACHE_EXT 3742 }; 3743 3744 //=== VK_EXT_headless_surface === 3745 3746 enum class HeadlessSurfaceCreateFlagBitsEXT : VkHeadlessSurfaceCreateFlagsEXT 3747 {}; 3748 3749 using HeadlessSurfaceCreateFlagsEXT = Flags<HeadlessSurfaceCreateFlagBitsEXT>; 3750 3751 3752 template <> struct FlagTraits<HeadlessSurfaceCreateFlagBitsEXT> 3753 { 3754 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 3755 static VULKAN_HPP_CONST_OR_CONSTEXPR HeadlessSurfaceCreateFlagsEXT allFlags = {}; 3756 }; 3757 3758 //=== VK_EXT_line_rasterization === 3759 3760 enum class LineRasterizationModeEXT 3761 { 3762 eDefault = VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT, 3763 eRectangular = VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT, 3764 eBresenham = VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT, 3765 eRectangularSmooth = VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT 3766 }; 3767 3768 //=== VK_KHR_object_refresh === 3769 3770 enum class RefreshObjectFlagBitsKHR : VkRefreshObjectFlagsKHR 3771 {}; 3772 3773 using RefreshObjectFlagsKHR = Flags<RefreshObjectFlagBitsKHR>; 3774 3775 3776 template <> struct FlagTraits<RefreshObjectFlagBitsKHR> 3777 { 3778 static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; 3779 static VULKAN_HPP_CONST_OR_CONSTEXPR RefreshObjectFlagsKHR allFlags = {}; 3780 }; 3781 3782 #if defined( VK_USE_PLATFORM_SCI ) 3783 //=== VK_NV_external_sci_sync === 3784 3785 enum class SciSyncClientTypeNV 3786 { 3787 eSignaler = VK_SCI_SYNC_CLIENT_TYPE_SIGNALER_NV, 3788 eWaiter = VK_SCI_SYNC_CLIENT_TYPE_WAITER_NV, 3789 eSignalerWaiter = VK_SCI_SYNC_CLIENT_TYPE_SIGNALER_WAITER_NV 3790 }; 3791 3792 enum class SciSyncPrimitiveTypeNV 3793 { 3794 eFence = VK_SCI_SYNC_PRIMITIVE_TYPE_FENCE_NV, 3795 eSemaphore = VK_SCI_SYNC_PRIMITIVE_TYPE_SEMAPHORE_NV 3796 }; 3797 #endif /*VK_USE_PLATFORM_SCI*/ 3798 3799 3800 3801 //========================= 3802 //=== Index Type Traits === 3803 //========================= 3804 3805 template<typename T> 3806 struct IndexTypeValue 3807 {}; 3808 3809 3810 template <> 3811 struct IndexTypeValue<uint16_t> 3812 { 3813 static VULKAN_HPP_CONST_OR_CONSTEXPR IndexType value = IndexType::eUint16; 3814 }; 3815 3816 template <> 3817 struct CppType<IndexType, IndexType::eUint16> 3818 { 3819 using Type = uint16_t; 3820 }; 3821 3822 template <> 3823 struct IndexTypeValue<uint32_t> 3824 { 3825 static VULKAN_HPP_CONST_OR_CONSTEXPR IndexType value = IndexType::eUint32; 3826 }; 3827 3828 template <> 3829 struct CppType<IndexType, IndexType::eUint32> 3830 { 3831 using Type = uint32_t; 3832 }; 3833 3834 template <> 3835 struct IndexTypeValue<uint8_t> 3836 { 3837 static VULKAN_HPP_CONST_OR_CONSTEXPR IndexType value = IndexType::eUint8EXT; 3838 }; 3839 3840 template <> 3841 struct CppType<IndexType, IndexType::eUint8EXT> 3842 { 3843 using Type = uint8_t; 3844 }; 3845 3846 3847 3848 //=========================================================== 3849 //=== Mapping from ObjectType to DebugReportObjectTypeEXT === 3850 //=========================================================== 3851 debugReportObjectType(VULKAN_HPP_NAMESPACE::ObjectType objectType)3852 VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType( VULKAN_HPP_NAMESPACE::ObjectType objectType ) 3853 { 3854 switch( objectType ) 3855 { 3856 3857 //=== VK_VERSION_1_0 === 3858 case VULKAN_HPP_NAMESPACE::ObjectType::eInstance : return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eInstance; 3859 case VULKAN_HPP_NAMESPACE::ObjectType::ePhysicalDevice : return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePhysicalDevice; 3860 case VULKAN_HPP_NAMESPACE::ObjectType::eDevice : return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDevice; 3861 case VULKAN_HPP_NAMESPACE::ObjectType::eQueue : return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eQueue; 3862 case VULKAN_HPP_NAMESPACE::ObjectType::eDeviceMemory : return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDeviceMemory; 3863 case VULKAN_HPP_NAMESPACE::ObjectType::eFence : return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eFence; 3864 case VULKAN_HPP_NAMESPACE::ObjectType::eSemaphore : return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSemaphore; 3865 case VULKAN_HPP_NAMESPACE::ObjectType::eEvent : return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eEvent; 3866 case VULKAN_HPP_NAMESPACE::ObjectType::eQueryPool : return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eQueryPool; 3867 case VULKAN_HPP_NAMESPACE::ObjectType::eBuffer : return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBuffer; 3868 case VULKAN_HPP_NAMESPACE::ObjectType::eBufferView : return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBufferView; 3869 case VULKAN_HPP_NAMESPACE::ObjectType::eImage : return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eImage; 3870 case VULKAN_HPP_NAMESPACE::ObjectType::eImageView : return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eImageView; 3871 case VULKAN_HPP_NAMESPACE::ObjectType::eShaderModule : return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eShaderModule; 3872 case VULKAN_HPP_NAMESPACE::ObjectType::ePipelineCache : return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipelineCache; 3873 case VULKAN_HPP_NAMESPACE::ObjectType::ePipeline : return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipeline; 3874 case VULKAN_HPP_NAMESPACE::ObjectType::ePipelineLayout : return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipelineLayout; 3875 case VULKAN_HPP_NAMESPACE::ObjectType::eSampler : return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSampler; 3876 case VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorPool : return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorPool; 3877 case VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorSet : return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorSet; 3878 case VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorSetLayout : return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorSetLayout; 3879 case VULKAN_HPP_NAMESPACE::ObjectType::eFramebuffer : return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eFramebuffer; 3880 case VULKAN_HPP_NAMESPACE::ObjectType::eRenderPass : return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eRenderPass; 3881 case VULKAN_HPP_NAMESPACE::ObjectType::eCommandPool : return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCommandPool; 3882 case VULKAN_HPP_NAMESPACE::ObjectType::eCommandBuffer : return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCommandBuffer; 3883 3884 //=== VK_VERSION_1_1 === 3885 case VULKAN_HPP_NAMESPACE::ObjectType::eSamplerYcbcrConversion : return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown; 3886 3887 //=== VK_VERSION_1_3 === 3888 case VULKAN_HPP_NAMESPACE::ObjectType::ePrivateDataSlot : return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown; 3889 3890 //=== VK_KHR_surface === 3891 case VULKAN_HPP_NAMESPACE::ObjectType::eSurfaceKHR : return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSurfaceKHR; 3892 3893 //=== VK_KHR_swapchain === 3894 case VULKAN_HPP_NAMESPACE::ObjectType::eSwapchainKHR : return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSwapchainKHR; 3895 3896 //=== VK_KHR_display === 3897 case VULKAN_HPP_NAMESPACE::ObjectType::eDisplayKHR : return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDisplayKHR; 3898 case VULKAN_HPP_NAMESPACE::ObjectType::eDisplayModeKHR : return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDisplayModeKHR; 3899 3900 //=== VK_EXT_debug_utils === 3901 case VULKAN_HPP_NAMESPACE::ObjectType::eDebugUtilsMessengerEXT : return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown; 3902 3903 #if defined( VK_USE_PLATFORM_SCI ) 3904 //=== VK_NV_external_sci_sync2 === 3905 case VULKAN_HPP_NAMESPACE::ObjectType::eSemaphoreSciSyncPoolNV : return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown; 3906 #endif /*VK_USE_PLATFORM_SCI*/ 3907 3908 default: 3909 VULKAN_HPP_ASSERT( false && "unknown ObjectType" ); 3910 return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown; 3911 } 3912 } 3913 3914 } // namespace VULKAN_HPP_NAMESPACE 3915 #endif 3916