1 // Copyright 2015-2024 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_HASH_HPP 9 #define VULKAN_HASH_HPP 10 11 #include <vulkan/vulkan.hpp> 12 13 namespace std 14 { 15 //======================================= 16 //=== HASH structures for Flags types === 17 //======================================= 18 19 template <typename BitType> 20 struct hash<VULKAN_HPP_NAMESPACE::Flags<BitType>> 21 { operator ()std::hash22 std::size_t operator()( VULKAN_HPP_NAMESPACE::Flags<BitType> const & flags ) const VULKAN_HPP_NOEXCEPT 23 { 24 return std::hash<typename std::underlying_type<BitType>::type>{}( static_cast<typename std::underlying_type<BitType>::type>( flags ) ); 25 } 26 }; 27 28 //=================================== 29 //=== HASH structures for handles === 30 //=================================== 31 32 //=== VK_VERSION_1_0 === 33 34 template <> 35 struct hash<VULKAN_HPP_NAMESPACE::Instance> 36 { operator ()std::hash37 std::size_t operator()( VULKAN_HPP_NAMESPACE::Instance const & instance ) const VULKAN_HPP_NOEXCEPT 38 { 39 return std::hash<VkInstance>{}( static_cast<VkInstance>( instance ) ); 40 } 41 }; 42 43 template <> 44 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevice> 45 { operator ()std::hash46 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevice const & physicalDevice ) const VULKAN_HPP_NOEXCEPT 47 { 48 return std::hash<VkPhysicalDevice>{}( static_cast<VkPhysicalDevice>( physicalDevice ) ); 49 } 50 }; 51 52 template <> 53 struct hash<VULKAN_HPP_NAMESPACE::Device> 54 { operator ()std::hash55 std::size_t operator()( VULKAN_HPP_NAMESPACE::Device const & device ) const VULKAN_HPP_NOEXCEPT 56 { 57 return std::hash<VkDevice>{}( static_cast<VkDevice>( device ) ); 58 } 59 }; 60 61 template <> 62 struct hash<VULKAN_HPP_NAMESPACE::Queue> 63 { operator ()std::hash64 std::size_t operator()( VULKAN_HPP_NAMESPACE::Queue const & queue ) const VULKAN_HPP_NOEXCEPT 65 { 66 return std::hash<VkQueue>{}( static_cast<VkQueue>( queue ) ); 67 } 68 }; 69 70 template <> 71 struct hash<VULKAN_HPP_NAMESPACE::DeviceMemory> 72 { operator ()std::hash73 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceMemory const & deviceMemory ) const VULKAN_HPP_NOEXCEPT 74 { 75 return std::hash<VkDeviceMemory>{}( static_cast<VkDeviceMemory>( deviceMemory ) ); 76 } 77 }; 78 79 template <> 80 struct hash<VULKAN_HPP_NAMESPACE::Fence> 81 { operator ()std::hash82 std::size_t operator()( VULKAN_HPP_NAMESPACE::Fence const & fence ) const VULKAN_HPP_NOEXCEPT 83 { 84 return std::hash<VkFence>{}( static_cast<VkFence>( fence ) ); 85 } 86 }; 87 88 template <> 89 struct hash<VULKAN_HPP_NAMESPACE::Semaphore> 90 { operator ()std::hash91 std::size_t operator()( VULKAN_HPP_NAMESPACE::Semaphore const & semaphore ) const VULKAN_HPP_NOEXCEPT 92 { 93 return std::hash<VkSemaphore>{}( static_cast<VkSemaphore>( semaphore ) ); 94 } 95 }; 96 97 template <> 98 struct hash<VULKAN_HPP_NAMESPACE::Event> 99 { operator ()std::hash100 std::size_t operator()( VULKAN_HPP_NAMESPACE::Event const & event ) const VULKAN_HPP_NOEXCEPT 101 { 102 return std::hash<VkEvent>{}( static_cast<VkEvent>( event ) ); 103 } 104 }; 105 106 template <> 107 struct hash<VULKAN_HPP_NAMESPACE::QueryPool> 108 { operator ()std::hash109 std::size_t operator()( VULKAN_HPP_NAMESPACE::QueryPool const & queryPool ) const VULKAN_HPP_NOEXCEPT 110 { 111 return std::hash<VkQueryPool>{}( static_cast<VkQueryPool>( queryPool ) ); 112 } 113 }; 114 115 template <> 116 struct hash<VULKAN_HPP_NAMESPACE::Buffer> 117 { operator ()std::hash118 std::size_t operator()( VULKAN_HPP_NAMESPACE::Buffer const & buffer ) const VULKAN_HPP_NOEXCEPT 119 { 120 return std::hash<VkBuffer>{}( static_cast<VkBuffer>( buffer ) ); 121 } 122 }; 123 124 template <> 125 struct hash<VULKAN_HPP_NAMESPACE::BufferView> 126 { operator ()std::hash127 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferView const & bufferView ) const VULKAN_HPP_NOEXCEPT 128 { 129 return std::hash<VkBufferView>{}( static_cast<VkBufferView>( bufferView ) ); 130 } 131 }; 132 133 template <> 134 struct hash<VULKAN_HPP_NAMESPACE::Image> 135 { operator ()std::hash136 std::size_t operator()( VULKAN_HPP_NAMESPACE::Image const & image ) const VULKAN_HPP_NOEXCEPT 137 { 138 return std::hash<VkImage>{}( static_cast<VkImage>( image ) ); 139 } 140 }; 141 142 template <> 143 struct hash<VULKAN_HPP_NAMESPACE::ImageView> 144 { operator ()std::hash145 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageView const & imageView ) const VULKAN_HPP_NOEXCEPT 146 { 147 return std::hash<VkImageView>{}( static_cast<VkImageView>( imageView ) ); 148 } 149 }; 150 151 template <> 152 struct hash<VULKAN_HPP_NAMESPACE::ShaderModule> 153 { operator ()std::hash154 std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderModule const & shaderModule ) const VULKAN_HPP_NOEXCEPT 155 { 156 return std::hash<VkShaderModule>{}( static_cast<VkShaderModule>( shaderModule ) ); 157 } 158 }; 159 160 template <> 161 struct hash<VULKAN_HPP_NAMESPACE::PipelineCache> 162 { operator ()std::hash163 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCache const & pipelineCache ) const VULKAN_HPP_NOEXCEPT 164 { 165 return std::hash<VkPipelineCache>{}( static_cast<VkPipelineCache>( pipelineCache ) ); 166 } 167 }; 168 169 template <> 170 struct hash<VULKAN_HPP_NAMESPACE::Pipeline> 171 { operator ()std::hash172 std::size_t operator()( VULKAN_HPP_NAMESPACE::Pipeline const & pipeline ) const VULKAN_HPP_NOEXCEPT 173 { 174 return std::hash<VkPipeline>{}( static_cast<VkPipeline>( pipeline ) ); 175 } 176 }; 177 178 template <> 179 struct hash<VULKAN_HPP_NAMESPACE::PipelineLayout> 180 { operator ()std::hash181 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineLayout const & pipelineLayout ) const VULKAN_HPP_NOEXCEPT 182 { 183 return std::hash<VkPipelineLayout>{}( static_cast<VkPipelineLayout>( pipelineLayout ) ); 184 } 185 }; 186 187 template <> 188 struct hash<VULKAN_HPP_NAMESPACE::Sampler> 189 { operator ()std::hash190 std::size_t operator()( VULKAN_HPP_NAMESPACE::Sampler const & sampler ) const VULKAN_HPP_NOEXCEPT 191 { 192 return std::hash<VkSampler>{}( static_cast<VkSampler>( sampler ) ); 193 } 194 }; 195 196 template <> 197 struct hash<VULKAN_HPP_NAMESPACE::DescriptorPool> 198 { operator ()std::hash199 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorPool const & descriptorPool ) const VULKAN_HPP_NOEXCEPT 200 { 201 return std::hash<VkDescriptorPool>{}( static_cast<VkDescriptorPool>( descriptorPool ) ); 202 } 203 }; 204 205 template <> 206 struct hash<VULKAN_HPP_NAMESPACE::DescriptorSet> 207 { operator ()std::hash208 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSet const & descriptorSet ) const VULKAN_HPP_NOEXCEPT 209 { 210 return std::hash<VkDescriptorSet>{}( static_cast<VkDescriptorSet>( descriptorSet ) ); 211 } 212 }; 213 214 template <> 215 struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetLayout> 216 { operator ()std::hash217 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetLayout const & descriptorSetLayout ) const VULKAN_HPP_NOEXCEPT 218 { 219 return std::hash<VkDescriptorSetLayout>{}( static_cast<VkDescriptorSetLayout>( descriptorSetLayout ) ); 220 } 221 }; 222 223 template <> 224 struct hash<VULKAN_HPP_NAMESPACE::Framebuffer> 225 { operator ()std::hash226 std::size_t operator()( VULKAN_HPP_NAMESPACE::Framebuffer const & framebuffer ) const VULKAN_HPP_NOEXCEPT 227 { 228 return std::hash<VkFramebuffer>{}( static_cast<VkFramebuffer>( framebuffer ) ); 229 } 230 }; 231 232 template <> 233 struct hash<VULKAN_HPP_NAMESPACE::RenderPass> 234 { operator ()std::hash235 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPass const & renderPass ) const VULKAN_HPP_NOEXCEPT 236 { 237 return std::hash<VkRenderPass>{}( static_cast<VkRenderPass>( renderPass ) ); 238 } 239 }; 240 241 template <> 242 struct hash<VULKAN_HPP_NAMESPACE::CommandPool> 243 { operator ()std::hash244 std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandPool const & commandPool ) const VULKAN_HPP_NOEXCEPT 245 { 246 return std::hash<VkCommandPool>{}( static_cast<VkCommandPool>( commandPool ) ); 247 } 248 }; 249 250 template <> 251 struct hash<VULKAN_HPP_NAMESPACE::CommandBuffer> 252 { operator ()std::hash253 std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBuffer const & commandBuffer ) const VULKAN_HPP_NOEXCEPT 254 { 255 return std::hash<VkCommandBuffer>{}( static_cast<VkCommandBuffer>( commandBuffer ) ); 256 } 257 }; 258 259 //=== VK_VERSION_1_1 === 260 261 template <> 262 struct hash<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion> 263 { operator ()std::hash264 std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion const & samplerYcbcrConversion ) const VULKAN_HPP_NOEXCEPT 265 { 266 return std::hash<VkSamplerYcbcrConversion>{}( static_cast<VkSamplerYcbcrConversion>( samplerYcbcrConversion ) ); 267 } 268 }; 269 270 template <> 271 struct hash<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate> 272 { operator ()std::hash273 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate const & descriptorUpdateTemplate ) const VULKAN_HPP_NOEXCEPT 274 { 275 return std::hash<VkDescriptorUpdateTemplate>{}( static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ) ); 276 } 277 }; 278 279 //=== VK_VERSION_1_3 === 280 281 template <> 282 struct hash<VULKAN_HPP_NAMESPACE::PrivateDataSlot> 283 { operator ()std::hash284 std::size_t operator()( VULKAN_HPP_NAMESPACE::PrivateDataSlot const & privateDataSlot ) const VULKAN_HPP_NOEXCEPT 285 { 286 return std::hash<VkPrivateDataSlot>{}( static_cast<VkPrivateDataSlot>( privateDataSlot ) ); 287 } 288 }; 289 290 //=== VK_KHR_surface === 291 292 template <> 293 struct hash<VULKAN_HPP_NAMESPACE::SurfaceKHR> 294 { operator ()std::hash295 std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceKHR const & surfaceKHR ) const VULKAN_HPP_NOEXCEPT 296 { 297 return std::hash<VkSurfaceKHR>{}( static_cast<VkSurfaceKHR>( surfaceKHR ) ); 298 } 299 }; 300 301 //=== VK_KHR_swapchain === 302 303 template <> 304 struct hash<VULKAN_HPP_NAMESPACE::SwapchainKHR> 305 { operator ()std::hash306 std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainKHR const & swapchainKHR ) const VULKAN_HPP_NOEXCEPT 307 { 308 return std::hash<VkSwapchainKHR>{}( static_cast<VkSwapchainKHR>( swapchainKHR ) ); 309 } 310 }; 311 312 //=== VK_KHR_display === 313 314 template <> 315 struct hash<VULKAN_HPP_NAMESPACE::DisplayKHR> 316 { operator ()std::hash317 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayKHR const & displayKHR ) const VULKAN_HPP_NOEXCEPT 318 { 319 return std::hash<VkDisplayKHR>{}( static_cast<VkDisplayKHR>( displayKHR ) ); 320 } 321 }; 322 323 template <> 324 struct hash<VULKAN_HPP_NAMESPACE::DisplayModeKHR> 325 { operator ()std::hash326 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayModeKHR const & displayModeKHR ) const VULKAN_HPP_NOEXCEPT 327 { 328 return std::hash<VkDisplayModeKHR>{}( static_cast<VkDisplayModeKHR>( displayModeKHR ) ); 329 } 330 }; 331 332 //=== VK_EXT_debug_report === 333 334 template <> 335 struct hash<VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT> 336 { operator ()std::hash337 std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT const & debugReportCallbackEXT ) const VULKAN_HPP_NOEXCEPT 338 { 339 return std::hash<VkDebugReportCallbackEXT>{}( static_cast<VkDebugReportCallbackEXT>( debugReportCallbackEXT ) ); 340 } 341 }; 342 343 //=== VK_KHR_video_queue === 344 345 template <> 346 struct hash<VULKAN_HPP_NAMESPACE::VideoSessionKHR> 347 { operator ()std::hash348 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoSessionKHR const & videoSessionKHR ) const VULKAN_HPP_NOEXCEPT 349 { 350 return std::hash<VkVideoSessionKHR>{}( static_cast<VkVideoSessionKHR>( videoSessionKHR ) ); 351 } 352 }; 353 354 template <> 355 struct hash<VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR> 356 { operator ()std::hash357 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR const & videoSessionParametersKHR ) const VULKAN_HPP_NOEXCEPT 358 { 359 return std::hash<VkVideoSessionParametersKHR>{}( static_cast<VkVideoSessionParametersKHR>( videoSessionParametersKHR ) ); 360 } 361 }; 362 363 //=== VK_NVX_binary_import === 364 365 template <> 366 struct hash<VULKAN_HPP_NAMESPACE::CuModuleNVX> 367 { operator ()std::hash368 std::size_t operator()( VULKAN_HPP_NAMESPACE::CuModuleNVX const & cuModuleNVX ) const VULKAN_HPP_NOEXCEPT 369 { 370 return std::hash<VkCuModuleNVX>{}( static_cast<VkCuModuleNVX>( cuModuleNVX ) ); 371 } 372 }; 373 374 template <> 375 struct hash<VULKAN_HPP_NAMESPACE::CuFunctionNVX> 376 { operator ()std::hash377 std::size_t operator()( VULKAN_HPP_NAMESPACE::CuFunctionNVX const & cuFunctionNVX ) const VULKAN_HPP_NOEXCEPT 378 { 379 return std::hash<VkCuFunctionNVX>{}( static_cast<VkCuFunctionNVX>( cuFunctionNVX ) ); 380 } 381 }; 382 383 //=== VK_EXT_debug_utils === 384 385 template <> 386 struct hash<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT> 387 { operator ()std::hash388 std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT const & debugUtilsMessengerEXT ) const VULKAN_HPP_NOEXCEPT 389 { 390 return std::hash<VkDebugUtilsMessengerEXT>{}( static_cast<VkDebugUtilsMessengerEXT>( debugUtilsMessengerEXT ) ); 391 } 392 }; 393 394 //=== VK_KHR_acceleration_structure === 395 396 template <> 397 struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> 398 { operator ()std::hash399 std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR const & accelerationStructureKHR ) const VULKAN_HPP_NOEXCEPT 400 { 401 return std::hash<VkAccelerationStructureKHR>{}( static_cast<VkAccelerationStructureKHR>( accelerationStructureKHR ) ); 402 } 403 }; 404 405 //=== VK_EXT_validation_cache === 406 407 template <> 408 struct hash<VULKAN_HPP_NAMESPACE::ValidationCacheEXT> 409 { operator ()std::hash410 std::size_t operator()( VULKAN_HPP_NAMESPACE::ValidationCacheEXT const & validationCacheEXT ) const VULKAN_HPP_NOEXCEPT 411 { 412 return std::hash<VkValidationCacheEXT>{}( static_cast<VkValidationCacheEXT>( validationCacheEXT ) ); 413 } 414 }; 415 416 //=== VK_NV_ray_tracing === 417 418 template <> 419 struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureNV> 420 { operator ()std::hash421 std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureNV const & accelerationStructureNV ) const VULKAN_HPP_NOEXCEPT 422 { 423 return std::hash<VkAccelerationStructureNV>{}( static_cast<VkAccelerationStructureNV>( accelerationStructureNV ) ); 424 } 425 }; 426 427 //=== VK_INTEL_performance_query === 428 429 template <> 430 struct hash<VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL> 431 { operator ()std::hash432 std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL const & performanceConfigurationINTEL ) const VULKAN_HPP_NOEXCEPT 433 { 434 return std::hash<VkPerformanceConfigurationINTEL>{}( static_cast<VkPerformanceConfigurationINTEL>( performanceConfigurationINTEL ) ); 435 } 436 }; 437 438 //=== VK_KHR_deferred_host_operations === 439 440 template <> 441 struct hash<VULKAN_HPP_NAMESPACE::DeferredOperationKHR> 442 { operator ()std::hash443 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeferredOperationKHR const & deferredOperationKHR ) const VULKAN_HPP_NOEXCEPT 444 { 445 return std::hash<VkDeferredOperationKHR>{}( static_cast<VkDeferredOperationKHR>( deferredOperationKHR ) ); 446 } 447 }; 448 449 //=== VK_NV_device_generated_commands === 450 451 template <> 452 struct hash<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV> 453 { operator ()std::hash454 std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV const & indirectCommandsLayoutNV ) const VULKAN_HPP_NOEXCEPT 455 { 456 return std::hash<VkIndirectCommandsLayoutNV>{}( static_cast<VkIndirectCommandsLayoutNV>( indirectCommandsLayoutNV ) ); 457 } 458 }; 459 460 #if defined( VK_ENABLE_BETA_EXTENSIONS ) 461 //=== VK_NV_cuda_kernel_launch === 462 463 template <> 464 struct hash<VULKAN_HPP_NAMESPACE::CudaModuleNV> 465 { operator ()std::hash466 std::size_t operator()( VULKAN_HPP_NAMESPACE::CudaModuleNV const & cudaModuleNV ) const VULKAN_HPP_NOEXCEPT 467 { 468 return std::hash<VkCudaModuleNV>{}( static_cast<VkCudaModuleNV>( cudaModuleNV ) ); 469 } 470 }; 471 472 template <> 473 struct hash<VULKAN_HPP_NAMESPACE::CudaFunctionNV> 474 { operator ()std::hash475 std::size_t operator()( VULKAN_HPP_NAMESPACE::CudaFunctionNV const & cudaFunctionNV ) const VULKAN_HPP_NOEXCEPT 476 { 477 return std::hash<VkCudaFunctionNV>{}( static_cast<VkCudaFunctionNV>( cudaFunctionNV ) ); 478 } 479 }; 480 #endif /*VK_ENABLE_BETA_EXTENSIONS*/ 481 482 #if defined( VK_USE_PLATFORM_FUCHSIA ) 483 //=== VK_FUCHSIA_buffer_collection === 484 485 template <> 486 struct hash<VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA> 487 { operator ()std::hash488 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA const & bufferCollectionFUCHSIA ) const VULKAN_HPP_NOEXCEPT 489 { 490 return std::hash<VkBufferCollectionFUCHSIA>{}( static_cast<VkBufferCollectionFUCHSIA>( bufferCollectionFUCHSIA ) ); 491 } 492 }; 493 #endif /*VK_USE_PLATFORM_FUCHSIA*/ 494 495 //=== VK_EXT_opacity_micromap === 496 497 template <> 498 struct hash<VULKAN_HPP_NAMESPACE::MicromapEXT> 499 { operator ()std::hash500 std::size_t operator()( VULKAN_HPP_NAMESPACE::MicromapEXT const & micromapEXT ) const VULKAN_HPP_NOEXCEPT 501 { 502 return std::hash<VkMicromapEXT>{}( static_cast<VkMicromapEXT>( micromapEXT ) ); 503 } 504 }; 505 506 //=== VK_NV_optical_flow === 507 508 template <> 509 struct hash<VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV> 510 { operator ()std::hash511 std::size_t operator()( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV const & opticalFlowSessionNV ) const VULKAN_HPP_NOEXCEPT 512 { 513 return std::hash<VkOpticalFlowSessionNV>{}( static_cast<VkOpticalFlowSessionNV>( opticalFlowSessionNV ) ); 514 } 515 }; 516 517 //=== VK_EXT_shader_object === 518 519 template <> 520 struct hash<VULKAN_HPP_NAMESPACE::ShaderEXT> 521 { operator ()std::hash522 std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderEXT const & shaderEXT ) const VULKAN_HPP_NOEXCEPT 523 { 524 return std::hash<VkShaderEXT>{}( static_cast<VkShaderEXT>( shaderEXT ) ); 525 } 526 }; 527 528 #if 14 <= VULKAN_HPP_CPP_VERSION 529 //====================================== 530 //=== HASH structures for structures === 531 //====================================== 532 533 # if !defined( VULKAN_HPP_HASH_COMBINE ) 534 # define VULKAN_HPP_HASH_COMBINE( seed, value ) \ 535 seed ^= std::hash<std::decay<decltype( value )>::type>{}( value ) + 0x9e3779b9 + ( seed << 6 ) + ( seed >> 2 ) 536 # endif 537 538 template <> 539 struct hash<VULKAN_HPP_NAMESPACE::AabbPositionsKHR> 540 { operator ()std::hash541 std::size_t operator()( VULKAN_HPP_NAMESPACE::AabbPositionsKHR const & aabbPositionsKHR ) const VULKAN_HPP_NOEXCEPT 542 { 543 std::size_t seed = 0; 544 VULKAN_HPP_HASH_COMBINE( seed, aabbPositionsKHR.minX ); 545 VULKAN_HPP_HASH_COMBINE( seed, aabbPositionsKHR.minY ); 546 VULKAN_HPP_HASH_COMBINE( seed, aabbPositionsKHR.minZ ); 547 VULKAN_HPP_HASH_COMBINE( seed, aabbPositionsKHR.maxX ); 548 VULKAN_HPP_HASH_COMBINE( seed, aabbPositionsKHR.maxY ); 549 VULKAN_HPP_HASH_COMBINE( seed, aabbPositionsKHR.maxZ ); 550 return seed; 551 } 552 }; 553 554 template <> 555 struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR> 556 { 557 std::size_t operator ()std::hash558 operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR const & accelerationStructureBuildRangeInfoKHR ) const VULKAN_HPP_NOEXCEPT 559 { 560 std::size_t seed = 0; 561 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildRangeInfoKHR.primitiveCount ); 562 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildRangeInfoKHR.primitiveOffset ); 563 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildRangeInfoKHR.firstVertex ); 564 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildRangeInfoKHR.transformOffset ); 565 return seed; 566 } 567 }; 568 569 template <> 570 struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR> 571 { 572 std::size_t operator ()std::hash573 operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR const & accelerationStructureBuildSizesInfoKHR ) const VULKAN_HPP_NOEXCEPT 574 { 575 std::size_t seed = 0; 576 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildSizesInfoKHR.sType ); 577 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildSizesInfoKHR.pNext ); 578 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildSizesInfoKHR.accelerationStructureSize ); 579 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildSizesInfoKHR.updateScratchSize ); 580 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildSizesInfoKHR.buildScratchSize ); 581 return seed; 582 } 583 }; 584 585 template <> 586 struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureCaptureDescriptorDataInfoEXT> 587 { operator ()std::hash588 std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureCaptureDescriptorDataInfoEXT const & accelerationStructureCaptureDescriptorDataInfoEXT ) 589 const VULKAN_HPP_NOEXCEPT 590 { 591 std::size_t seed = 0; 592 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCaptureDescriptorDataInfoEXT.sType ); 593 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCaptureDescriptorDataInfoEXT.pNext ); 594 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCaptureDescriptorDataInfoEXT.accelerationStructure ); 595 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCaptureDescriptorDataInfoEXT.accelerationStructureNV ); 596 return seed; 597 } 598 }; 599 600 template <> 601 struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR> 602 { operator ()std::hash603 std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR const & accelerationStructureCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 604 { 605 std::size_t seed = 0; 606 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoKHR.sType ); 607 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoKHR.pNext ); 608 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoKHR.createFlags ); 609 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoKHR.buffer ); 610 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoKHR.offset ); 611 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoKHR.size ); 612 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoKHR.type ); 613 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoKHR.deviceAddress ); 614 return seed; 615 } 616 }; 617 618 template <> 619 struct hash<VULKAN_HPP_NAMESPACE::GeometryTrianglesNV> 620 { operator ()std::hash621 std::size_t operator()( VULKAN_HPP_NAMESPACE::GeometryTrianglesNV const & geometryTrianglesNV ) const VULKAN_HPP_NOEXCEPT 622 { 623 std::size_t seed = 0; 624 VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.sType ); 625 VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.pNext ); 626 VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.vertexData ); 627 VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.vertexOffset ); 628 VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.vertexCount ); 629 VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.vertexStride ); 630 VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.vertexFormat ); 631 VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.indexData ); 632 VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.indexOffset ); 633 VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.indexCount ); 634 VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.indexType ); 635 VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.transformData ); 636 VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.transformOffset ); 637 return seed; 638 } 639 }; 640 641 template <> 642 struct hash<VULKAN_HPP_NAMESPACE::GeometryAABBNV> 643 { operator ()std::hash644 std::size_t operator()( VULKAN_HPP_NAMESPACE::GeometryAABBNV const & geometryAABBNV ) const VULKAN_HPP_NOEXCEPT 645 { 646 std::size_t seed = 0; 647 VULKAN_HPP_HASH_COMBINE( seed, geometryAABBNV.sType ); 648 VULKAN_HPP_HASH_COMBINE( seed, geometryAABBNV.pNext ); 649 VULKAN_HPP_HASH_COMBINE( seed, geometryAABBNV.aabbData ); 650 VULKAN_HPP_HASH_COMBINE( seed, geometryAABBNV.numAABBs ); 651 VULKAN_HPP_HASH_COMBINE( seed, geometryAABBNV.stride ); 652 VULKAN_HPP_HASH_COMBINE( seed, geometryAABBNV.offset ); 653 return seed; 654 } 655 }; 656 657 template <> 658 struct hash<VULKAN_HPP_NAMESPACE::GeometryDataNV> 659 { operator ()std::hash660 std::size_t operator()( VULKAN_HPP_NAMESPACE::GeometryDataNV const & geometryDataNV ) const VULKAN_HPP_NOEXCEPT 661 { 662 std::size_t seed = 0; 663 VULKAN_HPP_HASH_COMBINE( seed, geometryDataNV.triangles ); 664 VULKAN_HPP_HASH_COMBINE( seed, geometryDataNV.aabbs ); 665 return seed; 666 } 667 }; 668 669 template <> 670 struct hash<VULKAN_HPP_NAMESPACE::GeometryNV> 671 { operator ()std::hash672 std::size_t operator()( VULKAN_HPP_NAMESPACE::GeometryNV const & geometryNV ) const VULKAN_HPP_NOEXCEPT 673 { 674 std::size_t seed = 0; 675 VULKAN_HPP_HASH_COMBINE( seed, geometryNV.sType ); 676 VULKAN_HPP_HASH_COMBINE( seed, geometryNV.pNext ); 677 VULKAN_HPP_HASH_COMBINE( seed, geometryNV.geometryType ); 678 VULKAN_HPP_HASH_COMBINE( seed, geometryNV.geometry ); 679 VULKAN_HPP_HASH_COMBINE( seed, geometryNV.flags ); 680 return seed; 681 } 682 }; 683 684 template <> 685 struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV> 686 { operator ()std::hash687 std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV const & accelerationStructureInfoNV ) const VULKAN_HPP_NOEXCEPT 688 { 689 std::size_t seed = 0; 690 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInfoNV.sType ); 691 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInfoNV.pNext ); 692 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInfoNV.type ); 693 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInfoNV.flags ); 694 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInfoNV.instanceCount ); 695 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInfoNV.geometryCount ); 696 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInfoNV.pGeometries ); 697 return seed; 698 } 699 }; 700 701 template <> 702 struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV> 703 { operator ()std::hash704 std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV const & accelerationStructureCreateInfoNV ) const VULKAN_HPP_NOEXCEPT 705 { 706 std::size_t seed = 0; 707 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoNV.sType ); 708 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoNV.pNext ); 709 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoNV.compactedSize ); 710 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoNV.info ); 711 return seed; 712 } 713 }; 714 715 template <> 716 struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR> 717 { 718 std::size_t operator ()std::hash719 operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR const & accelerationStructureDeviceAddressInfoKHR ) const VULKAN_HPP_NOEXCEPT 720 { 721 std::size_t seed = 0; 722 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureDeviceAddressInfoKHR.sType ); 723 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureDeviceAddressInfoKHR.pNext ); 724 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureDeviceAddressInfoKHR.accelerationStructure ); 725 return seed; 726 } 727 }; 728 729 template <> 730 struct hash<VULKAN_HPP_NAMESPACE::TransformMatrixKHR> 731 { operator ()std::hash732 std::size_t operator()( VULKAN_HPP_NAMESPACE::TransformMatrixKHR const & transformMatrixKHR ) const VULKAN_HPP_NOEXCEPT 733 { 734 std::size_t seed = 0; 735 for ( size_t i = 0; i < 3; ++i ) 736 { 737 for ( size_t j = 0; j < 4; ++j ) 738 { 739 VULKAN_HPP_HASH_COMBINE( seed, transformMatrixKHR.matrix[i][j] ); 740 } 741 } 742 return seed; 743 } 744 }; 745 746 template <> 747 struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureInstanceKHR> 748 { operator ()std::hash749 std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureInstanceKHR const & accelerationStructureInstanceKHR ) const VULKAN_HPP_NOEXCEPT 750 { 751 std::size_t seed = 0; 752 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInstanceKHR.transform ); 753 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInstanceKHR.instanceCustomIndex ); 754 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInstanceKHR.mask ); 755 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInstanceKHR.instanceShaderBindingTableRecordOffset ); 756 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInstanceKHR.flags ); 757 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInstanceKHR.accelerationStructureReference ); 758 return seed; 759 } 760 }; 761 762 template <> 763 struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureMatrixMotionInstanceNV> 764 { operator ()std::hash765 std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureMatrixMotionInstanceNV const & accelerationStructureMatrixMotionInstanceNV ) const 766 VULKAN_HPP_NOEXCEPT 767 { 768 std::size_t seed = 0; 769 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMatrixMotionInstanceNV.transformT0 ); 770 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMatrixMotionInstanceNV.transformT1 ); 771 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMatrixMotionInstanceNV.instanceCustomIndex ); 772 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMatrixMotionInstanceNV.mask ); 773 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMatrixMotionInstanceNV.instanceShaderBindingTableRecordOffset ); 774 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMatrixMotionInstanceNV.flags ); 775 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMatrixMotionInstanceNV.accelerationStructureReference ); 776 return seed; 777 } 778 }; 779 780 template <> 781 struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV> 782 { operator ()std::hash783 std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV const & accelerationStructureMemoryRequirementsInfoNV ) const 784 VULKAN_HPP_NOEXCEPT 785 { 786 std::size_t seed = 0; 787 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMemoryRequirementsInfoNV.sType ); 788 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMemoryRequirementsInfoNV.pNext ); 789 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMemoryRequirementsInfoNV.type ); 790 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMemoryRequirementsInfoNV.accelerationStructure ); 791 return seed; 792 } 793 }; 794 795 template <> 796 struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInfoNV> 797 { operator ()std::hash798 std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInfoNV const & accelerationStructureMotionInfoNV ) const VULKAN_HPP_NOEXCEPT 799 { 800 std::size_t seed = 0; 801 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMotionInfoNV.sType ); 802 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMotionInfoNV.pNext ); 803 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMotionInfoNV.maxInstances ); 804 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMotionInfoNV.flags ); 805 return seed; 806 } 807 }; 808 809 template <> 810 struct hash<VULKAN_HPP_NAMESPACE::SRTDataNV> 811 { operator ()std::hash812 std::size_t operator()( VULKAN_HPP_NAMESPACE::SRTDataNV const & sRTDataNV ) const VULKAN_HPP_NOEXCEPT 813 { 814 std::size_t seed = 0; 815 VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.sx ); 816 VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.a ); 817 VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.b ); 818 VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.pvx ); 819 VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.sy ); 820 VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.c ); 821 VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.pvy ); 822 VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.sz ); 823 VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.pvz ); 824 VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.qx ); 825 VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.qy ); 826 VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.qz ); 827 VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.qw ); 828 VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.tx ); 829 VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.ty ); 830 VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.tz ); 831 return seed; 832 } 833 }; 834 835 template <> 836 struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureSRTMotionInstanceNV> 837 { 838 std::size_t operator ()std::hash839 operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureSRTMotionInstanceNV const & accelerationStructureSRTMotionInstanceNV ) const VULKAN_HPP_NOEXCEPT 840 { 841 std::size_t seed = 0; 842 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureSRTMotionInstanceNV.transformT0 ); 843 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureSRTMotionInstanceNV.transformT1 ); 844 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureSRTMotionInstanceNV.instanceCustomIndex ); 845 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureSRTMotionInstanceNV.mask ); 846 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureSRTMotionInstanceNV.instanceShaderBindingTableRecordOffset ); 847 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureSRTMotionInstanceNV.flags ); 848 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureSRTMotionInstanceNV.accelerationStructureReference ); 849 return seed; 850 } 851 }; 852 853 template <> 854 struct hash<VULKAN_HPP_NAMESPACE::MicromapUsageEXT> 855 { operator ()std::hash856 std::size_t operator()( VULKAN_HPP_NAMESPACE::MicromapUsageEXT const & micromapUsageEXT ) const VULKAN_HPP_NOEXCEPT 857 { 858 std::size_t seed = 0; 859 VULKAN_HPP_HASH_COMBINE( seed, micromapUsageEXT.count ); 860 VULKAN_HPP_HASH_COMBINE( seed, micromapUsageEXT.subdivisionLevel ); 861 VULKAN_HPP_HASH_COMBINE( seed, micromapUsageEXT.format ); 862 return seed; 863 } 864 }; 865 866 template <> 867 struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureVersionInfoKHR> 868 { operator ()std::hash869 std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureVersionInfoKHR const & accelerationStructureVersionInfoKHR ) const VULKAN_HPP_NOEXCEPT 870 { 871 std::size_t seed = 0; 872 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureVersionInfoKHR.sType ); 873 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureVersionInfoKHR.pNext ); 874 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureVersionInfoKHR.pVersionData ); 875 return seed; 876 } 877 }; 878 879 template <> 880 struct hash<VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR> 881 { operator ()std::hash882 std::size_t operator()( VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR const & acquireNextImageInfoKHR ) const VULKAN_HPP_NOEXCEPT 883 { 884 std::size_t seed = 0; 885 VULKAN_HPP_HASH_COMBINE( seed, acquireNextImageInfoKHR.sType ); 886 VULKAN_HPP_HASH_COMBINE( seed, acquireNextImageInfoKHR.pNext ); 887 VULKAN_HPP_HASH_COMBINE( seed, acquireNextImageInfoKHR.swapchain ); 888 VULKAN_HPP_HASH_COMBINE( seed, acquireNextImageInfoKHR.timeout ); 889 VULKAN_HPP_HASH_COMBINE( seed, acquireNextImageInfoKHR.semaphore ); 890 VULKAN_HPP_HASH_COMBINE( seed, acquireNextImageInfoKHR.fence ); 891 VULKAN_HPP_HASH_COMBINE( seed, acquireNextImageInfoKHR.deviceMask ); 892 return seed; 893 } 894 }; 895 896 template <> 897 struct hash<VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR> 898 { operator ()std::hash899 std::size_t operator()( VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR const & acquireProfilingLockInfoKHR ) const VULKAN_HPP_NOEXCEPT 900 { 901 std::size_t seed = 0; 902 VULKAN_HPP_HASH_COMBINE( seed, acquireProfilingLockInfoKHR.sType ); 903 VULKAN_HPP_HASH_COMBINE( seed, acquireProfilingLockInfoKHR.pNext ); 904 VULKAN_HPP_HASH_COMBINE( seed, acquireProfilingLockInfoKHR.flags ); 905 VULKAN_HPP_HASH_COMBINE( seed, acquireProfilingLockInfoKHR.timeout ); 906 return seed; 907 } 908 }; 909 910 template <> 911 struct hash<VULKAN_HPP_NAMESPACE::AllocationCallbacks> 912 { operator ()std::hash913 std::size_t operator()( VULKAN_HPP_NAMESPACE::AllocationCallbacks const & allocationCallbacks ) const VULKAN_HPP_NOEXCEPT 914 { 915 std::size_t seed = 0; 916 VULKAN_HPP_HASH_COMBINE( seed, allocationCallbacks.pUserData ); 917 VULKAN_HPP_HASH_COMBINE( seed, allocationCallbacks.pfnAllocation ); 918 VULKAN_HPP_HASH_COMBINE( seed, allocationCallbacks.pfnReallocation ); 919 VULKAN_HPP_HASH_COMBINE( seed, allocationCallbacks.pfnFree ); 920 VULKAN_HPP_HASH_COMBINE( seed, allocationCallbacks.pfnInternalAllocation ); 921 VULKAN_HPP_HASH_COMBINE( seed, allocationCallbacks.pfnInternalFree ); 922 return seed; 923 } 924 }; 925 926 template <> 927 struct hash<VULKAN_HPP_NAMESPACE::AmigoProfilingSubmitInfoSEC> 928 { operator ()std::hash929 std::size_t operator()( VULKAN_HPP_NAMESPACE::AmigoProfilingSubmitInfoSEC const & amigoProfilingSubmitInfoSEC ) const VULKAN_HPP_NOEXCEPT 930 { 931 std::size_t seed = 0; 932 VULKAN_HPP_HASH_COMBINE( seed, amigoProfilingSubmitInfoSEC.sType ); 933 VULKAN_HPP_HASH_COMBINE( seed, amigoProfilingSubmitInfoSEC.pNext ); 934 VULKAN_HPP_HASH_COMBINE( seed, amigoProfilingSubmitInfoSEC.firstDrawTimestamp ); 935 VULKAN_HPP_HASH_COMBINE( seed, amigoProfilingSubmitInfoSEC.swapBufferTimestamp ); 936 return seed; 937 } 938 }; 939 940 template <> 941 struct hash<VULKAN_HPP_NAMESPACE::ComponentMapping> 942 { operator ()std::hash943 std::size_t operator()( VULKAN_HPP_NAMESPACE::ComponentMapping const & componentMapping ) const VULKAN_HPP_NOEXCEPT 944 { 945 std::size_t seed = 0; 946 VULKAN_HPP_HASH_COMBINE( seed, componentMapping.r ); 947 VULKAN_HPP_HASH_COMBINE( seed, componentMapping.g ); 948 VULKAN_HPP_HASH_COMBINE( seed, componentMapping.b ); 949 VULKAN_HPP_HASH_COMBINE( seed, componentMapping.a ); 950 return seed; 951 } 952 }; 953 954 # if defined( VK_USE_PLATFORM_ANDROID_KHR ) 955 template <> 956 struct hash<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatProperties2ANDROID> 957 { operator ()std::hash958 std::size_t operator()( VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatProperties2ANDROID const & androidHardwareBufferFormatProperties2ANDROID ) const 959 VULKAN_HPP_NOEXCEPT 960 { 961 std::size_t seed = 0; 962 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.sType ); 963 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.pNext ); 964 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.format ); 965 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.externalFormat ); 966 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.formatFeatures ); 967 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.samplerYcbcrConversionComponents ); 968 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.suggestedYcbcrModel ); 969 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.suggestedYcbcrRange ); 970 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.suggestedXChromaOffset ); 971 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.suggestedYChromaOffset ); 972 return seed; 973 } 974 }; 975 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ 976 977 # if defined( VK_USE_PLATFORM_ANDROID_KHR ) 978 template <> 979 struct hash<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatPropertiesANDROID> 980 { operator ()std::hash981 std::size_t operator()( VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatPropertiesANDROID const & androidHardwareBufferFormatPropertiesANDROID ) const 982 VULKAN_HPP_NOEXCEPT 983 { 984 std::size_t seed = 0; 985 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.sType ); 986 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.pNext ); 987 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.format ); 988 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.externalFormat ); 989 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.formatFeatures ); 990 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.samplerYcbcrConversionComponents ); 991 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.suggestedYcbcrModel ); 992 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.suggestedYcbcrRange ); 993 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.suggestedXChromaOffset ); 994 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.suggestedYChromaOffset ); 995 return seed; 996 } 997 }; 998 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ 999 1000 # if defined( VK_USE_PLATFORM_ANDROID_KHR ) 1001 template <> 1002 struct hash<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatResolvePropertiesANDROID> 1003 { 1004 std::size_t operator ()std::hash1005 operator()( VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatResolvePropertiesANDROID const & androidHardwareBufferFormatResolvePropertiesANDROID ) const 1006 VULKAN_HPP_NOEXCEPT 1007 { 1008 std::size_t seed = 0; 1009 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatResolvePropertiesANDROID.sType ); 1010 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatResolvePropertiesANDROID.pNext ); 1011 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatResolvePropertiesANDROID.colorAttachmentFormat ); 1012 return seed; 1013 } 1014 }; 1015 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ 1016 1017 # if defined( VK_USE_PLATFORM_ANDROID_KHR ) 1018 template <> 1019 struct hash<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID> 1020 { 1021 std::size_t operator ()std::hash1022 operator()( VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID const & androidHardwareBufferPropertiesANDROID ) const VULKAN_HPP_NOEXCEPT 1023 { 1024 std::size_t seed = 0; 1025 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferPropertiesANDROID.sType ); 1026 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferPropertiesANDROID.pNext ); 1027 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferPropertiesANDROID.allocationSize ); 1028 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferPropertiesANDROID.memoryTypeBits ); 1029 return seed; 1030 } 1031 }; 1032 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ 1033 1034 # if defined( VK_USE_PLATFORM_ANDROID_KHR ) 1035 template <> 1036 struct hash<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferUsageANDROID> 1037 { operator ()std::hash1038 std::size_t operator()( VULKAN_HPP_NAMESPACE::AndroidHardwareBufferUsageANDROID const & androidHardwareBufferUsageANDROID ) const VULKAN_HPP_NOEXCEPT 1039 { 1040 std::size_t seed = 0; 1041 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferUsageANDROID.sType ); 1042 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferUsageANDROID.pNext ); 1043 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferUsageANDROID.androidHardwareBufferUsage ); 1044 return seed; 1045 } 1046 }; 1047 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ 1048 1049 # if defined( VK_USE_PLATFORM_ANDROID_KHR ) 1050 template <> 1051 struct hash<VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR> 1052 { operator ()std::hash1053 std::size_t operator()( VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR const & androidSurfaceCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 1054 { 1055 std::size_t seed = 0; 1056 VULKAN_HPP_HASH_COMBINE( seed, androidSurfaceCreateInfoKHR.sType ); 1057 VULKAN_HPP_HASH_COMBINE( seed, androidSurfaceCreateInfoKHR.pNext ); 1058 VULKAN_HPP_HASH_COMBINE( seed, androidSurfaceCreateInfoKHR.flags ); 1059 VULKAN_HPP_HASH_COMBINE( seed, androidSurfaceCreateInfoKHR.window ); 1060 return seed; 1061 } 1062 }; 1063 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ 1064 1065 template <> 1066 struct hash<VULKAN_HPP_NAMESPACE::ApplicationInfo> 1067 { operator ()std::hash1068 std::size_t operator()( VULKAN_HPP_NAMESPACE::ApplicationInfo const & applicationInfo ) const VULKAN_HPP_NOEXCEPT 1069 { 1070 std::size_t seed = 0; 1071 VULKAN_HPP_HASH_COMBINE( seed, applicationInfo.sType ); 1072 VULKAN_HPP_HASH_COMBINE( seed, applicationInfo.pNext ); 1073 for ( const char * p = applicationInfo.pApplicationName; *p != '\0'; ++p ) 1074 { 1075 VULKAN_HPP_HASH_COMBINE( seed, *p ); 1076 } 1077 VULKAN_HPP_HASH_COMBINE( seed, applicationInfo.applicationVersion ); 1078 for ( const char * p = applicationInfo.pEngineName; *p != '\0'; ++p ) 1079 { 1080 VULKAN_HPP_HASH_COMBINE( seed, *p ); 1081 } 1082 VULKAN_HPP_HASH_COMBINE( seed, applicationInfo.engineVersion ); 1083 VULKAN_HPP_HASH_COMBINE( seed, applicationInfo.apiVersion ); 1084 return seed; 1085 } 1086 }; 1087 1088 template <> 1089 struct hash<VULKAN_HPP_NAMESPACE::AttachmentDescription> 1090 { operator ()std::hash1091 std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentDescription const & attachmentDescription ) const VULKAN_HPP_NOEXCEPT 1092 { 1093 std::size_t seed = 0; 1094 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.flags ); 1095 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.format ); 1096 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.samples ); 1097 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.loadOp ); 1098 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.storeOp ); 1099 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.stencilLoadOp ); 1100 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.stencilStoreOp ); 1101 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.initialLayout ); 1102 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.finalLayout ); 1103 return seed; 1104 } 1105 }; 1106 1107 template <> 1108 struct hash<VULKAN_HPP_NAMESPACE::AttachmentDescription2> 1109 { operator ()std::hash1110 std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentDescription2 const & attachmentDescription2 ) const VULKAN_HPP_NOEXCEPT 1111 { 1112 std::size_t seed = 0; 1113 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.sType ); 1114 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.pNext ); 1115 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.flags ); 1116 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.format ); 1117 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.samples ); 1118 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.loadOp ); 1119 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.storeOp ); 1120 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.stencilLoadOp ); 1121 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.stencilStoreOp ); 1122 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.initialLayout ); 1123 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.finalLayout ); 1124 return seed; 1125 } 1126 }; 1127 1128 template <> 1129 struct hash<VULKAN_HPP_NAMESPACE::AttachmentDescriptionStencilLayout> 1130 { operator ()std::hash1131 std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentDescriptionStencilLayout const & attachmentDescriptionStencilLayout ) const VULKAN_HPP_NOEXCEPT 1132 { 1133 std::size_t seed = 0; 1134 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescriptionStencilLayout.sType ); 1135 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescriptionStencilLayout.pNext ); 1136 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescriptionStencilLayout.stencilInitialLayout ); 1137 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescriptionStencilLayout.stencilFinalLayout ); 1138 return seed; 1139 } 1140 }; 1141 1142 template <> 1143 struct hash<VULKAN_HPP_NAMESPACE::AttachmentReference> 1144 { operator ()std::hash1145 std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentReference const & attachmentReference ) const VULKAN_HPP_NOEXCEPT 1146 { 1147 std::size_t seed = 0; 1148 VULKAN_HPP_HASH_COMBINE( seed, attachmentReference.attachment ); 1149 VULKAN_HPP_HASH_COMBINE( seed, attachmentReference.layout ); 1150 return seed; 1151 } 1152 }; 1153 1154 template <> 1155 struct hash<VULKAN_HPP_NAMESPACE::AttachmentReference2> 1156 { operator ()std::hash1157 std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentReference2 const & attachmentReference2 ) const VULKAN_HPP_NOEXCEPT 1158 { 1159 std::size_t seed = 0; 1160 VULKAN_HPP_HASH_COMBINE( seed, attachmentReference2.sType ); 1161 VULKAN_HPP_HASH_COMBINE( seed, attachmentReference2.pNext ); 1162 VULKAN_HPP_HASH_COMBINE( seed, attachmentReference2.attachment ); 1163 VULKAN_HPP_HASH_COMBINE( seed, attachmentReference2.layout ); 1164 VULKAN_HPP_HASH_COMBINE( seed, attachmentReference2.aspectMask ); 1165 return seed; 1166 } 1167 }; 1168 1169 template <> 1170 struct hash<VULKAN_HPP_NAMESPACE::AttachmentReferenceStencilLayout> 1171 { operator ()std::hash1172 std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentReferenceStencilLayout const & attachmentReferenceStencilLayout ) const VULKAN_HPP_NOEXCEPT 1173 { 1174 std::size_t seed = 0; 1175 VULKAN_HPP_HASH_COMBINE( seed, attachmentReferenceStencilLayout.sType ); 1176 VULKAN_HPP_HASH_COMBINE( seed, attachmentReferenceStencilLayout.pNext ); 1177 VULKAN_HPP_HASH_COMBINE( seed, attachmentReferenceStencilLayout.stencilLayout ); 1178 return seed; 1179 } 1180 }; 1181 1182 template <> 1183 struct hash<VULKAN_HPP_NAMESPACE::AttachmentSampleCountInfoAMD> 1184 { operator ()std::hash1185 std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentSampleCountInfoAMD const & attachmentSampleCountInfoAMD ) const VULKAN_HPP_NOEXCEPT 1186 { 1187 std::size_t seed = 0; 1188 VULKAN_HPP_HASH_COMBINE( seed, attachmentSampleCountInfoAMD.sType ); 1189 VULKAN_HPP_HASH_COMBINE( seed, attachmentSampleCountInfoAMD.pNext ); 1190 VULKAN_HPP_HASH_COMBINE( seed, attachmentSampleCountInfoAMD.colorAttachmentCount ); 1191 VULKAN_HPP_HASH_COMBINE( seed, attachmentSampleCountInfoAMD.pColorAttachmentSamples ); 1192 VULKAN_HPP_HASH_COMBINE( seed, attachmentSampleCountInfoAMD.depthStencilAttachmentSamples ); 1193 return seed; 1194 } 1195 }; 1196 1197 template <> 1198 struct hash<VULKAN_HPP_NAMESPACE::Extent2D> 1199 { operator ()std::hash1200 std::size_t operator()( VULKAN_HPP_NAMESPACE::Extent2D const & extent2D ) const VULKAN_HPP_NOEXCEPT 1201 { 1202 std::size_t seed = 0; 1203 VULKAN_HPP_HASH_COMBINE( seed, extent2D.width ); 1204 VULKAN_HPP_HASH_COMBINE( seed, extent2D.height ); 1205 return seed; 1206 } 1207 }; 1208 1209 template <> 1210 struct hash<VULKAN_HPP_NAMESPACE::SampleLocationEXT> 1211 { operator ()std::hash1212 std::size_t operator()( VULKAN_HPP_NAMESPACE::SampleLocationEXT const & sampleLocationEXT ) const VULKAN_HPP_NOEXCEPT 1213 { 1214 std::size_t seed = 0; 1215 VULKAN_HPP_HASH_COMBINE( seed, sampleLocationEXT.x ); 1216 VULKAN_HPP_HASH_COMBINE( seed, sampleLocationEXT.y ); 1217 return seed; 1218 } 1219 }; 1220 1221 template <> 1222 struct hash<VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT> 1223 { operator ()std::hash1224 std::size_t operator()( VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT const & sampleLocationsInfoEXT ) const VULKAN_HPP_NOEXCEPT 1225 { 1226 std::size_t seed = 0; 1227 VULKAN_HPP_HASH_COMBINE( seed, sampleLocationsInfoEXT.sType ); 1228 VULKAN_HPP_HASH_COMBINE( seed, sampleLocationsInfoEXT.pNext ); 1229 VULKAN_HPP_HASH_COMBINE( seed, sampleLocationsInfoEXT.sampleLocationsPerPixel ); 1230 VULKAN_HPP_HASH_COMBINE( seed, sampleLocationsInfoEXT.sampleLocationGridSize ); 1231 VULKAN_HPP_HASH_COMBINE( seed, sampleLocationsInfoEXT.sampleLocationsCount ); 1232 VULKAN_HPP_HASH_COMBINE( seed, sampleLocationsInfoEXT.pSampleLocations ); 1233 return seed; 1234 } 1235 }; 1236 1237 template <> 1238 struct hash<VULKAN_HPP_NAMESPACE::AttachmentSampleLocationsEXT> 1239 { operator ()std::hash1240 std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentSampleLocationsEXT const & attachmentSampleLocationsEXT ) const VULKAN_HPP_NOEXCEPT 1241 { 1242 std::size_t seed = 0; 1243 VULKAN_HPP_HASH_COMBINE( seed, attachmentSampleLocationsEXT.attachmentIndex ); 1244 VULKAN_HPP_HASH_COMBINE( seed, attachmentSampleLocationsEXT.sampleLocationsInfo ); 1245 return seed; 1246 } 1247 }; 1248 1249 template <> 1250 struct hash<VULKAN_HPP_NAMESPACE::BaseInStructure> 1251 { operator ()std::hash1252 std::size_t operator()( VULKAN_HPP_NAMESPACE::BaseInStructure const & baseInStructure ) const VULKAN_HPP_NOEXCEPT 1253 { 1254 std::size_t seed = 0; 1255 VULKAN_HPP_HASH_COMBINE( seed, baseInStructure.sType ); 1256 VULKAN_HPP_HASH_COMBINE( seed, baseInStructure.pNext ); 1257 return seed; 1258 } 1259 }; 1260 1261 template <> 1262 struct hash<VULKAN_HPP_NAMESPACE::BaseOutStructure> 1263 { operator ()std::hash1264 std::size_t operator()( VULKAN_HPP_NAMESPACE::BaseOutStructure const & baseOutStructure ) const VULKAN_HPP_NOEXCEPT 1265 { 1266 std::size_t seed = 0; 1267 VULKAN_HPP_HASH_COMBINE( seed, baseOutStructure.sType ); 1268 VULKAN_HPP_HASH_COMBINE( seed, baseOutStructure.pNext ); 1269 return seed; 1270 } 1271 }; 1272 1273 template <> 1274 struct hash<VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV> 1275 { 1276 std::size_t operator ()std::hash1277 operator()( VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV const & bindAccelerationStructureMemoryInfoNV ) const VULKAN_HPP_NOEXCEPT 1278 { 1279 std::size_t seed = 0; 1280 VULKAN_HPP_HASH_COMBINE( seed, bindAccelerationStructureMemoryInfoNV.sType ); 1281 VULKAN_HPP_HASH_COMBINE( seed, bindAccelerationStructureMemoryInfoNV.pNext ); 1282 VULKAN_HPP_HASH_COMBINE( seed, bindAccelerationStructureMemoryInfoNV.accelerationStructure ); 1283 VULKAN_HPP_HASH_COMBINE( seed, bindAccelerationStructureMemoryInfoNV.memory ); 1284 VULKAN_HPP_HASH_COMBINE( seed, bindAccelerationStructureMemoryInfoNV.memoryOffset ); 1285 VULKAN_HPP_HASH_COMBINE( seed, bindAccelerationStructureMemoryInfoNV.deviceIndexCount ); 1286 VULKAN_HPP_HASH_COMBINE( seed, bindAccelerationStructureMemoryInfoNV.pDeviceIndices ); 1287 return seed; 1288 } 1289 }; 1290 1291 template <> 1292 struct hash<VULKAN_HPP_NAMESPACE::BindBufferMemoryDeviceGroupInfo> 1293 { operator ()std::hash1294 std::size_t operator()( VULKAN_HPP_NAMESPACE::BindBufferMemoryDeviceGroupInfo const & bindBufferMemoryDeviceGroupInfo ) const VULKAN_HPP_NOEXCEPT 1295 { 1296 std::size_t seed = 0; 1297 VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryDeviceGroupInfo.sType ); 1298 VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryDeviceGroupInfo.pNext ); 1299 VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryDeviceGroupInfo.deviceIndexCount ); 1300 VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryDeviceGroupInfo.pDeviceIndices ); 1301 return seed; 1302 } 1303 }; 1304 1305 template <> 1306 struct hash<VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo> 1307 { operator ()std::hash1308 std::size_t operator()( VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo const & bindBufferMemoryInfo ) const VULKAN_HPP_NOEXCEPT 1309 { 1310 std::size_t seed = 0; 1311 VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryInfo.sType ); 1312 VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryInfo.pNext ); 1313 VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryInfo.buffer ); 1314 VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryInfo.memory ); 1315 VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryInfo.memoryOffset ); 1316 return seed; 1317 } 1318 }; 1319 1320 template <> 1321 struct hash<VULKAN_HPP_NAMESPACE::BindDescriptorBufferEmbeddedSamplersInfoEXT> 1322 { operator ()std::hash1323 std::size_t operator()( VULKAN_HPP_NAMESPACE::BindDescriptorBufferEmbeddedSamplersInfoEXT const & bindDescriptorBufferEmbeddedSamplersInfoEXT ) const 1324 VULKAN_HPP_NOEXCEPT 1325 { 1326 std::size_t seed = 0; 1327 VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorBufferEmbeddedSamplersInfoEXT.sType ); 1328 VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorBufferEmbeddedSamplersInfoEXT.pNext ); 1329 VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorBufferEmbeddedSamplersInfoEXT.stageFlags ); 1330 VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorBufferEmbeddedSamplersInfoEXT.layout ); 1331 VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorBufferEmbeddedSamplersInfoEXT.set ); 1332 return seed; 1333 } 1334 }; 1335 1336 template <> 1337 struct hash<VULKAN_HPP_NAMESPACE::BindDescriptorSetsInfoKHR> 1338 { operator ()std::hash1339 std::size_t operator()( VULKAN_HPP_NAMESPACE::BindDescriptorSetsInfoKHR const & bindDescriptorSetsInfoKHR ) const VULKAN_HPP_NOEXCEPT 1340 { 1341 std::size_t seed = 0; 1342 VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorSetsInfoKHR.sType ); 1343 VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorSetsInfoKHR.pNext ); 1344 VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorSetsInfoKHR.stageFlags ); 1345 VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorSetsInfoKHR.layout ); 1346 VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorSetsInfoKHR.firstSet ); 1347 VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorSetsInfoKHR.descriptorSetCount ); 1348 VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorSetsInfoKHR.pDescriptorSets ); 1349 VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorSetsInfoKHR.dynamicOffsetCount ); 1350 VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorSetsInfoKHR.pDynamicOffsets ); 1351 return seed; 1352 } 1353 }; 1354 1355 template <> 1356 struct hash<VULKAN_HPP_NAMESPACE::Offset2D> 1357 { operator ()std::hash1358 std::size_t operator()( VULKAN_HPP_NAMESPACE::Offset2D const & offset2D ) const VULKAN_HPP_NOEXCEPT 1359 { 1360 std::size_t seed = 0; 1361 VULKAN_HPP_HASH_COMBINE( seed, offset2D.x ); 1362 VULKAN_HPP_HASH_COMBINE( seed, offset2D.y ); 1363 return seed; 1364 } 1365 }; 1366 1367 template <> 1368 struct hash<VULKAN_HPP_NAMESPACE::Rect2D> 1369 { operator ()std::hash1370 std::size_t operator()( VULKAN_HPP_NAMESPACE::Rect2D const & rect2D ) const VULKAN_HPP_NOEXCEPT 1371 { 1372 std::size_t seed = 0; 1373 VULKAN_HPP_HASH_COMBINE( seed, rect2D.offset ); 1374 VULKAN_HPP_HASH_COMBINE( seed, rect2D.extent ); 1375 return seed; 1376 } 1377 }; 1378 1379 template <> 1380 struct hash<VULKAN_HPP_NAMESPACE::BindImageMemoryDeviceGroupInfo> 1381 { operator ()std::hash1382 std::size_t operator()( VULKAN_HPP_NAMESPACE::BindImageMemoryDeviceGroupInfo const & bindImageMemoryDeviceGroupInfo ) const VULKAN_HPP_NOEXCEPT 1383 { 1384 std::size_t seed = 0; 1385 VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryDeviceGroupInfo.sType ); 1386 VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryDeviceGroupInfo.pNext ); 1387 VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryDeviceGroupInfo.deviceIndexCount ); 1388 VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryDeviceGroupInfo.pDeviceIndices ); 1389 VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryDeviceGroupInfo.splitInstanceBindRegionCount ); 1390 VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryDeviceGroupInfo.pSplitInstanceBindRegions ); 1391 return seed; 1392 } 1393 }; 1394 1395 template <> 1396 struct hash<VULKAN_HPP_NAMESPACE::BindImageMemoryInfo> 1397 { operator ()std::hash1398 std::size_t operator()( VULKAN_HPP_NAMESPACE::BindImageMemoryInfo const & bindImageMemoryInfo ) const VULKAN_HPP_NOEXCEPT 1399 { 1400 std::size_t seed = 0; 1401 VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryInfo.sType ); 1402 VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryInfo.pNext ); 1403 VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryInfo.image ); 1404 VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryInfo.memory ); 1405 VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryInfo.memoryOffset ); 1406 return seed; 1407 } 1408 }; 1409 1410 template <> 1411 struct hash<VULKAN_HPP_NAMESPACE::BindImageMemorySwapchainInfoKHR> 1412 { operator ()std::hash1413 std::size_t operator()( VULKAN_HPP_NAMESPACE::BindImageMemorySwapchainInfoKHR const & bindImageMemorySwapchainInfoKHR ) const VULKAN_HPP_NOEXCEPT 1414 { 1415 std::size_t seed = 0; 1416 VULKAN_HPP_HASH_COMBINE( seed, bindImageMemorySwapchainInfoKHR.sType ); 1417 VULKAN_HPP_HASH_COMBINE( seed, bindImageMemorySwapchainInfoKHR.pNext ); 1418 VULKAN_HPP_HASH_COMBINE( seed, bindImageMemorySwapchainInfoKHR.swapchain ); 1419 VULKAN_HPP_HASH_COMBINE( seed, bindImageMemorySwapchainInfoKHR.imageIndex ); 1420 return seed; 1421 } 1422 }; 1423 1424 template <> 1425 struct hash<VULKAN_HPP_NAMESPACE::BindImagePlaneMemoryInfo> 1426 { operator ()std::hash1427 std::size_t operator()( VULKAN_HPP_NAMESPACE::BindImagePlaneMemoryInfo const & bindImagePlaneMemoryInfo ) const VULKAN_HPP_NOEXCEPT 1428 { 1429 std::size_t seed = 0; 1430 VULKAN_HPP_HASH_COMBINE( seed, bindImagePlaneMemoryInfo.sType ); 1431 VULKAN_HPP_HASH_COMBINE( seed, bindImagePlaneMemoryInfo.pNext ); 1432 VULKAN_HPP_HASH_COMBINE( seed, bindImagePlaneMemoryInfo.planeAspect ); 1433 return seed; 1434 } 1435 }; 1436 1437 template <> 1438 struct hash<VULKAN_HPP_NAMESPACE::BindIndexBufferIndirectCommandNV> 1439 { operator ()std::hash1440 std::size_t operator()( VULKAN_HPP_NAMESPACE::BindIndexBufferIndirectCommandNV const & bindIndexBufferIndirectCommandNV ) const VULKAN_HPP_NOEXCEPT 1441 { 1442 std::size_t seed = 0; 1443 VULKAN_HPP_HASH_COMBINE( seed, bindIndexBufferIndirectCommandNV.bufferAddress ); 1444 VULKAN_HPP_HASH_COMBINE( seed, bindIndexBufferIndirectCommandNV.size ); 1445 VULKAN_HPP_HASH_COMBINE( seed, bindIndexBufferIndirectCommandNV.indexType ); 1446 return seed; 1447 } 1448 }; 1449 1450 template <> 1451 struct hash<VULKAN_HPP_NAMESPACE::BindMemoryStatusKHR> 1452 { operator ()std::hash1453 std::size_t operator()( VULKAN_HPP_NAMESPACE::BindMemoryStatusKHR const & bindMemoryStatusKHR ) const VULKAN_HPP_NOEXCEPT 1454 { 1455 std::size_t seed = 0; 1456 VULKAN_HPP_HASH_COMBINE( seed, bindMemoryStatusKHR.sType ); 1457 VULKAN_HPP_HASH_COMBINE( seed, bindMemoryStatusKHR.pNext ); 1458 VULKAN_HPP_HASH_COMBINE( seed, bindMemoryStatusKHR.pResult ); 1459 return seed; 1460 } 1461 }; 1462 1463 template <> 1464 struct hash<VULKAN_HPP_NAMESPACE::BindPipelineIndirectCommandNV> 1465 { operator ()std::hash1466 std::size_t operator()( VULKAN_HPP_NAMESPACE::BindPipelineIndirectCommandNV const & bindPipelineIndirectCommandNV ) const VULKAN_HPP_NOEXCEPT 1467 { 1468 std::size_t seed = 0; 1469 VULKAN_HPP_HASH_COMBINE( seed, bindPipelineIndirectCommandNV.pipelineAddress ); 1470 return seed; 1471 } 1472 }; 1473 1474 template <> 1475 struct hash<VULKAN_HPP_NAMESPACE::BindShaderGroupIndirectCommandNV> 1476 { operator ()std::hash1477 std::size_t operator()( VULKAN_HPP_NAMESPACE::BindShaderGroupIndirectCommandNV const & bindShaderGroupIndirectCommandNV ) const VULKAN_HPP_NOEXCEPT 1478 { 1479 std::size_t seed = 0; 1480 VULKAN_HPP_HASH_COMBINE( seed, bindShaderGroupIndirectCommandNV.groupIndex ); 1481 return seed; 1482 } 1483 }; 1484 1485 template <> 1486 struct hash<VULKAN_HPP_NAMESPACE::SparseMemoryBind> 1487 { operator ()std::hash1488 std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseMemoryBind const & sparseMemoryBind ) const VULKAN_HPP_NOEXCEPT 1489 { 1490 std::size_t seed = 0; 1491 VULKAN_HPP_HASH_COMBINE( seed, sparseMemoryBind.resourceOffset ); 1492 VULKAN_HPP_HASH_COMBINE( seed, sparseMemoryBind.size ); 1493 VULKAN_HPP_HASH_COMBINE( seed, sparseMemoryBind.memory ); 1494 VULKAN_HPP_HASH_COMBINE( seed, sparseMemoryBind.memoryOffset ); 1495 VULKAN_HPP_HASH_COMBINE( seed, sparseMemoryBind.flags ); 1496 return seed; 1497 } 1498 }; 1499 1500 template <> 1501 struct hash<VULKAN_HPP_NAMESPACE::SparseBufferMemoryBindInfo> 1502 { operator ()std::hash1503 std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseBufferMemoryBindInfo const & sparseBufferMemoryBindInfo ) const VULKAN_HPP_NOEXCEPT 1504 { 1505 std::size_t seed = 0; 1506 VULKAN_HPP_HASH_COMBINE( seed, sparseBufferMemoryBindInfo.buffer ); 1507 VULKAN_HPP_HASH_COMBINE( seed, sparseBufferMemoryBindInfo.bindCount ); 1508 VULKAN_HPP_HASH_COMBINE( seed, sparseBufferMemoryBindInfo.pBinds ); 1509 return seed; 1510 } 1511 }; 1512 1513 template <> 1514 struct hash<VULKAN_HPP_NAMESPACE::SparseImageOpaqueMemoryBindInfo> 1515 { operator ()std::hash1516 std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageOpaqueMemoryBindInfo const & sparseImageOpaqueMemoryBindInfo ) const VULKAN_HPP_NOEXCEPT 1517 { 1518 std::size_t seed = 0; 1519 VULKAN_HPP_HASH_COMBINE( seed, sparseImageOpaqueMemoryBindInfo.image ); 1520 VULKAN_HPP_HASH_COMBINE( seed, sparseImageOpaqueMemoryBindInfo.bindCount ); 1521 VULKAN_HPP_HASH_COMBINE( seed, sparseImageOpaqueMemoryBindInfo.pBinds ); 1522 return seed; 1523 } 1524 }; 1525 1526 template <> 1527 struct hash<VULKAN_HPP_NAMESPACE::ImageSubresource> 1528 { operator ()std::hash1529 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageSubresource const & imageSubresource ) const VULKAN_HPP_NOEXCEPT 1530 { 1531 std::size_t seed = 0; 1532 VULKAN_HPP_HASH_COMBINE( seed, imageSubresource.aspectMask ); 1533 VULKAN_HPP_HASH_COMBINE( seed, imageSubresource.mipLevel ); 1534 VULKAN_HPP_HASH_COMBINE( seed, imageSubresource.arrayLayer ); 1535 return seed; 1536 } 1537 }; 1538 1539 template <> 1540 struct hash<VULKAN_HPP_NAMESPACE::Offset3D> 1541 { operator ()std::hash1542 std::size_t operator()( VULKAN_HPP_NAMESPACE::Offset3D const & offset3D ) const VULKAN_HPP_NOEXCEPT 1543 { 1544 std::size_t seed = 0; 1545 VULKAN_HPP_HASH_COMBINE( seed, offset3D.x ); 1546 VULKAN_HPP_HASH_COMBINE( seed, offset3D.y ); 1547 VULKAN_HPP_HASH_COMBINE( seed, offset3D.z ); 1548 return seed; 1549 } 1550 }; 1551 1552 template <> 1553 struct hash<VULKAN_HPP_NAMESPACE::Extent3D> 1554 { operator ()std::hash1555 std::size_t operator()( VULKAN_HPP_NAMESPACE::Extent3D const & extent3D ) const VULKAN_HPP_NOEXCEPT 1556 { 1557 std::size_t seed = 0; 1558 VULKAN_HPP_HASH_COMBINE( seed, extent3D.width ); 1559 VULKAN_HPP_HASH_COMBINE( seed, extent3D.height ); 1560 VULKAN_HPP_HASH_COMBINE( seed, extent3D.depth ); 1561 return seed; 1562 } 1563 }; 1564 1565 template <> 1566 struct hash<VULKAN_HPP_NAMESPACE::SparseImageMemoryBind> 1567 { operator ()std::hash1568 std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageMemoryBind const & sparseImageMemoryBind ) const VULKAN_HPP_NOEXCEPT 1569 { 1570 std::size_t seed = 0; 1571 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBind.subresource ); 1572 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBind.offset ); 1573 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBind.extent ); 1574 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBind.memory ); 1575 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBind.memoryOffset ); 1576 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBind.flags ); 1577 return seed; 1578 } 1579 }; 1580 1581 template <> 1582 struct hash<VULKAN_HPP_NAMESPACE::SparseImageMemoryBindInfo> 1583 { operator ()std::hash1584 std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageMemoryBindInfo const & sparseImageMemoryBindInfo ) const VULKAN_HPP_NOEXCEPT 1585 { 1586 std::size_t seed = 0; 1587 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBindInfo.image ); 1588 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBindInfo.bindCount ); 1589 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBindInfo.pBinds ); 1590 return seed; 1591 } 1592 }; 1593 1594 template <> 1595 struct hash<VULKAN_HPP_NAMESPACE::BindSparseInfo> 1596 { operator ()std::hash1597 std::size_t operator()( VULKAN_HPP_NAMESPACE::BindSparseInfo const & bindSparseInfo ) const VULKAN_HPP_NOEXCEPT 1598 { 1599 std::size_t seed = 0; 1600 VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.sType ); 1601 VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.pNext ); 1602 VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.waitSemaphoreCount ); 1603 VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.pWaitSemaphores ); 1604 VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.bufferBindCount ); 1605 VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.pBufferBinds ); 1606 VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.imageOpaqueBindCount ); 1607 VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.pImageOpaqueBinds ); 1608 VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.imageBindCount ); 1609 VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.pImageBinds ); 1610 VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.signalSemaphoreCount ); 1611 VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.pSignalSemaphores ); 1612 return seed; 1613 } 1614 }; 1615 1616 template <> 1617 struct hash<VULKAN_HPP_NAMESPACE::BindVertexBufferIndirectCommandNV> 1618 { operator ()std::hash1619 std::size_t operator()( VULKAN_HPP_NAMESPACE::BindVertexBufferIndirectCommandNV const & bindVertexBufferIndirectCommandNV ) const VULKAN_HPP_NOEXCEPT 1620 { 1621 std::size_t seed = 0; 1622 VULKAN_HPP_HASH_COMBINE( seed, bindVertexBufferIndirectCommandNV.bufferAddress ); 1623 VULKAN_HPP_HASH_COMBINE( seed, bindVertexBufferIndirectCommandNV.size ); 1624 VULKAN_HPP_HASH_COMBINE( seed, bindVertexBufferIndirectCommandNV.stride ); 1625 return seed; 1626 } 1627 }; 1628 1629 template <> 1630 struct hash<VULKAN_HPP_NAMESPACE::BindVideoSessionMemoryInfoKHR> 1631 { operator ()std::hash1632 std::size_t operator()( VULKAN_HPP_NAMESPACE::BindVideoSessionMemoryInfoKHR const & bindVideoSessionMemoryInfoKHR ) const VULKAN_HPP_NOEXCEPT 1633 { 1634 std::size_t seed = 0; 1635 VULKAN_HPP_HASH_COMBINE( seed, bindVideoSessionMemoryInfoKHR.sType ); 1636 VULKAN_HPP_HASH_COMBINE( seed, bindVideoSessionMemoryInfoKHR.pNext ); 1637 VULKAN_HPP_HASH_COMBINE( seed, bindVideoSessionMemoryInfoKHR.memoryBindIndex ); 1638 VULKAN_HPP_HASH_COMBINE( seed, bindVideoSessionMemoryInfoKHR.memory ); 1639 VULKAN_HPP_HASH_COMBINE( seed, bindVideoSessionMemoryInfoKHR.memoryOffset ); 1640 VULKAN_HPP_HASH_COMBINE( seed, bindVideoSessionMemoryInfoKHR.memorySize ); 1641 return seed; 1642 } 1643 }; 1644 1645 template <> 1646 struct hash<VULKAN_HPP_NAMESPACE::BlitImageCubicWeightsInfoQCOM> 1647 { operator ()std::hash1648 std::size_t operator()( VULKAN_HPP_NAMESPACE::BlitImageCubicWeightsInfoQCOM const & blitImageCubicWeightsInfoQCOM ) const VULKAN_HPP_NOEXCEPT 1649 { 1650 std::size_t seed = 0; 1651 VULKAN_HPP_HASH_COMBINE( seed, blitImageCubicWeightsInfoQCOM.sType ); 1652 VULKAN_HPP_HASH_COMBINE( seed, blitImageCubicWeightsInfoQCOM.pNext ); 1653 VULKAN_HPP_HASH_COMBINE( seed, blitImageCubicWeightsInfoQCOM.cubicWeights ); 1654 return seed; 1655 } 1656 }; 1657 1658 template <> 1659 struct hash<VULKAN_HPP_NAMESPACE::ImageSubresourceLayers> 1660 { operator ()std::hash1661 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const & imageSubresourceLayers ) const VULKAN_HPP_NOEXCEPT 1662 { 1663 std::size_t seed = 0; 1664 VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceLayers.aspectMask ); 1665 VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceLayers.mipLevel ); 1666 VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceLayers.baseArrayLayer ); 1667 VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceLayers.layerCount ); 1668 return seed; 1669 } 1670 }; 1671 1672 template <> 1673 struct hash<VULKAN_HPP_NAMESPACE::ImageBlit2> 1674 { operator ()std::hash1675 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageBlit2 const & imageBlit2 ) const VULKAN_HPP_NOEXCEPT 1676 { 1677 std::size_t seed = 0; 1678 VULKAN_HPP_HASH_COMBINE( seed, imageBlit2.sType ); 1679 VULKAN_HPP_HASH_COMBINE( seed, imageBlit2.pNext ); 1680 VULKAN_HPP_HASH_COMBINE( seed, imageBlit2.srcSubresource ); 1681 for ( size_t i = 0; i < 2; ++i ) 1682 { 1683 VULKAN_HPP_HASH_COMBINE( seed, imageBlit2.srcOffsets[i] ); 1684 } 1685 VULKAN_HPP_HASH_COMBINE( seed, imageBlit2.dstSubresource ); 1686 for ( size_t i = 0; i < 2; ++i ) 1687 { 1688 VULKAN_HPP_HASH_COMBINE( seed, imageBlit2.dstOffsets[i] ); 1689 } 1690 return seed; 1691 } 1692 }; 1693 1694 template <> 1695 struct hash<VULKAN_HPP_NAMESPACE::BlitImageInfo2> 1696 { operator ()std::hash1697 std::size_t operator()( VULKAN_HPP_NAMESPACE::BlitImageInfo2 const & blitImageInfo2 ) const VULKAN_HPP_NOEXCEPT 1698 { 1699 std::size_t seed = 0; 1700 VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.sType ); 1701 VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.pNext ); 1702 VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.srcImage ); 1703 VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.srcImageLayout ); 1704 VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.dstImage ); 1705 VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.dstImageLayout ); 1706 VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.regionCount ); 1707 VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.pRegions ); 1708 VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.filter ); 1709 return seed; 1710 } 1711 }; 1712 1713 template <> 1714 struct hash<VULKAN_HPP_NAMESPACE::BufferCaptureDescriptorDataInfoEXT> 1715 { operator ()std::hash1716 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCaptureDescriptorDataInfoEXT const & bufferCaptureDescriptorDataInfoEXT ) const VULKAN_HPP_NOEXCEPT 1717 { 1718 std::size_t seed = 0; 1719 VULKAN_HPP_HASH_COMBINE( seed, bufferCaptureDescriptorDataInfoEXT.sType ); 1720 VULKAN_HPP_HASH_COMBINE( seed, bufferCaptureDescriptorDataInfoEXT.pNext ); 1721 VULKAN_HPP_HASH_COMBINE( seed, bufferCaptureDescriptorDataInfoEXT.buffer ); 1722 return seed; 1723 } 1724 }; 1725 1726 # if defined( VK_USE_PLATFORM_FUCHSIA ) 1727 template <> 1728 struct hash<VULKAN_HPP_NAMESPACE::BufferCollectionBufferCreateInfoFUCHSIA> 1729 { 1730 std::size_t operator ()std::hash1731 operator()( VULKAN_HPP_NAMESPACE::BufferCollectionBufferCreateInfoFUCHSIA const & bufferCollectionBufferCreateInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT 1732 { 1733 std::size_t seed = 0; 1734 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionBufferCreateInfoFUCHSIA.sType ); 1735 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionBufferCreateInfoFUCHSIA.pNext ); 1736 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionBufferCreateInfoFUCHSIA.collection ); 1737 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionBufferCreateInfoFUCHSIA.index ); 1738 return seed; 1739 } 1740 }; 1741 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 1742 1743 # if defined( VK_USE_PLATFORM_FUCHSIA ) 1744 template <> 1745 struct hash<VULKAN_HPP_NAMESPACE::BufferCollectionConstraintsInfoFUCHSIA> 1746 { 1747 std::size_t operator ()std::hash1748 operator()( VULKAN_HPP_NAMESPACE::BufferCollectionConstraintsInfoFUCHSIA const & bufferCollectionConstraintsInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT 1749 { 1750 std::size_t seed = 0; 1751 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionConstraintsInfoFUCHSIA.sType ); 1752 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionConstraintsInfoFUCHSIA.pNext ); 1753 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionConstraintsInfoFUCHSIA.minBufferCount ); 1754 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionConstraintsInfoFUCHSIA.maxBufferCount ); 1755 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionConstraintsInfoFUCHSIA.minBufferCountForCamping ); 1756 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionConstraintsInfoFUCHSIA.minBufferCountForDedicatedSlack ); 1757 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionConstraintsInfoFUCHSIA.minBufferCountForSharedSlack ); 1758 return seed; 1759 } 1760 }; 1761 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 1762 1763 # if defined( VK_USE_PLATFORM_FUCHSIA ) 1764 template <> 1765 struct hash<VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA> 1766 { operator ()std::hash1767 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA const & bufferCollectionCreateInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT 1768 { 1769 std::size_t seed = 0; 1770 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionCreateInfoFUCHSIA.sType ); 1771 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionCreateInfoFUCHSIA.pNext ); 1772 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionCreateInfoFUCHSIA.collectionToken ); 1773 return seed; 1774 } 1775 }; 1776 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 1777 1778 # if defined( VK_USE_PLATFORM_FUCHSIA ) 1779 template <> 1780 struct hash<VULKAN_HPP_NAMESPACE::BufferCollectionImageCreateInfoFUCHSIA> 1781 { 1782 std::size_t operator ()std::hash1783 operator()( VULKAN_HPP_NAMESPACE::BufferCollectionImageCreateInfoFUCHSIA const & bufferCollectionImageCreateInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT 1784 { 1785 std::size_t seed = 0; 1786 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionImageCreateInfoFUCHSIA.sType ); 1787 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionImageCreateInfoFUCHSIA.pNext ); 1788 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionImageCreateInfoFUCHSIA.collection ); 1789 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionImageCreateInfoFUCHSIA.index ); 1790 return seed; 1791 } 1792 }; 1793 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 1794 1795 # if defined( VK_USE_PLATFORM_FUCHSIA ) 1796 template <> 1797 struct hash<VULKAN_HPP_NAMESPACE::SysmemColorSpaceFUCHSIA> 1798 { operator ()std::hash1799 std::size_t operator()( VULKAN_HPP_NAMESPACE::SysmemColorSpaceFUCHSIA const & sysmemColorSpaceFUCHSIA ) const VULKAN_HPP_NOEXCEPT 1800 { 1801 std::size_t seed = 0; 1802 VULKAN_HPP_HASH_COMBINE( seed, sysmemColorSpaceFUCHSIA.sType ); 1803 VULKAN_HPP_HASH_COMBINE( seed, sysmemColorSpaceFUCHSIA.pNext ); 1804 VULKAN_HPP_HASH_COMBINE( seed, sysmemColorSpaceFUCHSIA.colorSpace ); 1805 return seed; 1806 } 1807 }; 1808 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 1809 1810 # if defined( VK_USE_PLATFORM_FUCHSIA ) 1811 template <> 1812 struct hash<VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA> 1813 { operator ()std::hash1814 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA const & bufferCollectionPropertiesFUCHSIA ) const VULKAN_HPP_NOEXCEPT 1815 { 1816 std::size_t seed = 0; 1817 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.sType ); 1818 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.pNext ); 1819 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.memoryTypeBits ); 1820 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.bufferCount ); 1821 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.createInfoIndex ); 1822 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.sysmemPixelFormat ); 1823 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.formatFeatures ); 1824 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.sysmemColorSpaceIndex ); 1825 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.samplerYcbcrConversionComponents ); 1826 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.suggestedYcbcrModel ); 1827 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.suggestedYcbcrRange ); 1828 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.suggestedXChromaOffset ); 1829 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.suggestedYChromaOffset ); 1830 return seed; 1831 } 1832 }; 1833 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 1834 1835 template <> 1836 struct hash<VULKAN_HPP_NAMESPACE::BufferCreateInfo> 1837 { operator ()std::hash1838 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCreateInfo const & bufferCreateInfo ) const VULKAN_HPP_NOEXCEPT 1839 { 1840 std::size_t seed = 0; 1841 VULKAN_HPP_HASH_COMBINE( seed, bufferCreateInfo.sType ); 1842 VULKAN_HPP_HASH_COMBINE( seed, bufferCreateInfo.pNext ); 1843 VULKAN_HPP_HASH_COMBINE( seed, bufferCreateInfo.flags ); 1844 VULKAN_HPP_HASH_COMBINE( seed, bufferCreateInfo.size ); 1845 VULKAN_HPP_HASH_COMBINE( seed, bufferCreateInfo.usage ); 1846 VULKAN_HPP_HASH_COMBINE( seed, bufferCreateInfo.sharingMode ); 1847 VULKAN_HPP_HASH_COMBINE( seed, bufferCreateInfo.queueFamilyIndexCount ); 1848 VULKAN_HPP_HASH_COMBINE( seed, bufferCreateInfo.pQueueFamilyIndices ); 1849 return seed; 1850 } 1851 }; 1852 1853 # if defined( VK_USE_PLATFORM_FUCHSIA ) 1854 template <> 1855 struct hash<VULKAN_HPP_NAMESPACE::BufferConstraintsInfoFUCHSIA> 1856 { operator ()std::hash1857 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferConstraintsInfoFUCHSIA const & bufferConstraintsInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT 1858 { 1859 std::size_t seed = 0; 1860 VULKAN_HPP_HASH_COMBINE( seed, bufferConstraintsInfoFUCHSIA.sType ); 1861 VULKAN_HPP_HASH_COMBINE( seed, bufferConstraintsInfoFUCHSIA.pNext ); 1862 VULKAN_HPP_HASH_COMBINE( seed, bufferConstraintsInfoFUCHSIA.createInfo ); 1863 VULKAN_HPP_HASH_COMBINE( seed, bufferConstraintsInfoFUCHSIA.requiredFormatFeatures ); 1864 VULKAN_HPP_HASH_COMBINE( seed, bufferConstraintsInfoFUCHSIA.bufferCollectionConstraints ); 1865 return seed; 1866 } 1867 }; 1868 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 1869 1870 template <> 1871 struct hash<VULKAN_HPP_NAMESPACE::BufferCopy> 1872 { operator ()std::hash1873 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCopy const & bufferCopy ) const VULKAN_HPP_NOEXCEPT 1874 { 1875 std::size_t seed = 0; 1876 VULKAN_HPP_HASH_COMBINE( seed, bufferCopy.srcOffset ); 1877 VULKAN_HPP_HASH_COMBINE( seed, bufferCopy.dstOffset ); 1878 VULKAN_HPP_HASH_COMBINE( seed, bufferCopy.size ); 1879 return seed; 1880 } 1881 }; 1882 1883 template <> 1884 struct hash<VULKAN_HPP_NAMESPACE::BufferCopy2> 1885 { operator ()std::hash1886 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCopy2 const & bufferCopy2 ) const VULKAN_HPP_NOEXCEPT 1887 { 1888 std::size_t seed = 0; 1889 VULKAN_HPP_HASH_COMBINE( seed, bufferCopy2.sType ); 1890 VULKAN_HPP_HASH_COMBINE( seed, bufferCopy2.pNext ); 1891 VULKAN_HPP_HASH_COMBINE( seed, bufferCopy2.srcOffset ); 1892 VULKAN_HPP_HASH_COMBINE( seed, bufferCopy2.dstOffset ); 1893 VULKAN_HPP_HASH_COMBINE( seed, bufferCopy2.size ); 1894 return seed; 1895 } 1896 }; 1897 1898 template <> 1899 struct hash<VULKAN_HPP_NAMESPACE::BufferDeviceAddressCreateInfoEXT> 1900 { operator ()std::hash1901 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferDeviceAddressCreateInfoEXT const & bufferDeviceAddressCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 1902 { 1903 std::size_t seed = 0; 1904 VULKAN_HPP_HASH_COMBINE( seed, bufferDeviceAddressCreateInfoEXT.sType ); 1905 VULKAN_HPP_HASH_COMBINE( seed, bufferDeviceAddressCreateInfoEXT.pNext ); 1906 VULKAN_HPP_HASH_COMBINE( seed, bufferDeviceAddressCreateInfoEXT.deviceAddress ); 1907 return seed; 1908 } 1909 }; 1910 1911 template <> 1912 struct hash<VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo> 1913 { operator ()std::hash1914 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo const & bufferDeviceAddressInfo ) const VULKAN_HPP_NOEXCEPT 1915 { 1916 std::size_t seed = 0; 1917 VULKAN_HPP_HASH_COMBINE( seed, bufferDeviceAddressInfo.sType ); 1918 VULKAN_HPP_HASH_COMBINE( seed, bufferDeviceAddressInfo.pNext ); 1919 VULKAN_HPP_HASH_COMBINE( seed, bufferDeviceAddressInfo.buffer ); 1920 return seed; 1921 } 1922 }; 1923 1924 template <> 1925 struct hash<VULKAN_HPP_NAMESPACE::BufferImageCopy> 1926 { operator ()std::hash1927 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferImageCopy const & bufferImageCopy ) const VULKAN_HPP_NOEXCEPT 1928 { 1929 std::size_t seed = 0; 1930 VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy.bufferOffset ); 1931 VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy.bufferRowLength ); 1932 VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy.bufferImageHeight ); 1933 VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy.imageSubresource ); 1934 VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy.imageOffset ); 1935 VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy.imageExtent ); 1936 return seed; 1937 } 1938 }; 1939 1940 template <> 1941 struct hash<VULKAN_HPP_NAMESPACE::BufferImageCopy2> 1942 { operator ()std::hash1943 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferImageCopy2 const & bufferImageCopy2 ) const VULKAN_HPP_NOEXCEPT 1944 { 1945 std::size_t seed = 0; 1946 VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy2.sType ); 1947 VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy2.pNext ); 1948 VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy2.bufferOffset ); 1949 VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy2.bufferRowLength ); 1950 VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy2.bufferImageHeight ); 1951 VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy2.imageSubresource ); 1952 VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy2.imageOffset ); 1953 VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy2.imageExtent ); 1954 return seed; 1955 } 1956 }; 1957 1958 template <> 1959 struct hash<VULKAN_HPP_NAMESPACE::BufferMemoryBarrier> 1960 { operator ()std::hash1961 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferMemoryBarrier const & bufferMemoryBarrier ) const VULKAN_HPP_NOEXCEPT 1962 { 1963 std::size_t seed = 0; 1964 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.sType ); 1965 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.pNext ); 1966 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.srcAccessMask ); 1967 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.dstAccessMask ); 1968 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.srcQueueFamilyIndex ); 1969 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.dstQueueFamilyIndex ); 1970 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.buffer ); 1971 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.offset ); 1972 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.size ); 1973 return seed; 1974 } 1975 }; 1976 1977 template <> 1978 struct hash<VULKAN_HPP_NAMESPACE::BufferMemoryBarrier2> 1979 { operator ()std::hash1980 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferMemoryBarrier2 const & bufferMemoryBarrier2 ) const VULKAN_HPP_NOEXCEPT 1981 { 1982 std::size_t seed = 0; 1983 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.sType ); 1984 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.pNext ); 1985 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.srcStageMask ); 1986 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.srcAccessMask ); 1987 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.dstStageMask ); 1988 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.dstAccessMask ); 1989 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.srcQueueFamilyIndex ); 1990 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.dstQueueFamilyIndex ); 1991 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.buffer ); 1992 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.offset ); 1993 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.size ); 1994 return seed; 1995 } 1996 }; 1997 1998 template <> 1999 struct hash<VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2> 2000 { operator ()std::hash2001 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 const & bufferMemoryRequirementsInfo2 ) const VULKAN_HPP_NOEXCEPT 2002 { 2003 std::size_t seed = 0; 2004 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryRequirementsInfo2.sType ); 2005 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryRequirementsInfo2.pNext ); 2006 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryRequirementsInfo2.buffer ); 2007 return seed; 2008 } 2009 }; 2010 2011 template <> 2012 struct hash<VULKAN_HPP_NAMESPACE::BufferOpaqueCaptureAddressCreateInfo> 2013 { operator ()std::hash2014 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferOpaqueCaptureAddressCreateInfo const & bufferOpaqueCaptureAddressCreateInfo ) const VULKAN_HPP_NOEXCEPT 2015 { 2016 std::size_t seed = 0; 2017 VULKAN_HPP_HASH_COMBINE( seed, bufferOpaqueCaptureAddressCreateInfo.sType ); 2018 VULKAN_HPP_HASH_COMBINE( seed, bufferOpaqueCaptureAddressCreateInfo.pNext ); 2019 VULKAN_HPP_HASH_COMBINE( seed, bufferOpaqueCaptureAddressCreateInfo.opaqueCaptureAddress ); 2020 return seed; 2021 } 2022 }; 2023 2024 template <> 2025 struct hash<VULKAN_HPP_NAMESPACE::BufferUsageFlags2CreateInfoKHR> 2026 { operator ()std::hash2027 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferUsageFlags2CreateInfoKHR const & bufferUsageFlags2CreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 2028 { 2029 std::size_t seed = 0; 2030 VULKAN_HPP_HASH_COMBINE( seed, bufferUsageFlags2CreateInfoKHR.sType ); 2031 VULKAN_HPP_HASH_COMBINE( seed, bufferUsageFlags2CreateInfoKHR.pNext ); 2032 VULKAN_HPP_HASH_COMBINE( seed, bufferUsageFlags2CreateInfoKHR.usage ); 2033 return seed; 2034 } 2035 }; 2036 2037 template <> 2038 struct hash<VULKAN_HPP_NAMESPACE::BufferViewCreateInfo> 2039 { operator ()std::hash2040 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferViewCreateInfo const & bufferViewCreateInfo ) const VULKAN_HPP_NOEXCEPT 2041 { 2042 std::size_t seed = 0; 2043 VULKAN_HPP_HASH_COMBINE( seed, bufferViewCreateInfo.sType ); 2044 VULKAN_HPP_HASH_COMBINE( seed, bufferViewCreateInfo.pNext ); 2045 VULKAN_HPP_HASH_COMBINE( seed, bufferViewCreateInfo.flags ); 2046 VULKAN_HPP_HASH_COMBINE( seed, bufferViewCreateInfo.buffer ); 2047 VULKAN_HPP_HASH_COMBINE( seed, bufferViewCreateInfo.format ); 2048 VULKAN_HPP_HASH_COMBINE( seed, bufferViewCreateInfo.offset ); 2049 VULKAN_HPP_HASH_COMBINE( seed, bufferViewCreateInfo.range ); 2050 return seed; 2051 } 2052 }; 2053 2054 template <> 2055 struct hash<VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR> 2056 { operator ()std::hash2057 std::size_t operator()( VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR const & calibratedTimestampInfoKHR ) const VULKAN_HPP_NOEXCEPT 2058 { 2059 std::size_t seed = 0; 2060 VULKAN_HPP_HASH_COMBINE( seed, calibratedTimestampInfoKHR.sType ); 2061 VULKAN_HPP_HASH_COMBINE( seed, calibratedTimestampInfoKHR.pNext ); 2062 VULKAN_HPP_HASH_COMBINE( seed, calibratedTimestampInfoKHR.timeDomain ); 2063 return seed; 2064 } 2065 }; 2066 2067 template <> 2068 struct hash<VULKAN_HPP_NAMESPACE::CheckpointData2NV> 2069 { operator ()std::hash2070 std::size_t operator()( VULKAN_HPP_NAMESPACE::CheckpointData2NV const & checkpointData2NV ) const VULKAN_HPP_NOEXCEPT 2071 { 2072 std::size_t seed = 0; 2073 VULKAN_HPP_HASH_COMBINE( seed, checkpointData2NV.sType ); 2074 VULKAN_HPP_HASH_COMBINE( seed, checkpointData2NV.pNext ); 2075 VULKAN_HPP_HASH_COMBINE( seed, checkpointData2NV.stage ); 2076 VULKAN_HPP_HASH_COMBINE( seed, checkpointData2NV.pCheckpointMarker ); 2077 return seed; 2078 } 2079 }; 2080 2081 template <> 2082 struct hash<VULKAN_HPP_NAMESPACE::CheckpointDataNV> 2083 { operator ()std::hash2084 std::size_t operator()( VULKAN_HPP_NAMESPACE::CheckpointDataNV const & checkpointDataNV ) const VULKAN_HPP_NOEXCEPT 2085 { 2086 std::size_t seed = 0; 2087 VULKAN_HPP_HASH_COMBINE( seed, checkpointDataNV.sType ); 2088 VULKAN_HPP_HASH_COMBINE( seed, checkpointDataNV.pNext ); 2089 VULKAN_HPP_HASH_COMBINE( seed, checkpointDataNV.stage ); 2090 VULKAN_HPP_HASH_COMBINE( seed, checkpointDataNV.pCheckpointMarker ); 2091 return seed; 2092 } 2093 }; 2094 2095 template <> 2096 struct hash<VULKAN_HPP_NAMESPACE::ClearDepthStencilValue> 2097 { operator ()std::hash2098 std::size_t operator()( VULKAN_HPP_NAMESPACE::ClearDepthStencilValue const & clearDepthStencilValue ) const VULKAN_HPP_NOEXCEPT 2099 { 2100 std::size_t seed = 0; 2101 VULKAN_HPP_HASH_COMBINE( seed, clearDepthStencilValue.depth ); 2102 VULKAN_HPP_HASH_COMBINE( seed, clearDepthStencilValue.stencil ); 2103 return seed; 2104 } 2105 }; 2106 2107 template <> 2108 struct hash<VULKAN_HPP_NAMESPACE::ClearRect> 2109 { operator ()std::hash2110 std::size_t operator()( VULKAN_HPP_NAMESPACE::ClearRect const & clearRect ) const VULKAN_HPP_NOEXCEPT 2111 { 2112 std::size_t seed = 0; 2113 VULKAN_HPP_HASH_COMBINE( seed, clearRect.rect ); 2114 VULKAN_HPP_HASH_COMBINE( seed, clearRect.baseArrayLayer ); 2115 VULKAN_HPP_HASH_COMBINE( seed, clearRect.layerCount ); 2116 return seed; 2117 } 2118 }; 2119 2120 template <> 2121 struct hash<VULKAN_HPP_NAMESPACE::CoarseSampleLocationNV> 2122 { operator ()std::hash2123 std::size_t operator()( VULKAN_HPP_NAMESPACE::CoarseSampleLocationNV const & coarseSampleLocationNV ) const VULKAN_HPP_NOEXCEPT 2124 { 2125 std::size_t seed = 0; 2126 VULKAN_HPP_HASH_COMBINE( seed, coarseSampleLocationNV.pixelX ); 2127 VULKAN_HPP_HASH_COMBINE( seed, coarseSampleLocationNV.pixelY ); 2128 VULKAN_HPP_HASH_COMBINE( seed, coarseSampleLocationNV.sample ); 2129 return seed; 2130 } 2131 }; 2132 2133 template <> 2134 struct hash<VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV> 2135 { operator ()std::hash2136 std::size_t operator()( VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV const & coarseSampleOrderCustomNV ) const VULKAN_HPP_NOEXCEPT 2137 { 2138 std::size_t seed = 0; 2139 VULKAN_HPP_HASH_COMBINE( seed, coarseSampleOrderCustomNV.shadingRate ); 2140 VULKAN_HPP_HASH_COMBINE( seed, coarseSampleOrderCustomNV.sampleCount ); 2141 VULKAN_HPP_HASH_COMBINE( seed, coarseSampleOrderCustomNV.sampleLocationCount ); 2142 VULKAN_HPP_HASH_COMBINE( seed, coarseSampleOrderCustomNV.pSampleLocations ); 2143 return seed; 2144 } 2145 }; 2146 2147 template <> 2148 struct hash<VULKAN_HPP_NAMESPACE::ColorBlendAdvancedEXT> 2149 { operator ()std::hash2150 std::size_t operator()( VULKAN_HPP_NAMESPACE::ColorBlendAdvancedEXT const & colorBlendAdvancedEXT ) const VULKAN_HPP_NOEXCEPT 2151 { 2152 std::size_t seed = 0; 2153 VULKAN_HPP_HASH_COMBINE( seed, colorBlendAdvancedEXT.advancedBlendOp ); 2154 VULKAN_HPP_HASH_COMBINE( seed, colorBlendAdvancedEXT.srcPremultiplied ); 2155 VULKAN_HPP_HASH_COMBINE( seed, colorBlendAdvancedEXT.dstPremultiplied ); 2156 VULKAN_HPP_HASH_COMBINE( seed, colorBlendAdvancedEXT.blendOverlap ); 2157 VULKAN_HPP_HASH_COMBINE( seed, colorBlendAdvancedEXT.clampResults ); 2158 return seed; 2159 } 2160 }; 2161 2162 template <> 2163 struct hash<VULKAN_HPP_NAMESPACE::ColorBlendEquationEXT> 2164 { operator ()std::hash2165 std::size_t operator()( VULKAN_HPP_NAMESPACE::ColorBlendEquationEXT const & colorBlendEquationEXT ) const VULKAN_HPP_NOEXCEPT 2166 { 2167 std::size_t seed = 0; 2168 VULKAN_HPP_HASH_COMBINE( seed, colorBlendEquationEXT.srcColorBlendFactor ); 2169 VULKAN_HPP_HASH_COMBINE( seed, colorBlendEquationEXT.dstColorBlendFactor ); 2170 VULKAN_HPP_HASH_COMBINE( seed, colorBlendEquationEXT.colorBlendOp ); 2171 VULKAN_HPP_HASH_COMBINE( seed, colorBlendEquationEXT.srcAlphaBlendFactor ); 2172 VULKAN_HPP_HASH_COMBINE( seed, colorBlendEquationEXT.dstAlphaBlendFactor ); 2173 VULKAN_HPP_HASH_COMBINE( seed, colorBlendEquationEXT.alphaBlendOp ); 2174 return seed; 2175 } 2176 }; 2177 2178 template <> 2179 struct hash<VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo> 2180 { operator ()std::hash2181 std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo const & commandBufferAllocateInfo ) const VULKAN_HPP_NOEXCEPT 2182 { 2183 std::size_t seed = 0; 2184 VULKAN_HPP_HASH_COMBINE( seed, commandBufferAllocateInfo.sType ); 2185 VULKAN_HPP_HASH_COMBINE( seed, commandBufferAllocateInfo.pNext ); 2186 VULKAN_HPP_HASH_COMBINE( seed, commandBufferAllocateInfo.commandPool ); 2187 VULKAN_HPP_HASH_COMBINE( seed, commandBufferAllocateInfo.level ); 2188 VULKAN_HPP_HASH_COMBINE( seed, commandBufferAllocateInfo.commandBufferCount ); 2189 return seed; 2190 } 2191 }; 2192 2193 template <> 2194 struct hash<VULKAN_HPP_NAMESPACE::CommandBufferInheritanceInfo> 2195 { operator ()std::hash2196 std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceInfo const & commandBufferInheritanceInfo ) const VULKAN_HPP_NOEXCEPT 2197 { 2198 std::size_t seed = 0; 2199 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceInfo.sType ); 2200 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceInfo.pNext ); 2201 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceInfo.renderPass ); 2202 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceInfo.subpass ); 2203 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceInfo.framebuffer ); 2204 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceInfo.occlusionQueryEnable ); 2205 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceInfo.queryFlags ); 2206 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceInfo.pipelineStatistics ); 2207 return seed; 2208 } 2209 }; 2210 2211 template <> 2212 struct hash<VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo> 2213 { operator ()std::hash2214 std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo const & commandBufferBeginInfo ) const VULKAN_HPP_NOEXCEPT 2215 { 2216 std::size_t seed = 0; 2217 VULKAN_HPP_HASH_COMBINE( seed, commandBufferBeginInfo.sType ); 2218 VULKAN_HPP_HASH_COMBINE( seed, commandBufferBeginInfo.pNext ); 2219 VULKAN_HPP_HASH_COMBINE( seed, commandBufferBeginInfo.flags ); 2220 VULKAN_HPP_HASH_COMBINE( seed, commandBufferBeginInfo.pInheritanceInfo ); 2221 return seed; 2222 } 2223 }; 2224 2225 template <> 2226 struct hash<VULKAN_HPP_NAMESPACE::CommandBufferInheritanceConditionalRenderingInfoEXT> 2227 { 2228 std::size_t operator ()std::hash2229 operator()( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceConditionalRenderingInfoEXT const & commandBufferInheritanceConditionalRenderingInfoEXT ) const 2230 VULKAN_HPP_NOEXCEPT 2231 { 2232 std::size_t seed = 0; 2233 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceConditionalRenderingInfoEXT.sType ); 2234 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceConditionalRenderingInfoEXT.pNext ); 2235 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceConditionalRenderingInfoEXT.conditionalRenderingEnable ); 2236 return seed; 2237 } 2238 }; 2239 2240 template <> 2241 struct hash<VULKAN_HPP_NAMESPACE::CommandBufferInheritanceRenderPassTransformInfoQCOM> 2242 { 2243 std::size_t operator ()std::hash2244 operator()( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceRenderPassTransformInfoQCOM const & commandBufferInheritanceRenderPassTransformInfoQCOM ) const 2245 VULKAN_HPP_NOEXCEPT 2246 { 2247 std::size_t seed = 0; 2248 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderPassTransformInfoQCOM.sType ); 2249 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderPassTransformInfoQCOM.pNext ); 2250 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderPassTransformInfoQCOM.transform ); 2251 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderPassTransformInfoQCOM.renderArea ); 2252 return seed; 2253 } 2254 }; 2255 2256 template <> 2257 struct hash<VULKAN_HPP_NAMESPACE::CommandBufferInheritanceRenderingInfo> 2258 { 2259 std::size_t operator ()std::hash2260 operator()( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceRenderingInfo const & commandBufferInheritanceRenderingInfo ) const VULKAN_HPP_NOEXCEPT 2261 { 2262 std::size_t seed = 0; 2263 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.sType ); 2264 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.pNext ); 2265 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.flags ); 2266 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.viewMask ); 2267 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.colorAttachmentCount ); 2268 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.pColorAttachmentFormats ); 2269 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.depthAttachmentFormat ); 2270 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.stencilAttachmentFormat ); 2271 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.rasterizationSamples ); 2272 return seed; 2273 } 2274 }; 2275 2276 template <> 2277 struct hash<VULKAN_HPP_NAMESPACE::Viewport> 2278 { operator ()std::hash2279 std::size_t operator()( VULKAN_HPP_NAMESPACE::Viewport const & viewport ) const VULKAN_HPP_NOEXCEPT 2280 { 2281 std::size_t seed = 0; 2282 VULKAN_HPP_HASH_COMBINE( seed, viewport.x ); 2283 VULKAN_HPP_HASH_COMBINE( seed, viewport.y ); 2284 VULKAN_HPP_HASH_COMBINE( seed, viewport.width ); 2285 VULKAN_HPP_HASH_COMBINE( seed, viewport.height ); 2286 VULKAN_HPP_HASH_COMBINE( seed, viewport.minDepth ); 2287 VULKAN_HPP_HASH_COMBINE( seed, viewport.maxDepth ); 2288 return seed; 2289 } 2290 }; 2291 2292 template <> 2293 struct hash<VULKAN_HPP_NAMESPACE::CommandBufferInheritanceViewportScissorInfoNV> 2294 { operator ()std::hash2295 std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceViewportScissorInfoNV const & commandBufferInheritanceViewportScissorInfoNV ) const 2296 VULKAN_HPP_NOEXCEPT 2297 { 2298 std::size_t seed = 0; 2299 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceViewportScissorInfoNV.sType ); 2300 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceViewportScissorInfoNV.pNext ); 2301 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceViewportScissorInfoNV.viewportScissor2D ); 2302 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceViewportScissorInfoNV.viewportDepthCount ); 2303 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceViewportScissorInfoNV.pViewportDepths ); 2304 return seed; 2305 } 2306 }; 2307 2308 template <> 2309 struct hash<VULKAN_HPP_NAMESPACE::CommandBufferSubmitInfo> 2310 { operator ()std::hash2311 std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBufferSubmitInfo const & commandBufferSubmitInfo ) const VULKAN_HPP_NOEXCEPT 2312 { 2313 std::size_t seed = 0; 2314 VULKAN_HPP_HASH_COMBINE( seed, commandBufferSubmitInfo.sType ); 2315 VULKAN_HPP_HASH_COMBINE( seed, commandBufferSubmitInfo.pNext ); 2316 VULKAN_HPP_HASH_COMBINE( seed, commandBufferSubmitInfo.commandBuffer ); 2317 VULKAN_HPP_HASH_COMBINE( seed, commandBufferSubmitInfo.deviceMask ); 2318 return seed; 2319 } 2320 }; 2321 2322 template <> 2323 struct hash<VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo> 2324 { operator ()std::hash2325 std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo const & commandPoolCreateInfo ) const VULKAN_HPP_NOEXCEPT 2326 { 2327 std::size_t seed = 0; 2328 VULKAN_HPP_HASH_COMBINE( seed, commandPoolCreateInfo.sType ); 2329 VULKAN_HPP_HASH_COMBINE( seed, commandPoolCreateInfo.pNext ); 2330 VULKAN_HPP_HASH_COMBINE( seed, commandPoolCreateInfo.flags ); 2331 VULKAN_HPP_HASH_COMBINE( seed, commandPoolCreateInfo.queueFamilyIndex ); 2332 return seed; 2333 } 2334 }; 2335 2336 template <> 2337 struct hash<VULKAN_HPP_NAMESPACE::SpecializationMapEntry> 2338 { operator ()std::hash2339 std::size_t operator()( VULKAN_HPP_NAMESPACE::SpecializationMapEntry const & specializationMapEntry ) const VULKAN_HPP_NOEXCEPT 2340 { 2341 std::size_t seed = 0; 2342 VULKAN_HPP_HASH_COMBINE( seed, specializationMapEntry.constantID ); 2343 VULKAN_HPP_HASH_COMBINE( seed, specializationMapEntry.offset ); 2344 VULKAN_HPP_HASH_COMBINE( seed, specializationMapEntry.size ); 2345 return seed; 2346 } 2347 }; 2348 2349 template <> 2350 struct hash<VULKAN_HPP_NAMESPACE::SpecializationInfo> 2351 { operator ()std::hash2352 std::size_t operator()( VULKAN_HPP_NAMESPACE::SpecializationInfo const & specializationInfo ) const VULKAN_HPP_NOEXCEPT 2353 { 2354 std::size_t seed = 0; 2355 VULKAN_HPP_HASH_COMBINE( seed, specializationInfo.mapEntryCount ); 2356 VULKAN_HPP_HASH_COMBINE( seed, specializationInfo.pMapEntries ); 2357 VULKAN_HPP_HASH_COMBINE( seed, specializationInfo.dataSize ); 2358 VULKAN_HPP_HASH_COMBINE( seed, specializationInfo.pData ); 2359 return seed; 2360 } 2361 }; 2362 2363 template <> 2364 struct hash<VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo> 2365 { operator ()std::hash2366 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo const & pipelineShaderStageCreateInfo ) const VULKAN_HPP_NOEXCEPT 2367 { 2368 std::size_t seed = 0; 2369 VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageCreateInfo.sType ); 2370 VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageCreateInfo.pNext ); 2371 VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageCreateInfo.flags ); 2372 VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageCreateInfo.stage ); 2373 VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageCreateInfo.module ); 2374 for ( const char * p = pipelineShaderStageCreateInfo.pName; *p != '\0'; ++p ) 2375 { 2376 VULKAN_HPP_HASH_COMBINE( seed, *p ); 2377 } 2378 VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageCreateInfo.pSpecializationInfo ); 2379 return seed; 2380 } 2381 }; 2382 2383 template <> 2384 struct hash<VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> 2385 { operator ()std::hash2386 std::size_t operator()( VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo const & computePipelineCreateInfo ) const VULKAN_HPP_NOEXCEPT 2387 { 2388 std::size_t seed = 0; 2389 VULKAN_HPP_HASH_COMBINE( seed, computePipelineCreateInfo.sType ); 2390 VULKAN_HPP_HASH_COMBINE( seed, computePipelineCreateInfo.pNext ); 2391 VULKAN_HPP_HASH_COMBINE( seed, computePipelineCreateInfo.flags ); 2392 VULKAN_HPP_HASH_COMBINE( seed, computePipelineCreateInfo.stage ); 2393 VULKAN_HPP_HASH_COMBINE( seed, computePipelineCreateInfo.layout ); 2394 VULKAN_HPP_HASH_COMBINE( seed, computePipelineCreateInfo.basePipelineHandle ); 2395 VULKAN_HPP_HASH_COMBINE( seed, computePipelineCreateInfo.basePipelineIndex ); 2396 return seed; 2397 } 2398 }; 2399 2400 template <> 2401 struct hash<VULKAN_HPP_NAMESPACE::ComputePipelineIndirectBufferInfoNV> 2402 { operator ()std::hash2403 std::size_t operator()( VULKAN_HPP_NAMESPACE::ComputePipelineIndirectBufferInfoNV const & computePipelineIndirectBufferInfoNV ) const VULKAN_HPP_NOEXCEPT 2404 { 2405 std::size_t seed = 0; 2406 VULKAN_HPP_HASH_COMBINE( seed, computePipelineIndirectBufferInfoNV.sType ); 2407 VULKAN_HPP_HASH_COMBINE( seed, computePipelineIndirectBufferInfoNV.pNext ); 2408 VULKAN_HPP_HASH_COMBINE( seed, computePipelineIndirectBufferInfoNV.deviceAddress ); 2409 VULKAN_HPP_HASH_COMBINE( seed, computePipelineIndirectBufferInfoNV.size ); 2410 VULKAN_HPP_HASH_COMBINE( seed, computePipelineIndirectBufferInfoNV.pipelineDeviceAddressCaptureReplay ); 2411 return seed; 2412 } 2413 }; 2414 2415 template <> 2416 struct hash<VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfoEXT> 2417 { operator ()std::hash2418 std::size_t operator()( VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfoEXT const & conditionalRenderingBeginInfoEXT ) const VULKAN_HPP_NOEXCEPT 2419 { 2420 std::size_t seed = 0; 2421 VULKAN_HPP_HASH_COMBINE( seed, conditionalRenderingBeginInfoEXT.sType ); 2422 VULKAN_HPP_HASH_COMBINE( seed, conditionalRenderingBeginInfoEXT.pNext ); 2423 VULKAN_HPP_HASH_COMBINE( seed, conditionalRenderingBeginInfoEXT.buffer ); 2424 VULKAN_HPP_HASH_COMBINE( seed, conditionalRenderingBeginInfoEXT.offset ); 2425 VULKAN_HPP_HASH_COMBINE( seed, conditionalRenderingBeginInfoEXT.flags ); 2426 return seed; 2427 } 2428 }; 2429 2430 template <> 2431 struct hash<VULKAN_HPP_NAMESPACE::ConformanceVersion> 2432 { operator ()std::hash2433 std::size_t operator()( VULKAN_HPP_NAMESPACE::ConformanceVersion const & conformanceVersion ) const VULKAN_HPP_NOEXCEPT 2434 { 2435 std::size_t seed = 0; 2436 VULKAN_HPP_HASH_COMBINE( seed, conformanceVersion.major ); 2437 VULKAN_HPP_HASH_COMBINE( seed, conformanceVersion.minor ); 2438 VULKAN_HPP_HASH_COMBINE( seed, conformanceVersion.subminor ); 2439 VULKAN_HPP_HASH_COMBINE( seed, conformanceVersion.patch ); 2440 return seed; 2441 } 2442 }; 2443 2444 template <> 2445 struct hash<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR> 2446 { operator ()std::hash2447 std::size_t operator()( VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR const & cooperativeMatrixPropertiesKHR ) const VULKAN_HPP_NOEXCEPT 2448 { 2449 std::size_t seed = 0; 2450 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.sType ); 2451 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.pNext ); 2452 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.MSize ); 2453 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.NSize ); 2454 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.KSize ); 2455 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.AType ); 2456 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.BType ); 2457 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.CType ); 2458 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.ResultType ); 2459 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.saturatingAccumulation ); 2460 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.scope ); 2461 return seed; 2462 } 2463 }; 2464 2465 template <> 2466 struct hash<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV> 2467 { operator ()std::hash2468 std::size_t operator()( VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV const & cooperativeMatrixPropertiesNV ) const VULKAN_HPP_NOEXCEPT 2469 { 2470 std::size_t seed = 0; 2471 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.sType ); 2472 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.pNext ); 2473 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.MSize ); 2474 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.NSize ); 2475 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.KSize ); 2476 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.AType ); 2477 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.BType ); 2478 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.CType ); 2479 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.DType ); 2480 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.scope ); 2481 return seed; 2482 } 2483 }; 2484 2485 template <> 2486 struct hash<VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR> 2487 { operator ()std::hash2488 std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR const & copyAccelerationStructureInfoKHR ) const VULKAN_HPP_NOEXCEPT 2489 { 2490 std::size_t seed = 0; 2491 VULKAN_HPP_HASH_COMBINE( seed, copyAccelerationStructureInfoKHR.sType ); 2492 VULKAN_HPP_HASH_COMBINE( seed, copyAccelerationStructureInfoKHR.pNext ); 2493 VULKAN_HPP_HASH_COMBINE( seed, copyAccelerationStructureInfoKHR.src ); 2494 VULKAN_HPP_HASH_COMBINE( seed, copyAccelerationStructureInfoKHR.dst ); 2495 VULKAN_HPP_HASH_COMBINE( seed, copyAccelerationStructureInfoKHR.mode ); 2496 return seed; 2497 } 2498 }; 2499 2500 template <> 2501 struct hash<VULKAN_HPP_NAMESPACE::CopyBufferInfo2> 2502 { operator ()std::hash2503 std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyBufferInfo2 const & copyBufferInfo2 ) const VULKAN_HPP_NOEXCEPT 2504 { 2505 std::size_t seed = 0; 2506 VULKAN_HPP_HASH_COMBINE( seed, copyBufferInfo2.sType ); 2507 VULKAN_HPP_HASH_COMBINE( seed, copyBufferInfo2.pNext ); 2508 VULKAN_HPP_HASH_COMBINE( seed, copyBufferInfo2.srcBuffer ); 2509 VULKAN_HPP_HASH_COMBINE( seed, copyBufferInfo2.dstBuffer ); 2510 VULKAN_HPP_HASH_COMBINE( seed, copyBufferInfo2.regionCount ); 2511 VULKAN_HPP_HASH_COMBINE( seed, copyBufferInfo2.pRegions ); 2512 return seed; 2513 } 2514 }; 2515 2516 template <> 2517 struct hash<VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2> 2518 { operator ()std::hash2519 std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 const & copyBufferToImageInfo2 ) const VULKAN_HPP_NOEXCEPT 2520 { 2521 std::size_t seed = 0; 2522 VULKAN_HPP_HASH_COMBINE( seed, copyBufferToImageInfo2.sType ); 2523 VULKAN_HPP_HASH_COMBINE( seed, copyBufferToImageInfo2.pNext ); 2524 VULKAN_HPP_HASH_COMBINE( seed, copyBufferToImageInfo2.srcBuffer ); 2525 VULKAN_HPP_HASH_COMBINE( seed, copyBufferToImageInfo2.dstImage ); 2526 VULKAN_HPP_HASH_COMBINE( seed, copyBufferToImageInfo2.dstImageLayout ); 2527 VULKAN_HPP_HASH_COMBINE( seed, copyBufferToImageInfo2.regionCount ); 2528 VULKAN_HPP_HASH_COMBINE( seed, copyBufferToImageInfo2.pRegions ); 2529 return seed; 2530 } 2531 }; 2532 2533 template <> 2534 struct hash<VULKAN_HPP_NAMESPACE::CopyCommandTransformInfoQCOM> 2535 { operator ()std::hash2536 std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyCommandTransformInfoQCOM const & copyCommandTransformInfoQCOM ) const VULKAN_HPP_NOEXCEPT 2537 { 2538 std::size_t seed = 0; 2539 VULKAN_HPP_HASH_COMBINE( seed, copyCommandTransformInfoQCOM.sType ); 2540 VULKAN_HPP_HASH_COMBINE( seed, copyCommandTransformInfoQCOM.pNext ); 2541 VULKAN_HPP_HASH_COMBINE( seed, copyCommandTransformInfoQCOM.transform ); 2542 return seed; 2543 } 2544 }; 2545 2546 template <> 2547 struct hash<VULKAN_HPP_NAMESPACE::CopyDescriptorSet> 2548 { operator ()std::hash2549 std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyDescriptorSet const & copyDescriptorSet ) const VULKAN_HPP_NOEXCEPT 2550 { 2551 std::size_t seed = 0; 2552 VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.sType ); 2553 VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.pNext ); 2554 VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.srcSet ); 2555 VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.srcBinding ); 2556 VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.srcArrayElement ); 2557 VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.dstSet ); 2558 VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.dstBinding ); 2559 VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.dstArrayElement ); 2560 VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.descriptorCount ); 2561 return seed; 2562 } 2563 }; 2564 2565 template <> 2566 struct hash<VULKAN_HPP_NAMESPACE::ImageCopy2> 2567 { operator ()std::hash2568 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageCopy2 const & imageCopy2 ) const VULKAN_HPP_NOEXCEPT 2569 { 2570 std::size_t seed = 0; 2571 VULKAN_HPP_HASH_COMBINE( seed, imageCopy2.sType ); 2572 VULKAN_HPP_HASH_COMBINE( seed, imageCopy2.pNext ); 2573 VULKAN_HPP_HASH_COMBINE( seed, imageCopy2.srcSubresource ); 2574 VULKAN_HPP_HASH_COMBINE( seed, imageCopy2.srcOffset ); 2575 VULKAN_HPP_HASH_COMBINE( seed, imageCopy2.dstSubresource ); 2576 VULKAN_HPP_HASH_COMBINE( seed, imageCopy2.dstOffset ); 2577 VULKAN_HPP_HASH_COMBINE( seed, imageCopy2.extent ); 2578 return seed; 2579 } 2580 }; 2581 2582 template <> 2583 struct hash<VULKAN_HPP_NAMESPACE::CopyImageInfo2> 2584 { operator ()std::hash2585 std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyImageInfo2 const & copyImageInfo2 ) const VULKAN_HPP_NOEXCEPT 2586 { 2587 std::size_t seed = 0; 2588 VULKAN_HPP_HASH_COMBINE( seed, copyImageInfo2.sType ); 2589 VULKAN_HPP_HASH_COMBINE( seed, copyImageInfo2.pNext ); 2590 VULKAN_HPP_HASH_COMBINE( seed, copyImageInfo2.srcImage ); 2591 VULKAN_HPP_HASH_COMBINE( seed, copyImageInfo2.srcImageLayout ); 2592 VULKAN_HPP_HASH_COMBINE( seed, copyImageInfo2.dstImage ); 2593 VULKAN_HPP_HASH_COMBINE( seed, copyImageInfo2.dstImageLayout ); 2594 VULKAN_HPP_HASH_COMBINE( seed, copyImageInfo2.regionCount ); 2595 VULKAN_HPP_HASH_COMBINE( seed, copyImageInfo2.pRegions ); 2596 return seed; 2597 } 2598 }; 2599 2600 template <> 2601 struct hash<VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2> 2602 { operator ()std::hash2603 std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 const & copyImageToBufferInfo2 ) const VULKAN_HPP_NOEXCEPT 2604 { 2605 std::size_t seed = 0; 2606 VULKAN_HPP_HASH_COMBINE( seed, copyImageToBufferInfo2.sType ); 2607 VULKAN_HPP_HASH_COMBINE( seed, copyImageToBufferInfo2.pNext ); 2608 VULKAN_HPP_HASH_COMBINE( seed, copyImageToBufferInfo2.srcImage ); 2609 VULKAN_HPP_HASH_COMBINE( seed, copyImageToBufferInfo2.srcImageLayout ); 2610 VULKAN_HPP_HASH_COMBINE( seed, copyImageToBufferInfo2.dstBuffer ); 2611 VULKAN_HPP_HASH_COMBINE( seed, copyImageToBufferInfo2.regionCount ); 2612 VULKAN_HPP_HASH_COMBINE( seed, copyImageToBufferInfo2.pRegions ); 2613 return seed; 2614 } 2615 }; 2616 2617 template <> 2618 struct hash<VULKAN_HPP_NAMESPACE::CopyImageToImageInfoEXT> 2619 { operator ()std::hash2620 std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyImageToImageInfoEXT const & copyImageToImageInfoEXT ) const VULKAN_HPP_NOEXCEPT 2621 { 2622 std::size_t seed = 0; 2623 VULKAN_HPP_HASH_COMBINE( seed, copyImageToImageInfoEXT.sType ); 2624 VULKAN_HPP_HASH_COMBINE( seed, copyImageToImageInfoEXT.pNext ); 2625 VULKAN_HPP_HASH_COMBINE( seed, copyImageToImageInfoEXT.flags ); 2626 VULKAN_HPP_HASH_COMBINE( seed, copyImageToImageInfoEXT.srcImage ); 2627 VULKAN_HPP_HASH_COMBINE( seed, copyImageToImageInfoEXT.srcImageLayout ); 2628 VULKAN_HPP_HASH_COMBINE( seed, copyImageToImageInfoEXT.dstImage ); 2629 VULKAN_HPP_HASH_COMBINE( seed, copyImageToImageInfoEXT.dstImageLayout ); 2630 VULKAN_HPP_HASH_COMBINE( seed, copyImageToImageInfoEXT.regionCount ); 2631 VULKAN_HPP_HASH_COMBINE( seed, copyImageToImageInfoEXT.pRegions ); 2632 return seed; 2633 } 2634 }; 2635 2636 template <> 2637 struct hash<VULKAN_HPP_NAMESPACE::ImageToMemoryCopyEXT> 2638 { operator ()std::hash2639 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageToMemoryCopyEXT const & imageToMemoryCopyEXT ) const VULKAN_HPP_NOEXCEPT 2640 { 2641 std::size_t seed = 0; 2642 VULKAN_HPP_HASH_COMBINE( seed, imageToMemoryCopyEXT.sType ); 2643 VULKAN_HPP_HASH_COMBINE( seed, imageToMemoryCopyEXT.pNext ); 2644 VULKAN_HPP_HASH_COMBINE( seed, imageToMemoryCopyEXT.pHostPointer ); 2645 VULKAN_HPP_HASH_COMBINE( seed, imageToMemoryCopyEXT.memoryRowLength ); 2646 VULKAN_HPP_HASH_COMBINE( seed, imageToMemoryCopyEXT.memoryImageHeight ); 2647 VULKAN_HPP_HASH_COMBINE( seed, imageToMemoryCopyEXT.imageSubresource ); 2648 VULKAN_HPP_HASH_COMBINE( seed, imageToMemoryCopyEXT.imageOffset ); 2649 VULKAN_HPP_HASH_COMBINE( seed, imageToMemoryCopyEXT.imageExtent ); 2650 return seed; 2651 } 2652 }; 2653 2654 template <> 2655 struct hash<VULKAN_HPP_NAMESPACE::CopyImageToMemoryInfoEXT> 2656 { operator ()std::hash2657 std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyImageToMemoryInfoEXT const & copyImageToMemoryInfoEXT ) const VULKAN_HPP_NOEXCEPT 2658 { 2659 std::size_t seed = 0; 2660 VULKAN_HPP_HASH_COMBINE( seed, copyImageToMemoryInfoEXT.sType ); 2661 VULKAN_HPP_HASH_COMBINE( seed, copyImageToMemoryInfoEXT.pNext ); 2662 VULKAN_HPP_HASH_COMBINE( seed, copyImageToMemoryInfoEXT.flags ); 2663 VULKAN_HPP_HASH_COMBINE( seed, copyImageToMemoryInfoEXT.srcImage ); 2664 VULKAN_HPP_HASH_COMBINE( seed, copyImageToMemoryInfoEXT.srcImageLayout ); 2665 VULKAN_HPP_HASH_COMBINE( seed, copyImageToMemoryInfoEXT.regionCount ); 2666 VULKAN_HPP_HASH_COMBINE( seed, copyImageToMemoryInfoEXT.pRegions ); 2667 return seed; 2668 } 2669 }; 2670 2671 template <> 2672 struct hash<VULKAN_HPP_NAMESPACE::CopyMemoryIndirectCommandNV> 2673 { operator ()std::hash2674 std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyMemoryIndirectCommandNV const & copyMemoryIndirectCommandNV ) const VULKAN_HPP_NOEXCEPT 2675 { 2676 std::size_t seed = 0; 2677 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryIndirectCommandNV.srcAddress ); 2678 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryIndirectCommandNV.dstAddress ); 2679 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryIndirectCommandNV.size ); 2680 return seed; 2681 } 2682 }; 2683 2684 template <> 2685 struct hash<VULKAN_HPP_NAMESPACE::CopyMemoryToImageIndirectCommandNV> 2686 { operator ()std::hash2687 std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyMemoryToImageIndirectCommandNV const & copyMemoryToImageIndirectCommandNV ) const VULKAN_HPP_NOEXCEPT 2688 { 2689 std::size_t seed = 0; 2690 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectCommandNV.srcAddress ); 2691 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectCommandNV.bufferRowLength ); 2692 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectCommandNV.bufferImageHeight ); 2693 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectCommandNV.imageSubresource ); 2694 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectCommandNV.imageOffset ); 2695 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectCommandNV.imageExtent ); 2696 return seed; 2697 } 2698 }; 2699 2700 template <> 2701 struct hash<VULKAN_HPP_NAMESPACE::MemoryToImageCopyEXT> 2702 { operator ()std::hash2703 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryToImageCopyEXT const & memoryToImageCopyEXT ) const VULKAN_HPP_NOEXCEPT 2704 { 2705 std::size_t seed = 0; 2706 VULKAN_HPP_HASH_COMBINE( seed, memoryToImageCopyEXT.sType ); 2707 VULKAN_HPP_HASH_COMBINE( seed, memoryToImageCopyEXT.pNext ); 2708 VULKAN_HPP_HASH_COMBINE( seed, memoryToImageCopyEXT.pHostPointer ); 2709 VULKAN_HPP_HASH_COMBINE( seed, memoryToImageCopyEXT.memoryRowLength ); 2710 VULKAN_HPP_HASH_COMBINE( seed, memoryToImageCopyEXT.memoryImageHeight ); 2711 VULKAN_HPP_HASH_COMBINE( seed, memoryToImageCopyEXT.imageSubresource ); 2712 VULKAN_HPP_HASH_COMBINE( seed, memoryToImageCopyEXT.imageOffset ); 2713 VULKAN_HPP_HASH_COMBINE( seed, memoryToImageCopyEXT.imageExtent ); 2714 return seed; 2715 } 2716 }; 2717 2718 template <> 2719 struct hash<VULKAN_HPP_NAMESPACE::CopyMemoryToImageInfoEXT> 2720 { operator ()std::hash2721 std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyMemoryToImageInfoEXT const & copyMemoryToImageInfoEXT ) const VULKAN_HPP_NOEXCEPT 2722 { 2723 std::size_t seed = 0; 2724 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageInfoEXT.sType ); 2725 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageInfoEXT.pNext ); 2726 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageInfoEXT.flags ); 2727 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageInfoEXT.dstImage ); 2728 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageInfoEXT.dstImageLayout ); 2729 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageInfoEXT.regionCount ); 2730 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageInfoEXT.pRegions ); 2731 return seed; 2732 } 2733 }; 2734 2735 template <> 2736 struct hash<VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT> 2737 { operator ()std::hash2738 std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT const & copyMicromapInfoEXT ) const VULKAN_HPP_NOEXCEPT 2739 { 2740 std::size_t seed = 0; 2741 VULKAN_HPP_HASH_COMBINE( seed, copyMicromapInfoEXT.sType ); 2742 VULKAN_HPP_HASH_COMBINE( seed, copyMicromapInfoEXT.pNext ); 2743 VULKAN_HPP_HASH_COMBINE( seed, copyMicromapInfoEXT.src ); 2744 VULKAN_HPP_HASH_COMBINE( seed, copyMicromapInfoEXT.dst ); 2745 VULKAN_HPP_HASH_COMBINE( seed, copyMicromapInfoEXT.mode ); 2746 return seed; 2747 } 2748 }; 2749 2750 template <> 2751 struct hash<VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX> 2752 { operator ()std::hash2753 std::size_t operator()( VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX const & cuFunctionCreateInfoNVX ) const VULKAN_HPP_NOEXCEPT 2754 { 2755 std::size_t seed = 0; 2756 VULKAN_HPP_HASH_COMBINE( seed, cuFunctionCreateInfoNVX.sType ); 2757 VULKAN_HPP_HASH_COMBINE( seed, cuFunctionCreateInfoNVX.pNext ); 2758 VULKAN_HPP_HASH_COMBINE( seed, cuFunctionCreateInfoNVX.module ); 2759 for ( const char * p = cuFunctionCreateInfoNVX.pName; *p != '\0'; ++p ) 2760 { 2761 VULKAN_HPP_HASH_COMBINE( seed, *p ); 2762 } 2763 return seed; 2764 } 2765 }; 2766 2767 template <> 2768 struct hash<VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX> 2769 { operator ()std::hash2770 std::size_t operator()( VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX const & cuLaunchInfoNVX ) const VULKAN_HPP_NOEXCEPT 2771 { 2772 std::size_t seed = 0; 2773 VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.sType ); 2774 VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.pNext ); 2775 VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.function ); 2776 VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.gridDimX ); 2777 VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.gridDimY ); 2778 VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.gridDimZ ); 2779 VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.blockDimX ); 2780 VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.blockDimY ); 2781 VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.blockDimZ ); 2782 VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.sharedMemBytes ); 2783 VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.paramCount ); 2784 VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.pParams ); 2785 VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.extraCount ); 2786 VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.pExtras ); 2787 return seed; 2788 } 2789 }; 2790 2791 template <> 2792 struct hash<VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX> 2793 { operator ()std::hash2794 std::size_t operator()( VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX const & cuModuleCreateInfoNVX ) const VULKAN_HPP_NOEXCEPT 2795 { 2796 std::size_t seed = 0; 2797 VULKAN_HPP_HASH_COMBINE( seed, cuModuleCreateInfoNVX.sType ); 2798 VULKAN_HPP_HASH_COMBINE( seed, cuModuleCreateInfoNVX.pNext ); 2799 VULKAN_HPP_HASH_COMBINE( seed, cuModuleCreateInfoNVX.dataSize ); 2800 VULKAN_HPP_HASH_COMBINE( seed, cuModuleCreateInfoNVX.pData ); 2801 return seed; 2802 } 2803 }; 2804 2805 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 2806 template <> 2807 struct hash<VULKAN_HPP_NAMESPACE::CudaFunctionCreateInfoNV> 2808 { operator ()std::hash2809 std::size_t operator()( VULKAN_HPP_NAMESPACE::CudaFunctionCreateInfoNV const & cudaFunctionCreateInfoNV ) const VULKAN_HPP_NOEXCEPT 2810 { 2811 std::size_t seed = 0; 2812 VULKAN_HPP_HASH_COMBINE( seed, cudaFunctionCreateInfoNV.sType ); 2813 VULKAN_HPP_HASH_COMBINE( seed, cudaFunctionCreateInfoNV.pNext ); 2814 VULKAN_HPP_HASH_COMBINE( seed, cudaFunctionCreateInfoNV.module ); 2815 for ( const char * p = cudaFunctionCreateInfoNV.pName; *p != '\0'; ++p ) 2816 { 2817 VULKAN_HPP_HASH_COMBINE( seed, *p ); 2818 } 2819 return seed; 2820 } 2821 }; 2822 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 2823 2824 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 2825 template <> 2826 struct hash<VULKAN_HPP_NAMESPACE::CudaLaunchInfoNV> 2827 { operator ()std::hash2828 std::size_t operator()( VULKAN_HPP_NAMESPACE::CudaLaunchInfoNV const & cudaLaunchInfoNV ) const VULKAN_HPP_NOEXCEPT 2829 { 2830 std::size_t seed = 0; 2831 VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.sType ); 2832 VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.pNext ); 2833 VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.function ); 2834 VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.gridDimX ); 2835 VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.gridDimY ); 2836 VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.gridDimZ ); 2837 VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.blockDimX ); 2838 VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.blockDimY ); 2839 VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.blockDimZ ); 2840 VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.sharedMemBytes ); 2841 VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.paramCount ); 2842 VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.pParams ); 2843 VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.extraCount ); 2844 VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.pExtras ); 2845 return seed; 2846 } 2847 }; 2848 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 2849 2850 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 2851 template <> 2852 struct hash<VULKAN_HPP_NAMESPACE::CudaModuleCreateInfoNV> 2853 { operator ()std::hash2854 std::size_t operator()( VULKAN_HPP_NAMESPACE::CudaModuleCreateInfoNV const & cudaModuleCreateInfoNV ) const VULKAN_HPP_NOEXCEPT 2855 { 2856 std::size_t seed = 0; 2857 VULKAN_HPP_HASH_COMBINE( seed, cudaModuleCreateInfoNV.sType ); 2858 VULKAN_HPP_HASH_COMBINE( seed, cudaModuleCreateInfoNV.pNext ); 2859 VULKAN_HPP_HASH_COMBINE( seed, cudaModuleCreateInfoNV.dataSize ); 2860 VULKAN_HPP_HASH_COMBINE( seed, cudaModuleCreateInfoNV.pData ); 2861 return seed; 2862 } 2863 }; 2864 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 2865 2866 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 2867 template <> 2868 struct hash<VULKAN_HPP_NAMESPACE::D3D12FenceSubmitInfoKHR> 2869 { operator ()std::hash2870 std::size_t operator()( VULKAN_HPP_NAMESPACE::D3D12FenceSubmitInfoKHR const & d3D12FenceSubmitInfoKHR ) const VULKAN_HPP_NOEXCEPT 2871 { 2872 std::size_t seed = 0; 2873 VULKAN_HPP_HASH_COMBINE( seed, d3D12FenceSubmitInfoKHR.sType ); 2874 VULKAN_HPP_HASH_COMBINE( seed, d3D12FenceSubmitInfoKHR.pNext ); 2875 VULKAN_HPP_HASH_COMBINE( seed, d3D12FenceSubmitInfoKHR.waitSemaphoreValuesCount ); 2876 VULKAN_HPP_HASH_COMBINE( seed, d3D12FenceSubmitInfoKHR.pWaitSemaphoreValues ); 2877 VULKAN_HPP_HASH_COMBINE( seed, d3D12FenceSubmitInfoKHR.signalSemaphoreValuesCount ); 2878 VULKAN_HPP_HASH_COMBINE( seed, d3D12FenceSubmitInfoKHR.pSignalSemaphoreValues ); 2879 return seed; 2880 } 2881 }; 2882 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 2883 2884 template <> 2885 struct hash<VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT> 2886 { operator ()std::hash2887 std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT const & debugMarkerMarkerInfoEXT ) const VULKAN_HPP_NOEXCEPT 2888 { 2889 std::size_t seed = 0; 2890 VULKAN_HPP_HASH_COMBINE( seed, debugMarkerMarkerInfoEXT.sType ); 2891 VULKAN_HPP_HASH_COMBINE( seed, debugMarkerMarkerInfoEXT.pNext ); 2892 for ( const char * p = debugMarkerMarkerInfoEXT.pMarkerName; *p != '\0'; ++p ) 2893 { 2894 VULKAN_HPP_HASH_COMBINE( seed, *p ); 2895 } 2896 for ( size_t i = 0; i < 4; ++i ) 2897 { 2898 VULKAN_HPP_HASH_COMBINE( seed, debugMarkerMarkerInfoEXT.color[i] ); 2899 } 2900 return seed; 2901 } 2902 }; 2903 2904 template <> 2905 struct hash<VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT> 2906 { operator ()std::hash2907 std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT const & debugMarkerObjectNameInfoEXT ) const VULKAN_HPP_NOEXCEPT 2908 { 2909 std::size_t seed = 0; 2910 VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectNameInfoEXT.sType ); 2911 VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectNameInfoEXT.pNext ); 2912 VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectNameInfoEXT.objectType ); 2913 VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectNameInfoEXT.object ); 2914 for ( const char * p = debugMarkerObjectNameInfoEXT.pObjectName; *p != '\0'; ++p ) 2915 { 2916 VULKAN_HPP_HASH_COMBINE( seed, *p ); 2917 } 2918 return seed; 2919 } 2920 }; 2921 2922 template <> 2923 struct hash<VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT> 2924 { operator ()std::hash2925 std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT const & debugMarkerObjectTagInfoEXT ) const VULKAN_HPP_NOEXCEPT 2926 { 2927 std::size_t seed = 0; 2928 VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectTagInfoEXT.sType ); 2929 VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectTagInfoEXT.pNext ); 2930 VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectTagInfoEXT.objectType ); 2931 VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectTagInfoEXT.object ); 2932 VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectTagInfoEXT.tagName ); 2933 VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectTagInfoEXT.tagSize ); 2934 VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectTagInfoEXT.pTag ); 2935 return seed; 2936 } 2937 }; 2938 2939 template <> 2940 struct hash<VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT> 2941 { operator ()std::hash2942 std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT const & debugReportCallbackCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 2943 { 2944 std::size_t seed = 0; 2945 VULKAN_HPP_HASH_COMBINE( seed, debugReportCallbackCreateInfoEXT.sType ); 2946 VULKAN_HPP_HASH_COMBINE( seed, debugReportCallbackCreateInfoEXT.pNext ); 2947 VULKAN_HPP_HASH_COMBINE( seed, debugReportCallbackCreateInfoEXT.flags ); 2948 VULKAN_HPP_HASH_COMBINE( seed, debugReportCallbackCreateInfoEXT.pfnCallback ); 2949 VULKAN_HPP_HASH_COMBINE( seed, debugReportCallbackCreateInfoEXT.pUserData ); 2950 return seed; 2951 } 2952 }; 2953 2954 template <> 2955 struct hash<VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT> 2956 { operator ()std::hash2957 std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT const & debugUtilsLabelEXT ) const VULKAN_HPP_NOEXCEPT 2958 { 2959 std::size_t seed = 0; 2960 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsLabelEXT.sType ); 2961 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsLabelEXT.pNext ); 2962 for ( const char * p = debugUtilsLabelEXT.pLabelName; *p != '\0'; ++p ) 2963 { 2964 VULKAN_HPP_HASH_COMBINE( seed, *p ); 2965 } 2966 for ( size_t i = 0; i < 4; ++i ) 2967 { 2968 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsLabelEXT.color[i] ); 2969 } 2970 return seed; 2971 } 2972 }; 2973 2974 template <> 2975 struct hash<VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT> 2976 { operator ()std::hash2977 std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT const & debugUtilsObjectNameInfoEXT ) const VULKAN_HPP_NOEXCEPT 2978 { 2979 std::size_t seed = 0; 2980 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectNameInfoEXT.sType ); 2981 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectNameInfoEXT.pNext ); 2982 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectNameInfoEXT.objectType ); 2983 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectNameInfoEXT.objectHandle ); 2984 for ( const char * p = debugUtilsObjectNameInfoEXT.pObjectName; *p != '\0'; ++p ) 2985 { 2986 VULKAN_HPP_HASH_COMBINE( seed, *p ); 2987 } 2988 return seed; 2989 } 2990 }; 2991 2992 template <> 2993 struct hash<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataEXT> 2994 { operator ()std::hash2995 std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataEXT const & debugUtilsMessengerCallbackDataEXT ) const VULKAN_HPP_NOEXCEPT 2996 { 2997 std::size_t seed = 0; 2998 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.sType ); 2999 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.pNext ); 3000 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.flags ); 3001 for ( const char * p = debugUtilsMessengerCallbackDataEXT.pMessageIdName; *p != '\0'; ++p ) 3002 { 3003 VULKAN_HPP_HASH_COMBINE( seed, *p ); 3004 } 3005 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.messageIdNumber ); 3006 for ( const char * p = debugUtilsMessengerCallbackDataEXT.pMessage; *p != '\0'; ++p ) 3007 { 3008 VULKAN_HPP_HASH_COMBINE( seed, *p ); 3009 } 3010 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.queueLabelCount ); 3011 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.pQueueLabels ); 3012 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.cmdBufLabelCount ); 3013 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.pCmdBufLabels ); 3014 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.objectCount ); 3015 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.pObjects ); 3016 return seed; 3017 } 3018 }; 3019 3020 template <> 3021 struct hash<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT> 3022 { operator ()std::hash3023 std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT const & debugUtilsMessengerCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 3024 { 3025 std::size_t seed = 0; 3026 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCreateInfoEXT.sType ); 3027 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCreateInfoEXT.pNext ); 3028 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCreateInfoEXT.flags ); 3029 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCreateInfoEXT.messageSeverity ); 3030 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCreateInfoEXT.messageType ); 3031 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCreateInfoEXT.pfnUserCallback ); 3032 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCreateInfoEXT.pUserData ); 3033 return seed; 3034 } 3035 }; 3036 3037 template <> 3038 struct hash<VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT> 3039 { operator ()std::hash3040 std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT const & debugUtilsObjectTagInfoEXT ) const VULKAN_HPP_NOEXCEPT 3041 { 3042 std::size_t seed = 0; 3043 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectTagInfoEXT.sType ); 3044 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectTagInfoEXT.pNext ); 3045 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectTagInfoEXT.objectType ); 3046 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectTagInfoEXT.objectHandle ); 3047 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectTagInfoEXT.tagName ); 3048 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectTagInfoEXT.tagSize ); 3049 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectTagInfoEXT.pTag ); 3050 return seed; 3051 } 3052 }; 3053 3054 template <> 3055 struct hash<VULKAN_HPP_NAMESPACE::DecompressMemoryRegionNV> 3056 { operator ()std::hash3057 std::size_t operator()( VULKAN_HPP_NAMESPACE::DecompressMemoryRegionNV const & decompressMemoryRegionNV ) const VULKAN_HPP_NOEXCEPT 3058 { 3059 std::size_t seed = 0; 3060 VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryRegionNV.srcAddress ); 3061 VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryRegionNV.dstAddress ); 3062 VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryRegionNV.compressedSize ); 3063 VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryRegionNV.decompressedSize ); 3064 VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryRegionNV.decompressionMethod ); 3065 return seed; 3066 } 3067 }; 3068 3069 template <> 3070 struct hash<VULKAN_HPP_NAMESPACE::DedicatedAllocationBufferCreateInfoNV> 3071 { 3072 std::size_t operator ()std::hash3073 operator()( VULKAN_HPP_NAMESPACE::DedicatedAllocationBufferCreateInfoNV const & dedicatedAllocationBufferCreateInfoNV ) const VULKAN_HPP_NOEXCEPT 3074 { 3075 std::size_t seed = 0; 3076 VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationBufferCreateInfoNV.sType ); 3077 VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationBufferCreateInfoNV.pNext ); 3078 VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationBufferCreateInfoNV.dedicatedAllocation ); 3079 return seed; 3080 } 3081 }; 3082 3083 template <> 3084 struct hash<VULKAN_HPP_NAMESPACE::DedicatedAllocationImageCreateInfoNV> 3085 { operator ()std::hash3086 std::size_t operator()( VULKAN_HPP_NAMESPACE::DedicatedAllocationImageCreateInfoNV const & dedicatedAllocationImageCreateInfoNV ) const VULKAN_HPP_NOEXCEPT 3087 { 3088 std::size_t seed = 0; 3089 VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationImageCreateInfoNV.sType ); 3090 VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationImageCreateInfoNV.pNext ); 3091 VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationImageCreateInfoNV.dedicatedAllocation ); 3092 return seed; 3093 } 3094 }; 3095 3096 template <> 3097 struct hash<VULKAN_HPP_NAMESPACE::DedicatedAllocationMemoryAllocateInfoNV> 3098 { 3099 std::size_t operator ()std::hash3100 operator()( VULKAN_HPP_NAMESPACE::DedicatedAllocationMemoryAllocateInfoNV const & dedicatedAllocationMemoryAllocateInfoNV ) const VULKAN_HPP_NOEXCEPT 3101 { 3102 std::size_t seed = 0; 3103 VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationMemoryAllocateInfoNV.sType ); 3104 VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationMemoryAllocateInfoNV.pNext ); 3105 VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationMemoryAllocateInfoNV.image ); 3106 VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationMemoryAllocateInfoNV.buffer ); 3107 return seed; 3108 } 3109 }; 3110 3111 template <> 3112 struct hash<VULKAN_HPP_NAMESPACE::MemoryBarrier2> 3113 { operator ()std::hash3114 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryBarrier2 const & memoryBarrier2 ) const VULKAN_HPP_NOEXCEPT 3115 { 3116 std::size_t seed = 0; 3117 VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier2.sType ); 3118 VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier2.pNext ); 3119 VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier2.srcStageMask ); 3120 VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier2.srcAccessMask ); 3121 VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier2.dstStageMask ); 3122 VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier2.dstAccessMask ); 3123 return seed; 3124 } 3125 }; 3126 3127 template <> 3128 struct hash<VULKAN_HPP_NAMESPACE::ImageSubresourceRange> 3129 { operator ()std::hash3130 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageSubresourceRange const & imageSubresourceRange ) const VULKAN_HPP_NOEXCEPT 3131 { 3132 std::size_t seed = 0; 3133 VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceRange.aspectMask ); 3134 VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceRange.baseMipLevel ); 3135 VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceRange.levelCount ); 3136 VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceRange.baseArrayLayer ); 3137 VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceRange.layerCount ); 3138 return seed; 3139 } 3140 }; 3141 3142 template <> 3143 struct hash<VULKAN_HPP_NAMESPACE::ImageMemoryBarrier2> 3144 { operator ()std::hash3145 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageMemoryBarrier2 const & imageMemoryBarrier2 ) const VULKAN_HPP_NOEXCEPT 3146 { 3147 std::size_t seed = 0; 3148 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.sType ); 3149 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.pNext ); 3150 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.srcStageMask ); 3151 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.srcAccessMask ); 3152 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.dstStageMask ); 3153 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.dstAccessMask ); 3154 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.oldLayout ); 3155 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.newLayout ); 3156 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.srcQueueFamilyIndex ); 3157 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.dstQueueFamilyIndex ); 3158 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.image ); 3159 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.subresourceRange ); 3160 return seed; 3161 } 3162 }; 3163 3164 template <> 3165 struct hash<VULKAN_HPP_NAMESPACE::DependencyInfo> 3166 { operator ()std::hash3167 std::size_t operator()( VULKAN_HPP_NAMESPACE::DependencyInfo const & dependencyInfo ) const VULKAN_HPP_NOEXCEPT 3168 { 3169 std::size_t seed = 0; 3170 VULKAN_HPP_HASH_COMBINE( seed, dependencyInfo.sType ); 3171 VULKAN_HPP_HASH_COMBINE( seed, dependencyInfo.pNext ); 3172 VULKAN_HPP_HASH_COMBINE( seed, dependencyInfo.dependencyFlags ); 3173 VULKAN_HPP_HASH_COMBINE( seed, dependencyInfo.memoryBarrierCount ); 3174 VULKAN_HPP_HASH_COMBINE( seed, dependencyInfo.pMemoryBarriers ); 3175 VULKAN_HPP_HASH_COMBINE( seed, dependencyInfo.bufferMemoryBarrierCount ); 3176 VULKAN_HPP_HASH_COMBINE( seed, dependencyInfo.pBufferMemoryBarriers ); 3177 VULKAN_HPP_HASH_COMBINE( seed, dependencyInfo.imageMemoryBarrierCount ); 3178 VULKAN_HPP_HASH_COMBINE( seed, dependencyInfo.pImageMemoryBarriers ); 3179 return seed; 3180 } 3181 }; 3182 3183 template <> 3184 struct hash<VULKAN_HPP_NAMESPACE::DepthBiasInfoEXT> 3185 { operator ()std::hash3186 std::size_t operator()( VULKAN_HPP_NAMESPACE::DepthBiasInfoEXT const & depthBiasInfoEXT ) const VULKAN_HPP_NOEXCEPT 3187 { 3188 std::size_t seed = 0; 3189 VULKAN_HPP_HASH_COMBINE( seed, depthBiasInfoEXT.sType ); 3190 VULKAN_HPP_HASH_COMBINE( seed, depthBiasInfoEXT.pNext ); 3191 VULKAN_HPP_HASH_COMBINE( seed, depthBiasInfoEXT.depthBiasConstantFactor ); 3192 VULKAN_HPP_HASH_COMBINE( seed, depthBiasInfoEXT.depthBiasClamp ); 3193 VULKAN_HPP_HASH_COMBINE( seed, depthBiasInfoEXT.depthBiasSlopeFactor ); 3194 return seed; 3195 } 3196 }; 3197 3198 template <> 3199 struct hash<VULKAN_HPP_NAMESPACE::DepthBiasRepresentationInfoEXT> 3200 { operator ()std::hash3201 std::size_t operator()( VULKAN_HPP_NAMESPACE::DepthBiasRepresentationInfoEXT const & depthBiasRepresentationInfoEXT ) const VULKAN_HPP_NOEXCEPT 3202 { 3203 std::size_t seed = 0; 3204 VULKAN_HPP_HASH_COMBINE( seed, depthBiasRepresentationInfoEXT.sType ); 3205 VULKAN_HPP_HASH_COMBINE( seed, depthBiasRepresentationInfoEXT.pNext ); 3206 VULKAN_HPP_HASH_COMBINE( seed, depthBiasRepresentationInfoEXT.depthBiasRepresentation ); 3207 VULKAN_HPP_HASH_COMBINE( seed, depthBiasRepresentationInfoEXT.depthBiasExact ); 3208 return seed; 3209 } 3210 }; 3211 3212 template <> 3213 struct hash<VULKAN_HPP_NAMESPACE::DescriptorAddressInfoEXT> 3214 { operator ()std::hash3215 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorAddressInfoEXT const & descriptorAddressInfoEXT ) const VULKAN_HPP_NOEXCEPT 3216 { 3217 std::size_t seed = 0; 3218 VULKAN_HPP_HASH_COMBINE( seed, descriptorAddressInfoEXT.sType ); 3219 VULKAN_HPP_HASH_COMBINE( seed, descriptorAddressInfoEXT.pNext ); 3220 VULKAN_HPP_HASH_COMBINE( seed, descriptorAddressInfoEXT.address ); 3221 VULKAN_HPP_HASH_COMBINE( seed, descriptorAddressInfoEXT.range ); 3222 VULKAN_HPP_HASH_COMBINE( seed, descriptorAddressInfoEXT.format ); 3223 return seed; 3224 } 3225 }; 3226 3227 template <> 3228 struct hash<VULKAN_HPP_NAMESPACE::DescriptorBufferBindingInfoEXT> 3229 { operator ()std::hash3230 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorBufferBindingInfoEXT const & descriptorBufferBindingInfoEXT ) const VULKAN_HPP_NOEXCEPT 3231 { 3232 std::size_t seed = 0; 3233 VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferBindingInfoEXT.sType ); 3234 VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferBindingInfoEXT.pNext ); 3235 VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferBindingInfoEXT.address ); 3236 VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferBindingInfoEXT.usage ); 3237 return seed; 3238 } 3239 }; 3240 3241 template <> 3242 struct hash<VULKAN_HPP_NAMESPACE::DescriptorBufferBindingPushDescriptorBufferHandleEXT> 3243 { operator ()std::hash3244 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorBufferBindingPushDescriptorBufferHandleEXT const & 3245 descriptorBufferBindingPushDescriptorBufferHandleEXT ) const VULKAN_HPP_NOEXCEPT 3246 { 3247 std::size_t seed = 0; 3248 VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferBindingPushDescriptorBufferHandleEXT.sType ); 3249 VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferBindingPushDescriptorBufferHandleEXT.pNext ); 3250 VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferBindingPushDescriptorBufferHandleEXT.buffer ); 3251 return seed; 3252 } 3253 }; 3254 3255 template <> 3256 struct hash<VULKAN_HPP_NAMESPACE::DescriptorBufferInfo> 3257 { operator ()std::hash3258 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorBufferInfo const & descriptorBufferInfo ) const VULKAN_HPP_NOEXCEPT 3259 { 3260 std::size_t seed = 0; 3261 VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferInfo.buffer ); 3262 VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferInfo.offset ); 3263 VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferInfo.range ); 3264 return seed; 3265 } 3266 }; 3267 3268 template <> 3269 struct hash<VULKAN_HPP_NAMESPACE::DescriptorImageInfo> 3270 { operator ()std::hash3271 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorImageInfo const & descriptorImageInfo ) const VULKAN_HPP_NOEXCEPT 3272 { 3273 std::size_t seed = 0; 3274 VULKAN_HPP_HASH_COMBINE( seed, descriptorImageInfo.sampler ); 3275 VULKAN_HPP_HASH_COMBINE( seed, descriptorImageInfo.imageView ); 3276 VULKAN_HPP_HASH_COMBINE( seed, descriptorImageInfo.imageLayout ); 3277 return seed; 3278 } 3279 }; 3280 3281 template <> 3282 struct hash<VULKAN_HPP_NAMESPACE::DescriptorPoolSize> 3283 { operator ()std::hash3284 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorPoolSize const & descriptorPoolSize ) const VULKAN_HPP_NOEXCEPT 3285 { 3286 std::size_t seed = 0; 3287 VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolSize.type ); 3288 VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolSize.descriptorCount ); 3289 return seed; 3290 } 3291 }; 3292 3293 template <> 3294 struct hash<VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo> 3295 { operator ()std::hash3296 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo const & descriptorPoolCreateInfo ) const VULKAN_HPP_NOEXCEPT 3297 { 3298 std::size_t seed = 0; 3299 VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolCreateInfo.sType ); 3300 VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolCreateInfo.pNext ); 3301 VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolCreateInfo.flags ); 3302 VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolCreateInfo.maxSets ); 3303 VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolCreateInfo.poolSizeCount ); 3304 VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolCreateInfo.pPoolSizes ); 3305 return seed; 3306 } 3307 }; 3308 3309 template <> 3310 struct hash<VULKAN_HPP_NAMESPACE::DescriptorPoolInlineUniformBlockCreateInfo> 3311 { operator ()std::hash3312 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorPoolInlineUniformBlockCreateInfo const & descriptorPoolInlineUniformBlockCreateInfo ) const 3313 VULKAN_HPP_NOEXCEPT 3314 { 3315 std::size_t seed = 0; 3316 VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolInlineUniformBlockCreateInfo.sType ); 3317 VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolInlineUniformBlockCreateInfo.pNext ); 3318 VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolInlineUniformBlockCreateInfo.maxInlineUniformBlockBindings ); 3319 return seed; 3320 } 3321 }; 3322 3323 template <> 3324 struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo> 3325 { operator ()std::hash3326 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo const & descriptorSetAllocateInfo ) const VULKAN_HPP_NOEXCEPT 3327 { 3328 std::size_t seed = 0; 3329 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetAllocateInfo.sType ); 3330 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetAllocateInfo.pNext ); 3331 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetAllocateInfo.descriptorPool ); 3332 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetAllocateInfo.descriptorSetCount ); 3333 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetAllocateInfo.pSetLayouts ); 3334 return seed; 3335 } 3336 }; 3337 3338 template <> 3339 struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetBindingReferenceVALVE> 3340 { operator ()std::hash3341 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetBindingReferenceVALVE const & descriptorSetBindingReferenceVALVE ) const VULKAN_HPP_NOEXCEPT 3342 { 3343 std::size_t seed = 0; 3344 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetBindingReferenceVALVE.sType ); 3345 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetBindingReferenceVALVE.pNext ); 3346 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetBindingReferenceVALVE.descriptorSetLayout ); 3347 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetBindingReferenceVALVE.binding ); 3348 return seed; 3349 } 3350 }; 3351 3352 template <> 3353 struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBinding> 3354 { operator ()std::hash3355 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBinding const & descriptorSetLayoutBinding ) const VULKAN_HPP_NOEXCEPT 3356 { 3357 std::size_t seed = 0; 3358 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutBinding.binding ); 3359 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutBinding.descriptorType ); 3360 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutBinding.descriptorCount ); 3361 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutBinding.stageFlags ); 3362 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutBinding.pImmutableSamplers ); 3363 return seed; 3364 } 3365 }; 3366 3367 template <> 3368 struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBindingFlagsCreateInfo> 3369 { 3370 std::size_t operator ()std::hash3371 operator()( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBindingFlagsCreateInfo const & descriptorSetLayoutBindingFlagsCreateInfo ) const VULKAN_HPP_NOEXCEPT 3372 { 3373 std::size_t seed = 0; 3374 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutBindingFlagsCreateInfo.sType ); 3375 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutBindingFlagsCreateInfo.pNext ); 3376 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutBindingFlagsCreateInfo.bindingCount ); 3377 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutBindingFlagsCreateInfo.pBindingFlags ); 3378 return seed; 3379 } 3380 }; 3381 3382 template <> 3383 struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo> 3384 { operator ()std::hash3385 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo const & descriptorSetLayoutCreateInfo ) const VULKAN_HPP_NOEXCEPT 3386 { 3387 std::size_t seed = 0; 3388 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutCreateInfo.sType ); 3389 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutCreateInfo.pNext ); 3390 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutCreateInfo.flags ); 3391 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutCreateInfo.bindingCount ); 3392 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutCreateInfo.pBindings ); 3393 return seed; 3394 } 3395 }; 3396 3397 template <> 3398 struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutHostMappingInfoVALVE> 3399 { 3400 std::size_t operator ()std::hash3401 operator()( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutHostMappingInfoVALVE const & descriptorSetLayoutHostMappingInfoVALVE ) const VULKAN_HPP_NOEXCEPT 3402 { 3403 std::size_t seed = 0; 3404 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutHostMappingInfoVALVE.sType ); 3405 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutHostMappingInfoVALVE.pNext ); 3406 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutHostMappingInfoVALVE.descriptorOffset ); 3407 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutHostMappingInfoVALVE.descriptorSize ); 3408 return seed; 3409 } 3410 }; 3411 3412 template <> 3413 struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport> 3414 { operator ()std::hash3415 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport const & descriptorSetLayoutSupport ) const VULKAN_HPP_NOEXCEPT 3416 { 3417 std::size_t seed = 0; 3418 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutSupport.sType ); 3419 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutSupport.pNext ); 3420 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutSupport.supported ); 3421 return seed; 3422 } 3423 }; 3424 3425 template <> 3426 struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetVariableDescriptorCountAllocateInfo> 3427 { operator ()std::hash3428 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetVariableDescriptorCountAllocateInfo const & descriptorSetVariableDescriptorCountAllocateInfo ) 3429 const VULKAN_HPP_NOEXCEPT 3430 { 3431 std::size_t seed = 0; 3432 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetVariableDescriptorCountAllocateInfo.sType ); 3433 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetVariableDescriptorCountAllocateInfo.pNext ); 3434 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetVariableDescriptorCountAllocateInfo.descriptorSetCount ); 3435 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetVariableDescriptorCountAllocateInfo.pDescriptorCounts ); 3436 return seed; 3437 } 3438 }; 3439 3440 template <> 3441 struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetVariableDescriptorCountLayoutSupport> 3442 { operator ()std::hash3443 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetVariableDescriptorCountLayoutSupport const & descriptorSetVariableDescriptorCountLayoutSupport ) 3444 const VULKAN_HPP_NOEXCEPT 3445 { 3446 std::size_t seed = 0; 3447 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetVariableDescriptorCountLayoutSupport.sType ); 3448 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetVariableDescriptorCountLayoutSupport.pNext ); 3449 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetVariableDescriptorCountLayoutSupport.maxVariableDescriptorCount ); 3450 return seed; 3451 } 3452 }; 3453 3454 template <> 3455 struct hash<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateEntry> 3456 { operator ()std::hash3457 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateEntry const & descriptorUpdateTemplateEntry ) const VULKAN_HPP_NOEXCEPT 3458 { 3459 std::size_t seed = 0; 3460 VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateEntry.dstBinding ); 3461 VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateEntry.dstArrayElement ); 3462 VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateEntry.descriptorCount ); 3463 VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateEntry.descriptorType ); 3464 VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateEntry.offset ); 3465 VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateEntry.stride ); 3466 return seed; 3467 } 3468 }; 3469 3470 template <> 3471 struct hash<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo> 3472 { operator ()std::hash3473 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo const & descriptorUpdateTemplateCreateInfo ) const VULKAN_HPP_NOEXCEPT 3474 { 3475 std::size_t seed = 0; 3476 VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.sType ); 3477 VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.pNext ); 3478 VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.flags ); 3479 VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.descriptorUpdateEntryCount ); 3480 VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.pDescriptorUpdateEntries ); 3481 VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.templateType ); 3482 VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.descriptorSetLayout ); 3483 VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.pipelineBindPoint ); 3484 VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.pipelineLayout ); 3485 VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.set ); 3486 return seed; 3487 } 3488 }; 3489 3490 template <> 3491 struct hash<VULKAN_HPP_NAMESPACE::DeviceAddressBindingCallbackDataEXT> 3492 { operator ()std::hash3493 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceAddressBindingCallbackDataEXT const & deviceAddressBindingCallbackDataEXT ) const VULKAN_HPP_NOEXCEPT 3494 { 3495 std::size_t seed = 0; 3496 VULKAN_HPP_HASH_COMBINE( seed, deviceAddressBindingCallbackDataEXT.sType ); 3497 VULKAN_HPP_HASH_COMBINE( seed, deviceAddressBindingCallbackDataEXT.pNext ); 3498 VULKAN_HPP_HASH_COMBINE( seed, deviceAddressBindingCallbackDataEXT.flags ); 3499 VULKAN_HPP_HASH_COMBINE( seed, deviceAddressBindingCallbackDataEXT.baseAddress ); 3500 VULKAN_HPP_HASH_COMBINE( seed, deviceAddressBindingCallbackDataEXT.size ); 3501 VULKAN_HPP_HASH_COMBINE( seed, deviceAddressBindingCallbackDataEXT.bindingType ); 3502 return seed; 3503 } 3504 }; 3505 3506 template <> 3507 struct hash<VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements> 3508 { operator ()std::hash3509 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements const & deviceBufferMemoryRequirements ) const VULKAN_HPP_NOEXCEPT 3510 { 3511 std::size_t seed = 0; 3512 VULKAN_HPP_HASH_COMBINE( seed, deviceBufferMemoryRequirements.sType ); 3513 VULKAN_HPP_HASH_COMBINE( seed, deviceBufferMemoryRequirements.pNext ); 3514 VULKAN_HPP_HASH_COMBINE( seed, deviceBufferMemoryRequirements.pCreateInfo ); 3515 return seed; 3516 } 3517 }; 3518 3519 template <> 3520 struct hash<VULKAN_HPP_NAMESPACE::DeviceQueueCreateInfo> 3521 { operator ()std::hash3522 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceQueueCreateInfo const & deviceQueueCreateInfo ) const VULKAN_HPP_NOEXCEPT 3523 { 3524 std::size_t seed = 0; 3525 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueCreateInfo.sType ); 3526 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueCreateInfo.pNext ); 3527 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueCreateInfo.flags ); 3528 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueCreateInfo.queueFamilyIndex ); 3529 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueCreateInfo.queueCount ); 3530 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueCreateInfo.pQueuePriorities ); 3531 return seed; 3532 } 3533 }; 3534 3535 template <> 3536 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures> 3537 { operator ()std::hash3538 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures const & physicalDeviceFeatures ) const VULKAN_HPP_NOEXCEPT 3539 { 3540 std::size_t seed = 0; 3541 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.robustBufferAccess ); 3542 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.fullDrawIndexUint32 ); 3543 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.imageCubeArray ); 3544 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.independentBlend ); 3545 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.geometryShader ); 3546 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.tessellationShader ); 3547 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sampleRateShading ); 3548 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.dualSrcBlend ); 3549 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.logicOp ); 3550 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.multiDrawIndirect ); 3551 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.drawIndirectFirstInstance ); 3552 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.depthClamp ); 3553 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.depthBiasClamp ); 3554 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.fillModeNonSolid ); 3555 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.depthBounds ); 3556 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.wideLines ); 3557 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.largePoints ); 3558 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.alphaToOne ); 3559 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.multiViewport ); 3560 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.samplerAnisotropy ); 3561 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.textureCompressionETC2 ); 3562 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.textureCompressionASTC_LDR ); 3563 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.textureCompressionBC ); 3564 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.occlusionQueryPrecise ); 3565 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.pipelineStatisticsQuery ); 3566 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.vertexPipelineStoresAndAtomics ); 3567 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.fragmentStoresAndAtomics ); 3568 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderTessellationAndGeometryPointSize ); 3569 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderImageGatherExtended ); 3570 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderStorageImageExtendedFormats ); 3571 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderStorageImageMultisample ); 3572 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderStorageImageReadWithoutFormat ); 3573 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderStorageImageWriteWithoutFormat ); 3574 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderUniformBufferArrayDynamicIndexing ); 3575 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderSampledImageArrayDynamicIndexing ); 3576 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderStorageBufferArrayDynamicIndexing ); 3577 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderStorageImageArrayDynamicIndexing ); 3578 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderClipDistance ); 3579 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderCullDistance ); 3580 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderFloat64 ); 3581 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderInt64 ); 3582 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderInt16 ); 3583 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderResourceResidency ); 3584 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderResourceMinLod ); 3585 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sparseBinding ); 3586 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sparseResidencyBuffer ); 3587 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sparseResidencyImage2D ); 3588 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sparseResidencyImage3D ); 3589 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sparseResidency2Samples ); 3590 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sparseResidency4Samples ); 3591 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sparseResidency8Samples ); 3592 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sparseResidency16Samples ); 3593 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sparseResidencyAliased ); 3594 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.variableMultisampleRate ); 3595 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.inheritedQueries ); 3596 return seed; 3597 } 3598 }; 3599 3600 template <> 3601 struct hash<VULKAN_HPP_NAMESPACE::DeviceCreateInfo> 3602 { operator ()std::hash3603 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceCreateInfo const & deviceCreateInfo ) const VULKAN_HPP_NOEXCEPT 3604 { 3605 std::size_t seed = 0; 3606 VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.sType ); 3607 VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.pNext ); 3608 VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.flags ); 3609 VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.queueCreateInfoCount ); 3610 VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.pQueueCreateInfos ); 3611 VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.enabledLayerCount ); 3612 for ( size_t i = 0; i < deviceCreateInfo.enabledLayerCount; ++i ) 3613 { 3614 for ( const char * p = deviceCreateInfo.ppEnabledLayerNames[i]; *p != '\0'; ++p ) 3615 { 3616 VULKAN_HPP_HASH_COMBINE( seed, *p ); 3617 } 3618 } 3619 VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.enabledExtensionCount ); 3620 for ( size_t i = 0; i < deviceCreateInfo.enabledExtensionCount; ++i ) 3621 { 3622 for ( const char * p = deviceCreateInfo.ppEnabledExtensionNames[i]; *p != '\0'; ++p ) 3623 { 3624 VULKAN_HPP_HASH_COMBINE( seed, *p ); 3625 } 3626 } 3627 VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.pEnabledFeatures ); 3628 return seed; 3629 } 3630 }; 3631 3632 template <> 3633 struct hash<VULKAN_HPP_NAMESPACE::DeviceDeviceMemoryReportCreateInfoEXT> 3634 { 3635 std::size_t operator ()std::hash3636 operator()( VULKAN_HPP_NAMESPACE::DeviceDeviceMemoryReportCreateInfoEXT const & deviceDeviceMemoryReportCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 3637 { 3638 std::size_t seed = 0; 3639 VULKAN_HPP_HASH_COMBINE( seed, deviceDeviceMemoryReportCreateInfoEXT.sType ); 3640 VULKAN_HPP_HASH_COMBINE( seed, deviceDeviceMemoryReportCreateInfoEXT.pNext ); 3641 VULKAN_HPP_HASH_COMBINE( seed, deviceDeviceMemoryReportCreateInfoEXT.flags ); 3642 VULKAN_HPP_HASH_COMBINE( seed, deviceDeviceMemoryReportCreateInfoEXT.pfnUserCallback ); 3643 VULKAN_HPP_HASH_COMBINE( seed, deviceDeviceMemoryReportCreateInfoEXT.pUserData ); 3644 return seed; 3645 } 3646 }; 3647 3648 template <> 3649 struct hash<VULKAN_HPP_NAMESPACE::DeviceDiagnosticsConfigCreateInfoNV> 3650 { operator ()std::hash3651 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceDiagnosticsConfigCreateInfoNV const & deviceDiagnosticsConfigCreateInfoNV ) const VULKAN_HPP_NOEXCEPT 3652 { 3653 std::size_t seed = 0; 3654 VULKAN_HPP_HASH_COMBINE( seed, deviceDiagnosticsConfigCreateInfoNV.sType ); 3655 VULKAN_HPP_HASH_COMBINE( seed, deviceDiagnosticsConfigCreateInfoNV.pNext ); 3656 VULKAN_HPP_HASH_COMBINE( seed, deviceDiagnosticsConfigCreateInfoNV.flags ); 3657 return seed; 3658 } 3659 }; 3660 3661 template <> 3662 struct hash<VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT> 3663 { operator ()std::hash3664 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT const & deviceEventInfoEXT ) const VULKAN_HPP_NOEXCEPT 3665 { 3666 std::size_t seed = 0; 3667 VULKAN_HPP_HASH_COMBINE( seed, deviceEventInfoEXT.sType ); 3668 VULKAN_HPP_HASH_COMBINE( seed, deviceEventInfoEXT.pNext ); 3669 VULKAN_HPP_HASH_COMBINE( seed, deviceEventInfoEXT.deviceEvent ); 3670 return seed; 3671 } 3672 }; 3673 3674 template <> 3675 struct hash<VULKAN_HPP_NAMESPACE::DeviceFaultAddressInfoEXT> 3676 { operator ()std::hash3677 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceFaultAddressInfoEXT const & deviceFaultAddressInfoEXT ) const VULKAN_HPP_NOEXCEPT 3678 { 3679 std::size_t seed = 0; 3680 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultAddressInfoEXT.addressType ); 3681 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultAddressInfoEXT.reportedAddress ); 3682 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultAddressInfoEXT.addressPrecision ); 3683 return seed; 3684 } 3685 }; 3686 3687 template <> 3688 struct hash<VULKAN_HPP_NAMESPACE::DeviceFaultCountsEXT> 3689 { operator ()std::hash3690 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceFaultCountsEXT const & deviceFaultCountsEXT ) const VULKAN_HPP_NOEXCEPT 3691 { 3692 std::size_t seed = 0; 3693 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultCountsEXT.sType ); 3694 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultCountsEXT.pNext ); 3695 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultCountsEXT.addressInfoCount ); 3696 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultCountsEXT.vendorInfoCount ); 3697 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultCountsEXT.vendorBinarySize ); 3698 return seed; 3699 } 3700 }; 3701 3702 template <> 3703 struct hash<VULKAN_HPP_NAMESPACE::DeviceFaultVendorInfoEXT> 3704 { operator ()std::hash3705 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceFaultVendorInfoEXT const & deviceFaultVendorInfoEXT ) const VULKAN_HPP_NOEXCEPT 3706 { 3707 std::size_t seed = 0; 3708 for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) 3709 { 3710 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorInfoEXT.description[i] ); 3711 } 3712 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorInfoEXT.vendorFaultCode ); 3713 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorInfoEXT.vendorFaultData ); 3714 return seed; 3715 } 3716 }; 3717 3718 template <> 3719 struct hash<VULKAN_HPP_NAMESPACE::DeviceFaultInfoEXT> 3720 { operator ()std::hash3721 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceFaultInfoEXT const & deviceFaultInfoEXT ) const VULKAN_HPP_NOEXCEPT 3722 { 3723 std::size_t seed = 0; 3724 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultInfoEXT.sType ); 3725 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultInfoEXT.pNext ); 3726 for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) 3727 { 3728 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultInfoEXT.description[i] ); 3729 } 3730 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultInfoEXT.pAddressInfos ); 3731 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultInfoEXT.pVendorInfos ); 3732 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultInfoEXT.pVendorBinaryData ); 3733 return seed; 3734 } 3735 }; 3736 3737 template <> 3738 struct hash<VULKAN_HPP_NAMESPACE::DeviceFaultVendorBinaryHeaderVersionOneEXT> 3739 { operator ()std::hash3740 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceFaultVendorBinaryHeaderVersionOneEXT const & deviceFaultVendorBinaryHeaderVersionOneEXT ) const 3741 VULKAN_HPP_NOEXCEPT 3742 { 3743 std::size_t seed = 0; 3744 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.headerSize ); 3745 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.headerVersion ); 3746 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.vendorID ); 3747 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.deviceID ); 3748 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.driverVersion ); 3749 for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) 3750 { 3751 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.pipelineCacheUUID[i] ); 3752 } 3753 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.applicationNameOffset ); 3754 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.applicationVersion ); 3755 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.engineNameOffset ); 3756 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.engineVersion ); 3757 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.apiVersion ); 3758 return seed; 3759 } 3760 }; 3761 3762 template <> 3763 struct hash<VULKAN_HPP_NAMESPACE::DeviceGroupBindSparseInfo> 3764 { operator ()std::hash3765 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupBindSparseInfo const & deviceGroupBindSparseInfo ) const VULKAN_HPP_NOEXCEPT 3766 { 3767 std::size_t seed = 0; 3768 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupBindSparseInfo.sType ); 3769 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupBindSparseInfo.pNext ); 3770 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupBindSparseInfo.resourceDeviceIndex ); 3771 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupBindSparseInfo.memoryDeviceIndex ); 3772 return seed; 3773 } 3774 }; 3775 3776 template <> 3777 struct hash<VULKAN_HPP_NAMESPACE::DeviceGroupCommandBufferBeginInfo> 3778 { operator ()std::hash3779 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupCommandBufferBeginInfo const & deviceGroupCommandBufferBeginInfo ) const VULKAN_HPP_NOEXCEPT 3780 { 3781 std::size_t seed = 0; 3782 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupCommandBufferBeginInfo.sType ); 3783 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupCommandBufferBeginInfo.pNext ); 3784 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupCommandBufferBeginInfo.deviceMask ); 3785 return seed; 3786 } 3787 }; 3788 3789 template <> 3790 struct hash<VULKAN_HPP_NAMESPACE::DeviceGroupDeviceCreateInfo> 3791 { operator ()std::hash3792 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupDeviceCreateInfo const & deviceGroupDeviceCreateInfo ) const VULKAN_HPP_NOEXCEPT 3793 { 3794 std::size_t seed = 0; 3795 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupDeviceCreateInfo.sType ); 3796 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupDeviceCreateInfo.pNext ); 3797 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupDeviceCreateInfo.physicalDeviceCount ); 3798 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupDeviceCreateInfo.pPhysicalDevices ); 3799 return seed; 3800 } 3801 }; 3802 3803 template <> 3804 struct hash<VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR> 3805 { operator ()std::hash3806 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR const & deviceGroupPresentCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT 3807 { 3808 std::size_t seed = 0; 3809 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupPresentCapabilitiesKHR.sType ); 3810 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupPresentCapabilitiesKHR.pNext ); 3811 for ( size_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; ++i ) 3812 { 3813 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupPresentCapabilitiesKHR.presentMask[i] ); 3814 } 3815 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupPresentCapabilitiesKHR.modes ); 3816 return seed; 3817 } 3818 }; 3819 3820 template <> 3821 struct hash<VULKAN_HPP_NAMESPACE::DeviceGroupPresentInfoKHR> 3822 { operator ()std::hash3823 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupPresentInfoKHR const & deviceGroupPresentInfoKHR ) const VULKAN_HPP_NOEXCEPT 3824 { 3825 std::size_t seed = 0; 3826 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupPresentInfoKHR.sType ); 3827 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupPresentInfoKHR.pNext ); 3828 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupPresentInfoKHR.swapchainCount ); 3829 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupPresentInfoKHR.pDeviceMasks ); 3830 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupPresentInfoKHR.mode ); 3831 return seed; 3832 } 3833 }; 3834 3835 template <> 3836 struct hash<VULKAN_HPP_NAMESPACE::DeviceGroupRenderPassBeginInfo> 3837 { operator ()std::hash3838 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupRenderPassBeginInfo const & deviceGroupRenderPassBeginInfo ) const VULKAN_HPP_NOEXCEPT 3839 { 3840 std::size_t seed = 0; 3841 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupRenderPassBeginInfo.sType ); 3842 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupRenderPassBeginInfo.pNext ); 3843 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupRenderPassBeginInfo.deviceMask ); 3844 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupRenderPassBeginInfo.deviceRenderAreaCount ); 3845 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupRenderPassBeginInfo.pDeviceRenderAreas ); 3846 return seed; 3847 } 3848 }; 3849 3850 template <> 3851 struct hash<VULKAN_HPP_NAMESPACE::DeviceGroupSubmitInfo> 3852 { operator ()std::hash3853 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupSubmitInfo const & deviceGroupSubmitInfo ) const VULKAN_HPP_NOEXCEPT 3854 { 3855 std::size_t seed = 0; 3856 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSubmitInfo.sType ); 3857 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSubmitInfo.pNext ); 3858 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSubmitInfo.waitSemaphoreCount ); 3859 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSubmitInfo.pWaitSemaphoreDeviceIndices ); 3860 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSubmitInfo.commandBufferCount ); 3861 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSubmitInfo.pCommandBufferDeviceMasks ); 3862 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSubmitInfo.signalSemaphoreCount ); 3863 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSubmitInfo.pSignalSemaphoreDeviceIndices ); 3864 return seed; 3865 } 3866 }; 3867 3868 template <> 3869 struct hash<VULKAN_HPP_NAMESPACE::DeviceGroupSwapchainCreateInfoKHR> 3870 { operator ()std::hash3871 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupSwapchainCreateInfoKHR const & deviceGroupSwapchainCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 3872 { 3873 std::size_t seed = 0; 3874 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSwapchainCreateInfoKHR.sType ); 3875 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSwapchainCreateInfoKHR.pNext ); 3876 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSwapchainCreateInfoKHR.modes ); 3877 return seed; 3878 } 3879 }; 3880 3881 template <> 3882 struct hash<VULKAN_HPP_NAMESPACE::ImageCreateInfo> 3883 { operator ()std::hash3884 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageCreateInfo const & imageCreateInfo ) const VULKAN_HPP_NOEXCEPT 3885 { 3886 std::size_t seed = 0; 3887 VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.sType ); 3888 VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.pNext ); 3889 VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.flags ); 3890 VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.imageType ); 3891 VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.format ); 3892 VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.extent ); 3893 VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.mipLevels ); 3894 VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.arrayLayers ); 3895 VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.samples ); 3896 VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.tiling ); 3897 VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.usage ); 3898 VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.sharingMode ); 3899 VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.queueFamilyIndexCount ); 3900 VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.pQueueFamilyIndices ); 3901 VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.initialLayout ); 3902 return seed; 3903 } 3904 }; 3905 3906 template <> 3907 struct hash<VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements> 3908 { operator ()std::hash3909 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements const & deviceImageMemoryRequirements ) const VULKAN_HPP_NOEXCEPT 3910 { 3911 std::size_t seed = 0; 3912 VULKAN_HPP_HASH_COMBINE( seed, deviceImageMemoryRequirements.sType ); 3913 VULKAN_HPP_HASH_COMBINE( seed, deviceImageMemoryRequirements.pNext ); 3914 VULKAN_HPP_HASH_COMBINE( seed, deviceImageMemoryRequirements.pCreateInfo ); 3915 VULKAN_HPP_HASH_COMBINE( seed, deviceImageMemoryRequirements.planeAspect ); 3916 return seed; 3917 } 3918 }; 3919 3920 template <> 3921 struct hash<VULKAN_HPP_NAMESPACE::ImageSubresource2KHR> 3922 { operator ()std::hash3923 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageSubresource2KHR const & imageSubresource2KHR ) const VULKAN_HPP_NOEXCEPT 3924 { 3925 std::size_t seed = 0; 3926 VULKAN_HPP_HASH_COMBINE( seed, imageSubresource2KHR.sType ); 3927 VULKAN_HPP_HASH_COMBINE( seed, imageSubresource2KHR.pNext ); 3928 VULKAN_HPP_HASH_COMBINE( seed, imageSubresource2KHR.imageSubresource ); 3929 return seed; 3930 } 3931 }; 3932 3933 template <> 3934 struct hash<VULKAN_HPP_NAMESPACE::DeviceImageSubresourceInfoKHR> 3935 { operator ()std::hash3936 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceImageSubresourceInfoKHR const & deviceImageSubresourceInfoKHR ) const VULKAN_HPP_NOEXCEPT 3937 { 3938 std::size_t seed = 0; 3939 VULKAN_HPP_HASH_COMBINE( seed, deviceImageSubresourceInfoKHR.sType ); 3940 VULKAN_HPP_HASH_COMBINE( seed, deviceImageSubresourceInfoKHR.pNext ); 3941 VULKAN_HPP_HASH_COMBINE( seed, deviceImageSubresourceInfoKHR.pCreateInfo ); 3942 VULKAN_HPP_HASH_COMBINE( seed, deviceImageSubresourceInfoKHR.pSubresource ); 3943 return seed; 3944 } 3945 }; 3946 3947 template <> 3948 struct hash<VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo> 3949 { operator ()std::hash3950 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo const & deviceMemoryOpaqueCaptureAddressInfo ) const VULKAN_HPP_NOEXCEPT 3951 { 3952 std::size_t seed = 0; 3953 VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryOpaqueCaptureAddressInfo.sType ); 3954 VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryOpaqueCaptureAddressInfo.pNext ); 3955 VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryOpaqueCaptureAddressInfo.memory ); 3956 return seed; 3957 } 3958 }; 3959 3960 template <> 3961 struct hash<VULKAN_HPP_NAMESPACE::DeviceMemoryOverallocationCreateInfoAMD> 3962 { 3963 std::size_t operator ()std::hash3964 operator()( VULKAN_HPP_NAMESPACE::DeviceMemoryOverallocationCreateInfoAMD const & deviceMemoryOverallocationCreateInfoAMD ) const VULKAN_HPP_NOEXCEPT 3965 { 3966 std::size_t seed = 0; 3967 VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryOverallocationCreateInfoAMD.sType ); 3968 VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryOverallocationCreateInfoAMD.pNext ); 3969 VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryOverallocationCreateInfoAMD.overallocationBehavior ); 3970 return seed; 3971 } 3972 }; 3973 3974 template <> 3975 struct hash<VULKAN_HPP_NAMESPACE::DeviceMemoryReportCallbackDataEXT> 3976 { operator ()std::hash3977 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceMemoryReportCallbackDataEXT const & deviceMemoryReportCallbackDataEXT ) const VULKAN_HPP_NOEXCEPT 3978 { 3979 std::size_t seed = 0; 3980 VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryReportCallbackDataEXT.sType ); 3981 VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryReportCallbackDataEXT.pNext ); 3982 VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryReportCallbackDataEXT.flags ); 3983 VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryReportCallbackDataEXT.type ); 3984 VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryReportCallbackDataEXT.memoryObjectId ); 3985 VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryReportCallbackDataEXT.size ); 3986 VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryReportCallbackDataEXT.objectType ); 3987 VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryReportCallbackDataEXT.objectHandle ); 3988 VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryReportCallbackDataEXT.heapIndex ); 3989 return seed; 3990 } 3991 }; 3992 3993 template <> 3994 struct hash<VULKAN_HPP_NAMESPACE::DevicePrivateDataCreateInfo> 3995 { operator ()std::hash3996 std::size_t operator()( VULKAN_HPP_NAMESPACE::DevicePrivateDataCreateInfo const & devicePrivateDataCreateInfo ) const VULKAN_HPP_NOEXCEPT 3997 { 3998 std::size_t seed = 0; 3999 VULKAN_HPP_HASH_COMBINE( seed, devicePrivateDataCreateInfo.sType ); 4000 VULKAN_HPP_HASH_COMBINE( seed, devicePrivateDataCreateInfo.pNext ); 4001 VULKAN_HPP_HASH_COMBINE( seed, devicePrivateDataCreateInfo.privateDataSlotRequestCount ); 4002 return seed; 4003 } 4004 }; 4005 4006 template <> 4007 struct hash<VULKAN_HPP_NAMESPACE::DeviceQueueGlobalPriorityCreateInfoKHR> 4008 { 4009 std::size_t operator ()std::hash4010 operator()( VULKAN_HPP_NAMESPACE::DeviceQueueGlobalPriorityCreateInfoKHR const & deviceQueueGlobalPriorityCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 4011 { 4012 std::size_t seed = 0; 4013 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueGlobalPriorityCreateInfoKHR.sType ); 4014 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueGlobalPriorityCreateInfoKHR.pNext ); 4015 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueGlobalPriorityCreateInfoKHR.globalPriority ); 4016 return seed; 4017 } 4018 }; 4019 4020 template <> 4021 struct hash<VULKAN_HPP_NAMESPACE::DeviceQueueInfo2> 4022 { operator ()std::hash4023 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceQueueInfo2 const & deviceQueueInfo2 ) const VULKAN_HPP_NOEXCEPT 4024 { 4025 std::size_t seed = 0; 4026 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueInfo2.sType ); 4027 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueInfo2.pNext ); 4028 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueInfo2.flags ); 4029 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueInfo2.queueFamilyIndex ); 4030 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueInfo2.queueIndex ); 4031 return seed; 4032 } 4033 }; 4034 4035 template <> 4036 struct hash<VULKAN_HPP_NAMESPACE::DeviceQueueShaderCoreControlCreateInfoARM> 4037 { 4038 std::size_t operator ()std::hash4039 operator()( VULKAN_HPP_NAMESPACE::DeviceQueueShaderCoreControlCreateInfoARM const & deviceQueueShaderCoreControlCreateInfoARM ) const VULKAN_HPP_NOEXCEPT 4040 { 4041 std::size_t seed = 0; 4042 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueShaderCoreControlCreateInfoARM.sType ); 4043 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueShaderCoreControlCreateInfoARM.pNext ); 4044 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueShaderCoreControlCreateInfoARM.shaderCoreCount ); 4045 return seed; 4046 } 4047 }; 4048 4049 template <> 4050 struct hash<VULKAN_HPP_NAMESPACE::DirectDriverLoadingInfoLUNARG> 4051 { operator ()std::hash4052 std::size_t operator()( VULKAN_HPP_NAMESPACE::DirectDriverLoadingInfoLUNARG const & directDriverLoadingInfoLUNARG ) const VULKAN_HPP_NOEXCEPT 4053 { 4054 std::size_t seed = 0; 4055 VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingInfoLUNARG.sType ); 4056 VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingInfoLUNARG.pNext ); 4057 VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingInfoLUNARG.flags ); 4058 VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingInfoLUNARG.pfnGetInstanceProcAddr ); 4059 return seed; 4060 } 4061 }; 4062 4063 template <> 4064 struct hash<VULKAN_HPP_NAMESPACE::DirectDriverLoadingListLUNARG> 4065 { operator ()std::hash4066 std::size_t operator()( VULKAN_HPP_NAMESPACE::DirectDriverLoadingListLUNARG const & directDriverLoadingListLUNARG ) const VULKAN_HPP_NOEXCEPT 4067 { 4068 std::size_t seed = 0; 4069 VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingListLUNARG.sType ); 4070 VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingListLUNARG.pNext ); 4071 VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingListLUNARG.mode ); 4072 VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingListLUNARG.driverCount ); 4073 VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingListLUNARG.pDrivers ); 4074 return seed; 4075 } 4076 }; 4077 4078 # if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) 4079 template <> 4080 struct hash<VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT> 4081 { operator ()std::hash4082 std::size_t operator()( VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT const & directFBSurfaceCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 4083 { 4084 std::size_t seed = 0; 4085 VULKAN_HPP_HASH_COMBINE( seed, directFBSurfaceCreateInfoEXT.sType ); 4086 VULKAN_HPP_HASH_COMBINE( seed, directFBSurfaceCreateInfoEXT.pNext ); 4087 VULKAN_HPP_HASH_COMBINE( seed, directFBSurfaceCreateInfoEXT.flags ); 4088 VULKAN_HPP_HASH_COMBINE( seed, directFBSurfaceCreateInfoEXT.dfb ); 4089 VULKAN_HPP_HASH_COMBINE( seed, directFBSurfaceCreateInfoEXT.surface ); 4090 return seed; 4091 } 4092 }; 4093 # endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ 4094 4095 template <> 4096 struct hash<VULKAN_HPP_NAMESPACE::DispatchIndirectCommand> 4097 { operator ()std::hash4098 std::size_t operator()( VULKAN_HPP_NAMESPACE::DispatchIndirectCommand const & dispatchIndirectCommand ) const VULKAN_HPP_NOEXCEPT 4099 { 4100 std::size_t seed = 0; 4101 VULKAN_HPP_HASH_COMBINE( seed, dispatchIndirectCommand.x ); 4102 VULKAN_HPP_HASH_COMBINE( seed, dispatchIndirectCommand.y ); 4103 VULKAN_HPP_HASH_COMBINE( seed, dispatchIndirectCommand.z ); 4104 return seed; 4105 } 4106 }; 4107 4108 template <> 4109 struct hash<VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT> 4110 { operator ()std::hash4111 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT const & displayEventInfoEXT ) const VULKAN_HPP_NOEXCEPT 4112 { 4113 std::size_t seed = 0; 4114 VULKAN_HPP_HASH_COMBINE( seed, displayEventInfoEXT.sType ); 4115 VULKAN_HPP_HASH_COMBINE( seed, displayEventInfoEXT.pNext ); 4116 VULKAN_HPP_HASH_COMBINE( seed, displayEventInfoEXT.displayEvent ); 4117 return seed; 4118 } 4119 }; 4120 4121 template <> 4122 struct hash<VULKAN_HPP_NAMESPACE::DisplayModeParametersKHR> 4123 { operator ()std::hash4124 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayModeParametersKHR const & displayModeParametersKHR ) const VULKAN_HPP_NOEXCEPT 4125 { 4126 std::size_t seed = 0; 4127 VULKAN_HPP_HASH_COMBINE( seed, displayModeParametersKHR.visibleRegion ); 4128 VULKAN_HPP_HASH_COMBINE( seed, displayModeParametersKHR.refreshRate ); 4129 return seed; 4130 } 4131 }; 4132 4133 template <> 4134 struct hash<VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR> 4135 { operator ()std::hash4136 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR const & displayModeCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 4137 { 4138 std::size_t seed = 0; 4139 VULKAN_HPP_HASH_COMBINE( seed, displayModeCreateInfoKHR.sType ); 4140 VULKAN_HPP_HASH_COMBINE( seed, displayModeCreateInfoKHR.pNext ); 4141 VULKAN_HPP_HASH_COMBINE( seed, displayModeCreateInfoKHR.flags ); 4142 VULKAN_HPP_HASH_COMBINE( seed, displayModeCreateInfoKHR.parameters ); 4143 return seed; 4144 } 4145 }; 4146 4147 template <> 4148 struct hash<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR> 4149 { operator ()std::hash4150 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR const & displayModePropertiesKHR ) const VULKAN_HPP_NOEXCEPT 4151 { 4152 std::size_t seed = 0; 4153 VULKAN_HPP_HASH_COMBINE( seed, displayModePropertiesKHR.displayMode ); 4154 VULKAN_HPP_HASH_COMBINE( seed, displayModePropertiesKHR.parameters ); 4155 return seed; 4156 } 4157 }; 4158 4159 template <> 4160 struct hash<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR> 4161 { operator ()std::hash4162 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR const & displayModeProperties2KHR ) const VULKAN_HPP_NOEXCEPT 4163 { 4164 std::size_t seed = 0; 4165 VULKAN_HPP_HASH_COMBINE( seed, displayModeProperties2KHR.sType ); 4166 VULKAN_HPP_HASH_COMBINE( seed, displayModeProperties2KHR.pNext ); 4167 VULKAN_HPP_HASH_COMBINE( seed, displayModeProperties2KHR.displayModeProperties ); 4168 return seed; 4169 } 4170 }; 4171 4172 template <> 4173 struct hash<VULKAN_HPP_NAMESPACE::DisplayNativeHdrSurfaceCapabilitiesAMD> 4174 { 4175 std::size_t operator ()std::hash4176 operator()( VULKAN_HPP_NAMESPACE::DisplayNativeHdrSurfaceCapabilitiesAMD const & displayNativeHdrSurfaceCapabilitiesAMD ) const VULKAN_HPP_NOEXCEPT 4177 { 4178 std::size_t seed = 0; 4179 VULKAN_HPP_HASH_COMBINE( seed, displayNativeHdrSurfaceCapabilitiesAMD.sType ); 4180 VULKAN_HPP_HASH_COMBINE( seed, displayNativeHdrSurfaceCapabilitiesAMD.pNext ); 4181 VULKAN_HPP_HASH_COMBINE( seed, displayNativeHdrSurfaceCapabilitiesAMD.localDimmingSupport ); 4182 return seed; 4183 } 4184 }; 4185 4186 template <> 4187 struct hash<VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR> 4188 { operator ()std::hash4189 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR const & displayPlaneCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT 4190 { 4191 std::size_t seed = 0; 4192 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilitiesKHR.supportedAlpha ); 4193 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilitiesKHR.minSrcPosition ); 4194 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilitiesKHR.maxSrcPosition ); 4195 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilitiesKHR.minSrcExtent ); 4196 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilitiesKHR.maxSrcExtent ); 4197 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilitiesKHR.minDstPosition ); 4198 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilitiesKHR.maxDstPosition ); 4199 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilitiesKHR.minDstExtent ); 4200 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilitiesKHR.maxDstExtent ); 4201 return seed; 4202 } 4203 }; 4204 4205 template <> 4206 struct hash<VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR> 4207 { operator ()std::hash4208 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR const & displayPlaneCapabilities2KHR ) const VULKAN_HPP_NOEXCEPT 4209 { 4210 std::size_t seed = 0; 4211 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilities2KHR.sType ); 4212 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilities2KHR.pNext ); 4213 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilities2KHR.capabilities ); 4214 return seed; 4215 } 4216 }; 4217 4218 template <> 4219 struct hash<VULKAN_HPP_NAMESPACE::DisplayPlaneInfo2KHR> 4220 { operator ()std::hash4221 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPlaneInfo2KHR const & displayPlaneInfo2KHR ) const VULKAN_HPP_NOEXCEPT 4222 { 4223 std::size_t seed = 0; 4224 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneInfo2KHR.sType ); 4225 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneInfo2KHR.pNext ); 4226 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneInfo2KHR.mode ); 4227 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneInfo2KHR.planeIndex ); 4228 return seed; 4229 } 4230 }; 4231 4232 template <> 4233 struct hash<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR> 4234 { operator ()std::hash4235 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR const & displayPlanePropertiesKHR ) const VULKAN_HPP_NOEXCEPT 4236 { 4237 std::size_t seed = 0; 4238 VULKAN_HPP_HASH_COMBINE( seed, displayPlanePropertiesKHR.currentDisplay ); 4239 VULKAN_HPP_HASH_COMBINE( seed, displayPlanePropertiesKHR.currentStackIndex ); 4240 return seed; 4241 } 4242 }; 4243 4244 template <> 4245 struct hash<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR> 4246 { operator ()std::hash4247 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR const & displayPlaneProperties2KHR ) const VULKAN_HPP_NOEXCEPT 4248 { 4249 std::size_t seed = 0; 4250 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneProperties2KHR.sType ); 4251 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneProperties2KHR.pNext ); 4252 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneProperties2KHR.displayPlaneProperties ); 4253 return seed; 4254 } 4255 }; 4256 4257 template <> 4258 struct hash<VULKAN_HPP_NAMESPACE::DisplayPowerInfoEXT> 4259 { operator ()std::hash4260 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPowerInfoEXT const & displayPowerInfoEXT ) const VULKAN_HPP_NOEXCEPT 4261 { 4262 std::size_t seed = 0; 4263 VULKAN_HPP_HASH_COMBINE( seed, displayPowerInfoEXT.sType ); 4264 VULKAN_HPP_HASH_COMBINE( seed, displayPowerInfoEXT.pNext ); 4265 VULKAN_HPP_HASH_COMBINE( seed, displayPowerInfoEXT.powerState ); 4266 return seed; 4267 } 4268 }; 4269 4270 template <> 4271 struct hash<VULKAN_HPP_NAMESPACE::DisplayPresentInfoKHR> 4272 { operator ()std::hash4273 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPresentInfoKHR const & displayPresentInfoKHR ) const VULKAN_HPP_NOEXCEPT 4274 { 4275 std::size_t seed = 0; 4276 VULKAN_HPP_HASH_COMBINE( seed, displayPresentInfoKHR.sType ); 4277 VULKAN_HPP_HASH_COMBINE( seed, displayPresentInfoKHR.pNext ); 4278 VULKAN_HPP_HASH_COMBINE( seed, displayPresentInfoKHR.srcRect ); 4279 VULKAN_HPP_HASH_COMBINE( seed, displayPresentInfoKHR.dstRect ); 4280 VULKAN_HPP_HASH_COMBINE( seed, displayPresentInfoKHR.persistent ); 4281 return seed; 4282 } 4283 }; 4284 4285 template <> 4286 struct hash<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR> 4287 { operator ()std::hash4288 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR const & displayPropertiesKHR ) const VULKAN_HPP_NOEXCEPT 4289 { 4290 std::size_t seed = 0; 4291 VULKAN_HPP_HASH_COMBINE( seed, displayPropertiesKHR.display ); 4292 for ( const char * p = displayPropertiesKHR.displayName; *p != '\0'; ++p ) 4293 { 4294 VULKAN_HPP_HASH_COMBINE( seed, *p ); 4295 } 4296 VULKAN_HPP_HASH_COMBINE( seed, displayPropertiesKHR.physicalDimensions ); 4297 VULKAN_HPP_HASH_COMBINE( seed, displayPropertiesKHR.physicalResolution ); 4298 VULKAN_HPP_HASH_COMBINE( seed, displayPropertiesKHR.supportedTransforms ); 4299 VULKAN_HPP_HASH_COMBINE( seed, displayPropertiesKHR.planeReorderPossible ); 4300 VULKAN_HPP_HASH_COMBINE( seed, displayPropertiesKHR.persistentContent ); 4301 return seed; 4302 } 4303 }; 4304 4305 template <> 4306 struct hash<VULKAN_HPP_NAMESPACE::DisplayProperties2KHR> 4307 { operator ()std::hash4308 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayProperties2KHR const & displayProperties2KHR ) const VULKAN_HPP_NOEXCEPT 4309 { 4310 std::size_t seed = 0; 4311 VULKAN_HPP_HASH_COMBINE( seed, displayProperties2KHR.sType ); 4312 VULKAN_HPP_HASH_COMBINE( seed, displayProperties2KHR.pNext ); 4313 VULKAN_HPP_HASH_COMBINE( seed, displayProperties2KHR.displayProperties ); 4314 return seed; 4315 } 4316 }; 4317 4318 template <> 4319 struct hash<VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR> 4320 { operator ()std::hash4321 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR const & displaySurfaceCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 4322 { 4323 std::size_t seed = 0; 4324 VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.sType ); 4325 VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.pNext ); 4326 VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.flags ); 4327 VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.displayMode ); 4328 VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.planeIndex ); 4329 VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.planeStackIndex ); 4330 VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.transform ); 4331 VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.globalAlpha ); 4332 VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.alphaMode ); 4333 VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.imageExtent ); 4334 return seed; 4335 } 4336 }; 4337 4338 template <> 4339 struct hash<VULKAN_HPP_NAMESPACE::DrawIndexedIndirectCommand> 4340 { operator ()std::hash4341 std::size_t operator()( VULKAN_HPP_NAMESPACE::DrawIndexedIndirectCommand const & drawIndexedIndirectCommand ) const VULKAN_HPP_NOEXCEPT 4342 { 4343 std::size_t seed = 0; 4344 VULKAN_HPP_HASH_COMBINE( seed, drawIndexedIndirectCommand.indexCount ); 4345 VULKAN_HPP_HASH_COMBINE( seed, drawIndexedIndirectCommand.instanceCount ); 4346 VULKAN_HPP_HASH_COMBINE( seed, drawIndexedIndirectCommand.firstIndex ); 4347 VULKAN_HPP_HASH_COMBINE( seed, drawIndexedIndirectCommand.vertexOffset ); 4348 VULKAN_HPP_HASH_COMBINE( seed, drawIndexedIndirectCommand.firstInstance ); 4349 return seed; 4350 } 4351 }; 4352 4353 template <> 4354 struct hash<VULKAN_HPP_NAMESPACE::DrawIndirectCommand> 4355 { operator ()std::hash4356 std::size_t operator()( VULKAN_HPP_NAMESPACE::DrawIndirectCommand const & drawIndirectCommand ) const VULKAN_HPP_NOEXCEPT 4357 { 4358 std::size_t seed = 0; 4359 VULKAN_HPP_HASH_COMBINE( seed, drawIndirectCommand.vertexCount ); 4360 VULKAN_HPP_HASH_COMBINE( seed, drawIndirectCommand.instanceCount ); 4361 VULKAN_HPP_HASH_COMBINE( seed, drawIndirectCommand.firstVertex ); 4362 VULKAN_HPP_HASH_COMBINE( seed, drawIndirectCommand.firstInstance ); 4363 return seed; 4364 } 4365 }; 4366 4367 template <> 4368 struct hash<VULKAN_HPP_NAMESPACE::DrawMeshTasksIndirectCommandEXT> 4369 { operator ()std::hash4370 std::size_t operator()( VULKAN_HPP_NAMESPACE::DrawMeshTasksIndirectCommandEXT const & drawMeshTasksIndirectCommandEXT ) const VULKAN_HPP_NOEXCEPT 4371 { 4372 std::size_t seed = 0; 4373 VULKAN_HPP_HASH_COMBINE( seed, drawMeshTasksIndirectCommandEXT.groupCountX ); 4374 VULKAN_HPP_HASH_COMBINE( seed, drawMeshTasksIndirectCommandEXT.groupCountY ); 4375 VULKAN_HPP_HASH_COMBINE( seed, drawMeshTasksIndirectCommandEXT.groupCountZ ); 4376 return seed; 4377 } 4378 }; 4379 4380 template <> 4381 struct hash<VULKAN_HPP_NAMESPACE::DrawMeshTasksIndirectCommandNV> 4382 { operator ()std::hash4383 std::size_t operator()( VULKAN_HPP_NAMESPACE::DrawMeshTasksIndirectCommandNV const & drawMeshTasksIndirectCommandNV ) const VULKAN_HPP_NOEXCEPT 4384 { 4385 std::size_t seed = 0; 4386 VULKAN_HPP_HASH_COMBINE( seed, drawMeshTasksIndirectCommandNV.taskCount ); 4387 VULKAN_HPP_HASH_COMBINE( seed, drawMeshTasksIndirectCommandNV.firstTask ); 4388 return seed; 4389 } 4390 }; 4391 4392 template <> 4393 struct hash<VULKAN_HPP_NAMESPACE::DrmFormatModifierProperties2EXT> 4394 { operator ()std::hash4395 std::size_t operator()( VULKAN_HPP_NAMESPACE::DrmFormatModifierProperties2EXT const & drmFormatModifierProperties2EXT ) const VULKAN_HPP_NOEXCEPT 4396 { 4397 std::size_t seed = 0; 4398 VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierProperties2EXT.drmFormatModifier ); 4399 VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierProperties2EXT.drmFormatModifierPlaneCount ); 4400 VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierProperties2EXT.drmFormatModifierTilingFeatures ); 4401 return seed; 4402 } 4403 }; 4404 4405 template <> 4406 struct hash<VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesEXT> 4407 { operator ()std::hash4408 std::size_t operator()( VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesEXT const & drmFormatModifierPropertiesEXT ) const VULKAN_HPP_NOEXCEPT 4409 { 4410 std::size_t seed = 0; 4411 VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesEXT.drmFormatModifier ); 4412 VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesEXT.drmFormatModifierPlaneCount ); 4413 VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesEXT.drmFormatModifierTilingFeatures ); 4414 return seed; 4415 } 4416 }; 4417 4418 template <> 4419 struct hash<VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesList2EXT> 4420 { operator ()std::hash4421 std::size_t operator()( VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesList2EXT const & drmFormatModifierPropertiesList2EXT ) const VULKAN_HPP_NOEXCEPT 4422 { 4423 std::size_t seed = 0; 4424 VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesList2EXT.sType ); 4425 VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesList2EXT.pNext ); 4426 VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesList2EXT.drmFormatModifierCount ); 4427 VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesList2EXT.pDrmFormatModifierProperties ); 4428 return seed; 4429 } 4430 }; 4431 4432 template <> 4433 struct hash<VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesListEXT> 4434 { operator ()std::hash4435 std::size_t operator()( VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesListEXT const & drmFormatModifierPropertiesListEXT ) const VULKAN_HPP_NOEXCEPT 4436 { 4437 std::size_t seed = 0; 4438 VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesListEXT.sType ); 4439 VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesListEXT.pNext ); 4440 VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesListEXT.drmFormatModifierCount ); 4441 VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesListEXT.pDrmFormatModifierProperties ); 4442 return seed; 4443 } 4444 }; 4445 4446 template <> 4447 struct hash<VULKAN_HPP_NAMESPACE::EventCreateInfo> 4448 { operator ()std::hash4449 std::size_t operator()( VULKAN_HPP_NAMESPACE::EventCreateInfo const & eventCreateInfo ) const VULKAN_HPP_NOEXCEPT 4450 { 4451 std::size_t seed = 0; 4452 VULKAN_HPP_HASH_COMBINE( seed, eventCreateInfo.sType ); 4453 VULKAN_HPP_HASH_COMBINE( seed, eventCreateInfo.pNext ); 4454 VULKAN_HPP_HASH_COMBINE( seed, eventCreateInfo.flags ); 4455 return seed; 4456 } 4457 }; 4458 4459 template <> 4460 struct hash<VULKAN_HPP_NAMESPACE::PipelineLibraryCreateInfoKHR> 4461 { operator ()std::hash4462 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineLibraryCreateInfoKHR const & pipelineLibraryCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 4463 { 4464 std::size_t seed = 0; 4465 VULKAN_HPP_HASH_COMBINE( seed, pipelineLibraryCreateInfoKHR.sType ); 4466 VULKAN_HPP_HASH_COMBINE( seed, pipelineLibraryCreateInfoKHR.pNext ); 4467 VULKAN_HPP_HASH_COMBINE( seed, pipelineLibraryCreateInfoKHR.libraryCount ); 4468 VULKAN_HPP_HASH_COMBINE( seed, pipelineLibraryCreateInfoKHR.pLibraries ); 4469 return seed; 4470 } 4471 }; 4472 4473 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 4474 template <> 4475 struct hash<VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX> 4476 { operator ()std::hash4477 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX const & executionGraphPipelineCreateInfoAMDX ) const VULKAN_HPP_NOEXCEPT 4478 { 4479 std::size_t seed = 0; 4480 VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineCreateInfoAMDX.sType ); 4481 VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineCreateInfoAMDX.pNext ); 4482 VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineCreateInfoAMDX.flags ); 4483 VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineCreateInfoAMDX.stageCount ); 4484 VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineCreateInfoAMDX.pStages ); 4485 VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineCreateInfoAMDX.pLibraryInfo ); 4486 VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineCreateInfoAMDX.layout ); 4487 VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineCreateInfoAMDX.basePipelineHandle ); 4488 VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineCreateInfoAMDX.basePipelineIndex ); 4489 return seed; 4490 } 4491 }; 4492 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 4493 4494 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 4495 template <> 4496 struct hash<VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineScratchSizeAMDX> 4497 { 4498 std::size_t operator ()std::hash4499 operator()( VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineScratchSizeAMDX const & executionGraphPipelineScratchSizeAMDX ) const VULKAN_HPP_NOEXCEPT 4500 { 4501 std::size_t seed = 0; 4502 VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineScratchSizeAMDX.sType ); 4503 VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineScratchSizeAMDX.pNext ); 4504 VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineScratchSizeAMDX.size ); 4505 return seed; 4506 } 4507 }; 4508 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 4509 4510 template <> 4511 struct hash<VULKAN_HPP_NAMESPACE::ExportFenceCreateInfo> 4512 { operator ()std::hash4513 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportFenceCreateInfo const & exportFenceCreateInfo ) const VULKAN_HPP_NOEXCEPT 4514 { 4515 std::size_t seed = 0; 4516 VULKAN_HPP_HASH_COMBINE( seed, exportFenceCreateInfo.sType ); 4517 VULKAN_HPP_HASH_COMBINE( seed, exportFenceCreateInfo.pNext ); 4518 VULKAN_HPP_HASH_COMBINE( seed, exportFenceCreateInfo.handleTypes ); 4519 return seed; 4520 } 4521 }; 4522 4523 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 4524 template <> 4525 struct hash<VULKAN_HPP_NAMESPACE::ExportFenceWin32HandleInfoKHR> 4526 { operator ()std::hash4527 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportFenceWin32HandleInfoKHR const & exportFenceWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT 4528 { 4529 std::size_t seed = 0; 4530 VULKAN_HPP_HASH_COMBINE( seed, exportFenceWin32HandleInfoKHR.sType ); 4531 VULKAN_HPP_HASH_COMBINE( seed, exportFenceWin32HandleInfoKHR.pNext ); 4532 VULKAN_HPP_HASH_COMBINE( seed, exportFenceWin32HandleInfoKHR.pAttributes ); 4533 VULKAN_HPP_HASH_COMBINE( seed, exportFenceWin32HandleInfoKHR.dwAccess ); 4534 VULKAN_HPP_HASH_COMBINE( seed, exportFenceWin32HandleInfoKHR.name ); 4535 return seed; 4536 } 4537 }; 4538 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 4539 4540 template <> 4541 struct hash<VULKAN_HPP_NAMESPACE::ExportMemoryAllocateInfo> 4542 { operator ()std::hash4543 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMemoryAllocateInfo const & exportMemoryAllocateInfo ) const VULKAN_HPP_NOEXCEPT 4544 { 4545 std::size_t seed = 0; 4546 VULKAN_HPP_HASH_COMBINE( seed, exportMemoryAllocateInfo.sType ); 4547 VULKAN_HPP_HASH_COMBINE( seed, exportMemoryAllocateInfo.pNext ); 4548 VULKAN_HPP_HASH_COMBINE( seed, exportMemoryAllocateInfo.handleTypes ); 4549 return seed; 4550 } 4551 }; 4552 4553 template <> 4554 struct hash<VULKAN_HPP_NAMESPACE::ExportMemoryAllocateInfoNV> 4555 { operator ()std::hash4556 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMemoryAllocateInfoNV const & exportMemoryAllocateInfoNV ) const VULKAN_HPP_NOEXCEPT 4557 { 4558 std::size_t seed = 0; 4559 VULKAN_HPP_HASH_COMBINE( seed, exportMemoryAllocateInfoNV.sType ); 4560 VULKAN_HPP_HASH_COMBINE( seed, exportMemoryAllocateInfoNV.pNext ); 4561 VULKAN_HPP_HASH_COMBINE( seed, exportMemoryAllocateInfoNV.handleTypes ); 4562 return seed; 4563 } 4564 }; 4565 4566 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 4567 template <> 4568 struct hash<VULKAN_HPP_NAMESPACE::ExportMemoryWin32HandleInfoKHR> 4569 { operator ()std::hash4570 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMemoryWin32HandleInfoKHR const & exportMemoryWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT 4571 { 4572 std::size_t seed = 0; 4573 VULKAN_HPP_HASH_COMBINE( seed, exportMemoryWin32HandleInfoKHR.sType ); 4574 VULKAN_HPP_HASH_COMBINE( seed, exportMemoryWin32HandleInfoKHR.pNext ); 4575 VULKAN_HPP_HASH_COMBINE( seed, exportMemoryWin32HandleInfoKHR.pAttributes ); 4576 VULKAN_HPP_HASH_COMBINE( seed, exportMemoryWin32HandleInfoKHR.dwAccess ); 4577 VULKAN_HPP_HASH_COMBINE( seed, exportMemoryWin32HandleInfoKHR.name ); 4578 return seed; 4579 } 4580 }; 4581 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 4582 4583 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 4584 template <> 4585 struct hash<VULKAN_HPP_NAMESPACE::ExportMemoryWin32HandleInfoNV> 4586 { operator ()std::hash4587 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMemoryWin32HandleInfoNV const & exportMemoryWin32HandleInfoNV ) const VULKAN_HPP_NOEXCEPT 4588 { 4589 std::size_t seed = 0; 4590 VULKAN_HPP_HASH_COMBINE( seed, exportMemoryWin32HandleInfoNV.sType ); 4591 VULKAN_HPP_HASH_COMBINE( seed, exportMemoryWin32HandleInfoNV.pNext ); 4592 VULKAN_HPP_HASH_COMBINE( seed, exportMemoryWin32HandleInfoNV.pAttributes ); 4593 VULKAN_HPP_HASH_COMBINE( seed, exportMemoryWin32HandleInfoNV.dwAccess ); 4594 return seed; 4595 } 4596 }; 4597 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 4598 4599 # if defined( VK_USE_PLATFORM_METAL_EXT ) 4600 template <> 4601 struct hash<VULKAN_HPP_NAMESPACE::ExportMetalBufferInfoEXT> 4602 { operator ()std::hash4603 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMetalBufferInfoEXT const & exportMetalBufferInfoEXT ) const VULKAN_HPP_NOEXCEPT 4604 { 4605 std::size_t seed = 0; 4606 VULKAN_HPP_HASH_COMBINE( seed, exportMetalBufferInfoEXT.sType ); 4607 VULKAN_HPP_HASH_COMBINE( seed, exportMetalBufferInfoEXT.pNext ); 4608 VULKAN_HPP_HASH_COMBINE( seed, exportMetalBufferInfoEXT.memory ); 4609 VULKAN_HPP_HASH_COMBINE( seed, exportMetalBufferInfoEXT.mtlBuffer ); 4610 return seed; 4611 } 4612 }; 4613 # endif /*VK_USE_PLATFORM_METAL_EXT*/ 4614 4615 # if defined( VK_USE_PLATFORM_METAL_EXT ) 4616 template <> 4617 struct hash<VULKAN_HPP_NAMESPACE::ExportMetalCommandQueueInfoEXT> 4618 { operator ()std::hash4619 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMetalCommandQueueInfoEXT const & exportMetalCommandQueueInfoEXT ) const VULKAN_HPP_NOEXCEPT 4620 { 4621 std::size_t seed = 0; 4622 VULKAN_HPP_HASH_COMBINE( seed, exportMetalCommandQueueInfoEXT.sType ); 4623 VULKAN_HPP_HASH_COMBINE( seed, exportMetalCommandQueueInfoEXT.pNext ); 4624 VULKAN_HPP_HASH_COMBINE( seed, exportMetalCommandQueueInfoEXT.queue ); 4625 VULKAN_HPP_HASH_COMBINE( seed, exportMetalCommandQueueInfoEXT.mtlCommandQueue ); 4626 return seed; 4627 } 4628 }; 4629 # endif /*VK_USE_PLATFORM_METAL_EXT*/ 4630 4631 # if defined( VK_USE_PLATFORM_METAL_EXT ) 4632 template <> 4633 struct hash<VULKAN_HPP_NAMESPACE::ExportMetalDeviceInfoEXT> 4634 { operator ()std::hash4635 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMetalDeviceInfoEXT const & exportMetalDeviceInfoEXT ) const VULKAN_HPP_NOEXCEPT 4636 { 4637 std::size_t seed = 0; 4638 VULKAN_HPP_HASH_COMBINE( seed, exportMetalDeviceInfoEXT.sType ); 4639 VULKAN_HPP_HASH_COMBINE( seed, exportMetalDeviceInfoEXT.pNext ); 4640 VULKAN_HPP_HASH_COMBINE( seed, exportMetalDeviceInfoEXT.mtlDevice ); 4641 return seed; 4642 } 4643 }; 4644 # endif /*VK_USE_PLATFORM_METAL_EXT*/ 4645 4646 # if defined( VK_USE_PLATFORM_METAL_EXT ) 4647 template <> 4648 struct hash<VULKAN_HPP_NAMESPACE::ExportMetalIOSurfaceInfoEXT> 4649 { operator ()std::hash4650 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMetalIOSurfaceInfoEXT const & exportMetalIOSurfaceInfoEXT ) const VULKAN_HPP_NOEXCEPT 4651 { 4652 std::size_t seed = 0; 4653 VULKAN_HPP_HASH_COMBINE( seed, exportMetalIOSurfaceInfoEXT.sType ); 4654 VULKAN_HPP_HASH_COMBINE( seed, exportMetalIOSurfaceInfoEXT.pNext ); 4655 VULKAN_HPP_HASH_COMBINE( seed, exportMetalIOSurfaceInfoEXT.image ); 4656 VULKAN_HPP_HASH_COMBINE( seed, exportMetalIOSurfaceInfoEXT.ioSurface ); 4657 return seed; 4658 } 4659 }; 4660 # endif /*VK_USE_PLATFORM_METAL_EXT*/ 4661 4662 # if defined( VK_USE_PLATFORM_METAL_EXT ) 4663 template <> 4664 struct hash<VULKAN_HPP_NAMESPACE::ExportMetalObjectCreateInfoEXT> 4665 { operator ()std::hash4666 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMetalObjectCreateInfoEXT const & exportMetalObjectCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 4667 { 4668 std::size_t seed = 0; 4669 VULKAN_HPP_HASH_COMBINE( seed, exportMetalObjectCreateInfoEXT.sType ); 4670 VULKAN_HPP_HASH_COMBINE( seed, exportMetalObjectCreateInfoEXT.pNext ); 4671 VULKAN_HPP_HASH_COMBINE( seed, exportMetalObjectCreateInfoEXT.exportObjectType ); 4672 return seed; 4673 } 4674 }; 4675 # endif /*VK_USE_PLATFORM_METAL_EXT*/ 4676 4677 # if defined( VK_USE_PLATFORM_METAL_EXT ) 4678 template <> 4679 struct hash<VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT> 4680 { operator ()std::hash4681 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT const & exportMetalObjectsInfoEXT ) const VULKAN_HPP_NOEXCEPT 4682 { 4683 std::size_t seed = 0; 4684 VULKAN_HPP_HASH_COMBINE( seed, exportMetalObjectsInfoEXT.sType ); 4685 VULKAN_HPP_HASH_COMBINE( seed, exportMetalObjectsInfoEXT.pNext ); 4686 return seed; 4687 } 4688 }; 4689 # endif /*VK_USE_PLATFORM_METAL_EXT*/ 4690 4691 # if defined( VK_USE_PLATFORM_METAL_EXT ) 4692 template <> 4693 struct hash<VULKAN_HPP_NAMESPACE::ExportMetalSharedEventInfoEXT> 4694 { operator ()std::hash4695 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMetalSharedEventInfoEXT const & exportMetalSharedEventInfoEXT ) const VULKAN_HPP_NOEXCEPT 4696 { 4697 std::size_t seed = 0; 4698 VULKAN_HPP_HASH_COMBINE( seed, exportMetalSharedEventInfoEXT.sType ); 4699 VULKAN_HPP_HASH_COMBINE( seed, exportMetalSharedEventInfoEXT.pNext ); 4700 VULKAN_HPP_HASH_COMBINE( seed, exportMetalSharedEventInfoEXT.semaphore ); 4701 VULKAN_HPP_HASH_COMBINE( seed, exportMetalSharedEventInfoEXT.event ); 4702 VULKAN_HPP_HASH_COMBINE( seed, exportMetalSharedEventInfoEXT.mtlSharedEvent ); 4703 return seed; 4704 } 4705 }; 4706 # endif /*VK_USE_PLATFORM_METAL_EXT*/ 4707 4708 # if defined( VK_USE_PLATFORM_METAL_EXT ) 4709 template <> 4710 struct hash<VULKAN_HPP_NAMESPACE::ExportMetalTextureInfoEXT> 4711 { operator ()std::hash4712 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMetalTextureInfoEXT const & exportMetalTextureInfoEXT ) const VULKAN_HPP_NOEXCEPT 4713 { 4714 std::size_t seed = 0; 4715 VULKAN_HPP_HASH_COMBINE( seed, exportMetalTextureInfoEXT.sType ); 4716 VULKAN_HPP_HASH_COMBINE( seed, exportMetalTextureInfoEXT.pNext ); 4717 VULKAN_HPP_HASH_COMBINE( seed, exportMetalTextureInfoEXT.image ); 4718 VULKAN_HPP_HASH_COMBINE( seed, exportMetalTextureInfoEXT.imageView ); 4719 VULKAN_HPP_HASH_COMBINE( seed, exportMetalTextureInfoEXT.bufferView ); 4720 VULKAN_HPP_HASH_COMBINE( seed, exportMetalTextureInfoEXT.plane ); 4721 VULKAN_HPP_HASH_COMBINE( seed, exportMetalTextureInfoEXT.mtlTexture ); 4722 return seed; 4723 } 4724 }; 4725 # endif /*VK_USE_PLATFORM_METAL_EXT*/ 4726 4727 template <> 4728 struct hash<VULKAN_HPP_NAMESPACE::ExportSemaphoreCreateInfo> 4729 { operator ()std::hash4730 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportSemaphoreCreateInfo const & exportSemaphoreCreateInfo ) const VULKAN_HPP_NOEXCEPT 4731 { 4732 std::size_t seed = 0; 4733 VULKAN_HPP_HASH_COMBINE( seed, exportSemaphoreCreateInfo.sType ); 4734 VULKAN_HPP_HASH_COMBINE( seed, exportSemaphoreCreateInfo.pNext ); 4735 VULKAN_HPP_HASH_COMBINE( seed, exportSemaphoreCreateInfo.handleTypes ); 4736 return seed; 4737 } 4738 }; 4739 4740 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 4741 template <> 4742 struct hash<VULKAN_HPP_NAMESPACE::ExportSemaphoreWin32HandleInfoKHR> 4743 { operator ()std::hash4744 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportSemaphoreWin32HandleInfoKHR const & exportSemaphoreWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT 4745 { 4746 std::size_t seed = 0; 4747 VULKAN_HPP_HASH_COMBINE( seed, exportSemaphoreWin32HandleInfoKHR.sType ); 4748 VULKAN_HPP_HASH_COMBINE( seed, exportSemaphoreWin32HandleInfoKHR.pNext ); 4749 VULKAN_HPP_HASH_COMBINE( seed, exportSemaphoreWin32HandleInfoKHR.pAttributes ); 4750 VULKAN_HPP_HASH_COMBINE( seed, exportSemaphoreWin32HandleInfoKHR.dwAccess ); 4751 VULKAN_HPP_HASH_COMBINE( seed, exportSemaphoreWin32HandleInfoKHR.name ); 4752 return seed; 4753 } 4754 }; 4755 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 4756 4757 template <> 4758 struct hash<VULKAN_HPP_NAMESPACE::ExtensionProperties> 4759 { operator ()std::hash4760 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExtensionProperties const & extensionProperties ) const VULKAN_HPP_NOEXCEPT 4761 { 4762 std::size_t seed = 0; 4763 for ( size_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i ) 4764 { 4765 VULKAN_HPP_HASH_COMBINE( seed, extensionProperties.extensionName[i] ); 4766 } 4767 VULKAN_HPP_HASH_COMBINE( seed, extensionProperties.specVersion ); 4768 return seed; 4769 } 4770 }; 4771 4772 template <> 4773 struct hash<VULKAN_HPP_NAMESPACE::ExternalMemoryProperties> 4774 { operator ()std::hash4775 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalMemoryProperties const & externalMemoryProperties ) const VULKAN_HPP_NOEXCEPT 4776 { 4777 std::size_t seed = 0; 4778 VULKAN_HPP_HASH_COMBINE( seed, externalMemoryProperties.externalMemoryFeatures ); 4779 VULKAN_HPP_HASH_COMBINE( seed, externalMemoryProperties.exportFromImportedHandleTypes ); 4780 VULKAN_HPP_HASH_COMBINE( seed, externalMemoryProperties.compatibleHandleTypes ); 4781 return seed; 4782 } 4783 }; 4784 4785 template <> 4786 struct hash<VULKAN_HPP_NAMESPACE::ExternalBufferProperties> 4787 { operator ()std::hash4788 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalBufferProperties const & externalBufferProperties ) const VULKAN_HPP_NOEXCEPT 4789 { 4790 std::size_t seed = 0; 4791 VULKAN_HPP_HASH_COMBINE( seed, externalBufferProperties.sType ); 4792 VULKAN_HPP_HASH_COMBINE( seed, externalBufferProperties.pNext ); 4793 VULKAN_HPP_HASH_COMBINE( seed, externalBufferProperties.externalMemoryProperties ); 4794 return seed; 4795 } 4796 }; 4797 4798 template <> 4799 struct hash<VULKAN_HPP_NAMESPACE::ExternalFenceProperties> 4800 { operator ()std::hash4801 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalFenceProperties const & externalFenceProperties ) const VULKAN_HPP_NOEXCEPT 4802 { 4803 std::size_t seed = 0; 4804 VULKAN_HPP_HASH_COMBINE( seed, externalFenceProperties.sType ); 4805 VULKAN_HPP_HASH_COMBINE( seed, externalFenceProperties.pNext ); 4806 VULKAN_HPP_HASH_COMBINE( seed, externalFenceProperties.exportFromImportedHandleTypes ); 4807 VULKAN_HPP_HASH_COMBINE( seed, externalFenceProperties.compatibleHandleTypes ); 4808 VULKAN_HPP_HASH_COMBINE( seed, externalFenceProperties.externalFenceFeatures ); 4809 return seed; 4810 } 4811 }; 4812 4813 # if defined( VK_USE_PLATFORM_ANDROID_KHR ) 4814 template <> 4815 struct hash<VULKAN_HPP_NAMESPACE::ExternalFormatANDROID> 4816 { operator ()std::hash4817 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalFormatANDROID const & externalFormatANDROID ) const VULKAN_HPP_NOEXCEPT 4818 { 4819 std::size_t seed = 0; 4820 VULKAN_HPP_HASH_COMBINE( seed, externalFormatANDROID.sType ); 4821 VULKAN_HPP_HASH_COMBINE( seed, externalFormatANDROID.pNext ); 4822 VULKAN_HPP_HASH_COMBINE( seed, externalFormatANDROID.externalFormat ); 4823 return seed; 4824 } 4825 }; 4826 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ 4827 4828 # if defined( VK_USE_PLATFORM_SCREEN_QNX ) 4829 template <> 4830 struct hash<VULKAN_HPP_NAMESPACE::ExternalFormatQNX> 4831 { operator ()std::hash4832 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalFormatQNX const & externalFormatQNX ) const VULKAN_HPP_NOEXCEPT 4833 { 4834 std::size_t seed = 0; 4835 VULKAN_HPP_HASH_COMBINE( seed, externalFormatQNX.sType ); 4836 VULKAN_HPP_HASH_COMBINE( seed, externalFormatQNX.pNext ); 4837 VULKAN_HPP_HASH_COMBINE( seed, externalFormatQNX.externalFormat ); 4838 return seed; 4839 } 4840 }; 4841 # endif /*VK_USE_PLATFORM_SCREEN_QNX*/ 4842 4843 template <> 4844 struct hash<VULKAN_HPP_NAMESPACE::ExternalImageFormatProperties> 4845 { operator ()std::hash4846 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalImageFormatProperties const & externalImageFormatProperties ) const VULKAN_HPP_NOEXCEPT 4847 { 4848 std::size_t seed = 0; 4849 VULKAN_HPP_HASH_COMBINE( seed, externalImageFormatProperties.sType ); 4850 VULKAN_HPP_HASH_COMBINE( seed, externalImageFormatProperties.pNext ); 4851 VULKAN_HPP_HASH_COMBINE( seed, externalImageFormatProperties.externalMemoryProperties ); 4852 return seed; 4853 } 4854 }; 4855 4856 template <> 4857 struct hash<VULKAN_HPP_NAMESPACE::ImageFormatProperties> 4858 { operator ()std::hash4859 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageFormatProperties const & imageFormatProperties ) const VULKAN_HPP_NOEXCEPT 4860 { 4861 std::size_t seed = 0; 4862 VULKAN_HPP_HASH_COMBINE( seed, imageFormatProperties.maxExtent ); 4863 VULKAN_HPP_HASH_COMBINE( seed, imageFormatProperties.maxMipLevels ); 4864 VULKAN_HPP_HASH_COMBINE( seed, imageFormatProperties.maxArrayLayers ); 4865 VULKAN_HPP_HASH_COMBINE( seed, imageFormatProperties.sampleCounts ); 4866 VULKAN_HPP_HASH_COMBINE( seed, imageFormatProperties.maxResourceSize ); 4867 return seed; 4868 } 4869 }; 4870 4871 template <> 4872 struct hash<VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV> 4873 { operator ()std::hash4874 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV const & externalImageFormatPropertiesNV ) const VULKAN_HPP_NOEXCEPT 4875 { 4876 std::size_t seed = 0; 4877 VULKAN_HPP_HASH_COMBINE( seed, externalImageFormatPropertiesNV.imageFormatProperties ); 4878 VULKAN_HPP_HASH_COMBINE( seed, externalImageFormatPropertiesNV.externalMemoryFeatures ); 4879 VULKAN_HPP_HASH_COMBINE( seed, externalImageFormatPropertiesNV.exportFromImportedHandleTypes ); 4880 VULKAN_HPP_HASH_COMBINE( seed, externalImageFormatPropertiesNV.compatibleHandleTypes ); 4881 return seed; 4882 } 4883 }; 4884 4885 template <> 4886 struct hash<VULKAN_HPP_NAMESPACE::ExternalMemoryAcquireUnmodifiedEXT> 4887 { operator ()std::hash4888 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalMemoryAcquireUnmodifiedEXT const & externalMemoryAcquireUnmodifiedEXT ) const VULKAN_HPP_NOEXCEPT 4889 { 4890 std::size_t seed = 0; 4891 VULKAN_HPP_HASH_COMBINE( seed, externalMemoryAcquireUnmodifiedEXT.sType ); 4892 VULKAN_HPP_HASH_COMBINE( seed, externalMemoryAcquireUnmodifiedEXT.pNext ); 4893 VULKAN_HPP_HASH_COMBINE( seed, externalMemoryAcquireUnmodifiedEXT.acquireUnmodifiedMemory ); 4894 return seed; 4895 } 4896 }; 4897 4898 template <> 4899 struct hash<VULKAN_HPP_NAMESPACE::ExternalMemoryBufferCreateInfo> 4900 { operator ()std::hash4901 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalMemoryBufferCreateInfo const & externalMemoryBufferCreateInfo ) const VULKAN_HPP_NOEXCEPT 4902 { 4903 std::size_t seed = 0; 4904 VULKAN_HPP_HASH_COMBINE( seed, externalMemoryBufferCreateInfo.sType ); 4905 VULKAN_HPP_HASH_COMBINE( seed, externalMemoryBufferCreateInfo.pNext ); 4906 VULKAN_HPP_HASH_COMBINE( seed, externalMemoryBufferCreateInfo.handleTypes ); 4907 return seed; 4908 } 4909 }; 4910 4911 template <> 4912 struct hash<VULKAN_HPP_NAMESPACE::ExternalMemoryImageCreateInfo> 4913 { operator ()std::hash4914 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalMemoryImageCreateInfo const & externalMemoryImageCreateInfo ) const VULKAN_HPP_NOEXCEPT 4915 { 4916 std::size_t seed = 0; 4917 VULKAN_HPP_HASH_COMBINE( seed, externalMemoryImageCreateInfo.sType ); 4918 VULKAN_HPP_HASH_COMBINE( seed, externalMemoryImageCreateInfo.pNext ); 4919 VULKAN_HPP_HASH_COMBINE( seed, externalMemoryImageCreateInfo.handleTypes ); 4920 return seed; 4921 } 4922 }; 4923 4924 template <> 4925 struct hash<VULKAN_HPP_NAMESPACE::ExternalMemoryImageCreateInfoNV> 4926 { operator ()std::hash4927 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalMemoryImageCreateInfoNV const & externalMemoryImageCreateInfoNV ) const VULKAN_HPP_NOEXCEPT 4928 { 4929 std::size_t seed = 0; 4930 VULKAN_HPP_HASH_COMBINE( seed, externalMemoryImageCreateInfoNV.sType ); 4931 VULKAN_HPP_HASH_COMBINE( seed, externalMemoryImageCreateInfoNV.pNext ); 4932 VULKAN_HPP_HASH_COMBINE( seed, externalMemoryImageCreateInfoNV.handleTypes ); 4933 return seed; 4934 } 4935 }; 4936 4937 template <> 4938 struct hash<VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties> 4939 { operator ()std::hash4940 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties const & externalSemaphoreProperties ) const VULKAN_HPP_NOEXCEPT 4941 { 4942 std::size_t seed = 0; 4943 VULKAN_HPP_HASH_COMBINE( seed, externalSemaphoreProperties.sType ); 4944 VULKAN_HPP_HASH_COMBINE( seed, externalSemaphoreProperties.pNext ); 4945 VULKAN_HPP_HASH_COMBINE( seed, externalSemaphoreProperties.exportFromImportedHandleTypes ); 4946 VULKAN_HPP_HASH_COMBINE( seed, externalSemaphoreProperties.compatibleHandleTypes ); 4947 VULKAN_HPP_HASH_COMBINE( seed, externalSemaphoreProperties.externalSemaphoreFeatures ); 4948 return seed; 4949 } 4950 }; 4951 4952 template <> 4953 struct hash<VULKAN_HPP_NAMESPACE::FenceCreateInfo> 4954 { operator ()std::hash4955 std::size_t operator()( VULKAN_HPP_NAMESPACE::FenceCreateInfo const & fenceCreateInfo ) const VULKAN_HPP_NOEXCEPT 4956 { 4957 std::size_t seed = 0; 4958 VULKAN_HPP_HASH_COMBINE( seed, fenceCreateInfo.sType ); 4959 VULKAN_HPP_HASH_COMBINE( seed, fenceCreateInfo.pNext ); 4960 VULKAN_HPP_HASH_COMBINE( seed, fenceCreateInfo.flags ); 4961 return seed; 4962 } 4963 }; 4964 4965 template <> 4966 struct hash<VULKAN_HPP_NAMESPACE::FenceGetFdInfoKHR> 4967 { operator ()std::hash4968 std::size_t operator()( VULKAN_HPP_NAMESPACE::FenceGetFdInfoKHR const & fenceGetFdInfoKHR ) const VULKAN_HPP_NOEXCEPT 4969 { 4970 std::size_t seed = 0; 4971 VULKAN_HPP_HASH_COMBINE( seed, fenceGetFdInfoKHR.sType ); 4972 VULKAN_HPP_HASH_COMBINE( seed, fenceGetFdInfoKHR.pNext ); 4973 VULKAN_HPP_HASH_COMBINE( seed, fenceGetFdInfoKHR.fence ); 4974 VULKAN_HPP_HASH_COMBINE( seed, fenceGetFdInfoKHR.handleType ); 4975 return seed; 4976 } 4977 }; 4978 4979 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 4980 template <> 4981 struct hash<VULKAN_HPP_NAMESPACE::FenceGetWin32HandleInfoKHR> 4982 { operator ()std::hash4983 std::size_t operator()( VULKAN_HPP_NAMESPACE::FenceGetWin32HandleInfoKHR const & fenceGetWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT 4984 { 4985 std::size_t seed = 0; 4986 VULKAN_HPP_HASH_COMBINE( seed, fenceGetWin32HandleInfoKHR.sType ); 4987 VULKAN_HPP_HASH_COMBINE( seed, fenceGetWin32HandleInfoKHR.pNext ); 4988 VULKAN_HPP_HASH_COMBINE( seed, fenceGetWin32HandleInfoKHR.fence ); 4989 VULKAN_HPP_HASH_COMBINE( seed, fenceGetWin32HandleInfoKHR.handleType ); 4990 return seed; 4991 } 4992 }; 4993 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 4994 4995 template <> 4996 struct hash<VULKAN_HPP_NAMESPACE::FilterCubicImageViewImageFormatPropertiesEXT> 4997 { operator ()std::hash4998 std::size_t operator()( VULKAN_HPP_NAMESPACE::FilterCubicImageViewImageFormatPropertiesEXT const & filterCubicImageViewImageFormatPropertiesEXT ) const 4999 VULKAN_HPP_NOEXCEPT 5000 { 5001 std::size_t seed = 0; 5002 VULKAN_HPP_HASH_COMBINE( seed, filterCubicImageViewImageFormatPropertiesEXT.sType ); 5003 VULKAN_HPP_HASH_COMBINE( seed, filterCubicImageViewImageFormatPropertiesEXT.pNext ); 5004 VULKAN_HPP_HASH_COMBINE( seed, filterCubicImageViewImageFormatPropertiesEXT.filterCubic ); 5005 VULKAN_HPP_HASH_COMBINE( seed, filterCubicImageViewImageFormatPropertiesEXT.filterCubicMinmax ); 5006 return seed; 5007 } 5008 }; 5009 5010 template <> 5011 struct hash<VULKAN_HPP_NAMESPACE::FormatProperties> 5012 { operator ()std::hash5013 std::size_t operator()( VULKAN_HPP_NAMESPACE::FormatProperties const & formatProperties ) const VULKAN_HPP_NOEXCEPT 5014 { 5015 std::size_t seed = 0; 5016 VULKAN_HPP_HASH_COMBINE( seed, formatProperties.linearTilingFeatures ); 5017 VULKAN_HPP_HASH_COMBINE( seed, formatProperties.optimalTilingFeatures ); 5018 VULKAN_HPP_HASH_COMBINE( seed, formatProperties.bufferFeatures ); 5019 return seed; 5020 } 5021 }; 5022 5023 template <> 5024 struct hash<VULKAN_HPP_NAMESPACE::FormatProperties2> 5025 { operator ()std::hash5026 std::size_t operator()( VULKAN_HPP_NAMESPACE::FormatProperties2 const & formatProperties2 ) const VULKAN_HPP_NOEXCEPT 5027 { 5028 std::size_t seed = 0; 5029 VULKAN_HPP_HASH_COMBINE( seed, formatProperties2.sType ); 5030 VULKAN_HPP_HASH_COMBINE( seed, formatProperties2.pNext ); 5031 VULKAN_HPP_HASH_COMBINE( seed, formatProperties2.formatProperties ); 5032 return seed; 5033 } 5034 }; 5035 5036 template <> 5037 struct hash<VULKAN_HPP_NAMESPACE::FormatProperties3> 5038 { operator ()std::hash5039 std::size_t operator()( VULKAN_HPP_NAMESPACE::FormatProperties3 const & formatProperties3 ) const VULKAN_HPP_NOEXCEPT 5040 { 5041 std::size_t seed = 0; 5042 VULKAN_HPP_HASH_COMBINE( seed, formatProperties3.sType ); 5043 VULKAN_HPP_HASH_COMBINE( seed, formatProperties3.pNext ); 5044 VULKAN_HPP_HASH_COMBINE( seed, formatProperties3.linearTilingFeatures ); 5045 VULKAN_HPP_HASH_COMBINE( seed, formatProperties3.optimalTilingFeatures ); 5046 VULKAN_HPP_HASH_COMBINE( seed, formatProperties3.bufferFeatures ); 5047 return seed; 5048 } 5049 }; 5050 5051 template <> 5052 struct hash<VULKAN_HPP_NAMESPACE::FragmentShadingRateAttachmentInfoKHR> 5053 { operator ()std::hash5054 std::size_t operator()( VULKAN_HPP_NAMESPACE::FragmentShadingRateAttachmentInfoKHR const & fragmentShadingRateAttachmentInfoKHR ) const VULKAN_HPP_NOEXCEPT 5055 { 5056 std::size_t seed = 0; 5057 VULKAN_HPP_HASH_COMBINE( seed, fragmentShadingRateAttachmentInfoKHR.sType ); 5058 VULKAN_HPP_HASH_COMBINE( seed, fragmentShadingRateAttachmentInfoKHR.pNext ); 5059 VULKAN_HPP_HASH_COMBINE( seed, fragmentShadingRateAttachmentInfoKHR.pFragmentShadingRateAttachment ); 5060 VULKAN_HPP_HASH_COMBINE( seed, fragmentShadingRateAttachmentInfoKHR.shadingRateAttachmentTexelSize ); 5061 return seed; 5062 } 5063 }; 5064 5065 template <> 5066 struct hash<VULKAN_HPP_NAMESPACE::FrameBoundaryEXT> 5067 { operator ()std::hash5068 std::size_t operator()( VULKAN_HPP_NAMESPACE::FrameBoundaryEXT const & frameBoundaryEXT ) const VULKAN_HPP_NOEXCEPT 5069 { 5070 std::size_t seed = 0; 5071 VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.sType ); 5072 VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.pNext ); 5073 VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.flags ); 5074 VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.frameID ); 5075 VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.imageCount ); 5076 VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.pImages ); 5077 VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.bufferCount ); 5078 VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.pBuffers ); 5079 VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.tagName ); 5080 VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.tagSize ); 5081 VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.pTag ); 5082 return seed; 5083 } 5084 }; 5085 5086 template <> 5087 struct hash<VULKAN_HPP_NAMESPACE::FramebufferAttachmentImageInfo> 5088 { operator ()std::hash5089 std::size_t operator()( VULKAN_HPP_NAMESPACE::FramebufferAttachmentImageInfo const & framebufferAttachmentImageInfo ) const VULKAN_HPP_NOEXCEPT 5090 { 5091 std::size_t seed = 0; 5092 VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentImageInfo.sType ); 5093 VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentImageInfo.pNext ); 5094 VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentImageInfo.flags ); 5095 VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentImageInfo.usage ); 5096 VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentImageInfo.width ); 5097 VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentImageInfo.height ); 5098 VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentImageInfo.layerCount ); 5099 VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentImageInfo.viewFormatCount ); 5100 VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentImageInfo.pViewFormats ); 5101 return seed; 5102 } 5103 }; 5104 5105 template <> 5106 struct hash<VULKAN_HPP_NAMESPACE::FramebufferAttachmentsCreateInfo> 5107 { operator ()std::hash5108 std::size_t operator()( VULKAN_HPP_NAMESPACE::FramebufferAttachmentsCreateInfo const & framebufferAttachmentsCreateInfo ) const VULKAN_HPP_NOEXCEPT 5109 { 5110 std::size_t seed = 0; 5111 VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentsCreateInfo.sType ); 5112 VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentsCreateInfo.pNext ); 5113 VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentsCreateInfo.attachmentImageInfoCount ); 5114 VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentsCreateInfo.pAttachmentImageInfos ); 5115 return seed; 5116 } 5117 }; 5118 5119 template <> 5120 struct hash<VULKAN_HPP_NAMESPACE::FramebufferCreateInfo> 5121 { operator ()std::hash5122 std::size_t operator()( VULKAN_HPP_NAMESPACE::FramebufferCreateInfo const & framebufferCreateInfo ) const VULKAN_HPP_NOEXCEPT 5123 { 5124 std::size_t seed = 0; 5125 VULKAN_HPP_HASH_COMBINE( seed, framebufferCreateInfo.sType ); 5126 VULKAN_HPP_HASH_COMBINE( seed, framebufferCreateInfo.pNext ); 5127 VULKAN_HPP_HASH_COMBINE( seed, framebufferCreateInfo.flags ); 5128 VULKAN_HPP_HASH_COMBINE( seed, framebufferCreateInfo.renderPass ); 5129 VULKAN_HPP_HASH_COMBINE( seed, framebufferCreateInfo.attachmentCount ); 5130 VULKAN_HPP_HASH_COMBINE( seed, framebufferCreateInfo.pAttachments ); 5131 VULKAN_HPP_HASH_COMBINE( seed, framebufferCreateInfo.width ); 5132 VULKAN_HPP_HASH_COMBINE( seed, framebufferCreateInfo.height ); 5133 VULKAN_HPP_HASH_COMBINE( seed, framebufferCreateInfo.layers ); 5134 return seed; 5135 } 5136 }; 5137 5138 template <> 5139 struct hash<VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV> 5140 { operator ()std::hash5141 std::size_t operator()( VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV const & framebufferMixedSamplesCombinationNV ) const VULKAN_HPP_NOEXCEPT 5142 { 5143 std::size_t seed = 0; 5144 VULKAN_HPP_HASH_COMBINE( seed, framebufferMixedSamplesCombinationNV.sType ); 5145 VULKAN_HPP_HASH_COMBINE( seed, framebufferMixedSamplesCombinationNV.pNext ); 5146 VULKAN_HPP_HASH_COMBINE( seed, framebufferMixedSamplesCombinationNV.coverageReductionMode ); 5147 VULKAN_HPP_HASH_COMBINE( seed, framebufferMixedSamplesCombinationNV.rasterizationSamples ); 5148 VULKAN_HPP_HASH_COMBINE( seed, framebufferMixedSamplesCombinationNV.depthStencilSamples ); 5149 VULKAN_HPP_HASH_COMBINE( seed, framebufferMixedSamplesCombinationNV.colorSamples ); 5150 return seed; 5151 } 5152 }; 5153 5154 template <> 5155 struct hash<VULKAN_HPP_NAMESPACE::IndirectCommandsStreamNV> 5156 { operator ()std::hash5157 std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectCommandsStreamNV const & indirectCommandsStreamNV ) const VULKAN_HPP_NOEXCEPT 5158 { 5159 std::size_t seed = 0; 5160 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsStreamNV.buffer ); 5161 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsStreamNV.offset ); 5162 return seed; 5163 } 5164 }; 5165 5166 template <> 5167 struct hash<VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV> 5168 { operator ()std::hash5169 std::size_t operator()( VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV const & generatedCommandsInfoNV ) const VULKAN_HPP_NOEXCEPT 5170 { 5171 std::size_t seed = 0; 5172 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.sType ); 5173 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.pNext ); 5174 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.pipelineBindPoint ); 5175 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.pipeline ); 5176 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.indirectCommandsLayout ); 5177 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.streamCount ); 5178 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.pStreams ); 5179 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.sequencesCount ); 5180 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.preprocessBuffer ); 5181 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.preprocessOffset ); 5182 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.preprocessSize ); 5183 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.sequencesCountBuffer ); 5184 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.sequencesCountOffset ); 5185 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.sequencesIndexBuffer ); 5186 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.sequencesIndexOffset ); 5187 return seed; 5188 } 5189 }; 5190 5191 template <> 5192 struct hash<VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV> 5193 { 5194 std::size_t operator ()std::hash5195 operator()( VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV const & generatedCommandsMemoryRequirementsInfoNV ) const VULKAN_HPP_NOEXCEPT 5196 { 5197 std::size_t seed = 0; 5198 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsMemoryRequirementsInfoNV.sType ); 5199 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsMemoryRequirementsInfoNV.pNext ); 5200 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsMemoryRequirementsInfoNV.pipelineBindPoint ); 5201 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsMemoryRequirementsInfoNV.pipeline ); 5202 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsMemoryRequirementsInfoNV.indirectCommandsLayout ); 5203 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsMemoryRequirementsInfoNV.maxSequencesCount ); 5204 return seed; 5205 } 5206 }; 5207 5208 template <> 5209 struct hash<VULKAN_HPP_NAMESPACE::LatencyTimingsFrameReportNV> 5210 { operator ()std::hash5211 std::size_t operator()( VULKAN_HPP_NAMESPACE::LatencyTimingsFrameReportNV const & latencyTimingsFrameReportNV ) const VULKAN_HPP_NOEXCEPT 5212 { 5213 std::size_t seed = 0; 5214 VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.sType ); 5215 VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.pNext ); 5216 VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.presentID ); 5217 VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.inputSampleTimeUs ); 5218 VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.simStartTimeUs ); 5219 VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.simEndTimeUs ); 5220 VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.renderSubmitStartTimeUs ); 5221 VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.renderSubmitEndTimeUs ); 5222 VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.presentStartTimeUs ); 5223 VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.presentEndTimeUs ); 5224 VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.driverStartTimeUs ); 5225 VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.driverEndTimeUs ); 5226 VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.osRenderQueueStartTimeUs ); 5227 VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.osRenderQueueEndTimeUs ); 5228 VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.gpuRenderStartTimeUs ); 5229 VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.gpuRenderEndTimeUs ); 5230 return seed; 5231 } 5232 }; 5233 5234 template <> 5235 struct hash<VULKAN_HPP_NAMESPACE::GetLatencyMarkerInfoNV> 5236 { operator ()std::hash5237 std::size_t operator()( VULKAN_HPP_NAMESPACE::GetLatencyMarkerInfoNV const & getLatencyMarkerInfoNV ) const VULKAN_HPP_NOEXCEPT 5238 { 5239 std::size_t seed = 0; 5240 VULKAN_HPP_HASH_COMBINE( seed, getLatencyMarkerInfoNV.sType ); 5241 VULKAN_HPP_HASH_COMBINE( seed, getLatencyMarkerInfoNV.pNext ); 5242 VULKAN_HPP_HASH_COMBINE( seed, getLatencyMarkerInfoNV.timingCount ); 5243 VULKAN_HPP_HASH_COMBINE( seed, getLatencyMarkerInfoNV.pTimings ); 5244 return seed; 5245 } 5246 }; 5247 5248 template <> 5249 struct hash<VULKAN_HPP_NAMESPACE::VertexInputBindingDescription> 5250 { operator ()std::hash5251 std::size_t operator()( VULKAN_HPP_NAMESPACE::VertexInputBindingDescription const & vertexInputBindingDescription ) const VULKAN_HPP_NOEXCEPT 5252 { 5253 std::size_t seed = 0; 5254 VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDescription.binding ); 5255 VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDescription.stride ); 5256 VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDescription.inputRate ); 5257 return seed; 5258 } 5259 }; 5260 5261 template <> 5262 struct hash<VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription> 5263 { operator ()std::hash5264 std::size_t operator()( VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription const & vertexInputAttributeDescription ) const VULKAN_HPP_NOEXCEPT 5265 { 5266 std::size_t seed = 0; 5267 VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription.location ); 5268 VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription.binding ); 5269 VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription.format ); 5270 VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription.offset ); 5271 return seed; 5272 } 5273 }; 5274 5275 template <> 5276 struct hash<VULKAN_HPP_NAMESPACE::PipelineVertexInputStateCreateInfo> 5277 { operator ()std::hash5278 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineVertexInputStateCreateInfo const & pipelineVertexInputStateCreateInfo ) const VULKAN_HPP_NOEXCEPT 5279 { 5280 std::size_t seed = 0; 5281 VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputStateCreateInfo.sType ); 5282 VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputStateCreateInfo.pNext ); 5283 VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputStateCreateInfo.flags ); 5284 VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputStateCreateInfo.vertexBindingDescriptionCount ); 5285 VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputStateCreateInfo.pVertexBindingDescriptions ); 5286 VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputStateCreateInfo.vertexAttributeDescriptionCount ); 5287 VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputStateCreateInfo.pVertexAttributeDescriptions ); 5288 return seed; 5289 } 5290 }; 5291 5292 template <> 5293 struct hash<VULKAN_HPP_NAMESPACE::PipelineInputAssemblyStateCreateInfo> 5294 { operator ()std::hash5295 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineInputAssemblyStateCreateInfo const & pipelineInputAssemblyStateCreateInfo ) const VULKAN_HPP_NOEXCEPT 5296 { 5297 std::size_t seed = 0; 5298 VULKAN_HPP_HASH_COMBINE( seed, pipelineInputAssemblyStateCreateInfo.sType ); 5299 VULKAN_HPP_HASH_COMBINE( seed, pipelineInputAssemblyStateCreateInfo.pNext ); 5300 VULKAN_HPP_HASH_COMBINE( seed, pipelineInputAssemblyStateCreateInfo.flags ); 5301 VULKAN_HPP_HASH_COMBINE( seed, pipelineInputAssemblyStateCreateInfo.topology ); 5302 VULKAN_HPP_HASH_COMBINE( seed, pipelineInputAssemblyStateCreateInfo.primitiveRestartEnable ); 5303 return seed; 5304 } 5305 }; 5306 5307 template <> 5308 struct hash<VULKAN_HPP_NAMESPACE::PipelineTessellationStateCreateInfo> 5309 { operator ()std::hash5310 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineTessellationStateCreateInfo const & pipelineTessellationStateCreateInfo ) const VULKAN_HPP_NOEXCEPT 5311 { 5312 std::size_t seed = 0; 5313 VULKAN_HPP_HASH_COMBINE( seed, pipelineTessellationStateCreateInfo.sType ); 5314 VULKAN_HPP_HASH_COMBINE( seed, pipelineTessellationStateCreateInfo.pNext ); 5315 VULKAN_HPP_HASH_COMBINE( seed, pipelineTessellationStateCreateInfo.flags ); 5316 VULKAN_HPP_HASH_COMBINE( seed, pipelineTessellationStateCreateInfo.patchControlPoints ); 5317 return seed; 5318 } 5319 }; 5320 5321 template <> 5322 struct hash<VULKAN_HPP_NAMESPACE::PipelineViewportStateCreateInfo> 5323 { operator ()std::hash5324 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineViewportStateCreateInfo const & pipelineViewportStateCreateInfo ) const VULKAN_HPP_NOEXCEPT 5325 { 5326 std::size_t seed = 0; 5327 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportStateCreateInfo.sType ); 5328 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportStateCreateInfo.pNext ); 5329 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportStateCreateInfo.flags ); 5330 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportStateCreateInfo.viewportCount ); 5331 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportStateCreateInfo.pViewports ); 5332 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportStateCreateInfo.scissorCount ); 5333 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportStateCreateInfo.pScissors ); 5334 return seed; 5335 } 5336 }; 5337 5338 template <> 5339 struct hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationStateCreateInfo> 5340 { operator ()std::hash5341 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationStateCreateInfo const & pipelineRasterizationStateCreateInfo ) const VULKAN_HPP_NOEXCEPT 5342 { 5343 std::size_t seed = 0; 5344 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.sType ); 5345 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.pNext ); 5346 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.flags ); 5347 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.depthClampEnable ); 5348 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.rasterizerDiscardEnable ); 5349 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.polygonMode ); 5350 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.cullMode ); 5351 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.frontFace ); 5352 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.depthBiasEnable ); 5353 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.depthBiasConstantFactor ); 5354 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.depthBiasClamp ); 5355 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.depthBiasSlopeFactor ); 5356 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.lineWidth ); 5357 return seed; 5358 } 5359 }; 5360 5361 template <> 5362 struct hash<VULKAN_HPP_NAMESPACE::PipelineMultisampleStateCreateInfo> 5363 { operator ()std::hash5364 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineMultisampleStateCreateInfo const & pipelineMultisampleStateCreateInfo ) const VULKAN_HPP_NOEXCEPT 5365 { 5366 std::size_t seed = 0; 5367 VULKAN_HPP_HASH_COMBINE( seed, pipelineMultisampleStateCreateInfo.sType ); 5368 VULKAN_HPP_HASH_COMBINE( seed, pipelineMultisampleStateCreateInfo.pNext ); 5369 VULKAN_HPP_HASH_COMBINE( seed, pipelineMultisampleStateCreateInfo.flags ); 5370 VULKAN_HPP_HASH_COMBINE( seed, pipelineMultisampleStateCreateInfo.rasterizationSamples ); 5371 VULKAN_HPP_HASH_COMBINE( seed, pipelineMultisampleStateCreateInfo.sampleShadingEnable ); 5372 VULKAN_HPP_HASH_COMBINE( seed, pipelineMultisampleStateCreateInfo.minSampleShading ); 5373 VULKAN_HPP_HASH_COMBINE( seed, pipelineMultisampleStateCreateInfo.pSampleMask ); 5374 VULKAN_HPP_HASH_COMBINE( seed, pipelineMultisampleStateCreateInfo.alphaToCoverageEnable ); 5375 VULKAN_HPP_HASH_COMBINE( seed, pipelineMultisampleStateCreateInfo.alphaToOneEnable ); 5376 return seed; 5377 } 5378 }; 5379 5380 template <> 5381 struct hash<VULKAN_HPP_NAMESPACE::StencilOpState> 5382 { operator ()std::hash5383 std::size_t operator()( VULKAN_HPP_NAMESPACE::StencilOpState const & stencilOpState ) const VULKAN_HPP_NOEXCEPT 5384 { 5385 std::size_t seed = 0; 5386 VULKAN_HPP_HASH_COMBINE( seed, stencilOpState.failOp ); 5387 VULKAN_HPP_HASH_COMBINE( seed, stencilOpState.passOp ); 5388 VULKAN_HPP_HASH_COMBINE( seed, stencilOpState.depthFailOp ); 5389 VULKAN_HPP_HASH_COMBINE( seed, stencilOpState.compareOp ); 5390 VULKAN_HPP_HASH_COMBINE( seed, stencilOpState.compareMask ); 5391 VULKAN_HPP_HASH_COMBINE( seed, stencilOpState.writeMask ); 5392 VULKAN_HPP_HASH_COMBINE( seed, stencilOpState.reference ); 5393 return seed; 5394 } 5395 }; 5396 5397 template <> 5398 struct hash<VULKAN_HPP_NAMESPACE::PipelineDepthStencilStateCreateInfo> 5399 { operator ()std::hash5400 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineDepthStencilStateCreateInfo const & pipelineDepthStencilStateCreateInfo ) const VULKAN_HPP_NOEXCEPT 5401 { 5402 std::size_t seed = 0; 5403 VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.sType ); 5404 VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.pNext ); 5405 VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.flags ); 5406 VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.depthTestEnable ); 5407 VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.depthWriteEnable ); 5408 VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.depthCompareOp ); 5409 VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.depthBoundsTestEnable ); 5410 VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.stencilTestEnable ); 5411 VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.front ); 5412 VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.back ); 5413 VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.minDepthBounds ); 5414 VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.maxDepthBounds ); 5415 return seed; 5416 } 5417 }; 5418 5419 template <> 5420 struct hash<VULKAN_HPP_NAMESPACE::PipelineColorBlendAttachmentState> 5421 { operator ()std::hash5422 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineColorBlendAttachmentState const & pipelineColorBlendAttachmentState ) const VULKAN_HPP_NOEXCEPT 5423 { 5424 std::size_t seed = 0; 5425 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAttachmentState.blendEnable ); 5426 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAttachmentState.srcColorBlendFactor ); 5427 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAttachmentState.dstColorBlendFactor ); 5428 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAttachmentState.colorBlendOp ); 5429 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAttachmentState.srcAlphaBlendFactor ); 5430 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAttachmentState.dstAlphaBlendFactor ); 5431 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAttachmentState.alphaBlendOp ); 5432 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAttachmentState.colorWriteMask ); 5433 return seed; 5434 } 5435 }; 5436 5437 template <> 5438 struct hash<VULKAN_HPP_NAMESPACE::PipelineColorBlendStateCreateInfo> 5439 { operator ()std::hash5440 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineColorBlendStateCreateInfo const & pipelineColorBlendStateCreateInfo ) const VULKAN_HPP_NOEXCEPT 5441 { 5442 std::size_t seed = 0; 5443 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendStateCreateInfo.sType ); 5444 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendStateCreateInfo.pNext ); 5445 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendStateCreateInfo.flags ); 5446 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendStateCreateInfo.logicOpEnable ); 5447 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendStateCreateInfo.logicOp ); 5448 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendStateCreateInfo.attachmentCount ); 5449 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendStateCreateInfo.pAttachments ); 5450 for ( size_t i = 0; i < 4; ++i ) 5451 { 5452 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendStateCreateInfo.blendConstants[i] ); 5453 } 5454 return seed; 5455 } 5456 }; 5457 5458 template <> 5459 struct hash<VULKAN_HPP_NAMESPACE::PipelineDynamicStateCreateInfo> 5460 { operator ()std::hash5461 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineDynamicStateCreateInfo const & pipelineDynamicStateCreateInfo ) const VULKAN_HPP_NOEXCEPT 5462 { 5463 std::size_t seed = 0; 5464 VULKAN_HPP_HASH_COMBINE( seed, pipelineDynamicStateCreateInfo.sType ); 5465 VULKAN_HPP_HASH_COMBINE( seed, pipelineDynamicStateCreateInfo.pNext ); 5466 VULKAN_HPP_HASH_COMBINE( seed, pipelineDynamicStateCreateInfo.flags ); 5467 VULKAN_HPP_HASH_COMBINE( seed, pipelineDynamicStateCreateInfo.dynamicStateCount ); 5468 VULKAN_HPP_HASH_COMBINE( seed, pipelineDynamicStateCreateInfo.pDynamicStates ); 5469 return seed; 5470 } 5471 }; 5472 5473 template <> 5474 struct hash<VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> 5475 { operator ()std::hash5476 std::size_t operator()( VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo const & graphicsPipelineCreateInfo ) const VULKAN_HPP_NOEXCEPT 5477 { 5478 std::size_t seed = 0; 5479 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.sType ); 5480 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pNext ); 5481 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.flags ); 5482 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.stageCount ); 5483 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pStages ); 5484 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pVertexInputState ); 5485 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pInputAssemblyState ); 5486 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pTessellationState ); 5487 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pViewportState ); 5488 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pRasterizationState ); 5489 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pMultisampleState ); 5490 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pDepthStencilState ); 5491 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pColorBlendState ); 5492 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pDynamicState ); 5493 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.layout ); 5494 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.renderPass ); 5495 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.subpass ); 5496 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.basePipelineHandle ); 5497 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.basePipelineIndex ); 5498 return seed; 5499 } 5500 }; 5501 5502 template <> 5503 struct hash<VULKAN_HPP_NAMESPACE::GraphicsPipelineLibraryCreateInfoEXT> 5504 { operator ()std::hash5505 std::size_t operator()( VULKAN_HPP_NAMESPACE::GraphicsPipelineLibraryCreateInfoEXT const & graphicsPipelineLibraryCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 5506 { 5507 std::size_t seed = 0; 5508 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineLibraryCreateInfoEXT.sType ); 5509 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineLibraryCreateInfoEXT.pNext ); 5510 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineLibraryCreateInfoEXT.flags ); 5511 return seed; 5512 } 5513 }; 5514 5515 template <> 5516 struct hash<VULKAN_HPP_NAMESPACE::GraphicsShaderGroupCreateInfoNV> 5517 { operator ()std::hash5518 std::size_t operator()( VULKAN_HPP_NAMESPACE::GraphicsShaderGroupCreateInfoNV const & graphicsShaderGroupCreateInfoNV ) const VULKAN_HPP_NOEXCEPT 5519 { 5520 std::size_t seed = 0; 5521 VULKAN_HPP_HASH_COMBINE( seed, graphicsShaderGroupCreateInfoNV.sType ); 5522 VULKAN_HPP_HASH_COMBINE( seed, graphicsShaderGroupCreateInfoNV.pNext ); 5523 VULKAN_HPP_HASH_COMBINE( seed, graphicsShaderGroupCreateInfoNV.stageCount ); 5524 VULKAN_HPP_HASH_COMBINE( seed, graphicsShaderGroupCreateInfoNV.pStages ); 5525 VULKAN_HPP_HASH_COMBINE( seed, graphicsShaderGroupCreateInfoNV.pVertexInputState ); 5526 VULKAN_HPP_HASH_COMBINE( seed, graphicsShaderGroupCreateInfoNV.pTessellationState ); 5527 return seed; 5528 } 5529 }; 5530 5531 template <> 5532 struct hash<VULKAN_HPP_NAMESPACE::GraphicsPipelineShaderGroupsCreateInfoNV> 5533 { 5534 std::size_t operator ()std::hash5535 operator()( VULKAN_HPP_NAMESPACE::GraphicsPipelineShaderGroupsCreateInfoNV const & graphicsPipelineShaderGroupsCreateInfoNV ) const VULKAN_HPP_NOEXCEPT 5536 { 5537 std::size_t seed = 0; 5538 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineShaderGroupsCreateInfoNV.sType ); 5539 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineShaderGroupsCreateInfoNV.pNext ); 5540 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineShaderGroupsCreateInfoNV.groupCount ); 5541 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineShaderGroupsCreateInfoNV.pGroups ); 5542 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineShaderGroupsCreateInfoNV.pipelineCount ); 5543 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineShaderGroupsCreateInfoNV.pPipelines ); 5544 return seed; 5545 } 5546 }; 5547 5548 template <> 5549 struct hash<VULKAN_HPP_NAMESPACE::XYColorEXT> 5550 { operator ()std::hash5551 std::size_t operator()( VULKAN_HPP_NAMESPACE::XYColorEXT const & xYColorEXT ) const VULKAN_HPP_NOEXCEPT 5552 { 5553 std::size_t seed = 0; 5554 VULKAN_HPP_HASH_COMBINE( seed, xYColorEXT.x ); 5555 VULKAN_HPP_HASH_COMBINE( seed, xYColorEXT.y ); 5556 return seed; 5557 } 5558 }; 5559 5560 template <> 5561 struct hash<VULKAN_HPP_NAMESPACE::HdrMetadataEXT> 5562 { operator ()std::hash5563 std::size_t operator()( VULKAN_HPP_NAMESPACE::HdrMetadataEXT const & hdrMetadataEXT ) const VULKAN_HPP_NOEXCEPT 5564 { 5565 std::size_t seed = 0; 5566 VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.sType ); 5567 VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.pNext ); 5568 VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.displayPrimaryRed ); 5569 VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.displayPrimaryGreen ); 5570 VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.displayPrimaryBlue ); 5571 VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.whitePoint ); 5572 VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.maxLuminance ); 5573 VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.minLuminance ); 5574 VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.maxContentLightLevel ); 5575 VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.maxFrameAverageLightLevel ); 5576 return seed; 5577 } 5578 }; 5579 5580 template <> 5581 struct hash<VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT> 5582 { operator ()std::hash5583 std::size_t operator()( VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT const & headlessSurfaceCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 5584 { 5585 std::size_t seed = 0; 5586 VULKAN_HPP_HASH_COMBINE( seed, headlessSurfaceCreateInfoEXT.sType ); 5587 VULKAN_HPP_HASH_COMBINE( seed, headlessSurfaceCreateInfoEXT.pNext ); 5588 VULKAN_HPP_HASH_COMBINE( seed, headlessSurfaceCreateInfoEXT.flags ); 5589 return seed; 5590 } 5591 }; 5592 5593 template <> 5594 struct hash<VULKAN_HPP_NAMESPACE::HostImageCopyDevicePerformanceQueryEXT> 5595 { 5596 std::size_t operator ()std::hash5597 operator()( VULKAN_HPP_NAMESPACE::HostImageCopyDevicePerformanceQueryEXT const & hostImageCopyDevicePerformanceQueryEXT ) const VULKAN_HPP_NOEXCEPT 5598 { 5599 std::size_t seed = 0; 5600 VULKAN_HPP_HASH_COMBINE( seed, hostImageCopyDevicePerformanceQueryEXT.sType ); 5601 VULKAN_HPP_HASH_COMBINE( seed, hostImageCopyDevicePerformanceQueryEXT.pNext ); 5602 VULKAN_HPP_HASH_COMBINE( seed, hostImageCopyDevicePerformanceQueryEXT.optimalDeviceAccess ); 5603 VULKAN_HPP_HASH_COMBINE( seed, hostImageCopyDevicePerformanceQueryEXT.identicalMemoryLayout ); 5604 return seed; 5605 } 5606 }; 5607 5608 template <> 5609 struct hash<VULKAN_HPP_NAMESPACE::HostImageLayoutTransitionInfoEXT> 5610 { operator ()std::hash5611 std::size_t operator()( VULKAN_HPP_NAMESPACE::HostImageLayoutTransitionInfoEXT const & hostImageLayoutTransitionInfoEXT ) const VULKAN_HPP_NOEXCEPT 5612 { 5613 std::size_t seed = 0; 5614 VULKAN_HPP_HASH_COMBINE( seed, hostImageLayoutTransitionInfoEXT.sType ); 5615 VULKAN_HPP_HASH_COMBINE( seed, hostImageLayoutTransitionInfoEXT.pNext ); 5616 VULKAN_HPP_HASH_COMBINE( seed, hostImageLayoutTransitionInfoEXT.image ); 5617 VULKAN_HPP_HASH_COMBINE( seed, hostImageLayoutTransitionInfoEXT.oldLayout ); 5618 VULKAN_HPP_HASH_COMBINE( seed, hostImageLayoutTransitionInfoEXT.newLayout ); 5619 VULKAN_HPP_HASH_COMBINE( seed, hostImageLayoutTransitionInfoEXT.subresourceRange ); 5620 return seed; 5621 } 5622 }; 5623 5624 # if defined( VK_USE_PLATFORM_IOS_MVK ) 5625 template <> 5626 struct hash<VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK> 5627 { operator ()std::hash5628 std::size_t operator()( VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK const & iOSSurfaceCreateInfoMVK ) const VULKAN_HPP_NOEXCEPT 5629 { 5630 std::size_t seed = 0; 5631 VULKAN_HPP_HASH_COMBINE( seed, iOSSurfaceCreateInfoMVK.sType ); 5632 VULKAN_HPP_HASH_COMBINE( seed, iOSSurfaceCreateInfoMVK.pNext ); 5633 VULKAN_HPP_HASH_COMBINE( seed, iOSSurfaceCreateInfoMVK.flags ); 5634 VULKAN_HPP_HASH_COMBINE( seed, iOSSurfaceCreateInfoMVK.pView ); 5635 return seed; 5636 } 5637 }; 5638 # endif /*VK_USE_PLATFORM_IOS_MVK*/ 5639 5640 template <> 5641 struct hash<VULKAN_HPP_NAMESPACE::ImageBlit> 5642 { operator ()std::hash5643 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageBlit const & imageBlit ) const VULKAN_HPP_NOEXCEPT 5644 { 5645 std::size_t seed = 0; 5646 VULKAN_HPP_HASH_COMBINE( seed, imageBlit.srcSubresource ); 5647 for ( size_t i = 0; i < 2; ++i ) 5648 { 5649 VULKAN_HPP_HASH_COMBINE( seed, imageBlit.srcOffsets[i] ); 5650 } 5651 VULKAN_HPP_HASH_COMBINE( seed, imageBlit.dstSubresource ); 5652 for ( size_t i = 0; i < 2; ++i ) 5653 { 5654 VULKAN_HPP_HASH_COMBINE( seed, imageBlit.dstOffsets[i] ); 5655 } 5656 return seed; 5657 } 5658 }; 5659 5660 template <> 5661 struct hash<VULKAN_HPP_NAMESPACE::ImageCaptureDescriptorDataInfoEXT> 5662 { operator ()std::hash5663 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageCaptureDescriptorDataInfoEXT const & imageCaptureDescriptorDataInfoEXT ) const VULKAN_HPP_NOEXCEPT 5664 { 5665 std::size_t seed = 0; 5666 VULKAN_HPP_HASH_COMBINE( seed, imageCaptureDescriptorDataInfoEXT.sType ); 5667 VULKAN_HPP_HASH_COMBINE( seed, imageCaptureDescriptorDataInfoEXT.pNext ); 5668 VULKAN_HPP_HASH_COMBINE( seed, imageCaptureDescriptorDataInfoEXT.image ); 5669 return seed; 5670 } 5671 }; 5672 5673 template <> 5674 struct hash<VULKAN_HPP_NAMESPACE::ImageCompressionControlEXT> 5675 { operator ()std::hash5676 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageCompressionControlEXT const & imageCompressionControlEXT ) const VULKAN_HPP_NOEXCEPT 5677 { 5678 std::size_t seed = 0; 5679 VULKAN_HPP_HASH_COMBINE( seed, imageCompressionControlEXT.sType ); 5680 VULKAN_HPP_HASH_COMBINE( seed, imageCompressionControlEXT.pNext ); 5681 VULKAN_HPP_HASH_COMBINE( seed, imageCompressionControlEXT.flags ); 5682 VULKAN_HPP_HASH_COMBINE( seed, imageCompressionControlEXT.compressionControlPlaneCount ); 5683 VULKAN_HPP_HASH_COMBINE( seed, imageCompressionControlEXT.pFixedRateFlags ); 5684 return seed; 5685 } 5686 }; 5687 5688 template <> 5689 struct hash<VULKAN_HPP_NAMESPACE::ImageCompressionPropertiesEXT> 5690 { operator ()std::hash5691 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageCompressionPropertiesEXT const & imageCompressionPropertiesEXT ) const VULKAN_HPP_NOEXCEPT 5692 { 5693 std::size_t seed = 0; 5694 VULKAN_HPP_HASH_COMBINE( seed, imageCompressionPropertiesEXT.sType ); 5695 VULKAN_HPP_HASH_COMBINE( seed, imageCompressionPropertiesEXT.pNext ); 5696 VULKAN_HPP_HASH_COMBINE( seed, imageCompressionPropertiesEXT.imageCompressionFlags ); 5697 VULKAN_HPP_HASH_COMBINE( seed, imageCompressionPropertiesEXT.imageCompressionFixedRateFlags ); 5698 return seed; 5699 } 5700 }; 5701 5702 # if defined( VK_USE_PLATFORM_FUCHSIA ) 5703 template <> 5704 struct hash<VULKAN_HPP_NAMESPACE::ImageFormatConstraintsInfoFUCHSIA> 5705 { operator ()std::hash5706 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageFormatConstraintsInfoFUCHSIA const & imageFormatConstraintsInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT 5707 { 5708 std::size_t seed = 0; 5709 VULKAN_HPP_HASH_COMBINE( seed, imageFormatConstraintsInfoFUCHSIA.sType ); 5710 VULKAN_HPP_HASH_COMBINE( seed, imageFormatConstraintsInfoFUCHSIA.pNext ); 5711 VULKAN_HPP_HASH_COMBINE( seed, imageFormatConstraintsInfoFUCHSIA.imageCreateInfo ); 5712 VULKAN_HPP_HASH_COMBINE( seed, imageFormatConstraintsInfoFUCHSIA.requiredFormatFeatures ); 5713 VULKAN_HPP_HASH_COMBINE( seed, imageFormatConstraintsInfoFUCHSIA.flags ); 5714 VULKAN_HPP_HASH_COMBINE( seed, imageFormatConstraintsInfoFUCHSIA.sysmemPixelFormat ); 5715 VULKAN_HPP_HASH_COMBINE( seed, imageFormatConstraintsInfoFUCHSIA.colorSpaceCount ); 5716 VULKAN_HPP_HASH_COMBINE( seed, imageFormatConstraintsInfoFUCHSIA.pColorSpaces ); 5717 return seed; 5718 } 5719 }; 5720 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 5721 5722 # if defined( VK_USE_PLATFORM_FUCHSIA ) 5723 template <> 5724 struct hash<VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFUCHSIA> 5725 { operator ()std::hash5726 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFUCHSIA const & imageConstraintsInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT 5727 { 5728 std::size_t seed = 0; 5729 VULKAN_HPP_HASH_COMBINE( seed, imageConstraintsInfoFUCHSIA.sType ); 5730 VULKAN_HPP_HASH_COMBINE( seed, imageConstraintsInfoFUCHSIA.pNext ); 5731 VULKAN_HPP_HASH_COMBINE( seed, imageConstraintsInfoFUCHSIA.formatConstraintsCount ); 5732 VULKAN_HPP_HASH_COMBINE( seed, imageConstraintsInfoFUCHSIA.pFormatConstraints ); 5733 VULKAN_HPP_HASH_COMBINE( seed, imageConstraintsInfoFUCHSIA.bufferCollectionConstraints ); 5734 VULKAN_HPP_HASH_COMBINE( seed, imageConstraintsInfoFUCHSIA.flags ); 5735 return seed; 5736 } 5737 }; 5738 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 5739 5740 template <> 5741 struct hash<VULKAN_HPP_NAMESPACE::ImageCopy> 5742 { operator ()std::hash5743 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageCopy const & imageCopy ) const VULKAN_HPP_NOEXCEPT 5744 { 5745 std::size_t seed = 0; 5746 VULKAN_HPP_HASH_COMBINE( seed, imageCopy.srcSubresource ); 5747 VULKAN_HPP_HASH_COMBINE( seed, imageCopy.srcOffset ); 5748 VULKAN_HPP_HASH_COMBINE( seed, imageCopy.dstSubresource ); 5749 VULKAN_HPP_HASH_COMBINE( seed, imageCopy.dstOffset ); 5750 VULKAN_HPP_HASH_COMBINE( seed, imageCopy.extent ); 5751 return seed; 5752 } 5753 }; 5754 5755 template <> 5756 struct hash<VULKAN_HPP_NAMESPACE::SubresourceLayout> 5757 { operator ()std::hash5758 std::size_t operator()( VULKAN_HPP_NAMESPACE::SubresourceLayout const & subresourceLayout ) const VULKAN_HPP_NOEXCEPT 5759 { 5760 std::size_t seed = 0; 5761 VULKAN_HPP_HASH_COMBINE( seed, subresourceLayout.offset ); 5762 VULKAN_HPP_HASH_COMBINE( seed, subresourceLayout.size ); 5763 VULKAN_HPP_HASH_COMBINE( seed, subresourceLayout.rowPitch ); 5764 VULKAN_HPP_HASH_COMBINE( seed, subresourceLayout.arrayPitch ); 5765 VULKAN_HPP_HASH_COMBINE( seed, subresourceLayout.depthPitch ); 5766 return seed; 5767 } 5768 }; 5769 5770 template <> 5771 struct hash<VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierExplicitCreateInfoEXT> 5772 { operator ()std::hash5773 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierExplicitCreateInfoEXT const & imageDrmFormatModifierExplicitCreateInfoEXT ) const 5774 VULKAN_HPP_NOEXCEPT 5775 { 5776 std::size_t seed = 0; 5777 VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierExplicitCreateInfoEXT.sType ); 5778 VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierExplicitCreateInfoEXT.pNext ); 5779 VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierExplicitCreateInfoEXT.drmFormatModifier ); 5780 VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierExplicitCreateInfoEXT.drmFormatModifierPlaneCount ); 5781 VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierExplicitCreateInfoEXT.pPlaneLayouts ); 5782 return seed; 5783 } 5784 }; 5785 5786 template <> 5787 struct hash<VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierListCreateInfoEXT> 5788 { 5789 std::size_t operator ()std::hash5790 operator()( VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierListCreateInfoEXT const & imageDrmFormatModifierListCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 5791 { 5792 std::size_t seed = 0; 5793 VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierListCreateInfoEXT.sType ); 5794 VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierListCreateInfoEXT.pNext ); 5795 VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierListCreateInfoEXT.drmFormatModifierCount ); 5796 VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierListCreateInfoEXT.pDrmFormatModifiers ); 5797 return seed; 5798 } 5799 }; 5800 5801 template <> 5802 struct hash<VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT> 5803 { operator ()std::hash5804 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT const & imageDrmFormatModifierPropertiesEXT ) const VULKAN_HPP_NOEXCEPT 5805 { 5806 std::size_t seed = 0; 5807 VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierPropertiesEXT.sType ); 5808 VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierPropertiesEXT.pNext ); 5809 VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierPropertiesEXT.drmFormatModifier ); 5810 return seed; 5811 } 5812 }; 5813 5814 template <> 5815 struct hash<VULKAN_HPP_NAMESPACE::ImageFormatListCreateInfo> 5816 { operator ()std::hash5817 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageFormatListCreateInfo const & imageFormatListCreateInfo ) const VULKAN_HPP_NOEXCEPT 5818 { 5819 std::size_t seed = 0; 5820 VULKAN_HPP_HASH_COMBINE( seed, imageFormatListCreateInfo.sType ); 5821 VULKAN_HPP_HASH_COMBINE( seed, imageFormatListCreateInfo.pNext ); 5822 VULKAN_HPP_HASH_COMBINE( seed, imageFormatListCreateInfo.viewFormatCount ); 5823 VULKAN_HPP_HASH_COMBINE( seed, imageFormatListCreateInfo.pViewFormats ); 5824 return seed; 5825 } 5826 }; 5827 5828 template <> 5829 struct hash<VULKAN_HPP_NAMESPACE::ImageFormatProperties2> 5830 { operator ()std::hash5831 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageFormatProperties2 const & imageFormatProperties2 ) const VULKAN_HPP_NOEXCEPT 5832 { 5833 std::size_t seed = 0; 5834 VULKAN_HPP_HASH_COMBINE( seed, imageFormatProperties2.sType ); 5835 VULKAN_HPP_HASH_COMBINE( seed, imageFormatProperties2.pNext ); 5836 VULKAN_HPP_HASH_COMBINE( seed, imageFormatProperties2.imageFormatProperties ); 5837 return seed; 5838 } 5839 }; 5840 5841 template <> 5842 struct hash<VULKAN_HPP_NAMESPACE::ImageMemoryBarrier> 5843 { operator ()std::hash5844 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageMemoryBarrier const & imageMemoryBarrier ) const VULKAN_HPP_NOEXCEPT 5845 { 5846 std::size_t seed = 0; 5847 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.sType ); 5848 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.pNext ); 5849 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.srcAccessMask ); 5850 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.dstAccessMask ); 5851 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.oldLayout ); 5852 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.newLayout ); 5853 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.srcQueueFamilyIndex ); 5854 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.dstQueueFamilyIndex ); 5855 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.image ); 5856 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.subresourceRange ); 5857 return seed; 5858 } 5859 }; 5860 5861 template <> 5862 struct hash<VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2> 5863 { operator ()std::hash5864 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 const & imageMemoryRequirementsInfo2 ) const VULKAN_HPP_NOEXCEPT 5865 { 5866 std::size_t seed = 0; 5867 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryRequirementsInfo2.sType ); 5868 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryRequirementsInfo2.pNext ); 5869 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryRequirementsInfo2.image ); 5870 return seed; 5871 } 5872 }; 5873 5874 # if defined( VK_USE_PLATFORM_FUCHSIA ) 5875 template <> 5876 struct hash<VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA> 5877 { operator ()std::hash5878 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA const & imagePipeSurfaceCreateInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT 5879 { 5880 std::size_t seed = 0; 5881 VULKAN_HPP_HASH_COMBINE( seed, imagePipeSurfaceCreateInfoFUCHSIA.sType ); 5882 VULKAN_HPP_HASH_COMBINE( seed, imagePipeSurfaceCreateInfoFUCHSIA.pNext ); 5883 VULKAN_HPP_HASH_COMBINE( seed, imagePipeSurfaceCreateInfoFUCHSIA.flags ); 5884 VULKAN_HPP_HASH_COMBINE( seed, imagePipeSurfaceCreateInfoFUCHSIA.imagePipeHandle ); 5885 return seed; 5886 } 5887 }; 5888 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 5889 5890 template <> 5891 struct hash<VULKAN_HPP_NAMESPACE::ImagePlaneMemoryRequirementsInfo> 5892 { operator ()std::hash5893 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImagePlaneMemoryRequirementsInfo const & imagePlaneMemoryRequirementsInfo ) const VULKAN_HPP_NOEXCEPT 5894 { 5895 std::size_t seed = 0; 5896 VULKAN_HPP_HASH_COMBINE( seed, imagePlaneMemoryRequirementsInfo.sType ); 5897 VULKAN_HPP_HASH_COMBINE( seed, imagePlaneMemoryRequirementsInfo.pNext ); 5898 VULKAN_HPP_HASH_COMBINE( seed, imagePlaneMemoryRequirementsInfo.planeAspect ); 5899 return seed; 5900 } 5901 }; 5902 5903 template <> 5904 struct hash<VULKAN_HPP_NAMESPACE::ImageResolve> 5905 { operator ()std::hash5906 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageResolve const & imageResolve ) const VULKAN_HPP_NOEXCEPT 5907 { 5908 std::size_t seed = 0; 5909 VULKAN_HPP_HASH_COMBINE( seed, imageResolve.srcSubresource ); 5910 VULKAN_HPP_HASH_COMBINE( seed, imageResolve.srcOffset ); 5911 VULKAN_HPP_HASH_COMBINE( seed, imageResolve.dstSubresource ); 5912 VULKAN_HPP_HASH_COMBINE( seed, imageResolve.dstOffset ); 5913 VULKAN_HPP_HASH_COMBINE( seed, imageResolve.extent ); 5914 return seed; 5915 } 5916 }; 5917 5918 template <> 5919 struct hash<VULKAN_HPP_NAMESPACE::ImageResolve2> 5920 { operator ()std::hash5921 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageResolve2 const & imageResolve2 ) const VULKAN_HPP_NOEXCEPT 5922 { 5923 std::size_t seed = 0; 5924 VULKAN_HPP_HASH_COMBINE( seed, imageResolve2.sType ); 5925 VULKAN_HPP_HASH_COMBINE( seed, imageResolve2.pNext ); 5926 VULKAN_HPP_HASH_COMBINE( seed, imageResolve2.srcSubresource ); 5927 VULKAN_HPP_HASH_COMBINE( seed, imageResolve2.srcOffset ); 5928 VULKAN_HPP_HASH_COMBINE( seed, imageResolve2.dstSubresource ); 5929 VULKAN_HPP_HASH_COMBINE( seed, imageResolve2.dstOffset ); 5930 VULKAN_HPP_HASH_COMBINE( seed, imageResolve2.extent ); 5931 return seed; 5932 } 5933 }; 5934 5935 template <> 5936 struct hash<VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2> 5937 { operator ()std::hash5938 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 const & imageSparseMemoryRequirementsInfo2 ) const VULKAN_HPP_NOEXCEPT 5939 { 5940 std::size_t seed = 0; 5941 VULKAN_HPP_HASH_COMBINE( seed, imageSparseMemoryRequirementsInfo2.sType ); 5942 VULKAN_HPP_HASH_COMBINE( seed, imageSparseMemoryRequirementsInfo2.pNext ); 5943 VULKAN_HPP_HASH_COMBINE( seed, imageSparseMemoryRequirementsInfo2.image ); 5944 return seed; 5945 } 5946 }; 5947 5948 template <> 5949 struct hash<VULKAN_HPP_NAMESPACE::ImageStencilUsageCreateInfo> 5950 { operator ()std::hash5951 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageStencilUsageCreateInfo const & imageStencilUsageCreateInfo ) const VULKAN_HPP_NOEXCEPT 5952 { 5953 std::size_t seed = 0; 5954 VULKAN_HPP_HASH_COMBINE( seed, imageStencilUsageCreateInfo.sType ); 5955 VULKAN_HPP_HASH_COMBINE( seed, imageStencilUsageCreateInfo.pNext ); 5956 VULKAN_HPP_HASH_COMBINE( seed, imageStencilUsageCreateInfo.stencilUsage ); 5957 return seed; 5958 } 5959 }; 5960 5961 template <> 5962 struct hash<VULKAN_HPP_NAMESPACE::ImageSwapchainCreateInfoKHR> 5963 { operator ()std::hash5964 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageSwapchainCreateInfoKHR const & imageSwapchainCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 5965 { 5966 std::size_t seed = 0; 5967 VULKAN_HPP_HASH_COMBINE( seed, imageSwapchainCreateInfoKHR.sType ); 5968 VULKAN_HPP_HASH_COMBINE( seed, imageSwapchainCreateInfoKHR.pNext ); 5969 VULKAN_HPP_HASH_COMBINE( seed, imageSwapchainCreateInfoKHR.swapchain ); 5970 return seed; 5971 } 5972 }; 5973 5974 template <> 5975 struct hash<VULKAN_HPP_NAMESPACE::ImageViewASTCDecodeModeEXT> 5976 { operator ()std::hash5977 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewASTCDecodeModeEXT const & imageViewASTCDecodeModeEXT ) const VULKAN_HPP_NOEXCEPT 5978 { 5979 std::size_t seed = 0; 5980 VULKAN_HPP_HASH_COMBINE( seed, imageViewASTCDecodeModeEXT.sType ); 5981 VULKAN_HPP_HASH_COMBINE( seed, imageViewASTCDecodeModeEXT.pNext ); 5982 VULKAN_HPP_HASH_COMBINE( seed, imageViewASTCDecodeModeEXT.decodeMode ); 5983 return seed; 5984 } 5985 }; 5986 5987 template <> 5988 struct hash<VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX> 5989 { operator ()std::hash5990 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX const & imageViewAddressPropertiesNVX ) const VULKAN_HPP_NOEXCEPT 5991 { 5992 std::size_t seed = 0; 5993 VULKAN_HPP_HASH_COMBINE( seed, imageViewAddressPropertiesNVX.sType ); 5994 VULKAN_HPP_HASH_COMBINE( seed, imageViewAddressPropertiesNVX.pNext ); 5995 VULKAN_HPP_HASH_COMBINE( seed, imageViewAddressPropertiesNVX.deviceAddress ); 5996 VULKAN_HPP_HASH_COMBINE( seed, imageViewAddressPropertiesNVX.size ); 5997 return seed; 5998 } 5999 }; 6000 6001 template <> 6002 struct hash<VULKAN_HPP_NAMESPACE::ImageViewCaptureDescriptorDataInfoEXT> 6003 { 6004 std::size_t operator ()std::hash6005 operator()( VULKAN_HPP_NAMESPACE::ImageViewCaptureDescriptorDataInfoEXT const & imageViewCaptureDescriptorDataInfoEXT ) const VULKAN_HPP_NOEXCEPT 6006 { 6007 std::size_t seed = 0; 6008 VULKAN_HPP_HASH_COMBINE( seed, imageViewCaptureDescriptorDataInfoEXT.sType ); 6009 VULKAN_HPP_HASH_COMBINE( seed, imageViewCaptureDescriptorDataInfoEXT.pNext ); 6010 VULKAN_HPP_HASH_COMBINE( seed, imageViewCaptureDescriptorDataInfoEXT.imageView ); 6011 return seed; 6012 } 6013 }; 6014 6015 template <> 6016 struct hash<VULKAN_HPP_NAMESPACE::ImageViewCreateInfo> 6017 { operator ()std::hash6018 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewCreateInfo const & imageViewCreateInfo ) const VULKAN_HPP_NOEXCEPT 6019 { 6020 std::size_t seed = 0; 6021 VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.sType ); 6022 VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.pNext ); 6023 VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.flags ); 6024 VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.image ); 6025 VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.viewType ); 6026 VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.format ); 6027 VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.components ); 6028 VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.subresourceRange ); 6029 return seed; 6030 } 6031 }; 6032 6033 template <> 6034 struct hash<VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX> 6035 { operator ()std::hash6036 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX const & imageViewHandleInfoNVX ) const VULKAN_HPP_NOEXCEPT 6037 { 6038 std::size_t seed = 0; 6039 VULKAN_HPP_HASH_COMBINE( seed, imageViewHandleInfoNVX.sType ); 6040 VULKAN_HPP_HASH_COMBINE( seed, imageViewHandleInfoNVX.pNext ); 6041 VULKAN_HPP_HASH_COMBINE( seed, imageViewHandleInfoNVX.imageView ); 6042 VULKAN_HPP_HASH_COMBINE( seed, imageViewHandleInfoNVX.descriptorType ); 6043 VULKAN_HPP_HASH_COMBINE( seed, imageViewHandleInfoNVX.sampler ); 6044 return seed; 6045 } 6046 }; 6047 6048 template <> 6049 struct hash<VULKAN_HPP_NAMESPACE::ImageViewMinLodCreateInfoEXT> 6050 { operator ()std::hash6051 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewMinLodCreateInfoEXT const & imageViewMinLodCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 6052 { 6053 std::size_t seed = 0; 6054 VULKAN_HPP_HASH_COMBINE( seed, imageViewMinLodCreateInfoEXT.sType ); 6055 VULKAN_HPP_HASH_COMBINE( seed, imageViewMinLodCreateInfoEXT.pNext ); 6056 VULKAN_HPP_HASH_COMBINE( seed, imageViewMinLodCreateInfoEXT.minLod ); 6057 return seed; 6058 } 6059 }; 6060 6061 template <> 6062 struct hash<VULKAN_HPP_NAMESPACE::ImageViewSampleWeightCreateInfoQCOM> 6063 { operator ()std::hash6064 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewSampleWeightCreateInfoQCOM const & imageViewSampleWeightCreateInfoQCOM ) const VULKAN_HPP_NOEXCEPT 6065 { 6066 std::size_t seed = 0; 6067 VULKAN_HPP_HASH_COMBINE( seed, imageViewSampleWeightCreateInfoQCOM.sType ); 6068 VULKAN_HPP_HASH_COMBINE( seed, imageViewSampleWeightCreateInfoQCOM.pNext ); 6069 VULKAN_HPP_HASH_COMBINE( seed, imageViewSampleWeightCreateInfoQCOM.filterCenter ); 6070 VULKAN_HPP_HASH_COMBINE( seed, imageViewSampleWeightCreateInfoQCOM.filterSize ); 6071 VULKAN_HPP_HASH_COMBINE( seed, imageViewSampleWeightCreateInfoQCOM.numPhases ); 6072 return seed; 6073 } 6074 }; 6075 6076 template <> 6077 struct hash<VULKAN_HPP_NAMESPACE::ImageViewSlicedCreateInfoEXT> 6078 { operator ()std::hash6079 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewSlicedCreateInfoEXT const & imageViewSlicedCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 6080 { 6081 std::size_t seed = 0; 6082 VULKAN_HPP_HASH_COMBINE( seed, imageViewSlicedCreateInfoEXT.sType ); 6083 VULKAN_HPP_HASH_COMBINE( seed, imageViewSlicedCreateInfoEXT.pNext ); 6084 VULKAN_HPP_HASH_COMBINE( seed, imageViewSlicedCreateInfoEXT.sliceOffset ); 6085 VULKAN_HPP_HASH_COMBINE( seed, imageViewSlicedCreateInfoEXT.sliceCount ); 6086 return seed; 6087 } 6088 }; 6089 6090 template <> 6091 struct hash<VULKAN_HPP_NAMESPACE::ImageViewUsageCreateInfo> 6092 { operator ()std::hash6093 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewUsageCreateInfo const & imageViewUsageCreateInfo ) const VULKAN_HPP_NOEXCEPT 6094 { 6095 std::size_t seed = 0; 6096 VULKAN_HPP_HASH_COMBINE( seed, imageViewUsageCreateInfo.sType ); 6097 VULKAN_HPP_HASH_COMBINE( seed, imageViewUsageCreateInfo.pNext ); 6098 VULKAN_HPP_HASH_COMBINE( seed, imageViewUsageCreateInfo.usage ); 6099 return seed; 6100 } 6101 }; 6102 6103 # if defined( VK_USE_PLATFORM_ANDROID_KHR ) 6104 template <> 6105 struct hash<VULKAN_HPP_NAMESPACE::ImportAndroidHardwareBufferInfoANDROID> 6106 { 6107 std::size_t operator ()std::hash6108 operator()( VULKAN_HPP_NAMESPACE::ImportAndroidHardwareBufferInfoANDROID const & importAndroidHardwareBufferInfoANDROID ) const VULKAN_HPP_NOEXCEPT 6109 { 6110 std::size_t seed = 0; 6111 VULKAN_HPP_HASH_COMBINE( seed, importAndroidHardwareBufferInfoANDROID.sType ); 6112 VULKAN_HPP_HASH_COMBINE( seed, importAndroidHardwareBufferInfoANDROID.pNext ); 6113 VULKAN_HPP_HASH_COMBINE( seed, importAndroidHardwareBufferInfoANDROID.buffer ); 6114 return seed; 6115 } 6116 }; 6117 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ 6118 6119 template <> 6120 struct hash<VULKAN_HPP_NAMESPACE::ImportFenceFdInfoKHR> 6121 { operator ()std::hash6122 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportFenceFdInfoKHR const & importFenceFdInfoKHR ) const VULKAN_HPP_NOEXCEPT 6123 { 6124 std::size_t seed = 0; 6125 VULKAN_HPP_HASH_COMBINE( seed, importFenceFdInfoKHR.sType ); 6126 VULKAN_HPP_HASH_COMBINE( seed, importFenceFdInfoKHR.pNext ); 6127 VULKAN_HPP_HASH_COMBINE( seed, importFenceFdInfoKHR.fence ); 6128 VULKAN_HPP_HASH_COMBINE( seed, importFenceFdInfoKHR.flags ); 6129 VULKAN_HPP_HASH_COMBINE( seed, importFenceFdInfoKHR.handleType ); 6130 VULKAN_HPP_HASH_COMBINE( seed, importFenceFdInfoKHR.fd ); 6131 return seed; 6132 } 6133 }; 6134 6135 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 6136 template <> 6137 struct hash<VULKAN_HPP_NAMESPACE::ImportFenceWin32HandleInfoKHR> 6138 { operator ()std::hash6139 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportFenceWin32HandleInfoKHR const & importFenceWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT 6140 { 6141 std::size_t seed = 0; 6142 VULKAN_HPP_HASH_COMBINE( seed, importFenceWin32HandleInfoKHR.sType ); 6143 VULKAN_HPP_HASH_COMBINE( seed, importFenceWin32HandleInfoKHR.pNext ); 6144 VULKAN_HPP_HASH_COMBINE( seed, importFenceWin32HandleInfoKHR.fence ); 6145 VULKAN_HPP_HASH_COMBINE( seed, importFenceWin32HandleInfoKHR.flags ); 6146 VULKAN_HPP_HASH_COMBINE( seed, importFenceWin32HandleInfoKHR.handleType ); 6147 VULKAN_HPP_HASH_COMBINE( seed, importFenceWin32HandleInfoKHR.handle ); 6148 VULKAN_HPP_HASH_COMBINE( seed, importFenceWin32HandleInfoKHR.name ); 6149 return seed; 6150 } 6151 }; 6152 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 6153 6154 # if defined( VK_USE_PLATFORM_FUCHSIA ) 6155 template <> 6156 struct hash<VULKAN_HPP_NAMESPACE::ImportMemoryBufferCollectionFUCHSIA> 6157 { operator ()std::hash6158 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMemoryBufferCollectionFUCHSIA const & importMemoryBufferCollectionFUCHSIA ) const VULKAN_HPP_NOEXCEPT 6159 { 6160 std::size_t seed = 0; 6161 VULKAN_HPP_HASH_COMBINE( seed, importMemoryBufferCollectionFUCHSIA.sType ); 6162 VULKAN_HPP_HASH_COMBINE( seed, importMemoryBufferCollectionFUCHSIA.pNext ); 6163 VULKAN_HPP_HASH_COMBINE( seed, importMemoryBufferCollectionFUCHSIA.collection ); 6164 VULKAN_HPP_HASH_COMBINE( seed, importMemoryBufferCollectionFUCHSIA.index ); 6165 return seed; 6166 } 6167 }; 6168 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 6169 6170 template <> 6171 struct hash<VULKAN_HPP_NAMESPACE::ImportMemoryFdInfoKHR> 6172 { operator ()std::hash6173 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMemoryFdInfoKHR const & importMemoryFdInfoKHR ) const VULKAN_HPP_NOEXCEPT 6174 { 6175 std::size_t seed = 0; 6176 VULKAN_HPP_HASH_COMBINE( seed, importMemoryFdInfoKHR.sType ); 6177 VULKAN_HPP_HASH_COMBINE( seed, importMemoryFdInfoKHR.pNext ); 6178 VULKAN_HPP_HASH_COMBINE( seed, importMemoryFdInfoKHR.handleType ); 6179 VULKAN_HPP_HASH_COMBINE( seed, importMemoryFdInfoKHR.fd ); 6180 return seed; 6181 } 6182 }; 6183 6184 template <> 6185 struct hash<VULKAN_HPP_NAMESPACE::ImportMemoryHostPointerInfoEXT> 6186 { operator ()std::hash6187 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMemoryHostPointerInfoEXT const & importMemoryHostPointerInfoEXT ) const VULKAN_HPP_NOEXCEPT 6188 { 6189 std::size_t seed = 0; 6190 VULKAN_HPP_HASH_COMBINE( seed, importMemoryHostPointerInfoEXT.sType ); 6191 VULKAN_HPP_HASH_COMBINE( seed, importMemoryHostPointerInfoEXT.pNext ); 6192 VULKAN_HPP_HASH_COMBINE( seed, importMemoryHostPointerInfoEXT.handleType ); 6193 VULKAN_HPP_HASH_COMBINE( seed, importMemoryHostPointerInfoEXT.pHostPointer ); 6194 return seed; 6195 } 6196 }; 6197 6198 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 6199 template <> 6200 struct hash<VULKAN_HPP_NAMESPACE::ImportMemoryWin32HandleInfoKHR> 6201 { operator ()std::hash6202 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMemoryWin32HandleInfoKHR const & importMemoryWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT 6203 { 6204 std::size_t seed = 0; 6205 VULKAN_HPP_HASH_COMBINE( seed, importMemoryWin32HandleInfoKHR.sType ); 6206 VULKAN_HPP_HASH_COMBINE( seed, importMemoryWin32HandleInfoKHR.pNext ); 6207 VULKAN_HPP_HASH_COMBINE( seed, importMemoryWin32HandleInfoKHR.handleType ); 6208 VULKAN_HPP_HASH_COMBINE( seed, importMemoryWin32HandleInfoKHR.handle ); 6209 VULKAN_HPP_HASH_COMBINE( seed, importMemoryWin32HandleInfoKHR.name ); 6210 return seed; 6211 } 6212 }; 6213 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 6214 6215 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 6216 template <> 6217 struct hash<VULKAN_HPP_NAMESPACE::ImportMemoryWin32HandleInfoNV> 6218 { operator ()std::hash6219 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMemoryWin32HandleInfoNV const & importMemoryWin32HandleInfoNV ) const VULKAN_HPP_NOEXCEPT 6220 { 6221 std::size_t seed = 0; 6222 VULKAN_HPP_HASH_COMBINE( seed, importMemoryWin32HandleInfoNV.sType ); 6223 VULKAN_HPP_HASH_COMBINE( seed, importMemoryWin32HandleInfoNV.pNext ); 6224 VULKAN_HPP_HASH_COMBINE( seed, importMemoryWin32HandleInfoNV.handleType ); 6225 VULKAN_HPP_HASH_COMBINE( seed, importMemoryWin32HandleInfoNV.handle ); 6226 return seed; 6227 } 6228 }; 6229 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 6230 6231 # if defined( VK_USE_PLATFORM_FUCHSIA ) 6232 template <> 6233 struct hash<VULKAN_HPP_NAMESPACE::ImportMemoryZirconHandleInfoFUCHSIA> 6234 { operator ()std::hash6235 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMemoryZirconHandleInfoFUCHSIA const & importMemoryZirconHandleInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT 6236 { 6237 std::size_t seed = 0; 6238 VULKAN_HPP_HASH_COMBINE( seed, importMemoryZirconHandleInfoFUCHSIA.sType ); 6239 VULKAN_HPP_HASH_COMBINE( seed, importMemoryZirconHandleInfoFUCHSIA.pNext ); 6240 VULKAN_HPP_HASH_COMBINE( seed, importMemoryZirconHandleInfoFUCHSIA.handleType ); 6241 VULKAN_HPP_HASH_COMBINE( seed, importMemoryZirconHandleInfoFUCHSIA.handle ); 6242 return seed; 6243 } 6244 }; 6245 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 6246 6247 # if defined( VK_USE_PLATFORM_METAL_EXT ) 6248 template <> 6249 struct hash<VULKAN_HPP_NAMESPACE::ImportMetalBufferInfoEXT> 6250 { operator ()std::hash6251 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMetalBufferInfoEXT const & importMetalBufferInfoEXT ) const VULKAN_HPP_NOEXCEPT 6252 { 6253 std::size_t seed = 0; 6254 VULKAN_HPP_HASH_COMBINE( seed, importMetalBufferInfoEXT.sType ); 6255 VULKAN_HPP_HASH_COMBINE( seed, importMetalBufferInfoEXT.pNext ); 6256 VULKAN_HPP_HASH_COMBINE( seed, importMetalBufferInfoEXT.mtlBuffer ); 6257 return seed; 6258 } 6259 }; 6260 # endif /*VK_USE_PLATFORM_METAL_EXT*/ 6261 6262 # if defined( VK_USE_PLATFORM_METAL_EXT ) 6263 template <> 6264 struct hash<VULKAN_HPP_NAMESPACE::ImportMetalIOSurfaceInfoEXT> 6265 { operator ()std::hash6266 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMetalIOSurfaceInfoEXT const & importMetalIOSurfaceInfoEXT ) const VULKAN_HPP_NOEXCEPT 6267 { 6268 std::size_t seed = 0; 6269 VULKAN_HPP_HASH_COMBINE( seed, importMetalIOSurfaceInfoEXT.sType ); 6270 VULKAN_HPP_HASH_COMBINE( seed, importMetalIOSurfaceInfoEXT.pNext ); 6271 VULKAN_HPP_HASH_COMBINE( seed, importMetalIOSurfaceInfoEXT.ioSurface ); 6272 return seed; 6273 } 6274 }; 6275 # endif /*VK_USE_PLATFORM_METAL_EXT*/ 6276 6277 # if defined( VK_USE_PLATFORM_METAL_EXT ) 6278 template <> 6279 struct hash<VULKAN_HPP_NAMESPACE::ImportMetalSharedEventInfoEXT> 6280 { operator ()std::hash6281 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMetalSharedEventInfoEXT const & importMetalSharedEventInfoEXT ) const VULKAN_HPP_NOEXCEPT 6282 { 6283 std::size_t seed = 0; 6284 VULKAN_HPP_HASH_COMBINE( seed, importMetalSharedEventInfoEXT.sType ); 6285 VULKAN_HPP_HASH_COMBINE( seed, importMetalSharedEventInfoEXT.pNext ); 6286 VULKAN_HPP_HASH_COMBINE( seed, importMetalSharedEventInfoEXT.mtlSharedEvent ); 6287 return seed; 6288 } 6289 }; 6290 # endif /*VK_USE_PLATFORM_METAL_EXT*/ 6291 6292 # if defined( VK_USE_PLATFORM_METAL_EXT ) 6293 template <> 6294 struct hash<VULKAN_HPP_NAMESPACE::ImportMetalTextureInfoEXT> 6295 { operator ()std::hash6296 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMetalTextureInfoEXT const & importMetalTextureInfoEXT ) const VULKAN_HPP_NOEXCEPT 6297 { 6298 std::size_t seed = 0; 6299 VULKAN_HPP_HASH_COMBINE( seed, importMetalTextureInfoEXT.sType ); 6300 VULKAN_HPP_HASH_COMBINE( seed, importMetalTextureInfoEXT.pNext ); 6301 VULKAN_HPP_HASH_COMBINE( seed, importMetalTextureInfoEXT.plane ); 6302 VULKAN_HPP_HASH_COMBINE( seed, importMetalTextureInfoEXT.mtlTexture ); 6303 return seed; 6304 } 6305 }; 6306 # endif /*VK_USE_PLATFORM_METAL_EXT*/ 6307 6308 # if defined( VK_USE_PLATFORM_SCREEN_QNX ) 6309 template <> 6310 struct hash<VULKAN_HPP_NAMESPACE::ImportScreenBufferInfoQNX> 6311 { operator ()std::hash6312 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportScreenBufferInfoQNX const & importScreenBufferInfoQNX ) const VULKAN_HPP_NOEXCEPT 6313 { 6314 std::size_t seed = 0; 6315 VULKAN_HPP_HASH_COMBINE( seed, importScreenBufferInfoQNX.sType ); 6316 VULKAN_HPP_HASH_COMBINE( seed, importScreenBufferInfoQNX.pNext ); 6317 VULKAN_HPP_HASH_COMBINE( seed, importScreenBufferInfoQNX.buffer ); 6318 return seed; 6319 } 6320 }; 6321 # endif /*VK_USE_PLATFORM_SCREEN_QNX*/ 6322 6323 template <> 6324 struct hash<VULKAN_HPP_NAMESPACE::ImportSemaphoreFdInfoKHR> 6325 { operator ()std::hash6326 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportSemaphoreFdInfoKHR const & importSemaphoreFdInfoKHR ) const VULKAN_HPP_NOEXCEPT 6327 { 6328 std::size_t seed = 0; 6329 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreFdInfoKHR.sType ); 6330 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreFdInfoKHR.pNext ); 6331 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreFdInfoKHR.semaphore ); 6332 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreFdInfoKHR.flags ); 6333 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreFdInfoKHR.handleType ); 6334 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreFdInfoKHR.fd ); 6335 return seed; 6336 } 6337 }; 6338 6339 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 6340 template <> 6341 struct hash<VULKAN_HPP_NAMESPACE::ImportSemaphoreWin32HandleInfoKHR> 6342 { operator ()std::hash6343 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportSemaphoreWin32HandleInfoKHR const & importSemaphoreWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT 6344 { 6345 std::size_t seed = 0; 6346 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreWin32HandleInfoKHR.sType ); 6347 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreWin32HandleInfoKHR.pNext ); 6348 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreWin32HandleInfoKHR.semaphore ); 6349 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreWin32HandleInfoKHR.flags ); 6350 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreWin32HandleInfoKHR.handleType ); 6351 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreWin32HandleInfoKHR.handle ); 6352 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreWin32HandleInfoKHR.name ); 6353 return seed; 6354 } 6355 }; 6356 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 6357 6358 # if defined( VK_USE_PLATFORM_FUCHSIA ) 6359 template <> 6360 struct hash<VULKAN_HPP_NAMESPACE::ImportSemaphoreZirconHandleInfoFUCHSIA> 6361 { 6362 std::size_t operator ()std::hash6363 operator()( VULKAN_HPP_NAMESPACE::ImportSemaphoreZirconHandleInfoFUCHSIA const & importSemaphoreZirconHandleInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT 6364 { 6365 std::size_t seed = 0; 6366 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreZirconHandleInfoFUCHSIA.sType ); 6367 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreZirconHandleInfoFUCHSIA.pNext ); 6368 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreZirconHandleInfoFUCHSIA.semaphore ); 6369 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreZirconHandleInfoFUCHSIA.flags ); 6370 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreZirconHandleInfoFUCHSIA.handleType ); 6371 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreZirconHandleInfoFUCHSIA.zirconHandle ); 6372 return seed; 6373 } 6374 }; 6375 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 6376 6377 template <> 6378 struct hash<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutTokenNV> 6379 { operator ()std::hash6380 std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutTokenNV const & indirectCommandsLayoutTokenNV ) const VULKAN_HPP_NOEXCEPT 6381 { 6382 std::size_t seed = 0; 6383 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.sType ); 6384 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.pNext ); 6385 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.tokenType ); 6386 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.stream ); 6387 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.offset ); 6388 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.vertexBindingUnit ); 6389 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.vertexDynamicStride ); 6390 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.pushconstantPipelineLayout ); 6391 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.pushconstantShaderStageFlags ); 6392 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.pushconstantOffset ); 6393 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.pushconstantSize ); 6394 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.indirectStateFlags ); 6395 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.indexTypeCount ); 6396 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.pIndexTypes ); 6397 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.pIndexTypeValues ); 6398 return seed; 6399 } 6400 }; 6401 6402 template <> 6403 struct hash<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV> 6404 { operator ()std::hash6405 std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV const & indirectCommandsLayoutCreateInfoNV ) const VULKAN_HPP_NOEXCEPT 6406 { 6407 std::size_t seed = 0; 6408 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoNV.sType ); 6409 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoNV.pNext ); 6410 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoNV.flags ); 6411 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoNV.pipelineBindPoint ); 6412 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoNV.tokenCount ); 6413 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoNV.pTokens ); 6414 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoNV.streamCount ); 6415 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoNV.pStreamStrides ); 6416 return seed; 6417 } 6418 }; 6419 6420 template <> 6421 struct hash<VULKAN_HPP_NAMESPACE::InitializePerformanceApiInfoINTEL> 6422 { operator ()std::hash6423 std::size_t operator()( VULKAN_HPP_NAMESPACE::InitializePerformanceApiInfoINTEL const & initializePerformanceApiInfoINTEL ) const VULKAN_HPP_NOEXCEPT 6424 { 6425 std::size_t seed = 0; 6426 VULKAN_HPP_HASH_COMBINE( seed, initializePerformanceApiInfoINTEL.sType ); 6427 VULKAN_HPP_HASH_COMBINE( seed, initializePerformanceApiInfoINTEL.pNext ); 6428 VULKAN_HPP_HASH_COMBINE( seed, initializePerformanceApiInfoINTEL.pUserData ); 6429 return seed; 6430 } 6431 }; 6432 6433 template <> 6434 struct hash<VULKAN_HPP_NAMESPACE::InputAttachmentAspectReference> 6435 { operator ()std::hash6436 std::size_t operator()( VULKAN_HPP_NAMESPACE::InputAttachmentAspectReference const & inputAttachmentAspectReference ) const VULKAN_HPP_NOEXCEPT 6437 { 6438 std::size_t seed = 0; 6439 VULKAN_HPP_HASH_COMBINE( seed, inputAttachmentAspectReference.subpass ); 6440 VULKAN_HPP_HASH_COMBINE( seed, inputAttachmentAspectReference.inputAttachmentIndex ); 6441 VULKAN_HPP_HASH_COMBINE( seed, inputAttachmentAspectReference.aspectMask ); 6442 return seed; 6443 } 6444 }; 6445 6446 template <> 6447 struct hash<VULKAN_HPP_NAMESPACE::InstanceCreateInfo> 6448 { operator ()std::hash6449 std::size_t operator()( VULKAN_HPP_NAMESPACE::InstanceCreateInfo const & instanceCreateInfo ) const VULKAN_HPP_NOEXCEPT 6450 { 6451 std::size_t seed = 0; 6452 VULKAN_HPP_HASH_COMBINE( seed, instanceCreateInfo.sType ); 6453 VULKAN_HPP_HASH_COMBINE( seed, instanceCreateInfo.pNext ); 6454 VULKAN_HPP_HASH_COMBINE( seed, instanceCreateInfo.flags ); 6455 VULKAN_HPP_HASH_COMBINE( seed, instanceCreateInfo.pApplicationInfo ); 6456 VULKAN_HPP_HASH_COMBINE( seed, instanceCreateInfo.enabledLayerCount ); 6457 for ( size_t i = 0; i < instanceCreateInfo.enabledLayerCount; ++i ) 6458 { 6459 for ( const char * p = instanceCreateInfo.ppEnabledLayerNames[i]; *p != '\0'; ++p ) 6460 { 6461 VULKAN_HPP_HASH_COMBINE( seed, *p ); 6462 } 6463 } 6464 VULKAN_HPP_HASH_COMBINE( seed, instanceCreateInfo.enabledExtensionCount ); 6465 for ( size_t i = 0; i < instanceCreateInfo.enabledExtensionCount; ++i ) 6466 { 6467 for ( const char * p = instanceCreateInfo.ppEnabledExtensionNames[i]; *p != '\0'; ++p ) 6468 { 6469 VULKAN_HPP_HASH_COMBINE( seed, *p ); 6470 } 6471 } 6472 return seed; 6473 } 6474 }; 6475 6476 template <> 6477 struct hash<VULKAN_HPP_NAMESPACE::LatencySleepInfoNV> 6478 { operator ()std::hash6479 std::size_t operator()( VULKAN_HPP_NAMESPACE::LatencySleepInfoNV const & latencySleepInfoNV ) const VULKAN_HPP_NOEXCEPT 6480 { 6481 std::size_t seed = 0; 6482 VULKAN_HPP_HASH_COMBINE( seed, latencySleepInfoNV.sType ); 6483 VULKAN_HPP_HASH_COMBINE( seed, latencySleepInfoNV.pNext ); 6484 VULKAN_HPP_HASH_COMBINE( seed, latencySleepInfoNV.signalSemaphore ); 6485 VULKAN_HPP_HASH_COMBINE( seed, latencySleepInfoNV.value ); 6486 return seed; 6487 } 6488 }; 6489 6490 template <> 6491 struct hash<VULKAN_HPP_NAMESPACE::LatencySleepModeInfoNV> 6492 { operator ()std::hash6493 std::size_t operator()( VULKAN_HPP_NAMESPACE::LatencySleepModeInfoNV const & latencySleepModeInfoNV ) const VULKAN_HPP_NOEXCEPT 6494 { 6495 std::size_t seed = 0; 6496 VULKAN_HPP_HASH_COMBINE( seed, latencySleepModeInfoNV.sType ); 6497 VULKAN_HPP_HASH_COMBINE( seed, latencySleepModeInfoNV.pNext ); 6498 VULKAN_HPP_HASH_COMBINE( seed, latencySleepModeInfoNV.lowLatencyMode ); 6499 VULKAN_HPP_HASH_COMBINE( seed, latencySleepModeInfoNV.lowLatencyBoost ); 6500 VULKAN_HPP_HASH_COMBINE( seed, latencySleepModeInfoNV.minimumIntervalUs ); 6501 return seed; 6502 } 6503 }; 6504 6505 template <> 6506 struct hash<VULKAN_HPP_NAMESPACE::LatencySubmissionPresentIdNV> 6507 { operator ()std::hash6508 std::size_t operator()( VULKAN_HPP_NAMESPACE::LatencySubmissionPresentIdNV const & latencySubmissionPresentIdNV ) const VULKAN_HPP_NOEXCEPT 6509 { 6510 std::size_t seed = 0; 6511 VULKAN_HPP_HASH_COMBINE( seed, latencySubmissionPresentIdNV.sType ); 6512 VULKAN_HPP_HASH_COMBINE( seed, latencySubmissionPresentIdNV.pNext ); 6513 VULKAN_HPP_HASH_COMBINE( seed, latencySubmissionPresentIdNV.presentID ); 6514 return seed; 6515 } 6516 }; 6517 6518 template <> 6519 struct hash<VULKAN_HPP_NAMESPACE::LatencySurfaceCapabilitiesNV> 6520 { operator ()std::hash6521 std::size_t operator()( VULKAN_HPP_NAMESPACE::LatencySurfaceCapabilitiesNV const & latencySurfaceCapabilitiesNV ) const VULKAN_HPP_NOEXCEPT 6522 { 6523 std::size_t seed = 0; 6524 VULKAN_HPP_HASH_COMBINE( seed, latencySurfaceCapabilitiesNV.sType ); 6525 VULKAN_HPP_HASH_COMBINE( seed, latencySurfaceCapabilitiesNV.pNext ); 6526 VULKAN_HPP_HASH_COMBINE( seed, latencySurfaceCapabilitiesNV.presentModeCount ); 6527 VULKAN_HPP_HASH_COMBINE( seed, latencySurfaceCapabilitiesNV.pPresentModes ); 6528 return seed; 6529 } 6530 }; 6531 6532 template <> 6533 struct hash<VULKAN_HPP_NAMESPACE::LayerProperties> 6534 { operator ()std::hash6535 std::size_t operator()( VULKAN_HPP_NAMESPACE::LayerProperties const & layerProperties ) const VULKAN_HPP_NOEXCEPT 6536 { 6537 std::size_t seed = 0; 6538 for ( size_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i ) 6539 { 6540 VULKAN_HPP_HASH_COMBINE( seed, layerProperties.layerName[i] ); 6541 } 6542 VULKAN_HPP_HASH_COMBINE( seed, layerProperties.specVersion ); 6543 VULKAN_HPP_HASH_COMBINE( seed, layerProperties.implementationVersion ); 6544 for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) 6545 { 6546 VULKAN_HPP_HASH_COMBINE( seed, layerProperties.description[i] ); 6547 } 6548 return seed; 6549 } 6550 }; 6551 6552 template <> 6553 struct hash<VULKAN_HPP_NAMESPACE::LayerSettingEXT> 6554 { operator ()std::hash6555 std::size_t operator()( VULKAN_HPP_NAMESPACE::LayerSettingEXT const & layerSettingEXT ) const VULKAN_HPP_NOEXCEPT 6556 { 6557 std::size_t seed = 0; 6558 for ( const char * p = layerSettingEXT.pLayerName; *p != '\0'; ++p ) 6559 { 6560 VULKAN_HPP_HASH_COMBINE( seed, *p ); 6561 } 6562 for ( const char * p = layerSettingEXT.pSettingName; *p != '\0'; ++p ) 6563 { 6564 VULKAN_HPP_HASH_COMBINE( seed, *p ); 6565 } 6566 VULKAN_HPP_HASH_COMBINE( seed, layerSettingEXT.type ); 6567 VULKAN_HPP_HASH_COMBINE( seed, layerSettingEXT.valueCount ); 6568 VULKAN_HPP_HASH_COMBINE( seed, layerSettingEXT.pValues ); 6569 return seed; 6570 } 6571 }; 6572 6573 template <> 6574 struct hash<VULKAN_HPP_NAMESPACE::LayerSettingsCreateInfoEXT> 6575 { operator ()std::hash6576 std::size_t operator()( VULKAN_HPP_NAMESPACE::LayerSettingsCreateInfoEXT const & layerSettingsCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 6577 { 6578 std::size_t seed = 0; 6579 VULKAN_HPP_HASH_COMBINE( seed, layerSettingsCreateInfoEXT.sType ); 6580 VULKAN_HPP_HASH_COMBINE( seed, layerSettingsCreateInfoEXT.pNext ); 6581 VULKAN_HPP_HASH_COMBINE( seed, layerSettingsCreateInfoEXT.settingCount ); 6582 VULKAN_HPP_HASH_COMBINE( seed, layerSettingsCreateInfoEXT.pSettings ); 6583 return seed; 6584 } 6585 }; 6586 6587 # if defined( VK_USE_PLATFORM_MACOS_MVK ) 6588 template <> 6589 struct hash<VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK> 6590 { operator ()std::hash6591 std::size_t operator()( VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK const & macOSSurfaceCreateInfoMVK ) const VULKAN_HPP_NOEXCEPT 6592 { 6593 std::size_t seed = 0; 6594 VULKAN_HPP_HASH_COMBINE( seed, macOSSurfaceCreateInfoMVK.sType ); 6595 VULKAN_HPP_HASH_COMBINE( seed, macOSSurfaceCreateInfoMVK.pNext ); 6596 VULKAN_HPP_HASH_COMBINE( seed, macOSSurfaceCreateInfoMVK.flags ); 6597 VULKAN_HPP_HASH_COMBINE( seed, macOSSurfaceCreateInfoMVK.pView ); 6598 return seed; 6599 } 6600 }; 6601 # endif /*VK_USE_PLATFORM_MACOS_MVK*/ 6602 6603 template <> 6604 struct hash<VULKAN_HPP_NAMESPACE::MappedMemoryRange> 6605 { operator ()std::hash6606 std::size_t operator()( VULKAN_HPP_NAMESPACE::MappedMemoryRange const & mappedMemoryRange ) const VULKAN_HPP_NOEXCEPT 6607 { 6608 std::size_t seed = 0; 6609 VULKAN_HPP_HASH_COMBINE( seed, mappedMemoryRange.sType ); 6610 VULKAN_HPP_HASH_COMBINE( seed, mappedMemoryRange.pNext ); 6611 VULKAN_HPP_HASH_COMBINE( seed, mappedMemoryRange.memory ); 6612 VULKAN_HPP_HASH_COMBINE( seed, mappedMemoryRange.offset ); 6613 VULKAN_HPP_HASH_COMBINE( seed, mappedMemoryRange.size ); 6614 return seed; 6615 } 6616 }; 6617 6618 template <> 6619 struct hash<VULKAN_HPP_NAMESPACE::MemoryAllocateFlagsInfo> 6620 { operator ()std::hash6621 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryAllocateFlagsInfo const & memoryAllocateFlagsInfo ) const VULKAN_HPP_NOEXCEPT 6622 { 6623 std::size_t seed = 0; 6624 VULKAN_HPP_HASH_COMBINE( seed, memoryAllocateFlagsInfo.sType ); 6625 VULKAN_HPP_HASH_COMBINE( seed, memoryAllocateFlagsInfo.pNext ); 6626 VULKAN_HPP_HASH_COMBINE( seed, memoryAllocateFlagsInfo.flags ); 6627 VULKAN_HPP_HASH_COMBINE( seed, memoryAllocateFlagsInfo.deviceMask ); 6628 return seed; 6629 } 6630 }; 6631 6632 template <> 6633 struct hash<VULKAN_HPP_NAMESPACE::MemoryAllocateInfo> 6634 { operator ()std::hash6635 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryAllocateInfo const & memoryAllocateInfo ) const VULKAN_HPP_NOEXCEPT 6636 { 6637 std::size_t seed = 0; 6638 VULKAN_HPP_HASH_COMBINE( seed, memoryAllocateInfo.sType ); 6639 VULKAN_HPP_HASH_COMBINE( seed, memoryAllocateInfo.pNext ); 6640 VULKAN_HPP_HASH_COMBINE( seed, memoryAllocateInfo.allocationSize ); 6641 VULKAN_HPP_HASH_COMBINE( seed, memoryAllocateInfo.memoryTypeIndex ); 6642 return seed; 6643 } 6644 }; 6645 6646 template <> 6647 struct hash<VULKAN_HPP_NAMESPACE::MemoryBarrier> 6648 { operator ()std::hash6649 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryBarrier const & memoryBarrier ) const VULKAN_HPP_NOEXCEPT 6650 { 6651 std::size_t seed = 0; 6652 VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier.sType ); 6653 VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier.pNext ); 6654 VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier.srcAccessMask ); 6655 VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier.dstAccessMask ); 6656 return seed; 6657 } 6658 }; 6659 6660 template <> 6661 struct hash<VULKAN_HPP_NAMESPACE::MemoryDedicatedAllocateInfo> 6662 { operator ()std::hash6663 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryDedicatedAllocateInfo const & memoryDedicatedAllocateInfo ) const VULKAN_HPP_NOEXCEPT 6664 { 6665 std::size_t seed = 0; 6666 VULKAN_HPP_HASH_COMBINE( seed, memoryDedicatedAllocateInfo.sType ); 6667 VULKAN_HPP_HASH_COMBINE( seed, memoryDedicatedAllocateInfo.pNext ); 6668 VULKAN_HPP_HASH_COMBINE( seed, memoryDedicatedAllocateInfo.image ); 6669 VULKAN_HPP_HASH_COMBINE( seed, memoryDedicatedAllocateInfo.buffer ); 6670 return seed; 6671 } 6672 }; 6673 6674 template <> 6675 struct hash<VULKAN_HPP_NAMESPACE::MemoryDedicatedRequirements> 6676 { operator ()std::hash6677 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryDedicatedRequirements const & memoryDedicatedRequirements ) const VULKAN_HPP_NOEXCEPT 6678 { 6679 std::size_t seed = 0; 6680 VULKAN_HPP_HASH_COMBINE( seed, memoryDedicatedRequirements.sType ); 6681 VULKAN_HPP_HASH_COMBINE( seed, memoryDedicatedRequirements.pNext ); 6682 VULKAN_HPP_HASH_COMBINE( seed, memoryDedicatedRequirements.prefersDedicatedAllocation ); 6683 VULKAN_HPP_HASH_COMBINE( seed, memoryDedicatedRequirements.requiresDedicatedAllocation ); 6684 return seed; 6685 } 6686 }; 6687 6688 template <> 6689 struct hash<VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR> 6690 { operator ()std::hash6691 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR const & memoryFdPropertiesKHR ) const VULKAN_HPP_NOEXCEPT 6692 { 6693 std::size_t seed = 0; 6694 VULKAN_HPP_HASH_COMBINE( seed, memoryFdPropertiesKHR.sType ); 6695 VULKAN_HPP_HASH_COMBINE( seed, memoryFdPropertiesKHR.pNext ); 6696 VULKAN_HPP_HASH_COMBINE( seed, memoryFdPropertiesKHR.memoryTypeBits ); 6697 return seed; 6698 } 6699 }; 6700 6701 # if defined( VK_USE_PLATFORM_ANDROID_KHR ) 6702 template <> 6703 struct hash<VULKAN_HPP_NAMESPACE::MemoryGetAndroidHardwareBufferInfoANDROID> 6704 { 6705 std::size_t operator ()std::hash6706 operator()( VULKAN_HPP_NAMESPACE::MemoryGetAndroidHardwareBufferInfoANDROID const & memoryGetAndroidHardwareBufferInfoANDROID ) const VULKAN_HPP_NOEXCEPT 6707 { 6708 std::size_t seed = 0; 6709 VULKAN_HPP_HASH_COMBINE( seed, memoryGetAndroidHardwareBufferInfoANDROID.sType ); 6710 VULKAN_HPP_HASH_COMBINE( seed, memoryGetAndroidHardwareBufferInfoANDROID.pNext ); 6711 VULKAN_HPP_HASH_COMBINE( seed, memoryGetAndroidHardwareBufferInfoANDROID.memory ); 6712 return seed; 6713 } 6714 }; 6715 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ 6716 6717 template <> 6718 struct hash<VULKAN_HPP_NAMESPACE::MemoryGetFdInfoKHR> 6719 { operator ()std::hash6720 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryGetFdInfoKHR const & memoryGetFdInfoKHR ) const VULKAN_HPP_NOEXCEPT 6721 { 6722 std::size_t seed = 0; 6723 VULKAN_HPP_HASH_COMBINE( seed, memoryGetFdInfoKHR.sType ); 6724 VULKAN_HPP_HASH_COMBINE( seed, memoryGetFdInfoKHR.pNext ); 6725 VULKAN_HPP_HASH_COMBINE( seed, memoryGetFdInfoKHR.memory ); 6726 VULKAN_HPP_HASH_COMBINE( seed, memoryGetFdInfoKHR.handleType ); 6727 return seed; 6728 } 6729 }; 6730 6731 template <> 6732 struct hash<VULKAN_HPP_NAMESPACE::MemoryGetRemoteAddressInfoNV> 6733 { operator ()std::hash6734 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryGetRemoteAddressInfoNV const & memoryGetRemoteAddressInfoNV ) const VULKAN_HPP_NOEXCEPT 6735 { 6736 std::size_t seed = 0; 6737 VULKAN_HPP_HASH_COMBINE( seed, memoryGetRemoteAddressInfoNV.sType ); 6738 VULKAN_HPP_HASH_COMBINE( seed, memoryGetRemoteAddressInfoNV.pNext ); 6739 VULKAN_HPP_HASH_COMBINE( seed, memoryGetRemoteAddressInfoNV.memory ); 6740 VULKAN_HPP_HASH_COMBINE( seed, memoryGetRemoteAddressInfoNV.handleType ); 6741 return seed; 6742 } 6743 }; 6744 6745 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 6746 template <> 6747 struct hash<VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR> 6748 { operator ()std::hash6749 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR const & memoryGetWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT 6750 { 6751 std::size_t seed = 0; 6752 VULKAN_HPP_HASH_COMBINE( seed, memoryGetWin32HandleInfoKHR.sType ); 6753 VULKAN_HPP_HASH_COMBINE( seed, memoryGetWin32HandleInfoKHR.pNext ); 6754 VULKAN_HPP_HASH_COMBINE( seed, memoryGetWin32HandleInfoKHR.memory ); 6755 VULKAN_HPP_HASH_COMBINE( seed, memoryGetWin32HandleInfoKHR.handleType ); 6756 return seed; 6757 } 6758 }; 6759 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 6760 6761 # if defined( VK_USE_PLATFORM_FUCHSIA ) 6762 template <> 6763 struct hash<VULKAN_HPP_NAMESPACE::MemoryGetZirconHandleInfoFUCHSIA> 6764 { operator ()std::hash6765 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryGetZirconHandleInfoFUCHSIA const & memoryGetZirconHandleInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT 6766 { 6767 std::size_t seed = 0; 6768 VULKAN_HPP_HASH_COMBINE( seed, memoryGetZirconHandleInfoFUCHSIA.sType ); 6769 VULKAN_HPP_HASH_COMBINE( seed, memoryGetZirconHandleInfoFUCHSIA.pNext ); 6770 VULKAN_HPP_HASH_COMBINE( seed, memoryGetZirconHandleInfoFUCHSIA.memory ); 6771 VULKAN_HPP_HASH_COMBINE( seed, memoryGetZirconHandleInfoFUCHSIA.handleType ); 6772 return seed; 6773 } 6774 }; 6775 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 6776 6777 template <> 6778 struct hash<VULKAN_HPP_NAMESPACE::MemoryHeap> 6779 { operator ()std::hash6780 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryHeap const & memoryHeap ) const VULKAN_HPP_NOEXCEPT 6781 { 6782 std::size_t seed = 0; 6783 VULKAN_HPP_HASH_COMBINE( seed, memoryHeap.size ); 6784 VULKAN_HPP_HASH_COMBINE( seed, memoryHeap.flags ); 6785 return seed; 6786 } 6787 }; 6788 6789 template <> 6790 struct hash<VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT> 6791 { operator ()std::hash6792 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT const & memoryHostPointerPropertiesEXT ) const VULKAN_HPP_NOEXCEPT 6793 { 6794 std::size_t seed = 0; 6795 VULKAN_HPP_HASH_COMBINE( seed, memoryHostPointerPropertiesEXT.sType ); 6796 VULKAN_HPP_HASH_COMBINE( seed, memoryHostPointerPropertiesEXT.pNext ); 6797 VULKAN_HPP_HASH_COMBINE( seed, memoryHostPointerPropertiesEXT.memoryTypeBits ); 6798 return seed; 6799 } 6800 }; 6801 6802 template <> 6803 struct hash<VULKAN_HPP_NAMESPACE::MemoryMapInfoKHR> 6804 { operator ()std::hash6805 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryMapInfoKHR const & memoryMapInfoKHR ) const VULKAN_HPP_NOEXCEPT 6806 { 6807 std::size_t seed = 0; 6808 VULKAN_HPP_HASH_COMBINE( seed, memoryMapInfoKHR.sType ); 6809 VULKAN_HPP_HASH_COMBINE( seed, memoryMapInfoKHR.pNext ); 6810 VULKAN_HPP_HASH_COMBINE( seed, memoryMapInfoKHR.flags ); 6811 VULKAN_HPP_HASH_COMBINE( seed, memoryMapInfoKHR.memory ); 6812 VULKAN_HPP_HASH_COMBINE( seed, memoryMapInfoKHR.offset ); 6813 VULKAN_HPP_HASH_COMBINE( seed, memoryMapInfoKHR.size ); 6814 return seed; 6815 } 6816 }; 6817 6818 template <> 6819 struct hash<VULKAN_HPP_NAMESPACE::MemoryOpaqueCaptureAddressAllocateInfo> 6820 { 6821 std::size_t operator ()std::hash6822 operator()( VULKAN_HPP_NAMESPACE::MemoryOpaqueCaptureAddressAllocateInfo const & memoryOpaqueCaptureAddressAllocateInfo ) const VULKAN_HPP_NOEXCEPT 6823 { 6824 std::size_t seed = 0; 6825 VULKAN_HPP_HASH_COMBINE( seed, memoryOpaqueCaptureAddressAllocateInfo.sType ); 6826 VULKAN_HPP_HASH_COMBINE( seed, memoryOpaqueCaptureAddressAllocateInfo.pNext ); 6827 VULKAN_HPP_HASH_COMBINE( seed, memoryOpaqueCaptureAddressAllocateInfo.opaqueCaptureAddress ); 6828 return seed; 6829 } 6830 }; 6831 6832 template <> 6833 struct hash<VULKAN_HPP_NAMESPACE::MemoryPriorityAllocateInfoEXT> 6834 { operator ()std::hash6835 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryPriorityAllocateInfoEXT const & memoryPriorityAllocateInfoEXT ) const VULKAN_HPP_NOEXCEPT 6836 { 6837 std::size_t seed = 0; 6838 VULKAN_HPP_HASH_COMBINE( seed, memoryPriorityAllocateInfoEXT.sType ); 6839 VULKAN_HPP_HASH_COMBINE( seed, memoryPriorityAllocateInfoEXT.pNext ); 6840 VULKAN_HPP_HASH_COMBINE( seed, memoryPriorityAllocateInfoEXT.priority ); 6841 return seed; 6842 } 6843 }; 6844 6845 template <> 6846 struct hash<VULKAN_HPP_NAMESPACE::MemoryRequirements> 6847 { operator ()std::hash6848 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryRequirements const & memoryRequirements ) const VULKAN_HPP_NOEXCEPT 6849 { 6850 std::size_t seed = 0; 6851 VULKAN_HPP_HASH_COMBINE( seed, memoryRequirements.size ); 6852 VULKAN_HPP_HASH_COMBINE( seed, memoryRequirements.alignment ); 6853 VULKAN_HPP_HASH_COMBINE( seed, memoryRequirements.memoryTypeBits ); 6854 return seed; 6855 } 6856 }; 6857 6858 template <> 6859 struct hash<VULKAN_HPP_NAMESPACE::MemoryRequirements2> 6860 { operator ()std::hash6861 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryRequirements2 const & memoryRequirements2 ) const VULKAN_HPP_NOEXCEPT 6862 { 6863 std::size_t seed = 0; 6864 VULKAN_HPP_HASH_COMBINE( seed, memoryRequirements2.sType ); 6865 VULKAN_HPP_HASH_COMBINE( seed, memoryRequirements2.pNext ); 6866 VULKAN_HPP_HASH_COMBINE( seed, memoryRequirements2.memoryRequirements ); 6867 return seed; 6868 } 6869 }; 6870 6871 template <> 6872 struct hash<VULKAN_HPP_NAMESPACE::MemoryType> 6873 { operator ()std::hash6874 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryType const & memoryType ) const VULKAN_HPP_NOEXCEPT 6875 { 6876 std::size_t seed = 0; 6877 VULKAN_HPP_HASH_COMBINE( seed, memoryType.propertyFlags ); 6878 VULKAN_HPP_HASH_COMBINE( seed, memoryType.heapIndex ); 6879 return seed; 6880 } 6881 }; 6882 6883 template <> 6884 struct hash<VULKAN_HPP_NAMESPACE::MemoryUnmapInfoKHR> 6885 { operator ()std::hash6886 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryUnmapInfoKHR const & memoryUnmapInfoKHR ) const VULKAN_HPP_NOEXCEPT 6887 { 6888 std::size_t seed = 0; 6889 VULKAN_HPP_HASH_COMBINE( seed, memoryUnmapInfoKHR.sType ); 6890 VULKAN_HPP_HASH_COMBINE( seed, memoryUnmapInfoKHR.pNext ); 6891 VULKAN_HPP_HASH_COMBINE( seed, memoryUnmapInfoKHR.flags ); 6892 VULKAN_HPP_HASH_COMBINE( seed, memoryUnmapInfoKHR.memory ); 6893 return seed; 6894 } 6895 }; 6896 6897 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 6898 template <> 6899 struct hash<VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR> 6900 { operator ()std::hash6901 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR const & memoryWin32HandlePropertiesKHR ) const VULKAN_HPP_NOEXCEPT 6902 { 6903 std::size_t seed = 0; 6904 VULKAN_HPP_HASH_COMBINE( seed, memoryWin32HandlePropertiesKHR.sType ); 6905 VULKAN_HPP_HASH_COMBINE( seed, memoryWin32HandlePropertiesKHR.pNext ); 6906 VULKAN_HPP_HASH_COMBINE( seed, memoryWin32HandlePropertiesKHR.memoryTypeBits ); 6907 return seed; 6908 } 6909 }; 6910 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 6911 6912 # if defined( VK_USE_PLATFORM_FUCHSIA ) 6913 template <> 6914 struct hash<VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA> 6915 { operator ()std::hash6916 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA const & memoryZirconHandlePropertiesFUCHSIA ) const VULKAN_HPP_NOEXCEPT 6917 { 6918 std::size_t seed = 0; 6919 VULKAN_HPP_HASH_COMBINE( seed, memoryZirconHandlePropertiesFUCHSIA.sType ); 6920 VULKAN_HPP_HASH_COMBINE( seed, memoryZirconHandlePropertiesFUCHSIA.pNext ); 6921 VULKAN_HPP_HASH_COMBINE( seed, memoryZirconHandlePropertiesFUCHSIA.memoryTypeBits ); 6922 return seed; 6923 } 6924 }; 6925 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 6926 6927 # if defined( VK_USE_PLATFORM_METAL_EXT ) 6928 template <> 6929 struct hash<VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT> 6930 { operator ()std::hash6931 std::size_t operator()( VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT const & metalSurfaceCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 6932 { 6933 std::size_t seed = 0; 6934 VULKAN_HPP_HASH_COMBINE( seed, metalSurfaceCreateInfoEXT.sType ); 6935 VULKAN_HPP_HASH_COMBINE( seed, metalSurfaceCreateInfoEXT.pNext ); 6936 VULKAN_HPP_HASH_COMBINE( seed, metalSurfaceCreateInfoEXT.flags ); 6937 VULKAN_HPP_HASH_COMBINE( seed, metalSurfaceCreateInfoEXT.pLayer ); 6938 return seed; 6939 } 6940 }; 6941 # endif /*VK_USE_PLATFORM_METAL_EXT*/ 6942 6943 template <> 6944 struct hash<VULKAN_HPP_NAMESPACE::MicromapBuildSizesInfoEXT> 6945 { operator ()std::hash6946 std::size_t operator()( VULKAN_HPP_NAMESPACE::MicromapBuildSizesInfoEXT const & micromapBuildSizesInfoEXT ) const VULKAN_HPP_NOEXCEPT 6947 { 6948 std::size_t seed = 0; 6949 VULKAN_HPP_HASH_COMBINE( seed, micromapBuildSizesInfoEXT.sType ); 6950 VULKAN_HPP_HASH_COMBINE( seed, micromapBuildSizesInfoEXT.pNext ); 6951 VULKAN_HPP_HASH_COMBINE( seed, micromapBuildSizesInfoEXT.micromapSize ); 6952 VULKAN_HPP_HASH_COMBINE( seed, micromapBuildSizesInfoEXT.buildScratchSize ); 6953 VULKAN_HPP_HASH_COMBINE( seed, micromapBuildSizesInfoEXT.discardable ); 6954 return seed; 6955 } 6956 }; 6957 6958 template <> 6959 struct hash<VULKAN_HPP_NAMESPACE::MicromapCreateInfoEXT> 6960 { operator ()std::hash6961 std::size_t operator()( VULKAN_HPP_NAMESPACE::MicromapCreateInfoEXT const & micromapCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 6962 { 6963 std::size_t seed = 0; 6964 VULKAN_HPP_HASH_COMBINE( seed, micromapCreateInfoEXT.sType ); 6965 VULKAN_HPP_HASH_COMBINE( seed, micromapCreateInfoEXT.pNext ); 6966 VULKAN_HPP_HASH_COMBINE( seed, micromapCreateInfoEXT.createFlags ); 6967 VULKAN_HPP_HASH_COMBINE( seed, micromapCreateInfoEXT.buffer ); 6968 VULKAN_HPP_HASH_COMBINE( seed, micromapCreateInfoEXT.offset ); 6969 VULKAN_HPP_HASH_COMBINE( seed, micromapCreateInfoEXT.size ); 6970 VULKAN_HPP_HASH_COMBINE( seed, micromapCreateInfoEXT.type ); 6971 VULKAN_HPP_HASH_COMBINE( seed, micromapCreateInfoEXT.deviceAddress ); 6972 return seed; 6973 } 6974 }; 6975 6976 template <> 6977 struct hash<VULKAN_HPP_NAMESPACE::MicromapTriangleEXT> 6978 { operator ()std::hash6979 std::size_t operator()( VULKAN_HPP_NAMESPACE::MicromapTriangleEXT const & micromapTriangleEXT ) const VULKAN_HPP_NOEXCEPT 6980 { 6981 std::size_t seed = 0; 6982 VULKAN_HPP_HASH_COMBINE( seed, micromapTriangleEXT.dataOffset ); 6983 VULKAN_HPP_HASH_COMBINE( seed, micromapTriangleEXT.subdivisionLevel ); 6984 VULKAN_HPP_HASH_COMBINE( seed, micromapTriangleEXT.format ); 6985 return seed; 6986 } 6987 }; 6988 6989 template <> 6990 struct hash<VULKAN_HPP_NAMESPACE::MicromapVersionInfoEXT> 6991 { operator ()std::hash6992 std::size_t operator()( VULKAN_HPP_NAMESPACE::MicromapVersionInfoEXT const & micromapVersionInfoEXT ) const VULKAN_HPP_NOEXCEPT 6993 { 6994 std::size_t seed = 0; 6995 VULKAN_HPP_HASH_COMBINE( seed, micromapVersionInfoEXT.sType ); 6996 VULKAN_HPP_HASH_COMBINE( seed, micromapVersionInfoEXT.pNext ); 6997 VULKAN_HPP_HASH_COMBINE( seed, micromapVersionInfoEXT.pVersionData ); 6998 return seed; 6999 } 7000 }; 7001 7002 template <> 7003 struct hash<VULKAN_HPP_NAMESPACE::MultiDrawIndexedInfoEXT> 7004 { operator ()std::hash7005 std::size_t operator()( VULKAN_HPP_NAMESPACE::MultiDrawIndexedInfoEXT const & multiDrawIndexedInfoEXT ) const VULKAN_HPP_NOEXCEPT 7006 { 7007 std::size_t seed = 0; 7008 VULKAN_HPP_HASH_COMBINE( seed, multiDrawIndexedInfoEXT.firstIndex ); 7009 VULKAN_HPP_HASH_COMBINE( seed, multiDrawIndexedInfoEXT.indexCount ); 7010 VULKAN_HPP_HASH_COMBINE( seed, multiDrawIndexedInfoEXT.vertexOffset ); 7011 return seed; 7012 } 7013 }; 7014 7015 template <> 7016 struct hash<VULKAN_HPP_NAMESPACE::MultiDrawInfoEXT> 7017 { operator ()std::hash7018 std::size_t operator()( VULKAN_HPP_NAMESPACE::MultiDrawInfoEXT const & multiDrawInfoEXT ) const VULKAN_HPP_NOEXCEPT 7019 { 7020 std::size_t seed = 0; 7021 VULKAN_HPP_HASH_COMBINE( seed, multiDrawInfoEXT.firstVertex ); 7022 VULKAN_HPP_HASH_COMBINE( seed, multiDrawInfoEXT.vertexCount ); 7023 return seed; 7024 } 7025 }; 7026 7027 template <> 7028 struct hash<VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT> 7029 { operator ()std::hash7030 std::size_t operator()( VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT const & multisamplePropertiesEXT ) const VULKAN_HPP_NOEXCEPT 7031 { 7032 std::size_t seed = 0; 7033 VULKAN_HPP_HASH_COMBINE( seed, multisamplePropertiesEXT.sType ); 7034 VULKAN_HPP_HASH_COMBINE( seed, multisamplePropertiesEXT.pNext ); 7035 VULKAN_HPP_HASH_COMBINE( seed, multisamplePropertiesEXT.maxSampleLocationGridSize ); 7036 return seed; 7037 } 7038 }; 7039 7040 template <> 7041 struct hash<VULKAN_HPP_NAMESPACE::MultisampledRenderToSingleSampledInfoEXT> 7042 { 7043 std::size_t operator ()std::hash7044 operator()( VULKAN_HPP_NAMESPACE::MultisampledRenderToSingleSampledInfoEXT const & multisampledRenderToSingleSampledInfoEXT ) const VULKAN_HPP_NOEXCEPT 7045 { 7046 std::size_t seed = 0; 7047 VULKAN_HPP_HASH_COMBINE( seed, multisampledRenderToSingleSampledInfoEXT.sType ); 7048 VULKAN_HPP_HASH_COMBINE( seed, multisampledRenderToSingleSampledInfoEXT.pNext ); 7049 VULKAN_HPP_HASH_COMBINE( seed, multisampledRenderToSingleSampledInfoEXT.multisampledRenderToSingleSampledEnable ); 7050 VULKAN_HPP_HASH_COMBINE( seed, multisampledRenderToSingleSampledInfoEXT.rasterizationSamples ); 7051 return seed; 7052 } 7053 }; 7054 7055 template <> 7056 struct hash<VULKAN_HPP_NAMESPACE::MultiviewPerViewAttributesInfoNVX> 7057 { operator ()std::hash7058 std::size_t operator()( VULKAN_HPP_NAMESPACE::MultiviewPerViewAttributesInfoNVX const & multiviewPerViewAttributesInfoNVX ) const VULKAN_HPP_NOEXCEPT 7059 { 7060 std::size_t seed = 0; 7061 VULKAN_HPP_HASH_COMBINE( seed, multiviewPerViewAttributesInfoNVX.sType ); 7062 VULKAN_HPP_HASH_COMBINE( seed, multiviewPerViewAttributesInfoNVX.pNext ); 7063 VULKAN_HPP_HASH_COMBINE( seed, multiviewPerViewAttributesInfoNVX.perViewAttributes ); 7064 VULKAN_HPP_HASH_COMBINE( seed, multiviewPerViewAttributesInfoNVX.perViewAttributesPositionXOnly ); 7065 return seed; 7066 } 7067 }; 7068 7069 template <> 7070 struct hash<VULKAN_HPP_NAMESPACE::MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM> 7071 { 7072 std::size_t operator ()std::hash7073 operator()( VULKAN_HPP_NAMESPACE::MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM const & multiviewPerViewRenderAreasRenderPassBeginInfoQCOM ) const 7074 VULKAN_HPP_NOEXCEPT 7075 { 7076 std::size_t seed = 0; 7077 VULKAN_HPP_HASH_COMBINE( seed, multiviewPerViewRenderAreasRenderPassBeginInfoQCOM.sType ); 7078 VULKAN_HPP_HASH_COMBINE( seed, multiviewPerViewRenderAreasRenderPassBeginInfoQCOM.pNext ); 7079 VULKAN_HPP_HASH_COMBINE( seed, multiviewPerViewRenderAreasRenderPassBeginInfoQCOM.perViewRenderAreaCount ); 7080 VULKAN_HPP_HASH_COMBINE( seed, multiviewPerViewRenderAreasRenderPassBeginInfoQCOM.pPerViewRenderAreas ); 7081 return seed; 7082 } 7083 }; 7084 7085 template <> 7086 struct hash<VULKAN_HPP_NAMESPACE::MutableDescriptorTypeListEXT> 7087 { operator ()std::hash7088 std::size_t operator()( VULKAN_HPP_NAMESPACE::MutableDescriptorTypeListEXT const & mutableDescriptorTypeListEXT ) const VULKAN_HPP_NOEXCEPT 7089 { 7090 std::size_t seed = 0; 7091 VULKAN_HPP_HASH_COMBINE( seed, mutableDescriptorTypeListEXT.descriptorTypeCount ); 7092 VULKAN_HPP_HASH_COMBINE( seed, mutableDescriptorTypeListEXT.pDescriptorTypes ); 7093 return seed; 7094 } 7095 }; 7096 7097 template <> 7098 struct hash<VULKAN_HPP_NAMESPACE::MutableDescriptorTypeCreateInfoEXT> 7099 { operator ()std::hash7100 std::size_t operator()( VULKAN_HPP_NAMESPACE::MutableDescriptorTypeCreateInfoEXT const & mutableDescriptorTypeCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 7101 { 7102 std::size_t seed = 0; 7103 VULKAN_HPP_HASH_COMBINE( seed, mutableDescriptorTypeCreateInfoEXT.sType ); 7104 VULKAN_HPP_HASH_COMBINE( seed, mutableDescriptorTypeCreateInfoEXT.pNext ); 7105 VULKAN_HPP_HASH_COMBINE( seed, mutableDescriptorTypeCreateInfoEXT.mutableDescriptorTypeListCount ); 7106 VULKAN_HPP_HASH_COMBINE( seed, mutableDescriptorTypeCreateInfoEXT.pMutableDescriptorTypeLists ); 7107 return seed; 7108 } 7109 }; 7110 7111 template <> 7112 struct hash<VULKAN_HPP_NAMESPACE::OpaqueCaptureDescriptorDataCreateInfoEXT> 7113 { 7114 std::size_t operator ()std::hash7115 operator()( VULKAN_HPP_NAMESPACE::OpaqueCaptureDescriptorDataCreateInfoEXT const & opaqueCaptureDescriptorDataCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 7116 { 7117 std::size_t seed = 0; 7118 VULKAN_HPP_HASH_COMBINE( seed, opaqueCaptureDescriptorDataCreateInfoEXT.sType ); 7119 VULKAN_HPP_HASH_COMBINE( seed, opaqueCaptureDescriptorDataCreateInfoEXT.pNext ); 7120 VULKAN_HPP_HASH_COMBINE( seed, opaqueCaptureDescriptorDataCreateInfoEXT.opaqueCaptureDescriptorData ); 7121 return seed; 7122 } 7123 }; 7124 7125 template <> 7126 struct hash<VULKAN_HPP_NAMESPACE::OpticalFlowExecuteInfoNV> 7127 { operator ()std::hash7128 std::size_t operator()( VULKAN_HPP_NAMESPACE::OpticalFlowExecuteInfoNV const & opticalFlowExecuteInfoNV ) const VULKAN_HPP_NOEXCEPT 7129 { 7130 std::size_t seed = 0; 7131 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowExecuteInfoNV.sType ); 7132 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowExecuteInfoNV.pNext ); 7133 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowExecuteInfoNV.flags ); 7134 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowExecuteInfoNV.regionCount ); 7135 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowExecuteInfoNV.pRegions ); 7136 return seed; 7137 } 7138 }; 7139 7140 template <> 7141 struct hash<VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatInfoNV> 7142 { operator ()std::hash7143 std::size_t operator()( VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatInfoNV const & opticalFlowImageFormatInfoNV ) const VULKAN_HPP_NOEXCEPT 7144 { 7145 std::size_t seed = 0; 7146 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowImageFormatInfoNV.sType ); 7147 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowImageFormatInfoNV.pNext ); 7148 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowImageFormatInfoNV.usage ); 7149 return seed; 7150 } 7151 }; 7152 7153 template <> 7154 struct hash<VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV> 7155 { operator ()std::hash7156 std::size_t operator()( VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV const & opticalFlowImageFormatPropertiesNV ) const VULKAN_HPP_NOEXCEPT 7157 { 7158 std::size_t seed = 0; 7159 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowImageFormatPropertiesNV.sType ); 7160 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowImageFormatPropertiesNV.pNext ); 7161 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowImageFormatPropertiesNV.format ); 7162 return seed; 7163 } 7164 }; 7165 7166 template <> 7167 struct hash<VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreateInfoNV> 7168 { operator ()std::hash7169 std::size_t operator()( VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreateInfoNV const & opticalFlowSessionCreateInfoNV ) const VULKAN_HPP_NOEXCEPT 7170 { 7171 std::size_t seed = 0; 7172 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.sType ); 7173 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.pNext ); 7174 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.width ); 7175 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.height ); 7176 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.imageFormat ); 7177 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.flowVectorFormat ); 7178 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.costFormat ); 7179 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.outputGridSize ); 7180 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.hintGridSize ); 7181 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.performanceLevel ); 7182 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.flags ); 7183 return seed; 7184 } 7185 }; 7186 7187 template <> 7188 struct hash<VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreatePrivateDataInfoNV> 7189 { 7190 std::size_t operator ()std::hash7191 operator()( VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreatePrivateDataInfoNV const & opticalFlowSessionCreatePrivateDataInfoNV ) const VULKAN_HPP_NOEXCEPT 7192 { 7193 std::size_t seed = 0; 7194 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreatePrivateDataInfoNV.sType ); 7195 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreatePrivateDataInfoNV.pNext ); 7196 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreatePrivateDataInfoNV.id ); 7197 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreatePrivateDataInfoNV.size ); 7198 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreatePrivateDataInfoNV.pPrivateData ); 7199 return seed; 7200 } 7201 }; 7202 7203 template <> 7204 struct hash<VULKAN_HPP_NAMESPACE::OutOfBandQueueTypeInfoNV> 7205 { operator ()std::hash7206 std::size_t operator()( VULKAN_HPP_NAMESPACE::OutOfBandQueueTypeInfoNV const & outOfBandQueueTypeInfoNV ) const VULKAN_HPP_NOEXCEPT 7207 { 7208 std::size_t seed = 0; 7209 VULKAN_HPP_HASH_COMBINE( seed, outOfBandQueueTypeInfoNV.sType ); 7210 VULKAN_HPP_HASH_COMBINE( seed, outOfBandQueueTypeInfoNV.pNext ); 7211 VULKAN_HPP_HASH_COMBINE( seed, outOfBandQueueTypeInfoNV.queueType ); 7212 return seed; 7213 } 7214 }; 7215 7216 template <> 7217 struct hash<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE> 7218 { operator ()std::hash7219 std::size_t operator()( VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE const & pastPresentationTimingGOOGLE ) const VULKAN_HPP_NOEXCEPT 7220 { 7221 std::size_t seed = 0; 7222 VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingGOOGLE.presentID ); 7223 VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingGOOGLE.desiredPresentTime ); 7224 VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingGOOGLE.actualPresentTime ); 7225 VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingGOOGLE.earliestPresentTime ); 7226 VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingGOOGLE.presentMargin ); 7227 return seed; 7228 } 7229 }; 7230 7231 template <> 7232 struct hash<VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL> 7233 { 7234 std::size_t operator ()std::hash7235 operator()( VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL const & performanceConfigurationAcquireInfoINTEL ) const VULKAN_HPP_NOEXCEPT 7236 { 7237 std::size_t seed = 0; 7238 VULKAN_HPP_HASH_COMBINE( seed, performanceConfigurationAcquireInfoINTEL.sType ); 7239 VULKAN_HPP_HASH_COMBINE( seed, performanceConfigurationAcquireInfoINTEL.pNext ); 7240 VULKAN_HPP_HASH_COMBINE( seed, performanceConfigurationAcquireInfoINTEL.type ); 7241 return seed; 7242 } 7243 }; 7244 7245 template <> 7246 struct hash<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR> 7247 { operator ()std::hash7248 std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR const & performanceCounterDescriptionKHR ) const VULKAN_HPP_NOEXCEPT 7249 { 7250 std::size_t seed = 0; 7251 VULKAN_HPP_HASH_COMBINE( seed, performanceCounterDescriptionKHR.sType ); 7252 VULKAN_HPP_HASH_COMBINE( seed, performanceCounterDescriptionKHR.pNext ); 7253 VULKAN_HPP_HASH_COMBINE( seed, performanceCounterDescriptionKHR.flags ); 7254 for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) 7255 { 7256 VULKAN_HPP_HASH_COMBINE( seed, performanceCounterDescriptionKHR.name[i] ); 7257 } 7258 for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) 7259 { 7260 VULKAN_HPP_HASH_COMBINE( seed, performanceCounterDescriptionKHR.category[i] ); 7261 } 7262 for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) 7263 { 7264 VULKAN_HPP_HASH_COMBINE( seed, performanceCounterDescriptionKHR.description[i] ); 7265 } 7266 return seed; 7267 } 7268 }; 7269 7270 template <> 7271 struct hash<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR> 7272 { operator ()std::hash7273 std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceCounterKHR const & performanceCounterKHR ) const VULKAN_HPP_NOEXCEPT 7274 { 7275 std::size_t seed = 0; 7276 VULKAN_HPP_HASH_COMBINE( seed, performanceCounterKHR.sType ); 7277 VULKAN_HPP_HASH_COMBINE( seed, performanceCounterKHR.pNext ); 7278 VULKAN_HPP_HASH_COMBINE( seed, performanceCounterKHR.unit ); 7279 VULKAN_HPP_HASH_COMBINE( seed, performanceCounterKHR.scope ); 7280 VULKAN_HPP_HASH_COMBINE( seed, performanceCounterKHR.storage ); 7281 for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) 7282 { 7283 VULKAN_HPP_HASH_COMBINE( seed, performanceCounterKHR.uuid[i] ); 7284 } 7285 return seed; 7286 } 7287 }; 7288 7289 template <> 7290 struct hash<VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL> 7291 { operator ()std::hash7292 std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL const & performanceMarkerInfoINTEL ) const VULKAN_HPP_NOEXCEPT 7293 { 7294 std::size_t seed = 0; 7295 VULKAN_HPP_HASH_COMBINE( seed, performanceMarkerInfoINTEL.sType ); 7296 VULKAN_HPP_HASH_COMBINE( seed, performanceMarkerInfoINTEL.pNext ); 7297 VULKAN_HPP_HASH_COMBINE( seed, performanceMarkerInfoINTEL.marker ); 7298 return seed; 7299 } 7300 }; 7301 7302 template <> 7303 struct hash<VULKAN_HPP_NAMESPACE::PerformanceOverrideInfoINTEL> 7304 { operator ()std::hash7305 std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceOverrideInfoINTEL const & performanceOverrideInfoINTEL ) const VULKAN_HPP_NOEXCEPT 7306 { 7307 std::size_t seed = 0; 7308 VULKAN_HPP_HASH_COMBINE( seed, performanceOverrideInfoINTEL.sType ); 7309 VULKAN_HPP_HASH_COMBINE( seed, performanceOverrideInfoINTEL.pNext ); 7310 VULKAN_HPP_HASH_COMBINE( seed, performanceOverrideInfoINTEL.type ); 7311 VULKAN_HPP_HASH_COMBINE( seed, performanceOverrideInfoINTEL.enable ); 7312 VULKAN_HPP_HASH_COMBINE( seed, performanceOverrideInfoINTEL.parameter ); 7313 return seed; 7314 } 7315 }; 7316 7317 template <> 7318 struct hash<VULKAN_HPP_NAMESPACE::PerformanceQuerySubmitInfoKHR> 7319 { operator ()std::hash7320 std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceQuerySubmitInfoKHR const & performanceQuerySubmitInfoKHR ) const VULKAN_HPP_NOEXCEPT 7321 { 7322 std::size_t seed = 0; 7323 VULKAN_HPP_HASH_COMBINE( seed, performanceQuerySubmitInfoKHR.sType ); 7324 VULKAN_HPP_HASH_COMBINE( seed, performanceQuerySubmitInfoKHR.pNext ); 7325 VULKAN_HPP_HASH_COMBINE( seed, performanceQuerySubmitInfoKHR.counterPassIndex ); 7326 return seed; 7327 } 7328 }; 7329 7330 template <> 7331 struct hash<VULKAN_HPP_NAMESPACE::PerformanceStreamMarkerInfoINTEL> 7332 { operator ()std::hash7333 std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceStreamMarkerInfoINTEL const & performanceStreamMarkerInfoINTEL ) const VULKAN_HPP_NOEXCEPT 7334 { 7335 std::size_t seed = 0; 7336 VULKAN_HPP_HASH_COMBINE( seed, performanceStreamMarkerInfoINTEL.sType ); 7337 VULKAN_HPP_HASH_COMBINE( seed, performanceStreamMarkerInfoINTEL.pNext ); 7338 VULKAN_HPP_HASH_COMBINE( seed, performanceStreamMarkerInfoINTEL.marker ); 7339 return seed; 7340 } 7341 }; 7342 7343 template <> 7344 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevice16BitStorageFeatures> 7345 { operator ()std::hash7346 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevice16BitStorageFeatures const & physicalDevice16BitStorageFeatures ) const VULKAN_HPP_NOEXCEPT 7347 { 7348 std::size_t seed = 0; 7349 VULKAN_HPP_HASH_COMBINE( seed, physicalDevice16BitStorageFeatures.sType ); 7350 VULKAN_HPP_HASH_COMBINE( seed, physicalDevice16BitStorageFeatures.pNext ); 7351 VULKAN_HPP_HASH_COMBINE( seed, physicalDevice16BitStorageFeatures.storageBuffer16BitAccess ); 7352 VULKAN_HPP_HASH_COMBINE( seed, physicalDevice16BitStorageFeatures.uniformAndStorageBuffer16BitAccess ); 7353 VULKAN_HPP_HASH_COMBINE( seed, physicalDevice16BitStorageFeatures.storagePushConstant16 ); 7354 VULKAN_HPP_HASH_COMBINE( seed, physicalDevice16BitStorageFeatures.storageInputOutput16 ); 7355 return seed; 7356 } 7357 }; 7358 7359 template <> 7360 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevice4444FormatsFeaturesEXT> 7361 { operator ()std::hash7362 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevice4444FormatsFeaturesEXT const & physicalDevice4444FormatsFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 7363 { 7364 std::size_t seed = 0; 7365 VULKAN_HPP_HASH_COMBINE( seed, physicalDevice4444FormatsFeaturesEXT.sType ); 7366 VULKAN_HPP_HASH_COMBINE( seed, physicalDevice4444FormatsFeaturesEXT.pNext ); 7367 VULKAN_HPP_HASH_COMBINE( seed, physicalDevice4444FormatsFeaturesEXT.formatA4R4G4B4 ); 7368 VULKAN_HPP_HASH_COMBINE( seed, physicalDevice4444FormatsFeaturesEXT.formatA4B4G4R4 ); 7369 return seed; 7370 } 7371 }; 7372 7373 template <> 7374 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevice8BitStorageFeatures> 7375 { operator ()std::hash7376 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevice8BitStorageFeatures const & physicalDevice8BitStorageFeatures ) const VULKAN_HPP_NOEXCEPT 7377 { 7378 std::size_t seed = 0; 7379 VULKAN_HPP_HASH_COMBINE( seed, physicalDevice8BitStorageFeatures.sType ); 7380 VULKAN_HPP_HASH_COMBINE( seed, physicalDevice8BitStorageFeatures.pNext ); 7381 VULKAN_HPP_HASH_COMBINE( seed, physicalDevice8BitStorageFeatures.storageBuffer8BitAccess ); 7382 VULKAN_HPP_HASH_COMBINE( seed, physicalDevice8BitStorageFeatures.uniformAndStorageBuffer8BitAccess ); 7383 VULKAN_HPP_HASH_COMBINE( seed, physicalDevice8BitStorageFeatures.storagePushConstant8 ); 7384 return seed; 7385 } 7386 }; 7387 7388 template <> 7389 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceASTCDecodeFeaturesEXT> 7390 { operator ()std::hash7391 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceASTCDecodeFeaturesEXT const & physicalDeviceASTCDecodeFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 7392 { 7393 std::size_t seed = 0; 7394 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceASTCDecodeFeaturesEXT.sType ); 7395 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceASTCDecodeFeaturesEXT.pNext ); 7396 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceASTCDecodeFeaturesEXT.decodeModeSharedExponent ); 7397 return seed; 7398 } 7399 }; 7400 7401 template <> 7402 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceAccelerationStructureFeaturesKHR> 7403 { operator ()std::hash7404 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceAccelerationStructureFeaturesKHR const & physicalDeviceAccelerationStructureFeaturesKHR ) const 7405 VULKAN_HPP_NOEXCEPT 7406 { 7407 std::size_t seed = 0; 7408 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructureFeaturesKHR.sType ); 7409 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructureFeaturesKHR.pNext ); 7410 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructureFeaturesKHR.accelerationStructure ); 7411 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructureFeaturesKHR.accelerationStructureCaptureReplay ); 7412 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructureFeaturesKHR.accelerationStructureIndirectBuild ); 7413 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructureFeaturesKHR.accelerationStructureHostCommands ); 7414 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructureFeaturesKHR.descriptorBindingAccelerationStructureUpdateAfterBind ); 7415 return seed; 7416 } 7417 }; 7418 7419 template <> 7420 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceAccelerationStructurePropertiesKHR> 7421 { operator ()std::hash7422 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceAccelerationStructurePropertiesKHR const & physicalDeviceAccelerationStructurePropertiesKHR ) 7423 const VULKAN_HPP_NOEXCEPT 7424 { 7425 std::size_t seed = 0; 7426 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.sType ); 7427 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.pNext ); 7428 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.maxGeometryCount ); 7429 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.maxInstanceCount ); 7430 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.maxPrimitiveCount ); 7431 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.maxPerStageDescriptorAccelerationStructures ); 7432 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.maxPerStageDescriptorUpdateAfterBindAccelerationStructures ); 7433 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.maxDescriptorSetAccelerationStructures ); 7434 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.maxDescriptorSetUpdateAfterBindAccelerationStructures ); 7435 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.minAccelerationStructureScratchOffsetAlignment ); 7436 return seed; 7437 } 7438 }; 7439 7440 template <> 7441 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceAddressBindingReportFeaturesEXT> 7442 { operator ()std::hash7443 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceAddressBindingReportFeaturesEXT const & physicalDeviceAddressBindingReportFeaturesEXT ) const 7444 VULKAN_HPP_NOEXCEPT 7445 { 7446 std::size_t seed = 0; 7447 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAddressBindingReportFeaturesEXT.sType ); 7448 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAddressBindingReportFeaturesEXT.pNext ); 7449 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAddressBindingReportFeaturesEXT.reportAddressBinding ); 7450 return seed; 7451 } 7452 }; 7453 7454 template <> 7455 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceAmigoProfilingFeaturesSEC> 7456 { 7457 std::size_t operator ()std::hash7458 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceAmigoProfilingFeaturesSEC const & physicalDeviceAmigoProfilingFeaturesSEC ) const VULKAN_HPP_NOEXCEPT 7459 { 7460 std::size_t seed = 0; 7461 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAmigoProfilingFeaturesSEC.sType ); 7462 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAmigoProfilingFeaturesSEC.pNext ); 7463 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAmigoProfilingFeaturesSEC.amigoProfiling ); 7464 return seed; 7465 } 7466 }; 7467 7468 template <> 7469 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT> 7470 { operator ()std::hash7471 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT const & 7472 physicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 7473 { 7474 std::size_t seed = 0; 7475 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT.sType ); 7476 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT.pNext ); 7477 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT.attachmentFeedbackLoopDynamicState ); 7478 return seed; 7479 } 7480 }; 7481 7482 template <> 7483 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT> 7484 { operator ()std::hash7485 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT const & 7486 physicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 7487 { 7488 std::size_t seed = 0; 7489 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT.sType ); 7490 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT.pNext ); 7491 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT.attachmentFeedbackLoopLayout ); 7492 return seed; 7493 } 7494 }; 7495 7496 template <> 7497 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceBlendOperationAdvancedFeaturesEXT> 7498 { operator ()std::hash7499 std::size_t operator()( 7500 VULKAN_HPP_NAMESPACE::PhysicalDeviceBlendOperationAdvancedFeaturesEXT const & physicalDeviceBlendOperationAdvancedFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 7501 { 7502 std::size_t seed = 0; 7503 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedFeaturesEXT.sType ); 7504 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedFeaturesEXT.pNext ); 7505 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedFeaturesEXT.advancedBlendCoherentOperations ); 7506 return seed; 7507 } 7508 }; 7509 7510 template <> 7511 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceBlendOperationAdvancedPropertiesEXT> 7512 { operator ()std::hash7513 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceBlendOperationAdvancedPropertiesEXT const & physicalDeviceBlendOperationAdvancedPropertiesEXT ) 7514 const VULKAN_HPP_NOEXCEPT 7515 { 7516 std::size_t seed = 0; 7517 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.sType ); 7518 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.pNext ); 7519 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendMaxColorAttachments ); 7520 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendIndependentBlend ); 7521 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendNonPremultipliedSrcColor ); 7522 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendNonPremultipliedDstColor ); 7523 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendCorrelatedOverlap ); 7524 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendAllOperations ); 7525 return seed; 7526 } 7527 }; 7528 7529 template <> 7530 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceBorderColorSwizzleFeaturesEXT> 7531 { operator ()std::hash7532 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceBorderColorSwizzleFeaturesEXT const & physicalDeviceBorderColorSwizzleFeaturesEXT ) const 7533 VULKAN_HPP_NOEXCEPT 7534 { 7535 std::size_t seed = 0; 7536 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBorderColorSwizzleFeaturesEXT.sType ); 7537 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBorderColorSwizzleFeaturesEXT.pNext ); 7538 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBorderColorSwizzleFeaturesEXT.borderColorSwizzle ); 7539 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBorderColorSwizzleFeaturesEXT.borderColorSwizzleFromImage ); 7540 return seed; 7541 } 7542 }; 7543 7544 template <> 7545 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceBufferDeviceAddressFeatures> 7546 { 7547 std::size_t operator ()std::hash7548 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceBufferDeviceAddressFeatures const & physicalDeviceBufferDeviceAddressFeatures ) const VULKAN_HPP_NOEXCEPT 7549 { 7550 std::size_t seed = 0; 7551 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeatures.sType ); 7552 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeatures.pNext ); 7553 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeatures.bufferDeviceAddress ); 7554 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeatures.bufferDeviceAddressCaptureReplay ); 7555 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeatures.bufferDeviceAddressMultiDevice ); 7556 return seed; 7557 } 7558 }; 7559 7560 template <> 7561 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceBufferDeviceAddressFeaturesEXT> 7562 { operator ()std::hash7563 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceBufferDeviceAddressFeaturesEXT const & physicalDeviceBufferDeviceAddressFeaturesEXT ) const 7564 VULKAN_HPP_NOEXCEPT 7565 { 7566 std::size_t seed = 0; 7567 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeaturesEXT.sType ); 7568 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeaturesEXT.pNext ); 7569 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeaturesEXT.bufferDeviceAddress ); 7570 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeaturesEXT.bufferDeviceAddressCaptureReplay ); 7571 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeaturesEXT.bufferDeviceAddressMultiDevice ); 7572 return seed; 7573 } 7574 }; 7575 7576 template <> 7577 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterCullingShaderFeaturesHUAWEI> 7578 { operator ()std::hash7579 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterCullingShaderFeaturesHUAWEI const & physicalDeviceClusterCullingShaderFeaturesHUAWEI ) 7580 const VULKAN_HPP_NOEXCEPT 7581 { 7582 std::size_t seed = 0; 7583 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderFeaturesHUAWEI.sType ); 7584 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderFeaturesHUAWEI.pNext ); 7585 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderFeaturesHUAWEI.clustercullingShader ); 7586 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderFeaturesHUAWEI.multiviewClusterCullingShader ); 7587 return seed; 7588 } 7589 }; 7590 7591 template <> 7592 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterCullingShaderPropertiesHUAWEI> 7593 { 7594 std::size_t operator ()std::hash7595 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterCullingShaderPropertiesHUAWEI const & physicalDeviceClusterCullingShaderPropertiesHUAWEI ) const 7596 VULKAN_HPP_NOEXCEPT 7597 { 7598 std::size_t seed = 0; 7599 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderPropertiesHUAWEI.sType ); 7600 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderPropertiesHUAWEI.pNext ); 7601 for ( size_t i = 0; i < 3; ++i ) 7602 { 7603 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderPropertiesHUAWEI.maxWorkGroupCount[i] ); 7604 } 7605 for ( size_t i = 0; i < 3; ++i ) 7606 { 7607 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderPropertiesHUAWEI.maxWorkGroupSize[i] ); 7608 } 7609 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderPropertiesHUAWEI.maxOutputClusterCount ); 7610 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderPropertiesHUAWEI.indirectBufferOffsetAlignment ); 7611 return seed; 7612 } 7613 }; 7614 7615 template <> 7616 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI> 7617 { 7618 std::size_t operator ()std::hash7619 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI const & physicalDeviceClusterCullingShaderVrsFeaturesHUAWEI ) const 7620 VULKAN_HPP_NOEXCEPT 7621 { 7622 std::size_t seed = 0; 7623 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderVrsFeaturesHUAWEI.sType ); 7624 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderVrsFeaturesHUAWEI.pNext ); 7625 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderVrsFeaturesHUAWEI.clusterShadingRate ); 7626 return seed; 7627 } 7628 }; 7629 7630 template <> 7631 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCoherentMemoryFeaturesAMD> 7632 { 7633 std::size_t operator ()std::hash7634 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCoherentMemoryFeaturesAMD const & physicalDeviceCoherentMemoryFeaturesAMD ) const VULKAN_HPP_NOEXCEPT 7635 { 7636 std::size_t seed = 0; 7637 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCoherentMemoryFeaturesAMD.sType ); 7638 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCoherentMemoryFeaturesAMD.pNext ); 7639 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCoherentMemoryFeaturesAMD.deviceCoherentMemory ); 7640 return seed; 7641 } 7642 }; 7643 7644 template <> 7645 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceColorWriteEnableFeaturesEXT> 7646 { 7647 std::size_t operator ()std::hash7648 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceColorWriteEnableFeaturesEXT const & physicalDeviceColorWriteEnableFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 7649 { 7650 std::size_t seed = 0; 7651 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceColorWriteEnableFeaturesEXT.sType ); 7652 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceColorWriteEnableFeaturesEXT.pNext ); 7653 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceColorWriteEnableFeaturesEXT.colorWriteEnable ); 7654 return seed; 7655 } 7656 }; 7657 7658 template <> 7659 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceComputeShaderDerivativesFeaturesNV> 7660 { operator ()std::hash7661 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceComputeShaderDerivativesFeaturesNV const & physicalDeviceComputeShaderDerivativesFeaturesNV ) 7662 const VULKAN_HPP_NOEXCEPT 7663 { 7664 std::size_t seed = 0; 7665 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceComputeShaderDerivativesFeaturesNV.sType ); 7666 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceComputeShaderDerivativesFeaturesNV.pNext ); 7667 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceComputeShaderDerivativesFeaturesNV.computeDerivativeGroupQuads ); 7668 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceComputeShaderDerivativesFeaturesNV.computeDerivativeGroupLinear ); 7669 return seed; 7670 } 7671 }; 7672 7673 template <> 7674 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceConditionalRenderingFeaturesEXT> 7675 { operator ()std::hash7676 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceConditionalRenderingFeaturesEXT const & physicalDeviceConditionalRenderingFeaturesEXT ) const 7677 VULKAN_HPP_NOEXCEPT 7678 { 7679 std::size_t seed = 0; 7680 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConditionalRenderingFeaturesEXT.sType ); 7681 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConditionalRenderingFeaturesEXT.pNext ); 7682 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConditionalRenderingFeaturesEXT.conditionalRendering ); 7683 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConditionalRenderingFeaturesEXT.inheritedConditionalRendering ); 7684 return seed; 7685 } 7686 }; 7687 7688 template <> 7689 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceConservativeRasterizationPropertiesEXT> 7690 { operator ()std::hash7691 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceConservativeRasterizationPropertiesEXT const & 7692 physicalDeviceConservativeRasterizationPropertiesEXT ) const VULKAN_HPP_NOEXCEPT 7693 { 7694 std::size_t seed = 0; 7695 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.sType ); 7696 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.pNext ); 7697 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.primitiveOverestimationSize ); 7698 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.maxExtraPrimitiveOverestimationSize ); 7699 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.extraPrimitiveOverestimationSizeGranularity ); 7700 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.primitiveUnderestimation ); 7701 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.conservativePointAndLineRasterization ); 7702 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.degenerateTrianglesRasterized ); 7703 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.degenerateLinesRasterized ); 7704 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.fullyCoveredFragmentShaderInputVariable ); 7705 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.conservativeRasterizationPostDepthCoverage ); 7706 return seed; 7707 } 7708 }; 7709 7710 template <> 7711 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixFeaturesKHR> 7712 { operator ()std::hash7713 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixFeaturesKHR const & physicalDeviceCooperativeMatrixFeaturesKHR ) const 7714 VULKAN_HPP_NOEXCEPT 7715 { 7716 std::size_t seed = 0; 7717 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixFeaturesKHR.sType ); 7718 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixFeaturesKHR.pNext ); 7719 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixFeaturesKHR.cooperativeMatrix ); 7720 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixFeaturesKHR.cooperativeMatrixRobustBufferAccess ); 7721 return seed; 7722 } 7723 }; 7724 7725 template <> 7726 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixFeaturesNV> 7727 { 7728 std::size_t operator ()std::hash7729 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixFeaturesNV const & physicalDeviceCooperativeMatrixFeaturesNV ) const VULKAN_HPP_NOEXCEPT 7730 { 7731 std::size_t seed = 0; 7732 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixFeaturesNV.sType ); 7733 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixFeaturesNV.pNext ); 7734 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixFeaturesNV.cooperativeMatrix ); 7735 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixFeaturesNV.cooperativeMatrixRobustBufferAccess ); 7736 return seed; 7737 } 7738 }; 7739 7740 template <> 7741 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixPropertiesKHR> 7742 { operator ()std::hash7743 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixPropertiesKHR const & physicalDeviceCooperativeMatrixPropertiesKHR ) const 7744 VULKAN_HPP_NOEXCEPT 7745 { 7746 std::size_t seed = 0; 7747 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixPropertiesKHR.sType ); 7748 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixPropertiesKHR.pNext ); 7749 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixPropertiesKHR.cooperativeMatrixSupportedStages ); 7750 return seed; 7751 } 7752 }; 7753 7754 template <> 7755 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixPropertiesNV> 7756 { operator ()std::hash7757 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixPropertiesNV const & physicalDeviceCooperativeMatrixPropertiesNV ) const 7758 VULKAN_HPP_NOEXCEPT 7759 { 7760 std::size_t seed = 0; 7761 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixPropertiesNV.sType ); 7762 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixPropertiesNV.pNext ); 7763 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixPropertiesNV.cooperativeMatrixSupportedStages ); 7764 return seed; 7765 } 7766 }; 7767 7768 template <> 7769 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectFeaturesNV> 7770 { operator ()std::hash7771 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectFeaturesNV const & physicalDeviceCopyMemoryIndirectFeaturesNV ) const 7772 VULKAN_HPP_NOEXCEPT 7773 { 7774 std::size_t seed = 0; 7775 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCopyMemoryIndirectFeaturesNV.sType ); 7776 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCopyMemoryIndirectFeaturesNV.pNext ); 7777 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCopyMemoryIndirectFeaturesNV.indirectCopy ); 7778 return seed; 7779 } 7780 }; 7781 7782 template <> 7783 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectPropertiesNV> 7784 { operator ()std::hash7785 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectPropertiesNV const & physicalDeviceCopyMemoryIndirectPropertiesNV ) const 7786 VULKAN_HPP_NOEXCEPT 7787 { 7788 std::size_t seed = 0; 7789 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCopyMemoryIndirectPropertiesNV.sType ); 7790 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCopyMemoryIndirectPropertiesNV.pNext ); 7791 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCopyMemoryIndirectPropertiesNV.supportedQueues ); 7792 return seed; 7793 } 7794 }; 7795 7796 template <> 7797 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCornerSampledImageFeaturesNV> 7798 { operator ()std::hash7799 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCornerSampledImageFeaturesNV const & physicalDeviceCornerSampledImageFeaturesNV ) const 7800 VULKAN_HPP_NOEXCEPT 7801 { 7802 std::size_t seed = 0; 7803 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCornerSampledImageFeaturesNV.sType ); 7804 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCornerSampledImageFeaturesNV.pNext ); 7805 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCornerSampledImageFeaturesNV.cornerSampledImage ); 7806 return seed; 7807 } 7808 }; 7809 7810 template <> 7811 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCoverageReductionModeFeaturesNV> 7812 { operator ()std::hash7813 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCoverageReductionModeFeaturesNV const & physicalDeviceCoverageReductionModeFeaturesNV ) const 7814 VULKAN_HPP_NOEXCEPT 7815 { 7816 std::size_t seed = 0; 7817 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCoverageReductionModeFeaturesNV.sType ); 7818 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCoverageReductionModeFeaturesNV.pNext ); 7819 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCoverageReductionModeFeaturesNV.coverageReductionMode ); 7820 return seed; 7821 } 7822 }; 7823 7824 template <> 7825 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCubicClampFeaturesQCOM> 7826 { operator ()std::hash7827 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCubicClampFeaturesQCOM const & physicalDeviceCubicClampFeaturesQCOM ) const VULKAN_HPP_NOEXCEPT 7828 { 7829 std::size_t seed = 0; 7830 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCubicClampFeaturesQCOM.sType ); 7831 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCubicClampFeaturesQCOM.pNext ); 7832 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCubicClampFeaturesQCOM.cubicRangeClamp ); 7833 return seed; 7834 } 7835 }; 7836 7837 template <> 7838 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCubicWeightsFeaturesQCOM> 7839 { 7840 std::size_t operator ()std::hash7841 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCubicWeightsFeaturesQCOM const & physicalDeviceCubicWeightsFeaturesQCOM ) const VULKAN_HPP_NOEXCEPT 7842 { 7843 std::size_t seed = 0; 7844 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCubicWeightsFeaturesQCOM.sType ); 7845 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCubicWeightsFeaturesQCOM.pNext ); 7846 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCubicWeightsFeaturesQCOM.selectableCubicWeights ); 7847 return seed; 7848 } 7849 }; 7850 7851 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 7852 template <> 7853 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCudaKernelLaunchFeaturesNV> 7854 { 7855 std::size_t operator ()std::hash7856 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCudaKernelLaunchFeaturesNV const & physicalDeviceCudaKernelLaunchFeaturesNV ) const VULKAN_HPP_NOEXCEPT 7857 { 7858 std::size_t seed = 0; 7859 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCudaKernelLaunchFeaturesNV.sType ); 7860 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCudaKernelLaunchFeaturesNV.pNext ); 7861 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCudaKernelLaunchFeaturesNV.cudaKernelLaunchFeatures ); 7862 return seed; 7863 } 7864 }; 7865 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 7866 7867 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 7868 template <> 7869 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCudaKernelLaunchPropertiesNV> 7870 { operator ()std::hash7871 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCudaKernelLaunchPropertiesNV const & physicalDeviceCudaKernelLaunchPropertiesNV ) const 7872 VULKAN_HPP_NOEXCEPT 7873 { 7874 std::size_t seed = 0; 7875 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCudaKernelLaunchPropertiesNV.sType ); 7876 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCudaKernelLaunchPropertiesNV.pNext ); 7877 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCudaKernelLaunchPropertiesNV.computeCapabilityMinor ); 7878 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCudaKernelLaunchPropertiesNV.computeCapabilityMajor ); 7879 return seed; 7880 } 7881 }; 7882 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 7883 7884 template <> 7885 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomBorderColorFeaturesEXT> 7886 { operator ()std::hash7887 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomBorderColorFeaturesEXT const & physicalDeviceCustomBorderColorFeaturesEXT ) const 7888 VULKAN_HPP_NOEXCEPT 7889 { 7890 std::size_t seed = 0; 7891 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCustomBorderColorFeaturesEXT.sType ); 7892 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCustomBorderColorFeaturesEXT.pNext ); 7893 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCustomBorderColorFeaturesEXT.customBorderColors ); 7894 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCustomBorderColorFeaturesEXT.customBorderColorWithoutFormat ); 7895 return seed; 7896 } 7897 }; 7898 7899 template <> 7900 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomBorderColorPropertiesEXT> 7901 { operator ()std::hash7902 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomBorderColorPropertiesEXT const & physicalDeviceCustomBorderColorPropertiesEXT ) const 7903 VULKAN_HPP_NOEXCEPT 7904 { 7905 std::size_t seed = 0; 7906 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCustomBorderColorPropertiesEXT.sType ); 7907 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCustomBorderColorPropertiesEXT.pNext ); 7908 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCustomBorderColorPropertiesEXT.maxCustomBorderColorSamplers ); 7909 return seed; 7910 } 7911 }; 7912 7913 template <> 7914 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV> 7915 { operator ()std::hash7916 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const & 7917 physicalDeviceDedicatedAllocationImageAliasingFeaturesNV ) const VULKAN_HPP_NOEXCEPT 7918 { 7919 std::size_t seed = 0; 7920 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDedicatedAllocationImageAliasingFeaturesNV.sType ); 7921 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDedicatedAllocationImageAliasingFeaturesNV.pNext ); 7922 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDedicatedAllocationImageAliasingFeaturesNV.dedicatedAllocationImageAliasing ); 7923 return seed; 7924 } 7925 }; 7926 7927 template <> 7928 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthBiasControlFeaturesEXT> 7929 { 7930 std::size_t operator ()std::hash7931 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthBiasControlFeaturesEXT const & physicalDeviceDepthBiasControlFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 7932 { 7933 std::size_t seed = 0; 7934 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthBiasControlFeaturesEXT.sType ); 7935 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthBiasControlFeaturesEXT.pNext ); 7936 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthBiasControlFeaturesEXT.depthBiasControl ); 7937 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthBiasControlFeaturesEXT.leastRepresentableValueForceUnormRepresentation ); 7938 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthBiasControlFeaturesEXT.floatRepresentation ); 7939 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthBiasControlFeaturesEXT.depthBiasExact ); 7940 return seed; 7941 } 7942 }; 7943 7944 template <> 7945 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClampZeroOneFeaturesEXT> 7946 { operator ()std::hash7947 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClampZeroOneFeaturesEXT const & physicalDeviceDepthClampZeroOneFeaturesEXT ) const 7948 VULKAN_HPP_NOEXCEPT 7949 { 7950 std::size_t seed = 0; 7951 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClampZeroOneFeaturesEXT.sType ); 7952 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClampZeroOneFeaturesEXT.pNext ); 7953 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClampZeroOneFeaturesEXT.depthClampZeroOne ); 7954 return seed; 7955 } 7956 }; 7957 7958 template <> 7959 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClipControlFeaturesEXT> 7960 { 7961 std::size_t operator ()std::hash7962 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClipControlFeaturesEXT const & physicalDeviceDepthClipControlFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 7963 { 7964 std::size_t seed = 0; 7965 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClipControlFeaturesEXT.sType ); 7966 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClipControlFeaturesEXT.pNext ); 7967 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClipControlFeaturesEXT.depthClipControl ); 7968 return seed; 7969 } 7970 }; 7971 7972 template <> 7973 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClipEnableFeaturesEXT> 7974 { 7975 std::size_t operator ()std::hash7976 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClipEnableFeaturesEXT const & physicalDeviceDepthClipEnableFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 7977 { 7978 std::size_t seed = 0; 7979 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClipEnableFeaturesEXT.sType ); 7980 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClipEnableFeaturesEXT.pNext ); 7981 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClipEnableFeaturesEXT.depthClipEnable ); 7982 return seed; 7983 } 7984 }; 7985 7986 template <> 7987 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthStencilResolveProperties> 7988 { operator ()std::hash7989 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthStencilResolveProperties const & physicalDeviceDepthStencilResolveProperties ) const 7990 VULKAN_HPP_NOEXCEPT 7991 { 7992 std::size_t seed = 0; 7993 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthStencilResolveProperties.sType ); 7994 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthStencilResolveProperties.pNext ); 7995 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthStencilResolveProperties.supportedDepthResolveModes ); 7996 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthStencilResolveProperties.supportedStencilResolveModes ); 7997 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthStencilResolveProperties.independentResolveNone ); 7998 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthStencilResolveProperties.independentResolve ); 7999 return seed; 8000 } 8001 }; 8002 8003 template <> 8004 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT> 8005 { operator ()std::hash8006 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT const & 8007 physicalDeviceDescriptorBufferDensityMapPropertiesEXT ) const VULKAN_HPP_NOEXCEPT 8008 { 8009 std::size_t seed = 0; 8010 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferDensityMapPropertiesEXT.sType ); 8011 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferDensityMapPropertiesEXT.pNext ); 8012 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferDensityMapPropertiesEXT.combinedImageSamplerDensityMapDescriptorSize ); 8013 return seed; 8014 } 8015 }; 8016 8017 template <> 8018 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferFeaturesEXT> 8019 { 8020 std::size_t operator ()std::hash8021 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferFeaturesEXT const & physicalDeviceDescriptorBufferFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 8022 { 8023 std::size_t seed = 0; 8024 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferFeaturesEXT.sType ); 8025 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferFeaturesEXT.pNext ); 8026 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferFeaturesEXT.descriptorBuffer ); 8027 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferFeaturesEXT.descriptorBufferCaptureReplay ); 8028 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferFeaturesEXT.descriptorBufferImageLayoutIgnored ); 8029 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferFeaturesEXT.descriptorBufferPushDescriptors ); 8030 return seed; 8031 } 8032 }; 8033 8034 template <> 8035 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferPropertiesEXT> 8036 { operator ()std::hash8037 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferPropertiesEXT const & physicalDeviceDescriptorBufferPropertiesEXT ) const 8038 VULKAN_HPP_NOEXCEPT 8039 { 8040 std::size_t seed = 0; 8041 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.sType ); 8042 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.pNext ); 8043 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.combinedImageSamplerDescriptorSingleArray ); 8044 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.bufferlessPushDescriptors ); 8045 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.allowSamplerImageViewPostSubmitCreation ); 8046 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.descriptorBufferOffsetAlignment ); 8047 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.maxDescriptorBufferBindings ); 8048 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.maxResourceDescriptorBufferBindings ); 8049 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.maxSamplerDescriptorBufferBindings ); 8050 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.maxEmbeddedImmutableSamplerBindings ); 8051 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.maxEmbeddedImmutableSamplers ); 8052 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.bufferCaptureReplayDescriptorDataSize ); 8053 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.imageCaptureReplayDescriptorDataSize ); 8054 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.imageViewCaptureReplayDescriptorDataSize ); 8055 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.samplerCaptureReplayDescriptorDataSize ); 8056 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.accelerationStructureCaptureReplayDescriptorDataSize ); 8057 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.samplerDescriptorSize ); 8058 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.combinedImageSamplerDescriptorSize ); 8059 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.sampledImageDescriptorSize ); 8060 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.storageImageDescriptorSize ); 8061 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.uniformTexelBufferDescriptorSize ); 8062 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.robustUniformTexelBufferDescriptorSize ); 8063 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.storageTexelBufferDescriptorSize ); 8064 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.robustStorageTexelBufferDescriptorSize ); 8065 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.uniformBufferDescriptorSize ); 8066 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.robustUniformBufferDescriptorSize ); 8067 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.storageBufferDescriptorSize ); 8068 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.robustStorageBufferDescriptorSize ); 8069 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.inputAttachmentDescriptorSize ); 8070 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.accelerationStructureDescriptorSize ); 8071 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.maxSamplerDescriptorBufferRange ); 8072 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.maxResourceDescriptorBufferRange ); 8073 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.samplerDescriptorBufferAddressSpaceSize ); 8074 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.resourceDescriptorBufferAddressSpaceSize ); 8075 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.descriptorBufferAddressSpaceSize ); 8076 return seed; 8077 } 8078 }; 8079 8080 template <> 8081 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorIndexingFeatures> 8082 { 8083 std::size_t operator ()std::hash8084 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorIndexingFeatures const & physicalDeviceDescriptorIndexingFeatures ) const VULKAN_HPP_NOEXCEPT 8085 { 8086 std::size_t seed = 0; 8087 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.sType ); 8088 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.pNext ); 8089 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderInputAttachmentArrayDynamicIndexing ); 8090 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderUniformTexelBufferArrayDynamicIndexing ); 8091 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderStorageTexelBufferArrayDynamicIndexing ); 8092 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderUniformBufferArrayNonUniformIndexing ); 8093 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderSampledImageArrayNonUniformIndexing ); 8094 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderStorageBufferArrayNonUniformIndexing ); 8095 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderStorageImageArrayNonUniformIndexing ); 8096 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderInputAttachmentArrayNonUniformIndexing ); 8097 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderUniformTexelBufferArrayNonUniformIndexing ); 8098 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderStorageTexelBufferArrayNonUniformIndexing ); 8099 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingUniformBufferUpdateAfterBind ); 8100 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingSampledImageUpdateAfterBind ); 8101 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingStorageImageUpdateAfterBind ); 8102 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingStorageBufferUpdateAfterBind ); 8103 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingUniformTexelBufferUpdateAfterBind ); 8104 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingStorageTexelBufferUpdateAfterBind ); 8105 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingUpdateUnusedWhilePending ); 8106 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingPartiallyBound ); 8107 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingVariableDescriptorCount ); 8108 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.runtimeDescriptorArray ); 8109 return seed; 8110 } 8111 }; 8112 8113 template <> 8114 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorIndexingProperties> 8115 { operator ()std::hash8116 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorIndexingProperties const & physicalDeviceDescriptorIndexingProperties ) const 8117 VULKAN_HPP_NOEXCEPT 8118 { 8119 std::size_t seed = 0; 8120 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.sType ); 8121 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.pNext ); 8122 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxUpdateAfterBindDescriptorsInAllPools ); 8123 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.shaderUniformBufferArrayNonUniformIndexingNative ); 8124 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.shaderSampledImageArrayNonUniformIndexingNative ); 8125 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.shaderStorageBufferArrayNonUniformIndexingNative ); 8126 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.shaderStorageImageArrayNonUniformIndexingNative ); 8127 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.shaderInputAttachmentArrayNonUniformIndexingNative ); 8128 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.robustBufferAccessUpdateAfterBind ); 8129 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.quadDivergentImplicitLod ); 8130 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindSamplers ); 8131 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindUniformBuffers ); 8132 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindStorageBuffers ); 8133 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindSampledImages ); 8134 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindStorageImages ); 8135 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindInputAttachments ); 8136 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxPerStageUpdateAfterBindResources ); 8137 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindSamplers ); 8138 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindUniformBuffers ); 8139 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic ); 8140 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindStorageBuffers ); 8141 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic ); 8142 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindSampledImages ); 8143 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindStorageImages ); 8144 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindInputAttachments ); 8145 return seed; 8146 } 8147 }; 8148 8149 template <> 8150 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorPoolOverallocationFeaturesNV> 8151 { operator ()std::hash8152 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorPoolOverallocationFeaturesNV const & 8153 physicalDeviceDescriptorPoolOverallocationFeaturesNV ) const VULKAN_HPP_NOEXCEPT 8154 { 8155 std::size_t seed = 0; 8156 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorPoolOverallocationFeaturesNV.sType ); 8157 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorPoolOverallocationFeaturesNV.pNext ); 8158 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorPoolOverallocationFeaturesNV.descriptorPoolOverallocation ); 8159 return seed; 8160 } 8161 }; 8162 8163 template <> 8164 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE> 8165 { 8166 std::size_t operator ()std::hash8167 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE const & physicalDeviceDescriptorSetHostMappingFeaturesVALVE ) const 8168 VULKAN_HPP_NOEXCEPT 8169 { 8170 std::size_t seed = 0; 8171 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorSetHostMappingFeaturesVALVE.sType ); 8172 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorSetHostMappingFeaturesVALVE.pNext ); 8173 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorSetHostMappingFeaturesVALVE.descriptorSetHostMapping ); 8174 return seed; 8175 } 8176 }; 8177 8178 template <> 8179 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV> 8180 { operator ()std::hash8181 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV const & 8182 physicalDeviceDeviceGeneratedCommandsComputeFeaturesNV ) const VULKAN_HPP_NOEXCEPT 8183 { 8184 std::size_t seed = 0; 8185 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsComputeFeaturesNV.sType ); 8186 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsComputeFeaturesNV.pNext ); 8187 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsComputeFeaturesNV.deviceGeneratedCompute ); 8188 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsComputeFeaturesNV.deviceGeneratedComputePipelines ); 8189 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsComputeFeaturesNV.deviceGeneratedComputeCaptureReplay ); 8190 return seed; 8191 } 8192 }; 8193 8194 template <> 8195 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsFeaturesNV> 8196 { operator ()std::hash8197 std::size_t operator()( 8198 VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsFeaturesNV const & physicalDeviceDeviceGeneratedCommandsFeaturesNV ) const VULKAN_HPP_NOEXCEPT 8199 { 8200 std::size_t seed = 0; 8201 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsFeaturesNV.sType ); 8202 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsFeaturesNV.pNext ); 8203 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsFeaturesNV.deviceGeneratedCommands ); 8204 return seed; 8205 } 8206 }; 8207 8208 template <> 8209 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsPropertiesNV> 8210 { operator ()std::hash8211 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsPropertiesNV const & physicalDeviceDeviceGeneratedCommandsPropertiesNV ) 8212 const VULKAN_HPP_NOEXCEPT 8213 { 8214 std::size_t seed = 0; 8215 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.sType ); 8216 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.pNext ); 8217 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxGraphicsShaderGroupCount ); 8218 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxIndirectSequenceCount ); 8219 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxIndirectCommandsTokenCount ); 8220 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxIndirectCommandsStreamCount ); 8221 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxIndirectCommandsTokenOffset ); 8222 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxIndirectCommandsStreamStride ); 8223 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.minSequencesCountBufferOffsetAlignment ); 8224 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.minSequencesIndexBufferOffsetAlignment ); 8225 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.minIndirectCommandsBufferOffsetAlignment ); 8226 return seed; 8227 } 8228 }; 8229 8230 template <> 8231 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceMemoryReportFeaturesEXT> 8232 { operator ()std::hash8233 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceMemoryReportFeaturesEXT const & physicalDeviceDeviceMemoryReportFeaturesEXT ) const 8234 VULKAN_HPP_NOEXCEPT 8235 { 8236 std::size_t seed = 0; 8237 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceMemoryReportFeaturesEXT.sType ); 8238 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceMemoryReportFeaturesEXT.pNext ); 8239 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceMemoryReportFeaturesEXT.deviceMemoryReport ); 8240 return seed; 8241 } 8242 }; 8243 8244 template <> 8245 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDiagnosticsConfigFeaturesNV> 8246 { 8247 std::size_t operator ()std::hash8248 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDiagnosticsConfigFeaturesNV const & physicalDeviceDiagnosticsConfigFeaturesNV ) const VULKAN_HPP_NOEXCEPT 8249 { 8250 std::size_t seed = 0; 8251 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDiagnosticsConfigFeaturesNV.sType ); 8252 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDiagnosticsConfigFeaturesNV.pNext ); 8253 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDiagnosticsConfigFeaturesNV.diagnosticsConfig ); 8254 return seed; 8255 } 8256 }; 8257 8258 template <> 8259 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDiscardRectanglePropertiesEXT> 8260 { operator ()std::hash8261 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDiscardRectanglePropertiesEXT const & physicalDeviceDiscardRectanglePropertiesEXT ) const 8262 VULKAN_HPP_NOEXCEPT 8263 { 8264 std::size_t seed = 0; 8265 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDiscardRectanglePropertiesEXT.sType ); 8266 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDiscardRectanglePropertiesEXT.pNext ); 8267 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDiscardRectanglePropertiesEXT.maxDiscardRectangles ); 8268 return seed; 8269 } 8270 }; 8271 8272 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 8273 template <> 8274 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDisplacementMicromapFeaturesNV> 8275 { operator ()std::hash8276 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDisplacementMicromapFeaturesNV const & physicalDeviceDisplacementMicromapFeaturesNV ) const 8277 VULKAN_HPP_NOEXCEPT 8278 { 8279 std::size_t seed = 0; 8280 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDisplacementMicromapFeaturesNV.sType ); 8281 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDisplacementMicromapFeaturesNV.pNext ); 8282 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDisplacementMicromapFeaturesNV.displacementMicromap ); 8283 return seed; 8284 } 8285 }; 8286 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 8287 8288 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 8289 template <> 8290 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDisplacementMicromapPropertiesNV> 8291 { operator ()std::hash8292 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDisplacementMicromapPropertiesNV const & physicalDeviceDisplacementMicromapPropertiesNV ) const 8293 VULKAN_HPP_NOEXCEPT 8294 { 8295 std::size_t seed = 0; 8296 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDisplacementMicromapPropertiesNV.sType ); 8297 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDisplacementMicromapPropertiesNV.pNext ); 8298 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDisplacementMicromapPropertiesNV.maxDisplacementMicromapSubdivisionLevel ); 8299 return seed; 8300 } 8301 }; 8302 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 8303 8304 template <> 8305 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDriverProperties> 8306 { operator ()std::hash8307 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDriverProperties const & physicalDeviceDriverProperties ) const VULKAN_HPP_NOEXCEPT 8308 { 8309 std::size_t seed = 0; 8310 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDriverProperties.sType ); 8311 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDriverProperties.pNext ); 8312 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDriverProperties.driverID ); 8313 for ( size_t i = 0; i < VK_MAX_DRIVER_NAME_SIZE; ++i ) 8314 { 8315 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDriverProperties.driverName[i] ); 8316 } 8317 for ( size_t i = 0; i < VK_MAX_DRIVER_INFO_SIZE; ++i ) 8318 { 8319 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDriverProperties.driverInfo[i] ); 8320 } 8321 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDriverProperties.conformanceVersion ); 8322 return seed; 8323 } 8324 }; 8325 8326 template <> 8327 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDrmPropertiesEXT> 8328 { operator ()std::hash8329 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDrmPropertiesEXT const & physicalDeviceDrmPropertiesEXT ) const VULKAN_HPP_NOEXCEPT 8330 { 8331 std::size_t seed = 0; 8332 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDrmPropertiesEXT.sType ); 8333 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDrmPropertiesEXT.pNext ); 8334 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDrmPropertiesEXT.hasPrimary ); 8335 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDrmPropertiesEXT.hasRender ); 8336 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDrmPropertiesEXT.primaryMajor ); 8337 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDrmPropertiesEXT.primaryMinor ); 8338 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDrmPropertiesEXT.renderMajor ); 8339 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDrmPropertiesEXT.renderMinor ); 8340 return seed; 8341 } 8342 }; 8343 8344 template <> 8345 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingFeatures> 8346 { 8347 std::size_t operator ()std::hash8348 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingFeatures const & physicalDeviceDynamicRenderingFeatures ) const VULKAN_HPP_NOEXCEPT 8349 { 8350 std::size_t seed = 0; 8351 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDynamicRenderingFeatures.sType ); 8352 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDynamicRenderingFeatures.pNext ); 8353 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDynamicRenderingFeatures.dynamicRendering ); 8354 return seed; 8355 } 8356 }; 8357 8358 template <> 8359 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT> 8360 { operator ()std::hash8361 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT const & 8362 physicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 8363 { 8364 std::size_t seed = 0; 8365 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT.sType ); 8366 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT.pNext ); 8367 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT.dynamicRenderingUnusedAttachments ); 8368 return seed; 8369 } 8370 }; 8371 8372 template <> 8373 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExclusiveScissorFeaturesNV> 8374 { 8375 std::size_t operator ()std::hash8376 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExclusiveScissorFeaturesNV const & physicalDeviceExclusiveScissorFeaturesNV ) const VULKAN_HPP_NOEXCEPT 8377 { 8378 std::size_t seed = 0; 8379 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExclusiveScissorFeaturesNV.sType ); 8380 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExclusiveScissorFeaturesNV.pNext ); 8381 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExclusiveScissorFeaturesNV.exclusiveScissor ); 8382 return seed; 8383 } 8384 }; 8385 8386 template <> 8387 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState2FeaturesEXT> 8388 { operator ()std::hash8389 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState2FeaturesEXT const & physicalDeviceExtendedDynamicState2FeaturesEXT ) const 8390 VULKAN_HPP_NOEXCEPT 8391 { 8392 std::size_t seed = 0; 8393 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState2FeaturesEXT.sType ); 8394 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState2FeaturesEXT.pNext ); 8395 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState2FeaturesEXT.extendedDynamicState2 ); 8396 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState2FeaturesEXT.extendedDynamicState2LogicOp ); 8397 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState2FeaturesEXT.extendedDynamicState2PatchControlPoints ); 8398 return seed; 8399 } 8400 }; 8401 8402 template <> 8403 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState3FeaturesEXT> 8404 { operator ()std::hash8405 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState3FeaturesEXT const & physicalDeviceExtendedDynamicState3FeaturesEXT ) const 8406 VULKAN_HPP_NOEXCEPT 8407 { 8408 std::size_t seed = 0; 8409 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.sType ); 8410 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.pNext ); 8411 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3TessellationDomainOrigin ); 8412 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3DepthClampEnable ); 8413 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3PolygonMode ); 8414 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3RasterizationSamples ); 8415 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3SampleMask ); 8416 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3AlphaToCoverageEnable ); 8417 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3AlphaToOneEnable ); 8418 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3LogicOpEnable ); 8419 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ColorBlendEnable ); 8420 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ColorBlendEquation ); 8421 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ColorWriteMask ); 8422 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3RasterizationStream ); 8423 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ConservativeRasterizationMode ); 8424 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ExtraPrimitiveOverestimationSize ); 8425 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3DepthClipEnable ); 8426 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3SampleLocationsEnable ); 8427 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ColorBlendAdvanced ); 8428 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ProvokingVertexMode ); 8429 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3LineRasterizationMode ); 8430 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3LineStippleEnable ); 8431 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3DepthClipNegativeOneToOne ); 8432 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ViewportWScalingEnable ); 8433 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ViewportSwizzle ); 8434 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3CoverageToColorEnable ); 8435 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3CoverageToColorLocation ); 8436 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3CoverageModulationMode ); 8437 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3CoverageModulationTableEnable ); 8438 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3CoverageModulationTable ); 8439 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3CoverageReductionMode ); 8440 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3RepresentativeFragmentTestEnable ); 8441 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ShadingRateImageEnable ); 8442 return seed; 8443 } 8444 }; 8445 8446 template <> 8447 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState3PropertiesEXT> 8448 { operator ()std::hash8449 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState3PropertiesEXT const & physicalDeviceExtendedDynamicState3PropertiesEXT ) 8450 const VULKAN_HPP_NOEXCEPT 8451 { 8452 std::size_t seed = 0; 8453 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3PropertiesEXT.sType ); 8454 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3PropertiesEXT.pNext ); 8455 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3PropertiesEXT.dynamicPrimitiveTopologyUnrestricted ); 8456 return seed; 8457 } 8458 }; 8459 8460 template <> 8461 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicStateFeaturesEXT> 8462 { operator ()std::hash8463 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicStateFeaturesEXT const & physicalDeviceExtendedDynamicStateFeaturesEXT ) const 8464 VULKAN_HPP_NOEXCEPT 8465 { 8466 std::size_t seed = 0; 8467 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicStateFeaturesEXT.sType ); 8468 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicStateFeaturesEXT.pNext ); 8469 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicStateFeaturesEXT.extendedDynamicState ); 8470 return seed; 8471 } 8472 }; 8473 8474 template <> 8475 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV> 8476 { 8477 std::size_t operator ()std::hash8478 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV const & physicalDeviceExtendedSparseAddressSpaceFeaturesNV ) const 8479 VULKAN_HPP_NOEXCEPT 8480 { 8481 std::size_t seed = 0; 8482 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedSparseAddressSpaceFeaturesNV.sType ); 8483 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedSparseAddressSpaceFeaturesNV.pNext ); 8484 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedSparseAddressSpaceFeaturesNV.extendedSparseAddressSpace ); 8485 return seed; 8486 } 8487 }; 8488 8489 template <> 8490 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedSparseAddressSpacePropertiesNV> 8491 { operator ()std::hash8492 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedSparseAddressSpacePropertiesNV const & 8493 physicalDeviceExtendedSparseAddressSpacePropertiesNV ) const VULKAN_HPP_NOEXCEPT 8494 { 8495 std::size_t seed = 0; 8496 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedSparseAddressSpacePropertiesNV.sType ); 8497 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedSparseAddressSpacePropertiesNV.pNext ); 8498 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedSparseAddressSpacePropertiesNV.extendedSparseAddressSpaceSize ); 8499 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedSparseAddressSpacePropertiesNV.extendedSparseImageUsageFlags ); 8500 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedSparseAddressSpacePropertiesNV.extendedSparseBufferUsageFlags ); 8501 return seed; 8502 } 8503 }; 8504 8505 template <> 8506 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo> 8507 { operator ()std::hash8508 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo const & physicalDeviceExternalBufferInfo ) const VULKAN_HPP_NOEXCEPT 8509 { 8510 std::size_t seed = 0; 8511 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalBufferInfo.sType ); 8512 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalBufferInfo.pNext ); 8513 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalBufferInfo.flags ); 8514 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalBufferInfo.usage ); 8515 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalBufferInfo.handleType ); 8516 return seed; 8517 } 8518 }; 8519 8520 template <> 8521 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo> 8522 { operator ()std::hash8523 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo const & physicalDeviceExternalFenceInfo ) const VULKAN_HPP_NOEXCEPT 8524 { 8525 std::size_t seed = 0; 8526 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFenceInfo.sType ); 8527 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFenceInfo.pNext ); 8528 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFenceInfo.handleType ); 8529 return seed; 8530 } 8531 }; 8532 8533 # if defined( VK_USE_PLATFORM_ANDROID_KHR ) 8534 template <> 8535 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFormatResolveFeaturesANDROID> 8536 { 8537 std::size_t operator ()std::hash8538 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFormatResolveFeaturesANDROID const & physicalDeviceExternalFormatResolveFeaturesANDROID ) const 8539 VULKAN_HPP_NOEXCEPT 8540 { 8541 std::size_t seed = 0; 8542 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFormatResolveFeaturesANDROID.sType ); 8543 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFormatResolveFeaturesANDROID.pNext ); 8544 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFormatResolveFeaturesANDROID.externalFormatResolve ); 8545 return seed; 8546 } 8547 }; 8548 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ 8549 8550 # if defined( VK_USE_PLATFORM_ANDROID_KHR ) 8551 template <> 8552 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFormatResolvePropertiesANDROID> 8553 { operator ()std::hash8554 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFormatResolvePropertiesANDROID const & 8555 physicalDeviceExternalFormatResolvePropertiesANDROID ) const VULKAN_HPP_NOEXCEPT 8556 { 8557 std::size_t seed = 0; 8558 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFormatResolvePropertiesANDROID.sType ); 8559 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFormatResolvePropertiesANDROID.pNext ); 8560 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFormatResolvePropertiesANDROID.nullColorAttachmentWithExternalFormatResolve ); 8561 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFormatResolvePropertiesANDROID.externalFormatResolveChromaOffsetX ); 8562 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFormatResolvePropertiesANDROID.externalFormatResolveChromaOffsetY ); 8563 return seed; 8564 } 8565 }; 8566 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ 8567 8568 template <> 8569 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalImageFormatInfo> 8570 { 8571 std::size_t operator ()std::hash8572 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalImageFormatInfo const & physicalDeviceExternalImageFormatInfo ) const VULKAN_HPP_NOEXCEPT 8573 { 8574 std::size_t seed = 0; 8575 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalImageFormatInfo.sType ); 8576 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalImageFormatInfo.pNext ); 8577 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalImageFormatInfo.handleType ); 8578 return seed; 8579 } 8580 }; 8581 8582 template <> 8583 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryHostPropertiesEXT> 8584 { operator ()std::hash8585 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryHostPropertiesEXT const & physicalDeviceExternalMemoryHostPropertiesEXT ) const 8586 VULKAN_HPP_NOEXCEPT 8587 { 8588 std::size_t seed = 0; 8589 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalMemoryHostPropertiesEXT.sType ); 8590 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalMemoryHostPropertiesEXT.pNext ); 8591 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalMemoryHostPropertiesEXT.minImportedHostPointerAlignment ); 8592 return seed; 8593 } 8594 }; 8595 8596 template <> 8597 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryRDMAFeaturesNV> 8598 { operator ()std::hash8599 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryRDMAFeaturesNV const & physicalDeviceExternalMemoryRDMAFeaturesNV ) const 8600 VULKAN_HPP_NOEXCEPT 8601 { 8602 std::size_t seed = 0; 8603 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalMemoryRDMAFeaturesNV.sType ); 8604 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalMemoryRDMAFeaturesNV.pNext ); 8605 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalMemoryRDMAFeaturesNV.externalMemoryRDMA ); 8606 return seed; 8607 } 8608 }; 8609 8610 # if defined( VK_USE_PLATFORM_SCREEN_QNX ) 8611 template <> 8612 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX> 8613 { 8614 std::size_t operator ()std::hash8615 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX const & physicalDeviceExternalMemoryScreenBufferFeaturesQNX ) const 8616 VULKAN_HPP_NOEXCEPT 8617 { 8618 std::size_t seed = 0; 8619 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalMemoryScreenBufferFeaturesQNX.sType ); 8620 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalMemoryScreenBufferFeaturesQNX.pNext ); 8621 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalMemoryScreenBufferFeaturesQNX.screenBufferImport ); 8622 return seed; 8623 } 8624 }; 8625 # endif /*VK_USE_PLATFORM_SCREEN_QNX*/ 8626 8627 template <> 8628 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo> 8629 { operator ()std::hash8630 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo const & physicalDeviceExternalSemaphoreInfo ) const VULKAN_HPP_NOEXCEPT 8631 { 8632 std::size_t seed = 0; 8633 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalSemaphoreInfo.sType ); 8634 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalSemaphoreInfo.pNext ); 8635 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalSemaphoreInfo.handleType ); 8636 return seed; 8637 } 8638 }; 8639 8640 template <> 8641 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFaultFeaturesEXT> 8642 { operator ()std::hash8643 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFaultFeaturesEXT const & physicalDeviceFaultFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 8644 { 8645 std::size_t seed = 0; 8646 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFaultFeaturesEXT.sType ); 8647 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFaultFeaturesEXT.pNext ); 8648 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFaultFeaturesEXT.deviceFault ); 8649 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFaultFeaturesEXT.deviceFaultVendorBinary ); 8650 return seed; 8651 } 8652 }; 8653 8654 template <> 8655 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2> 8656 { operator ()std::hash8657 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 const & physicalDeviceFeatures2 ) const VULKAN_HPP_NOEXCEPT 8658 { 8659 std::size_t seed = 0; 8660 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures2.sType ); 8661 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures2.pNext ); 8662 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures2.features ); 8663 return seed; 8664 } 8665 }; 8666 8667 template <> 8668 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFloatControlsProperties> 8669 { 8670 std::size_t operator ()std::hash8671 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFloatControlsProperties const & physicalDeviceFloatControlsProperties ) const VULKAN_HPP_NOEXCEPT 8672 { 8673 std::size_t seed = 0; 8674 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.sType ); 8675 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.pNext ); 8676 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.denormBehaviorIndependence ); 8677 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.roundingModeIndependence ); 8678 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderSignedZeroInfNanPreserveFloat16 ); 8679 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderSignedZeroInfNanPreserveFloat32 ); 8680 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderSignedZeroInfNanPreserveFloat64 ); 8681 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderDenormPreserveFloat16 ); 8682 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderDenormPreserveFloat32 ); 8683 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderDenormPreserveFloat64 ); 8684 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderDenormFlushToZeroFloat16 ); 8685 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderDenormFlushToZeroFloat32 ); 8686 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderDenormFlushToZeroFloat64 ); 8687 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTEFloat16 ); 8688 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTEFloat32 ); 8689 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTEFloat64 ); 8690 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTZFloat16 ); 8691 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTZFloat32 ); 8692 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTZFloat64 ); 8693 return seed; 8694 } 8695 }; 8696 8697 template <> 8698 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMap2FeaturesEXT> 8699 { operator ()std::hash8700 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMap2FeaturesEXT const & physicalDeviceFragmentDensityMap2FeaturesEXT ) const 8701 VULKAN_HPP_NOEXCEPT 8702 { 8703 std::size_t seed = 0; 8704 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMap2FeaturesEXT.sType ); 8705 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMap2FeaturesEXT.pNext ); 8706 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMap2FeaturesEXT.fragmentDensityMapDeferred ); 8707 return seed; 8708 } 8709 }; 8710 8711 template <> 8712 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMap2PropertiesEXT> 8713 { operator ()std::hash8714 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMap2PropertiesEXT const & physicalDeviceFragmentDensityMap2PropertiesEXT ) const 8715 VULKAN_HPP_NOEXCEPT 8716 { 8717 std::size_t seed = 0; 8718 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMap2PropertiesEXT.sType ); 8719 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMap2PropertiesEXT.pNext ); 8720 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMap2PropertiesEXT.subsampledLoads ); 8721 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMap2PropertiesEXT.subsampledCoarseReconstructionEarlyAccess ); 8722 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMap2PropertiesEXT.maxSubsampledArrayLayers ); 8723 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMap2PropertiesEXT.maxDescriptorSetSubsampledSamplers ); 8724 return seed; 8725 } 8726 }; 8727 8728 template <> 8729 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapFeaturesEXT> 8730 { operator ()std::hash8731 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapFeaturesEXT const & physicalDeviceFragmentDensityMapFeaturesEXT ) const 8732 VULKAN_HPP_NOEXCEPT 8733 { 8734 std::size_t seed = 0; 8735 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapFeaturesEXT.sType ); 8736 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapFeaturesEXT.pNext ); 8737 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapFeaturesEXT.fragmentDensityMap ); 8738 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapFeaturesEXT.fragmentDensityMapDynamic ); 8739 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapFeaturesEXT.fragmentDensityMapNonSubsampledImages ); 8740 return seed; 8741 } 8742 }; 8743 8744 template <> 8745 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM> 8746 { 8747 std::size_t operator ()std::hash8748 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM const & physicalDeviceFragmentDensityMapOffsetFeaturesQCOM ) const 8749 VULKAN_HPP_NOEXCEPT 8750 { 8751 std::size_t seed = 0; 8752 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetFeaturesQCOM.sType ); 8753 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetFeaturesQCOM.pNext ); 8754 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetFeaturesQCOM.fragmentDensityMapOffset ); 8755 return seed; 8756 } 8757 }; 8758 8759 template <> 8760 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM> 8761 { operator ()std::hash8762 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM const & 8763 physicalDeviceFragmentDensityMapOffsetPropertiesQCOM ) const VULKAN_HPP_NOEXCEPT 8764 { 8765 std::size_t seed = 0; 8766 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetPropertiesQCOM.sType ); 8767 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetPropertiesQCOM.pNext ); 8768 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetPropertiesQCOM.fragmentDensityOffsetGranularity ); 8769 return seed; 8770 } 8771 }; 8772 8773 template <> 8774 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapPropertiesEXT> 8775 { operator ()std::hash8776 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapPropertiesEXT const & physicalDeviceFragmentDensityMapPropertiesEXT ) const 8777 VULKAN_HPP_NOEXCEPT 8778 { 8779 std::size_t seed = 0; 8780 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapPropertiesEXT.sType ); 8781 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapPropertiesEXT.pNext ); 8782 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapPropertiesEXT.minFragmentDensityTexelSize ); 8783 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapPropertiesEXT.maxFragmentDensityTexelSize ); 8784 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapPropertiesEXT.fragmentDensityInvocations ); 8785 return seed; 8786 } 8787 }; 8788 8789 template <> 8790 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderBarycentricFeaturesKHR> 8791 { 8792 std::size_t operator ()std::hash8793 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderBarycentricFeaturesKHR const & physicalDeviceFragmentShaderBarycentricFeaturesKHR ) const 8794 VULKAN_HPP_NOEXCEPT 8795 { 8796 std::size_t seed = 0; 8797 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderBarycentricFeaturesKHR.sType ); 8798 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderBarycentricFeaturesKHR.pNext ); 8799 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderBarycentricFeaturesKHR.fragmentShaderBarycentric ); 8800 return seed; 8801 } 8802 }; 8803 8804 template <> 8805 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderBarycentricPropertiesKHR> 8806 { operator ()std::hash8807 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderBarycentricPropertiesKHR const & 8808 physicalDeviceFragmentShaderBarycentricPropertiesKHR ) const VULKAN_HPP_NOEXCEPT 8809 { 8810 std::size_t seed = 0; 8811 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderBarycentricPropertiesKHR.sType ); 8812 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderBarycentricPropertiesKHR.pNext ); 8813 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderBarycentricPropertiesKHR.triStripVertexOrderIndependentOfProvokingVertex ); 8814 return seed; 8815 } 8816 }; 8817 8818 template <> 8819 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderInterlockFeaturesEXT> 8820 { operator ()std::hash8821 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderInterlockFeaturesEXT const & physicalDeviceFragmentShaderInterlockFeaturesEXT ) 8822 const VULKAN_HPP_NOEXCEPT 8823 { 8824 std::size_t seed = 0; 8825 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderInterlockFeaturesEXT.sType ); 8826 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderInterlockFeaturesEXT.pNext ); 8827 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderInterlockFeaturesEXT.fragmentShaderSampleInterlock ); 8828 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderInterlockFeaturesEXT.fragmentShaderPixelInterlock ); 8829 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderInterlockFeaturesEXT.fragmentShaderShadingRateInterlock ); 8830 return seed; 8831 } 8832 }; 8833 8834 template <> 8835 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateEnumsFeaturesNV> 8836 { operator ()std::hash8837 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateEnumsFeaturesNV const & physicalDeviceFragmentShadingRateEnumsFeaturesNV ) 8838 const VULKAN_HPP_NOEXCEPT 8839 { 8840 std::size_t seed = 0; 8841 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateEnumsFeaturesNV.sType ); 8842 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateEnumsFeaturesNV.pNext ); 8843 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateEnumsFeaturesNV.fragmentShadingRateEnums ); 8844 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateEnumsFeaturesNV.supersampleFragmentShadingRates ); 8845 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateEnumsFeaturesNV.noInvocationFragmentShadingRates ); 8846 return seed; 8847 } 8848 }; 8849 8850 template <> 8851 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateEnumsPropertiesNV> 8852 { 8853 std::size_t operator ()std::hash8854 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateEnumsPropertiesNV const & physicalDeviceFragmentShadingRateEnumsPropertiesNV ) const 8855 VULKAN_HPP_NOEXCEPT 8856 { 8857 std::size_t seed = 0; 8858 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateEnumsPropertiesNV.sType ); 8859 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateEnumsPropertiesNV.pNext ); 8860 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateEnumsPropertiesNV.maxFragmentShadingRateInvocationCount ); 8861 return seed; 8862 } 8863 }; 8864 8865 template <> 8866 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateFeaturesKHR> 8867 { operator ()std::hash8868 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateFeaturesKHR const & physicalDeviceFragmentShadingRateFeaturesKHR ) const 8869 VULKAN_HPP_NOEXCEPT 8870 { 8871 std::size_t seed = 0; 8872 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateFeaturesKHR.sType ); 8873 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateFeaturesKHR.pNext ); 8874 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateFeaturesKHR.pipelineFragmentShadingRate ); 8875 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateFeaturesKHR.primitiveFragmentShadingRate ); 8876 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateFeaturesKHR.attachmentFragmentShadingRate ); 8877 return seed; 8878 } 8879 }; 8880 8881 template <> 8882 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR> 8883 { operator ()std::hash8884 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR const & physicalDeviceFragmentShadingRateKHR ) const VULKAN_HPP_NOEXCEPT 8885 { 8886 std::size_t seed = 0; 8887 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateKHR.sType ); 8888 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateKHR.pNext ); 8889 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateKHR.sampleCounts ); 8890 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateKHR.fragmentSize ); 8891 return seed; 8892 } 8893 }; 8894 8895 template <> 8896 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRatePropertiesKHR> 8897 { operator ()std::hash8898 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRatePropertiesKHR const & physicalDeviceFragmentShadingRatePropertiesKHR ) const 8899 VULKAN_HPP_NOEXCEPT 8900 { 8901 std::size_t seed = 0; 8902 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.sType ); 8903 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.pNext ); 8904 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.minFragmentShadingRateAttachmentTexelSize ); 8905 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentShadingRateAttachmentTexelSize ); 8906 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentShadingRateAttachmentTexelSizeAspectRatio ); 8907 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.primitiveFragmentShadingRateWithMultipleViewports ); 8908 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.layeredShadingRateAttachments ); 8909 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateNonTrivialCombinerOps ); 8910 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentSize ); 8911 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentSizeAspectRatio ); 8912 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentShadingRateCoverageSamples ); 8913 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentShadingRateRasterizationSamples ); 8914 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithShaderDepthStencilWrites ); 8915 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithSampleMask ); 8916 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithShaderSampleMask ); 8917 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithConservativeRasterization ); 8918 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithFragmentShaderInterlock ); 8919 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithCustomSampleLocations ); 8920 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateStrictMultiplyCombiner ); 8921 return seed; 8922 } 8923 }; 8924 8925 template <> 8926 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFrameBoundaryFeaturesEXT> 8927 { 8928 std::size_t operator ()std::hash8929 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFrameBoundaryFeaturesEXT const & physicalDeviceFrameBoundaryFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 8930 { 8931 std::size_t seed = 0; 8932 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFrameBoundaryFeaturesEXT.sType ); 8933 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFrameBoundaryFeaturesEXT.pNext ); 8934 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFrameBoundaryFeaturesEXT.frameBoundary ); 8935 return seed; 8936 } 8937 }; 8938 8939 template <> 8940 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceGlobalPriorityQueryFeaturesKHR> 8941 { operator ()std::hash8942 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceGlobalPriorityQueryFeaturesKHR const & physicalDeviceGlobalPriorityQueryFeaturesKHR ) const 8943 VULKAN_HPP_NOEXCEPT 8944 { 8945 std::size_t seed = 0; 8946 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGlobalPriorityQueryFeaturesKHR.sType ); 8947 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGlobalPriorityQueryFeaturesKHR.pNext ); 8948 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGlobalPriorityQueryFeaturesKHR.globalPriorityQuery ); 8949 return seed; 8950 } 8951 }; 8952 8953 template <> 8954 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT> 8955 { operator ()std::hash8956 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT const & physicalDeviceGraphicsPipelineLibraryFeaturesEXT ) 8957 const VULKAN_HPP_NOEXCEPT 8958 { 8959 std::size_t seed = 0; 8960 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGraphicsPipelineLibraryFeaturesEXT.sType ); 8961 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGraphicsPipelineLibraryFeaturesEXT.pNext ); 8962 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGraphicsPipelineLibraryFeaturesEXT.graphicsPipelineLibrary ); 8963 return seed; 8964 } 8965 }; 8966 8967 template <> 8968 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT> 8969 { 8970 std::size_t operator ()std::hash8971 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT const & physicalDeviceGraphicsPipelineLibraryPropertiesEXT ) const 8972 VULKAN_HPP_NOEXCEPT 8973 { 8974 std::size_t seed = 0; 8975 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGraphicsPipelineLibraryPropertiesEXT.sType ); 8976 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGraphicsPipelineLibraryPropertiesEXT.pNext ); 8977 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGraphicsPipelineLibraryPropertiesEXT.graphicsPipelineLibraryFastLinking ); 8978 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGraphicsPipelineLibraryPropertiesEXT.graphicsPipelineLibraryIndependentInterpolationDecoration ); 8979 return seed; 8980 } 8981 }; 8982 8983 template <> 8984 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties> 8985 { operator ()std::hash8986 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties const & physicalDeviceGroupProperties ) const VULKAN_HPP_NOEXCEPT 8987 { 8988 std::size_t seed = 0; 8989 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGroupProperties.sType ); 8990 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGroupProperties.pNext ); 8991 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGroupProperties.physicalDeviceCount ); 8992 for ( size_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; ++i ) 8993 { 8994 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGroupProperties.physicalDevices[i] ); 8995 } 8996 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGroupProperties.subsetAllocation ); 8997 return seed; 8998 } 8999 }; 9000 9001 template <> 9002 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceHostImageCopyFeaturesEXT> 9003 { 9004 std::size_t operator ()std::hash9005 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceHostImageCopyFeaturesEXT const & physicalDeviceHostImageCopyFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 9006 { 9007 std::size_t seed = 0; 9008 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyFeaturesEXT.sType ); 9009 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyFeaturesEXT.pNext ); 9010 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyFeaturesEXT.hostImageCopy ); 9011 return seed; 9012 } 9013 }; 9014 9015 template <> 9016 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceHostImageCopyPropertiesEXT> 9017 { 9018 std::size_t operator ()std::hash9019 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceHostImageCopyPropertiesEXT const & physicalDeviceHostImageCopyPropertiesEXT ) const VULKAN_HPP_NOEXCEPT 9020 { 9021 std::size_t seed = 0; 9022 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyPropertiesEXT.sType ); 9023 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyPropertiesEXT.pNext ); 9024 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyPropertiesEXT.copySrcLayoutCount ); 9025 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyPropertiesEXT.pCopySrcLayouts ); 9026 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyPropertiesEXT.copyDstLayoutCount ); 9027 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyPropertiesEXT.pCopyDstLayouts ); 9028 for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) 9029 { 9030 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyPropertiesEXT.optimalTilingLayoutUUID[i] ); 9031 } 9032 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyPropertiesEXT.identicalMemoryTypeRequirements ); 9033 return seed; 9034 } 9035 }; 9036 9037 template <> 9038 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceHostQueryResetFeatures> 9039 { operator ()std::hash9040 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceHostQueryResetFeatures const & physicalDeviceHostQueryResetFeatures ) const VULKAN_HPP_NOEXCEPT 9041 { 9042 std::size_t seed = 0; 9043 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostQueryResetFeatures.sType ); 9044 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostQueryResetFeatures.pNext ); 9045 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostQueryResetFeatures.hostQueryReset ); 9046 return seed; 9047 } 9048 }; 9049 9050 template <> 9051 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceIDProperties> 9052 { operator ()std::hash9053 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceIDProperties const & physicalDeviceIDProperties ) const VULKAN_HPP_NOEXCEPT 9054 { 9055 std::size_t seed = 0; 9056 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIDProperties.sType ); 9057 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIDProperties.pNext ); 9058 for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) 9059 { 9060 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIDProperties.deviceUUID[i] ); 9061 } 9062 for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) 9063 { 9064 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIDProperties.driverUUID[i] ); 9065 } 9066 for ( size_t i = 0; i < VK_LUID_SIZE; ++i ) 9067 { 9068 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIDProperties.deviceLUID[i] ); 9069 } 9070 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIDProperties.deviceNodeMask ); 9071 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIDProperties.deviceLUIDValid ); 9072 return seed; 9073 } 9074 }; 9075 9076 template <> 9077 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImage2DViewOf3DFeaturesEXT> 9078 { 9079 std::size_t operator ()std::hash9080 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImage2DViewOf3DFeaturesEXT const & physicalDeviceImage2DViewOf3DFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 9081 { 9082 std::size_t seed = 0; 9083 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImage2DViewOf3DFeaturesEXT.sType ); 9084 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImage2DViewOf3DFeaturesEXT.pNext ); 9085 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImage2DViewOf3DFeaturesEXT.image2DViewOf3D ); 9086 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImage2DViewOf3DFeaturesEXT.sampler2DViewOf3D ); 9087 return seed; 9088 } 9089 }; 9090 9091 template <> 9092 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageCompressionControlFeaturesEXT> 9093 { operator ()std::hash9094 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageCompressionControlFeaturesEXT const & physicalDeviceImageCompressionControlFeaturesEXT ) 9095 const VULKAN_HPP_NOEXCEPT 9096 { 9097 std::size_t seed = 0; 9098 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageCompressionControlFeaturesEXT.sType ); 9099 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageCompressionControlFeaturesEXT.pNext ); 9100 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageCompressionControlFeaturesEXT.imageCompressionControl ); 9101 return seed; 9102 } 9103 }; 9104 9105 template <> 9106 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT> 9107 { operator ()std::hash9108 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT const & 9109 physicalDeviceImageCompressionControlSwapchainFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 9110 { 9111 std::size_t seed = 0; 9112 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageCompressionControlSwapchainFeaturesEXT.sType ); 9113 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageCompressionControlSwapchainFeaturesEXT.pNext ); 9114 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageCompressionControlSwapchainFeaturesEXT.imageCompressionControlSwapchain ); 9115 return seed; 9116 } 9117 }; 9118 9119 template <> 9120 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageDrmFormatModifierInfoEXT> 9121 { operator ()std::hash9122 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageDrmFormatModifierInfoEXT const & physicalDeviceImageDrmFormatModifierInfoEXT ) const 9123 VULKAN_HPP_NOEXCEPT 9124 { 9125 std::size_t seed = 0; 9126 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageDrmFormatModifierInfoEXT.sType ); 9127 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageDrmFormatModifierInfoEXT.pNext ); 9128 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageDrmFormatModifierInfoEXT.drmFormatModifier ); 9129 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageDrmFormatModifierInfoEXT.sharingMode ); 9130 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageDrmFormatModifierInfoEXT.queueFamilyIndexCount ); 9131 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageDrmFormatModifierInfoEXT.pQueueFamilyIndices ); 9132 return seed; 9133 } 9134 }; 9135 9136 template <> 9137 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2> 9138 { operator ()std::hash9139 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 const & physicalDeviceImageFormatInfo2 ) const VULKAN_HPP_NOEXCEPT 9140 { 9141 std::size_t seed = 0; 9142 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageFormatInfo2.sType ); 9143 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageFormatInfo2.pNext ); 9144 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageFormatInfo2.format ); 9145 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageFormatInfo2.type ); 9146 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageFormatInfo2.tiling ); 9147 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageFormatInfo2.usage ); 9148 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageFormatInfo2.flags ); 9149 return seed; 9150 } 9151 }; 9152 9153 template <> 9154 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessing2FeaturesQCOM> 9155 { operator ()std::hash9156 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessing2FeaturesQCOM const & physicalDeviceImageProcessing2FeaturesQCOM ) const 9157 VULKAN_HPP_NOEXCEPT 9158 { 9159 std::size_t seed = 0; 9160 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessing2FeaturesQCOM.sType ); 9161 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessing2FeaturesQCOM.pNext ); 9162 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessing2FeaturesQCOM.textureBlockMatch2 ); 9163 return seed; 9164 } 9165 }; 9166 9167 template <> 9168 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessing2PropertiesQCOM> 9169 { operator ()std::hash9170 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessing2PropertiesQCOM const & physicalDeviceImageProcessing2PropertiesQCOM ) const 9171 VULKAN_HPP_NOEXCEPT 9172 { 9173 std::size_t seed = 0; 9174 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessing2PropertiesQCOM.sType ); 9175 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessing2PropertiesQCOM.pNext ); 9176 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessing2PropertiesQCOM.maxBlockMatchWindow ); 9177 return seed; 9178 } 9179 }; 9180 9181 template <> 9182 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessingFeaturesQCOM> 9183 { 9184 std::size_t operator ()std::hash9185 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessingFeaturesQCOM const & physicalDeviceImageProcessingFeaturesQCOM ) const VULKAN_HPP_NOEXCEPT 9186 { 9187 std::size_t seed = 0; 9188 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingFeaturesQCOM.sType ); 9189 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingFeaturesQCOM.pNext ); 9190 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingFeaturesQCOM.textureSampleWeighted ); 9191 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingFeaturesQCOM.textureBoxFilter ); 9192 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingFeaturesQCOM.textureBlockMatch ); 9193 return seed; 9194 } 9195 }; 9196 9197 template <> 9198 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessingPropertiesQCOM> 9199 { operator ()std::hash9200 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessingPropertiesQCOM const & physicalDeviceImageProcessingPropertiesQCOM ) const 9201 VULKAN_HPP_NOEXCEPT 9202 { 9203 std::size_t seed = 0; 9204 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingPropertiesQCOM.sType ); 9205 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingPropertiesQCOM.pNext ); 9206 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingPropertiesQCOM.maxWeightFilterPhases ); 9207 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingPropertiesQCOM.maxWeightFilterDimension ); 9208 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingPropertiesQCOM.maxBlockMatchRegion ); 9209 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingPropertiesQCOM.maxBoxFilterBlockSize ); 9210 return seed; 9211 } 9212 }; 9213 9214 template <> 9215 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageRobustnessFeatures> 9216 { 9217 std::size_t operator ()std::hash9218 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageRobustnessFeatures const & physicalDeviceImageRobustnessFeatures ) const VULKAN_HPP_NOEXCEPT 9219 { 9220 std::size_t seed = 0; 9221 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageRobustnessFeatures.sType ); 9222 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageRobustnessFeatures.pNext ); 9223 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageRobustnessFeatures.robustImageAccess ); 9224 return seed; 9225 } 9226 }; 9227 9228 template <> 9229 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageSlicedViewOf3DFeaturesEXT> 9230 { operator ()std::hash9231 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageSlicedViewOf3DFeaturesEXT const & physicalDeviceImageSlicedViewOf3DFeaturesEXT ) const 9232 VULKAN_HPP_NOEXCEPT 9233 { 9234 std::size_t seed = 0; 9235 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageSlicedViewOf3DFeaturesEXT.sType ); 9236 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageSlicedViewOf3DFeaturesEXT.pNext ); 9237 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageSlicedViewOf3DFeaturesEXT.imageSlicedViewOf3D ); 9238 return seed; 9239 } 9240 }; 9241 9242 template <> 9243 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageViewImageFormatInfoEXT> 9244 { 9245 std::size_t operator ()std::hash9246 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageViewImageFormatInfoEXT const & physicalDeviceImageViewImageFormatInfoEXT ) const VULKAN_HPP_NOEXCEPT 9247 { 9248 std::size_t seed = 0; 9249 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageViewImageFormatInfoEXT.sType ); 9250 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageViewImageFormatInfoEXT.pNext ); 9251 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageViewImageFormatInfoEXT.imageViewType ); 9252 return seed; 9253 } 9254 }; 9255 9256 template <> 9257 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageViewMinLodFeaturesEXT> 9258 { 9259 std::size_t operator ()std::hash9260 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageViewMinLodFeaturesEXT const & physicalDeviceImageViewMinLodFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 9261 { 9262 std::size_t seed = 0; 9263 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageViewMinLodFeaturesEXT.sType ); 9264 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageViewMinLodFeaturesEXT.pNext ); 9265 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageViewMinLodFeaturesEXT.minLod ); 9266 return seed; 9267 } 9268 }; 9269 9270 template <> 9271 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImagelessFramebufferFeatures> 9272 { operator ()std::hash9273 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImagelessFramebufferFeatures const & physicalDeviceImagelessFramebufferFeatures ) const 9274 VULKAN_HPP_NOEXCEPT 9275 { 9276 std::size_t seed = 0; 9277 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImagelessFramebufferFeatures.sType ); 9278 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImagelessFramebufferFeatures.pNext ); 9279 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImagelessFramebufferFeatures.imagelessFramebuffer ); 9280 return seed; 9281 } 9282 }; 9283 9284 template <> 9285 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceIndexTypeUint8FeaturesEXT> 9286 { 9287 std::size_t operator ()std::hash9288 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceIndexTypeUint8FeaturesEXT const & physicalDeviceIndexTypeUint8FeaturesEXT ) const VULKAN_HPP_NOEXCEPT 9289 { 9290 std::size_t seed = 0; 9291 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIndexTypeUint8FeaturesEXT.sType ); 9292 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIndexTypeUint8FeaturesEXT.pNext ); 9293 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIndexTypeUint8FeaturesEXT.indexTypeUint8 ); 9294 return seed; 9295 } 9296 }; 9297 9298 template <> 9299 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceInheritedViewportScissorFeaturesNV> 9300 { operator ()std::hash9301 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceInheritedViewportScissorFeaturesNV const & physicalDeviceInheritedViewportScissorFeaturesNV ) 9302 const VULKAN_HPP_NOEXCEPT 9303 { 9304 std::size_t seed = 0; 9305 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInheritedViewportScissorFeaturesNV.sType ); 9306 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInheritedViewportScissorFeaturesNV.pNext ); 9307 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInheritedViewportScissorFeaturesNV.inheritedViewportScissor2D ); 9308 return seed; 9309 } 9310 }; 9311 9312 template <> 9313 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceInlineUniformBlockFeatures> 9314 { 9315 std::size_t operator ()std::hash9316 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceInlineUniformBlockFeatures const & physicalDeviceInlineUniformBlockFeatures ) const VULKAN_HPP_NOEXCEPT 9317 { 9318 std::size_t seed = 0; 9319 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockFeatures.sType ); 9320 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockFeatures.pNext ); 9321 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockFeatures.inlineUniformBlock ); 9322 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockFeatures.descriptorBindingInlineUniformBlockUpdateAfterBind ); 9323 return seed; 9324 } 9325 }; 9326 9327 template <> 9328 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceInlineUniformBlockProperties> 9329 { operator ()std::hash9330 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceInlineUniformBlockProperties const & physicalDeviceInlineUniformBlockProperties ) const 9331 VULKAN_HPP_NOEXCEPT 9332 { 9333 std::size_t seed = 0; 9334 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockProperties.sType ); 9335 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockProperties.pNext ); 9336 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockProperties.maxInlineUniformBlockSize ); 9337 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockProperties.maxPerStageDescriptorInlineUniformBlocks ); 9338 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockProperties.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks ); 9339 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockProperties.maxDescriptorSetInlineUniformBlocks ); 9340 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockProperties.maxDescriptorSetUpdateAfterBindInlineUniformBlocks ); 9341 return seed; 9342 } 9343 }; 9344 9345 template <> 9346 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceInvocationMaskFeaturesHUAWEI> 9347 { operator ()std::hash9348 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceInvocationMaskFeaturesHUAWEI const & physicalDeviceInvocationMaskFeaturesHUAWEI ) const 9349 VULKAN_HPP_NOEXCEPT 9350 { 9351 std::size_t seed = 0; 9352 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInvocationMaskFeaturesHUAWEI.sType ); 9353 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInvocationMaskFeaturesHUAWEI.pNext ); 9354 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInvocationMaskFeaturesHUAWEI.invocationMask ); 9355 return seed; 9356 } 9357 }; 9358 9359 template <> 9360 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredDriverPropertiesMSFT> 9361 { 9362 std::size_t operator ()std::hash9363 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredDriverPropertiesMSFT const & physicalDeviceLayeredDriverPropertiesMSFT ) const VULKAN_HPP_NOEXCEPT 9364 { 9365 std::size_t seed = 0; 9366 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredDriverPropertiesMSFT.sType ); 9367 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredDriverPropertiesMSFT.pNext ); 9368 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredDriverPropertiesMSFT.underlyingAPI ); 9369 return seed; 9370 } 9371 }; 9372 9373 template <> 9374 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLegacyDitheringFeaturesEXT> 9375 { 9376 std::size_t operator ()std::hash9377 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLegacyDitheringFeaturesEXT const & physicalDeviceLegacyDitheringFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 9378 { 9379 std::size_t seed = 0; 9380 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyDitheringFeaturesEXT.sType ); 9381 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyDitheringFeaturesEXT.pNext ); 9382 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyDitheringFeaturesEXT.legacyDithering ); 9383 return seed; 9384 } 9385 }; 9386 9387 template <> 9388 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLimits> 9389 { operator ()std::hash9390 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLimits const & physicalDeviceLimits ) const VULKAN_HPP_NOEXCEPT 9391 { 9392 std::size_t seed = 0; 9393 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxImageDimension1D ); 9394 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxImageDimension2D ); 9395 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxImageDimension3D ); 9396 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxImageDimensionCube ); 9397 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxImageArrayLayers ); 9398 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTexelBufferElements ); 9399 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxUniformBufferRange ); 9400 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxStorageBufferRange ); 9401 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxPushConstantsSize ); 9402 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxMemoryAllocationCount ); 9403 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxSamplerAllocationCount ); 9404 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.bufferImageGranularity ); 9405 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.sparseAddressSpaceSize ); 9406 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxBoundDescriptorSets ); 9407 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxPerStageDescriptorSamplers ); 9408 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxPerStageDescriptorUniformBuffers ); 9409 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxPerStageDescriptorStorageBuffers ); 9410 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxPerStageDescriptorSampledImages ); 9411 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxPerStageDescriptorStorageImages ); 9412 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxPerStageDescriptorInputAttachments ); 9413 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxPerStageResources ); 9414 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDescriptorSetSamplers ); 9415 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDescriptorSetUniformBuffers ); 9416 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDescriptorSetUniformBuffersDynamic ); 9417 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDescriptorSetStorageBuffers ); 9418 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDescriptorSetStorageBuffersDynamic ); 9419 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDescriptorSetSampledImages ); 9420 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDescriptorSetStorageImages ); 9421 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDescriptorSetInputAttachments ); 9422 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxVertexInputAttributes ); 9423 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxVertexInputBindings ); 9424 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxVertexInputAttributeOffset ); 9425 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxVertexInputBindingStride ); 9426 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxVertexOutputComponents ); 9427 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTessellationGenerationLevel ); 9428 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTessellationPatchSize ); 9429 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTessellationControlPerVertexInputComponents ); 9430 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTessellationControlPerVertexOutputComponents ); 9431 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTessellationControlPerPatchOutputComponents ); 9432 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTessellationControlTotalOutputComponents ); 9433 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTessellationEvaluationInputComponents ); 9434 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTessellationEvaluationOutputComponents ); 9435 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxGeometryShaderInvocations ); 9436 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxGeometryInputComponents ); 9437 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxGeometryOutputComponents ); 9438 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxGeometryOutputVertices ); 9439 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxGeometryTotalOutputComponents ); 9440 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxFragmentInputComponents ); 9441 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxFragmentOutputAttachments ); 9442 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxFragmentDualSrcAttachments ); 9443 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxFragmentCombinedOutputResources ); 9444 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxComputeSharedMemorySize ); 9445 for ( size_t i = 0; i < 3; ++i ) 9446 { 9447 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxComputeWorkGroupCount[i] ); 9448 } 9449 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxComputeWorkGroupInvocations ); 9450 for ( size_t i = 0; i < 3; ++i ) 9451 { 9452 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxComputeWorkGroupSize[i] ); 9453 } 9454 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.subPixelPrecisionBits ); 9455 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.subTexelPrecisionBits ); 9456 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.mipmapPrecisionBits ); 9457 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDrawIndexedIndexValue ); 9458 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDrawIndirectCount ); 9459 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxSamplerLodBias ); 9460 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxSamplerAnisotropy ); 9461 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxViewports ); 9462 for ( size_t i = 0; i < 2; ++i ) 9463 { 9464 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxViewportDimensions[i] ); 9465 } 9466 for ( size_t i = 0; i < 2; ++i ) 9467 { 9468 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.viewportBoundsRange[i] ); 9469 } 9470 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.viewportSubPixelBits ); 9471 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.minMemoryMapAlignment ); 9472 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.minTexelBufferOffsetAlignment ); 9473 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.minUniformBufferOffsetAlignment ); 9474 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.minStorageBufferOffsetAlignment ); 9475 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.minTexelOffset ); 9476 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTexelOffset ); 9477 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.minTexelGatherOffset ); 9478 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTexelGatherOffset ); 9479 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.minInterpolationOffset ); 9480 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxInterpolationOffset ); 9481 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.subPixelInterpolationOffsetBits ); 9482 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxFramebufferWidth ); 9483 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxFramebufferHeight ); 9484 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxFramebufferLayers ); 9485 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.framebufferColorSampleCounts ); 9486 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.framebufferDepthSampleCounts ); 9487 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.framebufferStencilSampleCounts ); 9488 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.framebufferNoAttachmentsSampleCounts ); 9489 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxColorAttachments ); 9490 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.sampledImageColorSampleCounts ); 9491 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.sampledImageIntegerSampleCounts ); 9492 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.sampledImageDepthSampleCounts ); 9493 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.sampledImageStencilSampleCounts ); 9494 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.storageImageSampleCounts ); 9495 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxSampleMaskWords ); 9496 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.timestampComputeAndGraphics ); 9497 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.timestampPeriod ); 9498 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxClipDistances ); 9499 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxCullDistances ); 9500 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxCombinedClipAndCullDistances ); 9501 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.discreteQueuePriorities ); 9502 for ( size_t i = 0; i < 2; ++i ) 9503 { 9504 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.pointSizeRange[i] ); 9505 } 9506 for ( size_t i = 0; i < 2; ++i ) 9507 { 9508 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.lineWidthRange[i] ); 9509 } 9510 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.pointSizeGranularity ); 9511 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.lineWidthGranularity ); 9512 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.strictLines ); 9513 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.standardSampleLocations ); 9514 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.optimalBufferCopyOffsetAlignment ); 9515 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.optimalBufferCopyRowPitchAlignment ); 9516 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.nonCoherentAtomSize ); 9517 return seed; 9518 } 9519 }; 9520 9521 template <> 9522 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationFeaturesEXT> 9523 { operator ()std::hash9524 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationFeaturesEXT const & physicalDeviceLineRasterizationFeaturesEXT ) const 9525 VULKAN_HPP_NOEXCEPT 9526 { 9527 std::size_t seed = 0; 9528 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeaturesEXT.sType ); 9529 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeaturesEXT.pNext ); 9530 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeaturesEXT.rectangularLines ); 9531 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeaturesEXT.bresenhamLines ); 9532 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeaturesEXT.smoothLines ); 9533 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeaturesEXT.stippledRectangularLines ); 9534 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeaturesEXT.stippledBresenhamLines ); 9535 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeaturesEXT.stippledSmoothLines ); 9536 return seed; 9537 } 9538 }; 9539 9540 template <> 9541 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationPropertiesEXT> 9542 { operator ()std::hash9543 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationPropertiesEXT const & physicalDeviceLineRasterizationPropertiesEXT ) const 9544 VULKAN_HPP_NOEXCEPT 9545 { 9546 std::size_t seed = 0; 9547 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationPropertiesEXT.sType ); 9548 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationPropertiesEXT.pNext ); 9549 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationPropertiesEXT.lineSubPixelPrecisionBits ); 9550 return seed; 9551 } 9552 }; 9553 9554 template <> 9555 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLinearColorAttachmentFeaturesNV> 9556 { operator ()std::hash9557 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLinearColorAttachmentFeaturesNV const & physicalDeviceLinearColorAttachmentFeaturesNV ) const 9558 VULKAN_HPP_NOEXCEPT 9559 { 9560 std::size_t seed = 0; 9561 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLinearColorAttachmentFeaturesNV.sType ); 9562 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLinearColorAttachmentFeaturesNV.pNext ); 9563 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLinearColorAttachmentFeaturesNV.linearColorAttachment ); 9564 return seed; 9565 } 9566 }; 9567 9568 template <> 9569 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance3Properties> 9570 { operator ()std::hash9571 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance3Properties const & physicalDeviceMaintenance3Properties ) const VULKAN_HPP_NOEXCEPT 9572 { 9573 std::size_t seed = 0; 9574 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance3Properties.sType ); 9575 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance3Properties.pNext ); 9576 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance3Properties.maxPerSetDescriptors ); 9577 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance3Properties.maxMemoryAllocationSize ); 9578 return seed; 9579 } 9580 }; 9581 9582 template <> 9583 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance4Features> 9584 { operator ()std::hash9585 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance4Features const & physicalDeviceMaintenance4Features ) const VULKAN_HPP_NOEXCEPT 9586 { 9587 std::size_t seed = 0; 9588 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance4Features.sType ); 9589 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance4Features.pNext ); 9590 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance4Features.maintenance4 ); 9591 return seed; 9592 } 9593 }; 9594 9595 template <> 9596 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance4Properties> 9597 { operator ()std::hash9598 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance4Properties const & physicalDeviceMaintenance4Properties ) const VULKAN_HPP_NOEXCEPT 9599 { 9600 std::size_t seed = 0; 9601 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance4Properties.sType ); 9602 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance4Properties.pNext ); 9603 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance4Properties.maxBufferSize ); 9604 return seed; 9605 } 9606 }; 9607 9608 template <> 9609 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance5FeaturesKHR> 9610 { 9611 std::size_t operator ()std::hash9612 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance5FeaturesKHR const & physicalDeviceMaintenance5FeaturesKHR ) const VULKAN_HPP_NOEXCEPT 9613 { 9614 std::size_t seed = 0; 9615 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5FeaturesKHR.sType ); 9616 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5FeaturesKHR.pNext ); 9617 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5FeaturesKHR.maintenance5 ); 9618 return seed; 9619 } 9620 }; 9621 9622 template <> 9623 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance5PropertiesKHR> 9624 { 9625 std::size_t operator ()std::hash9626 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance5PropertiesKHR const & physicalDeviceMaintenance5PropertiesKHR ) const VULKAN_HPP_NOEXCEPT 9627 { 9628 std::size_t seed = 0; 9629 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5PropertiesKHR.sType ); 9630 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5PropertiesKHR.pNext ); 9631 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5PropertiesKHR.earlyFragmentMultisampleCoverageAfterSampleCounting ); 9632 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5PropertiesKHR.earlyFragmentSampleMaskTestBeforeSampleCounting ); 9633 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5PropertiesKHR.depthStencilSwizzleOneSupport ); 9634 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5PropertiesKHR.polygonModePointSize ); 9635 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5PropertiesKHR.nonStrictSinglePixelWideLinesUseParallelogram ); 9636 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5PropertiesKHR.nonStrictWideLinesUseParallelogram ); 9637 return seed; 9638 } 9639 }; 9640 9641 template <> 9642 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance6FeaturesKHR> 9643 { 9644 std::size_t operator ()std::hash9645 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance6FeaturesKHR const & physicalDeviceMaintenance6FeaturesKHR ) const VULKAN_HPP_NOEXCEPT 9646 { 9647 std::size_t seed = 0; 9648 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance6FeaturesKHR.sType ); 9649 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance6FeaturesKHR.pNext ); 9650 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance6FeaturesKHR.maintenance6 ); 9651 return seed; 9652 } 9653 }; 9654 9655 template <> 9656 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance6PropertiesKHR> 9657 { 9658 std::size_t operator ()std::hash9659 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance6PropertiesKHR const & physicalDeviceMaintenance6PropertiesKHR ) const VULKAN_HPP_NOEXCEPT 9660 { 9661 std::size_t seed = 0; 9662 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance6PropertiesKHR.sType ); 9663 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance6PropertiesKHR.pNext ); 9664 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance6PropertiesKHR.blockTexelViewCompatibleMultipleLayers ); 9665 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance6PropertiesKHR.maxCombinedImageSamplerDescriptorCount ); 9666 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance6PropertiesKHR.fragmentShadingRateClampCombinerInputs ); 9667 return seed; 9668 } 9669 }; 9670 9671 template <> 9672 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryBudgetPropertiesEXT> 9673 { 9674 std::size_t operator ()std::hash9675 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryBudgetPropertiesEXT const & physicalDeviceMemoryBudgetPropertiesEXT ) const VULKAN_HPP_NOEXCEPT 9676 { 9677 std::size_t seed = 0; 9678 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryBudgetPropertiesEXT.sType ); 9679 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryBudgetPropertiesEXT.pNext ); 9680 for ( size_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i ) 9681 { 9682 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryBudgetPropertiesEXT.heapBudget[i] ); 9683 } 9684 for ( size_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i ) 9685 { 9686 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryBudgetPropertiesEXT.heapUsage[i] ); 9687 } 9688 return seed; 9689 } 9690 }; 9691 9692 template <> 9693 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryDecompressionFeaturesNV> 9694 { operator ()std::hash9695 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryDecompressionFeaturesNV const & physicalDeviceMemoryDecompressionFeaturesNV ) const 9696 VULKAN_HPP_NOEXCEPT 9697 { 9698 std::size_t seed = 0; 9699 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionFeaturesNV.sType ); 9700 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionFeaturesNV.pNext ); 9701 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionFeaturesNV.memoryDecompression ); 9702 return seed; 9703 } 9704 }; 9705 9706 template <> 9707 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryDecompressionPropertiesNV> 9708 { operator ()std::hash9709 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryDecompressionPropertiesNV const & physicalDeviceMemoryDecompressionPropertiesNV ) const 9710 VULKAN_HPP_NOEXCEPT 9711 { 9712 std::size_t seed = 0; 9713 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionPropertiesNV.sType ); 9714 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionPropertiesNV.pNext ); 9715 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionPropertiesNV.decompressionMethods ); 9716 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionPropertiesNV.maxDecompressionIndirectCount ); 9717 return seed; 9718 } 9719 }; 9720 9721 template <> 9722 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryPriorityFeaturesEXT> 9723 { 9724 std::size_t operator ()std::hash9725 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryPriorityFeaturesEXT const & physicalDeviceMemoryPriorityFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 9726 { 9727 std::size_t seed = 0; 9728 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryPriorityFeaturesEXT.sType ); 9729 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryPriorityFeaturesEXT.pNext ); 9730 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryPriorityFeaturesEXT.memoryPriority ); 9731 return seed; 9732 } 9733 }; 9734 9735 template <> 9736 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties> 9737 { operator ()std::hash9738 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties const & physicalDeviceMemoryProperties ) const VULKAN_HPP_NOEXCEPT 9739 { 9740 std::size_t seed = 0; 9741 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryProperties.memoryTypeCount ); 9742 for ( size_t i = 0; i < VK_MAX_MEMORY_TYPES; ++i ) 9743 { 9744 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryProperties.memoryTypes[i] ); 9745 } 9746 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryProperties.memoryHeapCount ); 9747 for ( size_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i ) 9748 { 9749 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryProperties.memoryHeaps[i] ); 9750 } 9751 return seed; 9752 } 9753 }; 9754 9755 template <> 9756 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2> 9757 { operator ()std::hash9758 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 const & physicalDeviceMemoryProperties2 ) const VULKAN_HPP_NOEXCEPT 9759 { 9760 std::size_t seed = 0; 9761 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryProperties2.sType ); 9762 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryProperties2.pNext ); 9763 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryProperties2.memoryProperties ); 9764 return seed; 9765 } 9766 }; 9767 9768 template <> 9769 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderFeaturesEXT> 9770 { operator ()std::hash9771 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderFeaturesEXT const & physicalDeviceMeshShaderFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 9772 { 9773 std::size_t seed = 0; 9774 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesEXT.sType ); 9775 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesEXT.pNext ); 9776 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesEXT.taskShader ); 9777 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesEXT.meshShader ); 9778 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesEXT.multiviewMeshShader ); 9779 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesEXT.primitiveFragmentShadingRateMeshShader ); 9780 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesEXT.meshShaderQueries ); 9781 return seed; 9782 } 9783 }; 9784 9785 template <> 9786 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderFeaturesNV> 9787 { operator ()std::hash9788 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderFeaturesNV const & physicalDeviceMeshShaderFeaturesNV ) const VULKAN_HPP_NOEXCEPT 9789 { 9790 std::size_t seed = 0; 9791 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesNV.sType ); 9792 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesNV.pNext ); 9793 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesNV.taskShader ); 9794 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesNV.meshShader ); 9795 return seed; 9796 } 9797 }; 9798 9799 template <> 9800 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderPropertiesEXT> 9801 { 9802 std::size_t operator ()std::hash9803 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderPropertiesEXT const & physicalDeviceMeshShaderPropertiesEXT ) const VULKAN_HPP_NOEXCEPT 9804 { 9805 std::size_t seed = 0; 9806 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.sType ); 9807 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.pNext ); 9808 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxTaskWorkGroupTotalCount ); 9809 for ( size_t i = 0; i < 3; ++i ) 9810 { 9811 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxTaskWorkGroupCount[i] ); 9812 } 9813 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxTaskWorkGroupInvocations ); 9814 for ( size_t i = 0; i < 3; ++i ) 9815 { 9816 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxTaskWorkGroupSize[i] ); 9817 } 9818 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxTaskPayloadSize ); 9819 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxTaskSharedMemorySize ); 9820 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxTaskPayloadAndSharedMemorySize ); 9821 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshWorkGroupTotalCount ); 9822 for ( size_t i = 0; i < 3; ++i ) 9823 { 9824 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshWorkGroupCount[i] ); 9825 } 9826 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshWorkGroupInvocations ); 9827 for ( size_t i = 0; i < 3; ++i ) 9828 { 9829 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshWorkGroupSize[i] ); 9830 } 9831 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshSharedMemorySize ); 9832 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshPayloadAndSharedMemorySize ); 9833 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshOutputMemorySize ); 9834 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshPayloadAndOutputMemorySize ); 9835 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshOutputComponents ); 9836 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshOutputVertices ); 9837 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshOutputPrimitives ); 9838 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshOutputLayers ); 9839 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshMultiviewViewCount ); 9840 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.meshOutputPerVertexGranularity ); 9841 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.meshOutputPerPrimitiveGranularity ); 9842 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxPreferredTaskWorkGroupInvocations ); 9843 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxPreferredMeshWorkGroupInvocations ); 9844 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.prefersLocalInvocationVertexOutput ); 9845 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.prefersLocalInvocationPrimitiveOutput ); 9846 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.prefersCompactVertexOutput ); 9847 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.prefersCompactPrimitiveOutput ); 9848 return seed; 9849 } 9850 }; 9851 9852 template <> 9853 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderPropertiesNV> 9854 { operator ()std::hash9855 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderPropertiesNV const & physicalDeviceMeshShaderPropertiesNV ) const VULKAN_HPP_NOEXCEPT 9856 { 9857 std::size_t seed = 0; 9858 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.sType ); 9859 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.pNext ); 9860 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxDrawMeshTasksCount ); 9861 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxTaskWorkGroupInvocations ); 9862 for ( size_t i = 0; i < 3; ++i ) 9863 { 9864 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxTaskWorkGroupSize[i] ); 9865 } 9866 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxTaskTotalMemorySize ); 9867 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxTaskOutputCount ); 9868 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxMeshWorkGroupInvocations ); 9869 for ( size_t i = 0; i < 3; ++i ) 9870 { 9871 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxMeshWorkGroupSize[i] ); 9872 } 9873 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxMeshTotalMemorySize ); 9874 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxMeshOutputVertices ); 9875 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxMeshOutputPrimitives ); 9876 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxMeshMultiviewViewCount ); 9877 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.meshOutputPerVertexGranularity ); 9878 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.meshOutputPerPrimitiveGranularity ); 9879 return seed; 9880 } 9881 }; 9882 9883 template <> 9884 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiDrawFeaturesEXT> 9885 { operator ()std::hash9886 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiDrawFeaturesEXT const & physicalDeviceMultiDrawFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 9887 { 9888 std::size_t seed = 0; 9889 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiDrawFeaturesEXT.sType ); 9890 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiDrawFeaturesEXT.pNext ); 9891 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiDrawFeaturesEXT.multiDraw ); 9892 return seed; 9893 } 9894 }; 9895 9896 template <> 9897 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiDrawPropertiesEXT> 9898 { operator ()std::hash9899 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiDrawPropertiesEXT const & physicalDeviceMultiDrawPropertiesEXT ) const VULKAN_HPP_NOEXCEPT 9900 { 9901 std::size_t seed = 0; 9902 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiDrawPropertiesEXT.sType ); 9903 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiDrawPropertiesEXT.pNext ); 9904 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiDrawPropertiesEXT.maxMultiDrawCount ); 9905 return seed; 9906 } 9907 }; 9908 9909 template <> 9910 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT> 9911 { operator ()std::hash9912 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT const & 9913 physicalDeviceMultisampledRenderToSingleSampledFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 9914 { 9915 std::size_t seed = 0; 9916 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultisampledRenderToSingleSampledFeaturesEXT.sType ); 9917 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultisampledRenderToSingleSampledFeaturesEXT.pNext ); 9918 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultisampledRenderToSingleSampledFeaturesEXT.multisampledRenderToSingleSampled ); 9919 return seed; 9920 } 9921 }; 9922 9923 template <> 9924 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewFeatures> 9925 { operator ()std::hash9926 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewFeatures const & physicalDeviceMultiviewFeatures ) const VULKAN_HPP_NOEXCEPT 9927 { 9928 std::size_t seed = 0; 9929 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewFeatures.sType ); 9930 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewFeatures.pNext ); 9931 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewFeatures.multiview ); 9932 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewFeatures.multiviewGeometryShader ); 9933 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewFeatures.multiviewTessellationShader ); 9934 return seed; 9935 } 9936 }; 9937 9938 template <> 9939 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX> 9940 { operator ()std::hash9941 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const & 9942 physicalDeviceMultiviewPerViewAttributesPropertiesNVX ) const VULKAN_HPP_NOEXCEPT 9943 { 9944 std::size_t seed = 0; 9945 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewAttributesPropertiesNVX.sType ); 9946 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewAttributesPropertiesNVX.pNext ); 9947 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewAttributesPropertiesNVX.perViewPositionAllComponents ); 9948 return seed; 9949 } 9950 }; 9951 9952 template <> 9953 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM> 9954 { operator ()std::hash9955 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM const & 9956 physicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM ) const VULKAN_HPP_NOEXCEPT 9957 { 9958 std::size_t seed = 0; 9959 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM.sType ); 9960 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM.pNext ); 9961 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM.multiviewPerViewRenderAreas ); 9962 return seed; 9963 } 9964 }; 9965 9966 template <> 9967 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM> 9968 { 9969 std::size_t operator ()std::hash9970 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM const & physicalDeviceMultiviewPerViewViewportsFeaturesQCOM ) const 9971 VULKAN_HPP_NOEXCEPT 9972 { 9973 std::size_t seed = 0; 9974 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewViewportsFeaturesQCOM.sType ); 9975 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewViewportsFeaturesQCOM.pNext ); 9976 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewViewportsFeaturesQCOM.multiviewPerViewViewports ); 9977 return seed; 9978 } 9979 }; 9980 9981 template <> 9982 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewProperties> 9983 { operator ()std::hash9984 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewProperties const & physicalDeviceMultiviewProperties ) const VULKAN_HPP_NOEXCEPT 9985 { 9986 std::size_t seed = 0; 9987 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewProperties.sType ); 9988 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewProperties.pNext ); 9989 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewProperties.maxMultiviewViewCount ); 9990 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewProperties.maxMultiviewInstanceIndex ); 9991 return seed; 9992 } 9993 }; 9994 9995 template <> 9996 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMutableDescriptorTypeFeaturesEXT> 9997 { operator ()std::hash9998 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMutableDescriptorTypeFeaturesEXT const & physicalDeviceMutableDescriptorTypeFeaturesEXT ) const 9999 VULKAN_HPP_NOEXCEPT 10000 { 10001 std::size_t seed = 0; 10002 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMutableDescriptorTypeFeaturesEXT.sType ); 10003 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMutableDescriptorTypeFeaturesEXT.pNext ); 10004 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMutableDescriptorTypeFeaturesEXT.mutableDescriptorType ); 10005 return seed; 10006 } 10007 }; 10008 10009 template <> 10010 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceNestedCommandBufferFeaturesEXT> 10011 { operator ()std::hash10012 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceNestedCommandBufferFeaturesEXT const & physicalDeviceNestedCommandBufferFeaturesEXT ) const 10013 VULKAN_HPP_NOEXCEPT 10014 { 10015 std::size_t seed = 0; 10016 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNestedCommandBufferFeaturesEXT.sType ); 10017 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNestedCommandBufferFeaturesEXT.pNext ); 10018 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNestedCommandBufferFeaturesEXT.nestedCommandBuffer ); 10019 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNestedCommandBufferFeaturesEXT.nestedCommandBufferRendering ); 10020 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNestedCommandBufferFeaturesEXT.nestedCommandBufferSimultaneousUse ); 10021 return seed; 10022 } 10023 }; 10024 10025 template <> 10026 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceNestedCommandBufferPropertiesEXT> 10027 { operator ()std::hash10028 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceNestedCommandBufferPropertiesEXT const & physicalDeviceNestedCommandBufferPropertiesEXT ) const 10029 VULKAN_HPP_NOEXCEPT 10030 { 10031 std::size_t seed = 0; 10032 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNestedCommandBufferPropertiesEXT.sType ); 10033 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNestedCommandBufferPropertiesEXT.pNext ); 10034 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNestedCommandBufferPropertiesEXT.maxCommandBufferNestingLevel ); 10035 return seed; 10036 } 10037 }; 10038 10039 template <> 10040 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceNonSeamlessCubeMapFeaturesEXT> 10041 { operator ()std::hash10042 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceNonSeamlessCubeMapFeaturesEXT const & physicalDeviceNonSeamlessCubeMapFeaturesEXT ) const 10043 VULKAN_HPP_NOEXCEPT 10044 { 10045 std::size_t seed = 0; 10046 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNonSeamlessCubeMapFeaturesEXT.sType ); 10047 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNonSeamlessCubeMapFeaturesEXT.pNext ); 10048 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNonSeamlessCubeMapFeaturesEXT.nonSeamlessCubeMap ); 10049 return seed; 10050 } 10051 }; 10052 10053 template <> 10054 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceOpacityMicromapFeaturesEXT> 10055 { 10056 std::size_t operator ()std::hash10057 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceOpacityMicromapFeaturesEXT const & physicalDeviceOpacityMicromapFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 10058 { 10059 std::size_t seed = 0; 10060 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapFeaturesEXT.sType ); 10061 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapFeaturesEXT.pNext ); 10062 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapFeaturesEXT.micromap ); 10063 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapFeaturesEXT.micromapCaptureReplay ); 10064 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapFeaturesEXT.micromapHostCommands ); 10065 return seed; 10066 } 10067 }; 10068 10069 template <> 10070 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceOpacityMicromapPropertiesEXT> 10071 { operator ()std::hash10072 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceOpacityMicromapPropertiesEXT const & physicalDeviceOpacityMicromapPropertiesEXT ) const 10073 VULKAN_HPP_NOEXCEPT 10074 { 10075 std::size_t seed = 0; 10076 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapPropertiesEXT.sType ); 10077 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapPropertiesEXT.pNext ); 10078 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapPropertiesEXT.maxOpacity2StateSubdivisionLevel ); 10079 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapPropertiesEXT.maxOpacity4StateSubdivisionLevel ); 10080 return seed; 10081 } 10082 }; 10083 10084 template <> 10085 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceOpticalFlowFeaturesNV> 10086 { operator ()std::hash10087 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceOpticalFlowFeaturesNV const & physicalDeviceOpticalFlowFeaturesNV ) const VULKAN_HPP_NOEXCEPT 10088 { 10089 std::size_t seed = 0; 10090 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowFeaturesNV.sType ); 10091 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowFeaturesNV.pNext ); 10092 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowFeaturesNV.opticalFlow ); 10093 return seed; 10094 } 10095 }; 10096 10097 template <> 10098 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceOpticalFlowPropertiesNV> 10099 { 10100 std::size_t operator ()std::hash10101 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceOpticalFlowPropertiesNV const & physicalDeviceOpticalFlowPropertiesNV ) const VULKAN_HPP_NOEXCEPT 10102 { 10103 std::size_t seed = 0; 10104 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.sType ); 10105 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.pNext ); 10106 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.supportedOutputGridSizes ); 10107 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.supportedHintGridSizes ); 10108 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.hintSupported ); 10109 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.costSupported ); 10110 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.bidirectionalFlowSupported ); 10111 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.globalFlowSupported ); 10112 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.minWidth ); 10113 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.minHeight ); 10114 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.maxWidth ); 10115 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.maxHeight ); 10116 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.maxNumRegionsOfInterest ); 10117 return seed; 10118 } 10119 }; 10120 10121 template <> 10122 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePCIBusInfoPropertiesEXT> 10123 { 10124 std::size_t operator ()std::hash10125 operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePCIBusInfoPropertiesEXT const & physicalDevicePCIBusInfoPropertiesEXT ) const VULKAN_HPP_NOEXCEPT 10126 { 10127 std::size_t seed = 0; 10128 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePCIBusInfoPropertiesEXT.sType ); 10129 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePCIBusInfoPropertiesEXT.pNext ); 10130 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePCIBusInfoPropertiesEXT.pciDomain ); 10131 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePCIBusInfoPropertiesEXT.pciBus ); 10132 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePCIBusInfoPropertiesEXT.pciDevice ); 10133 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePCIBusInfoPropertiesEXT.pciFunction ); 10134 return seed; 10135 } 10136 }; 10137 10138 template <> 10139 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT> 10140 { 10141 std::size_t operator ()std::hash10142 operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT const & physicalDevicePageableDeviceLocalMemoryFeaturesEXT ) const 10143 VULKAN_HPP_NOEXCEPT 10144 { 10145 std::size_t seed = 0; 10146 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePageableDeviceLocalMemoryFeaturesEXT.sType ); 10147 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePageableDeviceLocalMemoryFeaturesEXT.pNext ); 10148 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePageableDeviceLocalMemoryFeaturesEXT.pageableDeviceLocalMemory ); 10149 return seed; 10150 } 10151 }; 10152 10153 template <> 10154 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePerStageDescriptorSetFeaturesNV> 10155 { operator ()std::hash10156 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePerStageDescriptorSetFeaturesNV const & physicalDevicePerStageDescriptorSetFeaturesNV ) const 10157 VULKAN_HPP_NOEXCEPT 10158 { 10159 std::size_t seed = 0; 10160 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerStageDescriptorSetFeaturesNV.sType ); 10161 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerStageDescriptorSetFeaturesNV.pNext ); 10162 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerStageDescriptorSetFeaturesNV.perStageDescriptorSet ); 10163 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerStageDescriptorSetFeaturesNV.dynamicPipelineLayout ); 10164 return seed; 10165 } 10166 }; 10167 10168 template <> 10169 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceQueryFeaturesKHR> 10170 { 10171 std::size_t operator ()std::hash10172 operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceQueryFeaturesKHR const & physicalDevicePerformanceQueryFeaturesKHR ) const VULKAN_HPP_NOEXCEPT 10173 { 10174 std::size_t seed = 0; 10175 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceQueryFeaturesKHR.sType ); 10176 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceQueryFeaturesKHR.pNext ); 10177 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceQueryFeaturesKHR.performanceCounterQueryPools ); 10178 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceQueryFeaturesKHR.performanceCounterMultipleQueryPools ); 10179 return seed; 10180 } 10181 }; 10182 10183 template <> 10184 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceQueryPropertiesKHR> 10185 { operator ()std::hash10186 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceQueryPropertiesKHR const & physicalDevicePerformanceQueryPropertiesKHR ) const 10187 VULKAN_HPP_NOEXCEPT 10188 { 10189 std::size_t seed = 0; 10190 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceQueryPropertiesKHR.sType ); 10191 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceQueryPropertiesKHR.pNext ); 10192 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceQueryPropertiesKHR.allowCommandBufferQueryCopies ); 10193 return seed; 10194 } 10195 }; 10196 10197 template <> 10198 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineCreationCacheControlFeatures> 10199 { 10200 std::size_t operator ()std::hash10201 operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineCreationCacheControlFeatures const & physicalDevicePipelineCreationCacheControlFeatures ) const 10202 VULKAN_HPP_NOEXCEPT 10203 { 10204 std::size_t seed = 0; 10205 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineCreationCacheControlFeatures.sType ); 10206 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineCreationCacheControlFeatures.pNext ); 10207 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineCreationCacheControlFeatures.pipelineCreationCacheControl ); 10208 return seed; 10209 } 10210 }; 10211 10212 template <> 10213 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR> 10214 { operator ()std::hash10215 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR const & 10216 physicalDevicePipelineExecutablePropertiesFeaturesKHR ) const VULKAN_HPP_NOEXCEPT 10217 { 10218 std::size_t seed = 0; 10219 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineExecutablePropertiesFeaturesKHR.sType ); 10220 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineExecutablePropertiesFeaturesKHR.pNext ); 10221 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineExecutablePropertiesFeaturesKHR.pipelineExecutableInfo ); 10222 return seed; 10223 } 10224 }; 10225 10226 template <> 10227 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT> 10228 { operator ()std::hash10229 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT const & 10230 physicalDevicePipelineLibraryGroupHandlesFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 10231 { 10232 std::size_t seed = 0; 10233 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineLibraryGroupHandlesFeaturesEXT.sType ); 10234 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineLibraryGroupHandlesFeaturesEXT.pNext ); 10235 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineLibraryGroupHandlesFeaturesEXT.pipelineLibraryGroupHandles ); 10236 return seed; 10237 } 10238 }; 10239 10240 template <> 10241 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelinePropertiesFeaturesEXT> 10242 { operator ()std::hash10243 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelinePropertiesFeaturesEXT const & physicalDevicePipelinePropertiesFeaturesEXT ) const 10244 VULKAN_HPP_NOEXCEPT 10245 { 10246 std::size_t seed = 0; 10247 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelinePropertiesFeaturesEXT.sType ); 10248 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelinePropertiesFeaturesEXT.pNext ); 10249 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelinePropertiesFeaturesEXT.pipelinePropertiesIdentifier ); 10250 return seed; 10251 } 10252 }; 10253 10254 template <> 10255 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineProtectedAccessFeaturesEXT> 10256 { operator ()std::hash10257 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineProtectedAccessFeaturesEXT const & physicalDevicePipelineProtectedAccessFeaturesEXT ) 10258 const VULKAN_HPP_NOEXCEPT 10259 { 10260 std::size_t seed = 0; 10261 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineProtectedAccessFeaturesEXT.sType ); 10262 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineProtectedAccessFeaturesEXT.pNext ); 10263 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineProtectedAccessFeaturesEXT.pipelineProtectedAccess ); 10264 return seed; 10265 } 10266 }; 10267 10268 template <> 10269 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineRobustnessFeaturesEXT> 10270 { operator ()std::hash10271 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineRobustnessFeaturesEXT const & physicalDevicePipelineRobustnessFeaturesEXT ) const 10272 VULKAN_HPP_NOEXCEPT 10273 { 10274 std::size_t seed = 0; 10275 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineRobustnessFeaturesEXT.sType ); 10276 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineRobustnessFeaturesEXT.pNext ); 10277 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineRobustnessFeaturesEXT.pipelineRobustness ); 10278 return seed; 10279 } 10280 }; 10281 10282 template <> 10283 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineRobustnessPropertiesEXT> 10284 { operator ()std::hash10285 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineRobustnessPropertiesEXT const & physicalDevicePipelineRobustnessPropertiesEXT ) const 10286 VULKAN_HPP_NOEXCEPT 10287 { 10288 std::size_t seed = 0; 10289 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineRobustnessPropertiesEXT.sType ); 10290 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineRobustnessPropertiesEXT.pNext ); 10291 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineRobustnessPropertiesEXT.defaultRobustnessStorageBuffers ); 10292 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineRobustnessPropertiesEXT.defaultRobustnessUniformBuffers ); 10293 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineRobustnessPropertiesEXT.defaultRobustnessVertexInputs ); 10294 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineRobustnessPropertiesEXT.defaultRobustnessImages ); 10295 return seed; 10296 } 10297 }; 10298 10299 template <> 10300 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePointClippingProperties> 10301 { 10302 std::size_t operator ()std::hash10303 operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePointClippingProperties const & physicalDevicePointClippingProperties ) const VULKAN_HPP_NOEXCEPT 10304 { 10305 std::size_t seed = 0; 10306 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePointClippingProperties.sType ); 10307 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePointClippingProperties.pNext ); 10308 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePointClippingProperties.pointClippingBehavior ); 10309 return seed; 10310 } 10311 }; 10312 10313 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 10314 template <> 10315 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePortabilitySubsetFeaturesKHR> 10316 { operator ()std::hash10317 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePortabilitySubsetFeaturesKHR const & physicalDevicePortabilitySubsetFeaturesKHR ) const 10318 VULKAN_HPP_NOEXCEPT 10319 { 10320 std::size_t seed = 0; 10321 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.sType ); 10322 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.pNext ); 10323 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.constantAlphaColorBlendFactors ); 10324 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.events ); 10325 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.imageViewFormatReinterpretation ); 10326 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.imageViewFormatSwizzle ); 10327 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.imageView2DOn3DImage ); 10328 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.multisampleArrayImage ); 10329 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.mutableComparisonSamplers ); 10330 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.pointPolygons ); 10331 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.samplerMipLodBias ); 10332 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.separateStencilMaskRef ); 10333 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.shaderSampleRateInterpolationFunctions ); 10334 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.tessellationIsolines ); 10335 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.tessellationPointMode ); 10336 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.triangleFans ); 10337 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.vertexAttributeAccessBeyondStride ); 10338 return seed; 10339 } 10340 }; 10341 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 10342 10343 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 10344 template <> 10345 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePortabilitySubsetPropertiesKHR> 10346 { operator ()std::hash10347 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePortabilitySubsetPropertiesKHR const & physicalDevicePortabilitySubsetPropertiesKHR ) const 10348 VULKAN_HPP_NOEXCEPT 10349 { 10350 std::size_t seed = 0; 10351 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetPropertiesKHR.sType ); 10352 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetPropertiesKHR.pNext ); 10353 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetPropertiesKHR.minVertexInputBindingStrideAlignment ); 10354 return seed; 10355 } 10356 }; 10357 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 10358 10359 template <> 10360 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePresentBarrierFeaturesNV> 10361 { 10362 std::size_t operator ()std::hash10363 operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePresentBarrierFeaturesNV const & physicalDevicePresentBarrierFeaturesNV ) const VULKAN_HPP_NOEXCEPT 10364 { 10365 std::size_t seed = 0; 10366 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentBarrierFeaturesNV.sType ); 10367 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentBarrierFeaturesNV.pNext ); 10368 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentBarrierFeaturesNV.presentBarrier ); 10369 return seed; 10370 } 10371 }; 10372 10373 template <> 10374 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePresentIdFeaturesKHR> 10375 { operator ()std::hash10376 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePresentIdFeaturesKHR const & physicalDevicePresentIdFeaturesKHR ) const VULKAN_HPP_NOEXCEPT 10377 { 10378 std::size_t seed = 0; 10379 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentIdFeaturesKHR.sType ); 10380 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentIdFeaturesKHR.pNext ); 10381 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentIdFeaturesKHR.presentId ); 10382 return seed; 10383 } 10384 }; 10385 10386 template <> 10387 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePresentWaitFeaturesKHR> 10388 { operator ()std::hash10389 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePresentWaitFeaturesKHR const & physicalDevicePresentWaitFeaturesKHR ) const VULKAN_HPP_NOEXCEPT 10390 { 10391 std::size_t seed = 0; 10392 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentWaitFeaturesKHR.sType ); 10393 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentWaitFeaturesKHR.pNext ); 10394 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentWaitFeaturesKHR.presentWait ); 10395 return seed; 10396 } 10397 }; 10398 10399 template <> 10400 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT> 10401 { operator ()std::hash10402 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT const & 10403 physicalDevicePrimitiveTopologyListRestartFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 10404 { 10405 std::size_t seed = 0; 10406 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrimitiveTopologyListRestartFeaturesEXT.sType ); 10407 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrimitiveTopologyListRestartFeaturesEXT.pNext ); 10408 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrimitiveTopologyListRestartFeaturesEXT.primitiveTopologyListRestart ); 10409 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrimitiveTopologyListRestartFeaturesEXT.primitiveTopologyPatchListRestart ); 10410 return seed; 10411 } 10412 }; 10413 10414 template <> 10415 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT> 10416 { operator ()std::hash10417 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT const & physicalDevicePrimitivesGeneratedQueryFeaturesEXT ) 10418 const VULKAN_HPP_NOEXCEPT 10419 { 10420 std::size_t seed = 0; 10421 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrimitivesGeneratedQueryFeaturesEXT.sType ); 10422 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrimitivesGeneratedQueryFeaturesEXT.pNext ); 10423 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrimitivesGeneratedQueryFeaturesEXT.primitivesGeneratedQuery ); 10424 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrimitivesGeneratedQueryFeaturesEXT.primitivesGeneratedQueryWithRasterizerDiscard ); 10425 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrimitivesGeneratedQueryFeaturesEXT.primitivesGeneratedQueryWithNonZeroStreams ); 10426 return seed; 10427 } 10428 }; 10429 10430 template <> 10431 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePrivateDataFeatures> 10432 { operator ()std::hash10433 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePrivateDataFeatures const & physicalDevicePrivateDataFeatures ) const VULKAN_HPP_NOEXCEPT 10434 { 10435 std::size_t seed = 0; 10436 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrivateDataFeatures.sType ); 10437 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrivateDataFeatures.pNext ); 10438 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrivateDataFeatures.privateData ); 10439 return seed; 10440 } 10441 }; 10442 10443 template <> 10444 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseProperties> 10445 { operator ()std::hash10446 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseProperties const & physicalDeviceSparseProperties ) const VULKAN_HPP_NOEXCEPT 10447 { 10448 std::size_t seed = 0; 10449 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseProperties.residencyStandard2DBlockShape ); 10450 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseProperties.residencyStandard2DMultisampleBlockShape ); 10451 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseProperties.residencyStandard3DBlockShape ); 10452 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseProperties.residencyAlignedMipSize ); 10453 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseProperties.residencyNonResidentStrict ); 10454 return seed; 10455 } 10456 }; 10457 10458 template <> 10459 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties> 10460 { operator ()std::hash10461 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties const & physicalDeviceProperties ) const VULKAN_HPP_NOEXCEPT 10462 { 10463 std::size_t seed = 0; 10464 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.apiVersion ); 10465 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.driverVersion ); 10466 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.vendorID ); 10467 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.deviceID ); 10468 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.deviceType ); 10469 for ( size_t i = 0; i < VK_MAX_PHYSICAL_DEVICE_NAME_SIZE; ++i ) 10470 { 10471 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.deviceName[i] ); 10472 } 10473 for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) 10474 { 10475 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.pipelineCacheUUID[i] ); 10476 } 10477 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.limits ); 10478 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.sparseProperties ); 10479 return seed; 10480 } 10481 }; 10482 10483 template <> 10484 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2> 10485 { operator ()std::hash10486 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 const & physicalDeviceProperties2 ) const VULKAN_HPP_NOEXCEPT 10487 { 10488 std::size_t seed = 0; 10489 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties2.sType ); 10490 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties2.pNext ); 10491 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties2.properties ); 10492 return seed; 10493 } 10494 }; 10495 10496 template <> 10497 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceProtectedMemoryFeatures> 10498 { 10499 std::size_t operator ()std::hash10500 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProtectedMemoryFeatures const & physicalDeviceProtectedMemoryFeatures ) const VULKAN_HPP_NOEXCEPT 10501 { 10502 std::size_t seed = 0; 10503 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProtectedMemoryFeatures.sType ); 10504 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProtectedMemoryFeatures.pNext ); 10505 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProtectedMemoryFeatures.protectedMemory ); 10506 return seed; 10507 } 10508 }; 10509 10510 template <> 10511 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceProtectedMemoryProperties> 10512 { 10513 std::size_t operator ()std::hash10514 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProtectedMemoryProperties const & physicalDeviceProtectedMemoryProperties ) const VULKAN_HPP_NOEXCEPT 10515 { 10516 std::size_t seed = 0; 10517 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProtectedMemoryProperties.sType ); 10518 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProtectedMemoryProperties.pNext ); 10519 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProtectedMemoryProperties.protectedNoFault ); 10520 return seed; 10521 } 10522 }; 10523 10524 template <> 10525 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceProvokingVertexFeaturesEXT> 10526 { 10527 std::size_t operator ()std::hash10528 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProvokingVertexFeaturesEXT const & physicalDeviceProvokingVertexFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 10529 { 10530 std::size_t seed = 0; 10531 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProvokingVertexFeaturesEXT.sType ); 10532 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProvokingVertexFeaturesEXT.pNext ); 10533 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProvokingVertexFeaturesEXT.provokingVertexLast ); 10534 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProvokingVertexFeaturesEXT.transformFeedbackPreservesProvokingVertex ); 10535 return seed; 10536 } 10537 }; 10538 10539 template <> 10540 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceProvokingVertexPropertiesEXT> 10541 { operator ()std::hash10542 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProvokingVertexPropertiesEXT const & physicalDeviceProvokingVertexPropertiesEXT ) const 10543 VULKAN_HPP_NOEXCEPT 10544 { 10545 std::size_t seed = 0; 10546 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProvokingVertexPropertiesEXT.sType ); 10547 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProvokingVertexPropertiesEXT.pNext ); 10548 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProvokingVertexPropertiesEXT.provokingVertexModePerPipeline ); 10549 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProvokingVertexPropertiesEXT.transformFeedbackPreservesTriangleFanProvokingVertex ); 10550 return seed; 10551 } 10552 }; 10553 10554 template <> 10555 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePushDescriptorPropertiesKHR> 10556 { 10557 std::size_t operator ()std::hash10558 operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePushDescriptorPropertiesKHR const & physicalDevicePushDescriptorPropertiesKHR ) const VULKAN_HPP_NOEXCEPT 10559 { 10560 std::size_t seed = 0; 10561 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePushDescriptorPropertiesKHR.sType ); 10562 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePushDescriptorPropertiesKHR.pNext ); 10563 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePushDescriptorPropertiesKHR.maxPushDescriptors ); 10564 return seed; 10565 } 10566 }; 10567 10568 template <> 10569 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRGBA10X6FormatsFeaturesEXT> 10570 { 10571 std::size_t operator ()std::hash10572 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRGBA10X6FormatsFeaturesEXT const & physicalDeviceRGBA10X6FormatsFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 10573 { 10574 std::size_t seed = 0; 10575 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRGBA10X6FormatsFeaturesEXT.sType ); 10576 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRGBA10X6FormatsFeaturesEXT.pNext ); 10577 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRGBA10X6FormatsFeaturesEXT.formatRgba10x6WithoutYCbCrSampler ); 10578 return seed; 10579 } 10580 }; 10581 10582 template <> 10583 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT> 10584 { operator ()std::hash10585 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT const & 10586 physicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 10587 { 10588 std::size_t seed = 0; 10589 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT.sType ); 10590 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT.pNext ); 10591 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT.rasterizationOrderColorAttachmentAccess ); 10592 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT.rasterizationOrderDepthAttachmentAccess ); 10593 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT.rasterizationOrderStencilAttachmentAccess ); 10594 return seed; 10595 } 10596 }; 10597 10598 template <> 10599 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayQueryFeaturesKHR> 10600 { operator ()std::hash10601 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayQueryFeaturesKHR const & physicalDeviceRayQueryFeaturesKHR ) const VULKAN_HPP_NOEXCEPT 10602 { 10603 std::size_t seed = 0; 10604 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayQueryFeaturesKHR.sType ); 10605 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayQueryFeaturesKHR.pNext ); 10606 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayQueryFeaturesKHR.rayQuery ); 10607 return seed; 10608 } 10609 }; 10610 10611 template <> 10612 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderFeaturesNV> 10613 { 10614 std::size_t operator ()std::hash10615 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderFeaturesNV const & physicalDeviceRayTracingInvocationReorderFeaturesNV ) const 10616 VULKAN_HPP_NOEXCEPT 10617 { 10618 std::size_t seed = 0; 10619 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderFeaturesNV.sType ); 10620 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderFeaturesNV.pNext ); 10621 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderFeaturesNV.rayTracingInvocationReorder ); 10622 return seed; 10623 } 10624 }; 10625 10626 template <> 10627 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderPropertiesNV> 10628 { operator ()std::hash10629 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderPropertiesNV const & 10630 physicalDeviceRayTracingInvocationReorderPropertiesNV ) const VULKAN_HPP_NOEXCEPT 10631 { 10632 std::size_t seed = 0; 10633 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderPropertiesNV.sType ); 10634 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderPropertiesNV.pNext ); 10635 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderPropertiesNV.rayTracingInvocationReorderReorderingHint ); 10636 return seed; 10637 } 10638 }; 10639 10640 template <> 10641 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingMaintenance1FeaturesKHR> 10642 { operator ()std::hash10643 std::size_t operator()( 10644 VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingMaintenance1FeaturesKHR const & physicalDeviceRayTracingMaintenance1FeaturesKHR ) const VULKAN_HPP_NOEXCEPT 10645 { 10646 std::size_t seed = 0; 10647 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingMaintenance1FeaturesKHR.sType ); 10648 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingMaintenance1FeaturesKHR.pNext ); 10649 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingMaintenance1FeaturesKHR.rayTracingMaintenance1 ); 10650 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingMaintenance1FeaturesKHR.rayTracingPipelineTraceRaysIndirect2 ); 10651 return seed; 10652 } 10653 }; 10654 10655 template <> 10656 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingMotionBlurFeaturesNV> 10657 { operator ()std::hash10658 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingMotionBlurFeaturesNV const & physicalDeviceRayTracingMotionBlurFeaturesNV ) const 10659 VULKAN_HPP_NOEXCEPT 10660 { 10661 std::size_t seed = 0; 10662 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingMotionBlurFeaturesNV.sType ); 10663 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingMotionBlurFeaturesNV.pNext ); 10664 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingMotionBlurFeaturesNV.rayTracingMotionBlur ); 10665 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingMotionBlurFeaturesNV.rayTracingMotionBlurPipelineTraceRaysIndirect ); 10666 return seed; 10667 } 10668 }; 10669 10670 template <> 10671 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPipelineFeaturesKHR> 10672 { operator ()std::hash10673 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPipelineFeaturesKHR const & physicalDeviceRayTracingPipelineFeaturesKHR ) const 10674 VULKAN_HPP_NOEXCEPT 10675 { 10676 std::size_t seed = 0; 10677 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelineFeaturesKHR.sType ); 10678 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelineFeaturesKHR.pNext ); 10679 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelineFeaturesKHR.rayTracingPipeline ); 10680 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelineFeaturesKHR.rayTracingPipelineShaderGroupHandleCaptureReplay ); 10681 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelineFeaturesKHR.rayTracingPipelineShaderGroupHandleCaptureReplayMixed ); 10682 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelineFeaturesKHR.rayTracingPipelineTraceRaysIndirect ); 10683 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelineFeaturesKHR.rayTraversalPrimitiveCulling ); 10684 return seed; 10685 } 10686 }; 10687 10688 template <> 10689 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPipelinePropertiesKHR> 10690 { operator ()std::hash10691 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPipelinePropertiesKHR const & physicalDeviceRayTracingPipelinePropertiesKHR ) const 10692 VULKAN_HPP_NOEXCEPT 10693 { 10694 std::size_t seed = 0; 10695 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.sType ); 10696 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.pNext ); 10697 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.shaderGroupHandleSize ); 10698 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.maxRayRecursionDepth ); 10699 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.maxShaderGroupStride ); 10700 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.shaderGroupBaseAlignment ); 10701 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.shaderGroupHandleCaptureReplaySize ); 10702 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.maxRayDispatchInvocationCount ); 10703 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.shaderGroupHandleAlignment ); 10704 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.maxRayHitAttributeSize ); 10705 return seed; 10706 } 10707 }; 10708 10709 template <> 10710 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPositionFetchFeaturesKHR> 10711 { operator ()std::hash10712 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPositionFetchFeaturesKHR const & physicalDeviceRayTracingPositionFetchFeaturesKHR ) 10713 const VULKAN_HPP_NOEXCEPT 10714 { 10715 std::size_t seed = 0; 10716 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPositionFetchFeaturesKHR.sType ); 10717 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPositionFetchFeaturesKHR.pNext ); 10718 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPositionFetchFeaturesKHR.rayTracingPositionFetch ); 10719 return seed; 10720 } 10721 }; 10722 10723 template <> 10724 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPropertiesNV> 10725 { operator ()std::hash10726 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPropertiesNV const & physicalDeviceRayTracingPropertiesNV ) const VULKAN_HPP_NOEXCEPT 10727 { 10728 std::size_t seed = 0; 10729 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.sType ); 10730 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.pNext ); 10731 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.shaderGroupHandleSize ); 10732 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.maxRecursionDepth ); 10733 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.maxShaderGroupStride ); 10734 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.shaderGroupBaseAlignment ); 10735 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.maxGeometryCount ); 10736 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.maxInstanceCount ); 10737 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.maxTriangleCount ); 10738 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.maxDescriptorSetAccelerationStructures ); 10739 return seed; 10740 } 10741 }; 10742 10743 template <> 10744 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRelaxedLineRasterizationFeaturesIMG> 10745 { operator ()std::hash10746 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRelaxedLineRasterizationFeaturesIMG const & physicalDeviceRelaxedLineRasterizationFeaturesIMG ) 10747 const VULKAN_HPP_NOEXCEPT 10748 { 10749 std::size_t seed = 0; 10750 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRelaxedLineRasterizationFeaturesIMG.sType ); 10751 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRelaxedLineRasterizationFeaturesIMG.pNext ); 10752 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRelaxedLineRasterizationFeaturesIMG.relaxedLineRasterization ); 10753 return seed; 10754 } 10755 }; 10756 10757 template <> 10758 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRenderPassStripedFeaturesARM> 10759 { operator ()std::hash10760 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRenderPassStripedFeaturesARM const & physicalDeviceRenderPassStripedFeaturesARM ) const 10761 VULKAN_HPP_NOEXCEPT 10762 { 10763 std::size_t seed = 0; 10764 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRenderPassStripedFeaturesARM.sType ); 10765 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRenderPassStripedFeaturesARM.pNext ); 10766 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRenderPassStripedFeaturesARM.renderPassStriped ); 10767 return seed; 10768 } 10769 }; 10770 10771 template <> 10772 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRenderPassStripedPropertiesARM> 10773 { operator ()std::hash10774 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRenderPassStripedPropertiesARM const & physicalDeviceRenderPassStripedPropertiesARM ) const 10775 VULKAN_HPP_NOEXCEPT 10776 { 10777 std::size_t seed = 0; 10778 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRenderPassStripedPropertiesARM.sType ); 10779 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRenderPassStripedPropertiesARM.pNext ); 10780 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRenderPassStripedPropertiesARM.renderPassStripeGranularity ); 10781 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRenderPassStripedPropertiesARM.maxRenderPassStripes ); 10782 return seed; 10783 } 10784 }; 10785 10786 template <> 10787 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRepresentativeFragmentTestFeaturesNV> 10788 { 10789 std::size_t operator ()std::hash10790 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRepresentativeFragmentTestFeaturesNV const & physicalDeviceRepresentativeFragmentTestFeaturesNV ) const 10791 VULKAN_HPP_NOEXCEPT 10792 { 10793 std::size_t seed = 0; 10794 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRepresentativeFragmentTestFeaturesNV.sType ); 10795 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRepresentativeFragmentTestFeaturesNV.pNext ); 10796 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRepresentativeFragmentTestFeaturesNV.representativeFragmentTest ); 10797 return seed; 10798 } 10799 }; 10800 10801 template <> 10802 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2FeaturesEXT> 10803 { operator ()std::hash10804 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2FeaturesEXT const & physicalDeviceRobustness2FeaturesEXT ) const VULKAN_HPP_NOEXCEPT 10805 { 10806 std::size_t seed = 0; 10807 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2FeaturesEXT.sType ); 10808 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2FeaturesEXT.pNext ); 10809 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2FeaturesEXT.robustBufferAccess2 ); 10810 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2FeaturesEXT.robustImageAccess2 ); 10811 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2FeaturesEXT.nullDescriptor ); 10812 return seed; 10813 } 10814 }; 10815 10816 template <> 10817 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2PropertiesEXT> 10818 { 10819 std::size_t operator ()std::hash10820 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2PropertiesEXT const & physicalDeviceRobustness2PropertiesEXT ) const VULKAN_HPP_NOEXCEPT 10821 { 10822 std::size_t seed = 0; 10823 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2PropertiesEXT.sType ); 10824 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2PropertiesEXT.pNext ); 10825 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2PropertiesEXT.robustStorageBufferAccessSizeAlignment ); 10826 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2PropertiesEXT.robustUniformBufferAccessSizeAlignment ); 10827 return seed; 10828 } 10829 }; 10830 10831 template <> 10832 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSampleLocationsPropertiesEXT> 10833 { operator ()std::hash10834 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSampleLocationsPropertiesEXT const & physicalDeviceSampleLocationsPropertiesEXT ) const 10835 VULKAN_HPP_NOEXCEPT 10836 { 10837 std::size_t seed = 0; 10838 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSampleLocationsPropertiesEXT.sType ); 10839 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSampleLocationsPropertiesEXT.pNext ); 10840 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSampleLocationsPropertiesEXT.sampleLocationSampleCounts ); 10841 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSampleLocationsPropertiesEXT.maxSampleLocationGridSize ); 10842 for ( size_t i = 0; i < 2; ++i ) 10843 { 10844 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSampleLocationsPropertiesEXT.sampleLocationCoordinateRange[i] ); 10845 } 10846 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSampleLocationsPropertiesEXT.sampleLocationSubPixelBits ); 10847 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSampleLocationsPropertiesEXT.variableSampleLocations ); 10848 return seed; 10849 } 10850 }; 10851 10852 template <> 10853 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSamplerFilterMinmaxProperties> 10854 { operator ()std::hash10855 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSamplerFilterMinmaxProperties const & physicalDeviceSamplerFilterMinmaxProperties ) const 10856 VULKAN_HPP_NOEXCEPT 10857 { 10858 std::size_t seed = 0; 10859 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSamplerFilterMinmaxProperties.sType ); 10860 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSamplerFilterMinmaxProperties.pNext ); 10861 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSamplerFilterMinmaxProperties.filterMinmaxSingleComponentFormats ); 10862 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSamplerFilterMinmaxProperties.filterMinmaxImageComponentMapping ); 10863 return seed; 10864 } 10865 }; 10866 10867 template <> 10868 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSamplerYcbcrConversionFeatures> 10869 { operator ()std::hash10870 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSamplerYcbcrConversionFeatures const & physicalDeviceSamplerYcbcrConversionFeatures ) const 10871 VULKAN_HPP_NOEXCEPT 10872 { 10873 std::size_t seed = 0; 10874 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSamplerYcbcrConversionFeatures.sType ); 10875 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSamplerYcbcrConversionFeatures.pNext ); 10876 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSamplerYcbcrConversionFeatures.samplerYcbcrConversion ); 10877 return seed; 10878 } 10879 }; 10880 10881 template <> 10882 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceScalarBlockLayoutFeatures> 10883 { 10884 std::size_t operator ()std::hash10885 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceScalarBlockLayoutFeatures const & physicalDeviceScalarBlockLayoutFeatures ) const VULKAN_HPP_NOEXCEPT 10886 { 10887 std::size_t seed = 0; 10888 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceScalarBlockLayoutFeatures.sType ); 10889 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceScalarBlockLayoutFeatures.pNext ); 10890 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceScalarBlockLayoutFeatures.scalarBlockLayout ); 10891 return seed; 10892 } 10893 }; 10894 10895 template <> 10896 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSchedulingControlsFeaturesARM> 10897 { operator ()std::hash10898 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSchedulingControlsFeaturesARM const & physicalDeviceSchedulingControlsFeaturesARM ) const 10899 VULKAN_HPP_NOEXCEPT 10900 { 10901 std::size_t seed = 0; 10902 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSchedulingControlsFeaturesARM.sType ); 10903 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSchedulingControlsFeaturesARM.pNext ); 10904 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSchedulingControlsFeaturesARM.schedulingControls ); 10905 return seed; 10906 } 10907 }; 10908 10909 template <> 10910 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSchedulingControlsPropertiesARM> 10911 { operator ()std::hash10912 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSchedulingControlsPropertiesARM const & physicalDeviceSchedulingControlsPropertiesARM ) const 10913 VULKAN_HPP_NOEXCEPT 10914 { 10915 std::size_t seed = 0; 10916 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSchedulingControlsPropertiesARM.sType ); 10917 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSchedulingControlsPropertiesARM.pNext ); 10918 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSchedulingControlsPropertiesARM.schedulingControlsFlags ); 10919 return seed; 10920 } 10921 }; 10922 10923 template <> 10924 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSeparateDepthStencilLayoutsFeatures> 10925 { operator ()std::hash10926 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSeparateDepthStencilLayoutsFeatures const & physicalDeviceSeparateDepthStencilLayoutsFeatures ) 10927 const VULKAN_HPP_NOEXCEPT 10928 { 10929 std::size_t seed = 0; 10930 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSeparateDepthStencilLayoutsFeatures.sType ); 10931 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSeparateDepthStencilLayoutsFeatures.pNext ); 10932 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSeparateDepthStencilLayoutsFeatures.separateDepthStencilLayouts ); 10933 return seed; 10934 } 10935 }; 10936 10937 template <> 10938 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloat2FeaturesEXT> 10939 { operator ()std::hash10940 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloat2FeaturesEXT const & physicalDeviceShaderAtomicFloat2FeaturesEXT ) const 10941 VULKAN_HPP_NOEXCEPT 10942 { 10943 std::size_t seed = 0; 10944 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.sType ); 10945 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.pNext ); 10946 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderBufferFloat16Atomics ); 10947 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderBufferFloat16AtomicAdd ); 10948 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderBufferFloat16AtomicMinMax ); 10949 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderBufferFloat32AtomicMinMax ); 10950 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderBufferFloat64AtomicMinMax ); 10951 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderSharedFloat16Atomics ); 10952 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderSharedFloat16AtomicAdd ); 10953 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderSharedFloat16AtomicMinMax ); 10954 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderSharedFloat32AtomicMinMax ); 10955 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderSharedFloat64AtomicMinMax ); 10956 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderImageFloat32AtomicMinMax ); 10957 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.sparseImageFloat32AtomicMinMax ); 10958 return seed; 10959 } 10960 }; 10961 10962 template <> 10963 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloatFeaturesEXT> 10964 { operator ()std::hash10965 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloatFeaturesEXT const & physicalDeviceShaderAtomicFloatFeaturesEXT ) const 10966 VULKAN_HPP_NOEXCEPT 10967 { 10968 std::size_t seed = 0; 10969 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.sType ); 10970 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.pNext ); 10971 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderBufferFloat32Atomics ); 10972 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderBufferFloat32AtomicAdd ); 10973 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderBufferFloat64Atomics ); 10974 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderBufferFloat64AtomicAdd ); 10975 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderSharedFloat32Atomics ); 10976 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderSharedFloat32AtomicAdd ); 10977 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderSharedFloat64Atomics ); 10978 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderSharedFloat64AtomicAdd ); 10979 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderImageFloat32Atomics ); 10980 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderImageFloat32AtomicAdd ); 10981 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.sparseImageFloat32Atomics ); 10982 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.sparseImageFloat32AtomicAdd ); 10983 return seed; 10984 } 10985 }; 10986 10987 template <> 10988 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicInt64Features> 10989 { 10990 std::size_t operator ()std::hash10991 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicInt64Features const & physicalDeviceShaderAtomicInt64Features ) const VULKAN_HPP_NOEXCEPT 10992 { 10993 std::size_t seed = 0; 10994 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicInt64Features.sType ); 10995 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicInt64Features.pNext ); 10996 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicInt64Features.shaderBufferInt64Atomics ); 10997 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicInt64Features.shaderSharedInt64Atomics ); 10998 return seed; 10999 } 11000 }; 11001 11002 template <> 11003 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderClockFeaturesKHR> 11004 { operator ()std::hash11005 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderClockFeaturesKHR const & physicalDeviceShaderClockFeaturesKHR ) const VULKAN_HPP_NOEXCEPT 11006 { 11007 std::size_t seed = 0; 11008 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderClockFeaturesKHR.sType ); 11009 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderClockFeaturesKHR.pNext ); 11010 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderClockFeaturesKHR.shaderSubgroupClock ); 11011 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderClockFeaturesKHR.shaderDeviceClock ); 11012 return seed; 11013 } 11014 }; 11015 11016 template <> 11017 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCoreBuiltinsFeaturesARM> 11018 { operator ()std::hash11019 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCoreBuiltinsFeaturesARM const & physicalDeviceShaderCoreBuiltinsFeaturesARM ) const 11020 VULKAN_HPP_NOEXCEPT 11021 { 11022 std::size_t seed = 0; 11023 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreBuiltinsFeaturesARM.sType ); 11024 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreBuiltinsFeaturesARM.pNext ); 11025 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreBuiltinsFeaturesARM.shaderCoreBuiltins ); 11026 return seed; 11027 } 11028 }; 11029 11030 template <> 11031 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCoreBuiltinsPropertiesARM> 11032 { operator ()std::hash11033 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCoreBuiltinsPropertiesARM const & physicalDeviceShaderCoreBuiltinsPropertiesARM ) const 11034 VULKAN_HPP_NOEXCEPT 11035 { 11036 std::size_t seed = 0; 11037 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreBuiltinsPropertiesARM.sType ); 11038 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreBuiltinsPropertiesARM.pNext ); 11039 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreBuiltinsPropertiesARM.shaderCoreMask ); 11040 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreBuiltinsPropertiesARM.shaderCoreCount ); 11041 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreBuiltinsPropertiesARM.shaderWarpsPerCore ); 11042 return seed; 11043 } 11044 }; 11045 11046 template <> 11047 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCoreProperties2AMD> 11048 { 11049 std::size_t operator ()std::hash11050 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCoreProperties2AMD const & physicalDeviceShaderCoreProperties2AMD ) const VULKAN_HPP_NOEXCEPT 11051 { 11052 std::size_t seed = 0; 11053 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreProperties2AMD.sType ); 11054 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreProperties2AMD.pNext ); 11055 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreProperties2AMD.shaderCoreFeatures ); 11056 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreProperties2AMD.activeComputeUnitCount ); 11057 return seed; 11058 } 11059 }; 11060 11061 template <> 11062 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCorePropertiesAMD> 11063 { 11064 std::size_t operator ()std::hash11065 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCorePropertiesAMD const & physicalDeviceShaderCorePropertiesAMD ) const VULKAN_HPP_NOEXCEPT 11066 { 11067 std::size_t seed = 0; 11068 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.sType ); 11069 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.pNext ); 11070 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.shaderEngineCount ); 11071 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.shaderArraysPerEngineCount ); 11072 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.computeUnitsPerShaderArray ); 11073 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.simdPerComputeUnit ); 11074 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.wavefrontsPerSimd ); 11075 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.wavefrontSize ); 11076 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.sgprsPerSimd ); 11077 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.minSgprAllocation ); 11078 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.maxSgprAllocation ); 11079 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.sgprAllocationGranularity ); 11080 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.vgprsPerSimd ); 11081 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.minVgprAllocation ); 11082 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.maxVgprAllocation ); 11083 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.vgprAllocationGranularity ); 11084 return seed; 11085 } 11086 }; 11087 11088 template <> 11089 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCorePropertiesARM> 11090 { 11091 std::size_t operator ()std::hash11092 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCorePropertiesARM const & physicalDeviceShaderCorePropertiesARM ) const VULKAN_HPP_NOEXCEPT 11093 { 11094 std::size_t seed = 0; 11095 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesARM.sType ); 11096 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesARM.pNext ); 11097 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesARM.pixelRate ); 11098 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesARM.texelRate ); 11099 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesARM.fmaRate ); 11100 return seed; 11101 } 11102 }; 11103 11104 template <> 11105 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderDemoteToHelperInvocationFeatures> 11106 { operator ()std::hash11107 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderDemoteToHelperInvocationFeatures const & 11108 physicalDeviceShaderDemoteToHelperInvocationFeatures ) const VULKAN_HPP_NOEXCEPT 11109 { 11110 std::size_t seed = 0; 11111 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderDemoteToHelperInvocationFeatures.sType ); 11112 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderDemoteToHelperInvocationFeatures.pNext ); 11113 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderDemoteToHelperInvocationFeatures.shaderDemoteToHelperInvocation ); 11114 return seed; 11115 } 11116 }; 11117 11118 template <> 11119 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderDrawParametersFeatures> 11120 { operator ()std::hash11121 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderDrawParametersFeatures const & physicalDeviceShaderDrawParametersFeatures ) const 11122 VULKAN_HPP_NOEXCEPT 11123 { 11124 std::size_t seed = 0; 11125 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderDrawParametersFeatures.sType ); 11126 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderDrawParametersFeatures.pNext ); 11127 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderDrawParametersFeatures.shaderDrawParameters ); 11128 return seed; 11129 } 11130 }; 11131 11132 template <> 11133 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD> 11134 { operator ()std::hash11135 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD const & 11136 physicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD ) const VULKAN_HPP_NOEXCEPT 11137 { 11138 std::size_t seed = 0; 11139 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD.sType ); 11140 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD.pNext ); 11141 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD.shaderEarlyAndLateFragmentTests ); 11142 return seed; 11143 } 11144 }; 11145 11146 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 11147 template <> 11148 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderEnqueueFeaturesAMDX> 11149 { 11150 std::size_t operator ()std::hash11151 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderEnqueueFeaturesAMDX const & physicalDeviceShaderEnqueueFeaturesAMDX ) const VULKAN_HPP_NOEXCEPT 11152 { 11153 std::size_t seed = 0; 11154 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueueFeaturesAMDX.sType ); 11155 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueueFeaturesAMDX.pNext ); 11156 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueueFeaturesAMDX.shaderEnqueue ); 11157 return seed; 11158 } 11159 }; 11160 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 11161 11162 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 11163 template <> 11164 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderEnqueuePropertiesAMDX> 11165 { 11166 std::size_t operator ()std::hash11167 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderEnqueuePropertiesAMDX const & physicalDeviceShaderEnqueuePropertiesAMDX ) const VULKAN_HPP_NOEXCEPT 11168 { 11169 std::size_t seed = 0; 11170 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueuePropertiesAMDX.sType ); 11171 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueuePropertiesAMDX.pNext ); 11172 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueuePropertiesAMDX.maxExecutionGraphDepth ); 11173 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueuePropertiesAMDX.maxExecutionGraphShaderOutputNodes ); 11174 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueuePropertiesAMDX.maxExecutionGraphShaderPayloadSize ); 11175 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueuePropertiesAMDX.maxExecutionGraphShaderPayloadCount ); 11176 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueuePropertiesAMDX.executionGraphDispatchAddressAlignment ); 11177 return seed; 11178 } 11179 }; 11180 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 11181 11182 template <> 11183 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFloat16Int8Features> 11184 { 11185 std::size_t operator ()std::hash11186 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFloat16Int8Features const & physicalDeviceShaderFloat16Int8Features ) const VULKAN_HPP_NOEXCEPT 11187 { 11188 std::size_t seed = 0; 11189 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFloat16Int8Features.sType ); 11190 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFloat16Int8Features.pNext ); 11191 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFloat16Int8Features.shaderFloat16 ); 11192 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFloat16Int8Features.shaderInt8 ); 11193 return seed; 11194 } 11195 }; 11196 11197 template <> 11198 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderImageAtomicInt64FeaturesEXT> 11199 { operator ()std::hash11200 std::size_t operator()( 11201 VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderImageAtomicInt64FeaturesEXT const & physicalDeviceShaderImageAtomicInt64FeaturesEXT ) const VULKAN_HPP_NOEXCEPT 11202 { 11203 std::size_t seed = 0; 11204 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderImageAtomicInt64FeaturesEXT.sType ); 11205 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderImageAtomicInt64FeaturesEXT.pNext ); 11206 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderImageAtomicInt64FeaturesEXT.shaderImageInt64Atomics ); 11207 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderImageAtomicInt64FeaturesEXT.sparseImageInt64Atomics ); 11208 return seed; 11209 } 11210 }; 11211 11212 template <> 11213 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderImageFootprintFeaturesNV> 11214 { operator ()std::hash11215 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderImageFootprintFeaturesNV const & physicalDeviceShaderImageFootprintFeaturesNV ) const 11216 VULKAN_HPP_NOEXCEPT 11217 { 11218 std::size_t seed = 0; 11219 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderImageFootprintFeaturesNV.sType ); 11220 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderImageFootprintFeaturesNV.pNext ); 11221 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderImageFootprintFeaturesNV.imageFootprint ); 11222 return seed; 11223 } 11224 }; 11225 11226 template <> 11227 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerDotProductFeatures> 11228 { operator ()std::hash11229 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerDotProductFeatures const & physicalDeviceShaderIntegerDotProductFeatures ) const 11230 VULKAN_HPP_NOEXCEPT 11231 { 11232 std::size_t seed = 0; 11233 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductFeatures.sType ); 11234 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductFeatures.pNext ); 11235 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductFeatures.shaderIntegerDotProduct ); 11236 return seed; 11237 } 11238 }; 11239 11240 template <> 11241 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerDotProductProperties> 11242 { operator ()std::hash11243 std::size_t operator()( 11244 VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerDotProductProperties const & physicalDeviceShaderIntegerDotProductProperties ) const VULKAN_HPP_NOEXCEPT 11245 { 11246 std::size_t seed = 0; 11247 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.sType ); 11248 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.pNext ); 11249 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct8BitUnsignedAccelerated ); 11250 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct8BitSignedAccelerated ); 11251 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct8BitMixedSignednessAccelerated ); 11252 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct4x8BitPackedUnsignedAccelerated ); 11253 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct4x8BitPackedSignedAccelerated ); 11254 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct4x8BitPackedMixedSignednessAccelerated ); 11255 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct16BitUnsignedAccelerated ); 11256 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct16BitSignedAccelerated ); 11257 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct16BitMixedSignednessAccelerated ); 11258 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct32BitUnsignedAccelerated ); 11259 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct32BitSignedAccelerated ); 11260 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct32BitMixedSignednessAccelerated ); 11261 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct64BitUnsignedAccelerated ); 11262 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct64BitSignedAccelerated ); 11263 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct64BitMixedSignednessAccelerated ); 11264 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating8BitUnsignedAccelerated ); 11265 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating8BitSignedAccelerated ); 11266 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated ); 11267 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated ); 11268 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated ); 11269 VULKAN_HPP_HASH_COMBINE( seed, 11270 physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated ); 11271 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating16BitUnsignedAccelerated ); 11272 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating16BitSignedAccelerated ); 11273 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated ); 11274 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating32BitUnsignedAccelerated ); 11275 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating32BitSignedAccelerated ); 11276 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated ); 11277 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating64BitUnsignedAccelerated ); 11278 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating64BitSignedAccelerated ); 11279 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated ); 11280 return seed; 11281 } 11282 }; 11283 11284 template <> 11285 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL> 11286 { 11287 std::size_t operator ()std::hash11288 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const & physicalDeviceShaderIntegerFunctions2FeaturesINTEL ) const 11289 VULKAN_HPP_NOEXCEPT 11290 { 11291 std::size_t seed = 0; 11292 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerFunctions2FeaturesINTEL.sType ); 11293 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerFunctions2FeaturesINTEL.pNext ); 11294 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerFunctions2FeaturesINTEL.shaderIntegerFunctions2 ); 11295 return seed; 11296 } 11297 }; 11298 11299 template <> 11300 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderModuleIdentifierFeaturesEXT> 11301 { operator ()std::hash11302 std::size_t operator()( 11303 VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderModuleIdentifierFeaturesEXT const & physicalDeviceShaderModuleIdentifierFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 11304 { 11305 std::size_t seed = 0; 11306 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderModuleIdentifierFeaturesEXT.sType ); 11307 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderModuleIdentifierFeaturesEXT.pNext ); 11308 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderModuleIdentifierFeaturesEXT.shaderModuleIdentifier ); 11309 return seed; 11310 } 11311 }; 11312 11313 template <> 11314 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderModuleIdentifierPropertiesEXT> 11315 { operator ()std::hash11316 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderModuleIdentifierPropertiesEXT const & physicalDeviceShaderModuleIdentifierPropertiesEXT ) 11317 const VULKAN_HPP_NOEXCEPT 11318 { 11319 std::size_t seed = 0; 11320 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderModuleIdentifierPropertiesEXT.sType ); 11321 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderModuleIdentifierPropertiesEXT.pNext ); 11322 for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) 11323 { 11324 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderModuleIdentifierPropertiesEXT.shaderModuleIdentifierAlgorithmUUID[i] ); 11325 } 11326 return seed; 11327 } 11328 }; 11329 11330 template <> 11331 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderObjectFeaturesEXT> 11332 { 11333 std::size_t operator ()std::hash11334 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderObjectFeaturesEXT const & physicalDeviceShaderObjectFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 11335 { 11336 std::size_t seed = 0; 11337 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderObjectFeaturesEXT.sType ); 11338 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderObjectFeaturesEXT.pNext ); 11339 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderObjectFeaturesEXT.shaderObject ); 11340 return seed; 11341 } 11342 }; 11343 11344 template <> 11345 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderObjectPropertiesEXT> 11346 { 11347 std::size_t operator ()std::hash11348 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderObjectPropertiesEXT const & physicalDeviceShaderObjectPropertiesEXT ) const VULKAN_HPP_NOEXCEPT 11349 { 11350 std::size_t seed = 0; 11351 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderObjectPropertiesEXT.sType ); 11352 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderObjectPropertiesEXT.pNext ); 11353 for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) 11354 { 11355 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderObjectPropertiesEXT.shaderBinaryUUID[i] ); 11356 } 11357 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderObjectPropertiesEXT.shaderBinaryVersion ); 11358 return seed; 11359 } 11360 }; 11361 11362 template <> 11363 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSMBuiltinsFeaturesNV> 11364 { 11365 std::size_t operator ()std::hash11366 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSMBuiltinsFeaturesNV const & physicalDeviceShaderSMBuiltinsFeaturesNV ) const VULKAN_HPP_NOEXCEPT 11367 { 11368 std::size_t seed = 0; 11369 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSMBuiltinsFeaturesNV.sType ); 11370 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSMBuiltinsFeaturesNV.pNext ); 11371 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSMBuiltinsFeaturesNV.shaderSMBuiltins ); 11372 return seed; 11373 } 11374 }; 11375 11376 template <> 11377 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSMBuiltinsPropertiesNV> 11378 { operator ()std::hash11379 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSMBuiltinsPropertiesNV const & physicalDeviceShaderSMBuiltinsPropertiesNV ) const 11380 VULKAN_HPP_NOEXCEPT 11381 { 11382 std::size_t seed = 0; 11383 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSMBuiltinsPropertiesNV.sType ); 11384 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSMBuiltinsPropertiesNV.pNext ); 11385 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSMBuiltinsPropertiesNV.shaderSMCount ); 11386 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSMBuiltinsPropertiesNV.shaderWarpsPerSM ); 11387 return seed; 11388 } 11389 }; 11390 11391 template <> 11392 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupExtendedTypesFeatures> 11393 { operator ()std::hash11394 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupExtendedTypesFeatures const & physicalDeviceShaderSubgroupExtendedTypesFeatures ) 11395 const VULKAN_HPP_NOEXCEPT 11396 { 11397 std::size_t seed = 0; 11398 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupExtendedTypesFeatures.sType ); 11399 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupExtendedTypesFeatures.pNext ); 11400 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupExtendedTypesFeatures.shaderSubgroupExtendedTypes ); 11401 return seed; 11402 } 11403 }; 11404 11405 template <> 11406 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR> 11407 { operator ()std::hash11408 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR const & 11409 physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR ) const VULKAN_HPP_NOEXCEPT 11410 { 11411 std::size_t seed = 0; 11412 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR.sType ); 11413 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR.pNext ); 11414 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR.shaderSubgroupUniformControlFlow ); 11415 return seed; 11416 } 11417 }; 11418 11419 template <> 11420 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderTerminateInvocationFeatures> 11421 { operator ()std::hash11422 std::size_t operator()( 11423 VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderTerminateInvocationFeatures const & physicalDeviceShaderTerminateInvocationFeatures ) const VULKAN_HPP_NOEXCEPT 11424 { 11425 std::size_t seed = 0; 11426 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTerminateInvocationFeatures.sType ); 11427 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTerminateInvocationFeatures.pNext ); 11428 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTerminateInvocationFeatures.shaderTerminateInvocation ); 11429 return seed; 11430 } 11431 }; 11432 11433 template <> 11434 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderTileImageFeaturesEXT> 11435 { 11436 std::size_t operator ()std::hash11437 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderTileImageFeaturesEXT const & physicalDeviceShaderTileImageFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 11438 { 11439 std::size_t seed = 0; 11440 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImageFeaturesEXT.sType ); 11441 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImageFeaturesEXT.pNext ); 11442 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImageFeaturesEXT.shaderTileImageColorReadAccess ); 11443 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImageFeaturesEXT.shaderTileImageDepthReadAccess ); 11444 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImageFeaturesEXT.shaderTileImageStencilReadAccess ); 11445 return seed; 11446 } 11447 }; 11448 11449 template <> 11450 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderTileImagePropertiesEXT> 11451 { operator ()std::hash11452 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderTileImagePropertiesEXT const & physicalDeviceShaderTileImagePropertiesEXT ) const 11453 VULKAN_HPP_NOEXCEPT 11454 { 11455 std::size_t seed = 0; 11456 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImagePropertiesEXT.sType ); 11457 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImagePropertiesEXT.pNext ); 11458 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImagePropertiesEXT.shaderTileImageCoherentReadAccelerated ); 11459 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImagePropertiesEXT.shaderTileImageReadSampleFromPixelRateInvocation ); 11460 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImagePropertiesEXT.shaderTileImageReadFromHelperInvocation ); 11461 return seed; 11462 } 11463 }; 11464 11465 template <> 11466 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShadingRateImageFeaturesNV> 11467 { 11468 std::size_t operator ()std::hash11469 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShadingRateImageFeaturesNV const & physicalDeviceShadingRateImageFeaturesNV ) const VULKAN_HPP_NOEXCEPT 11470 { 11471 std::size_t seed = 0; 11472 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShadingRateImageFeaturesNV.sType ); 11473 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShadingRateImageFeaturesNV.pNext ); 11474 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShadingRateImageFeaturesNV.shadingRateImage ); 11475 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShadingRateImageFeaturesNV.shadingRateCoarseSampleOrder ); 11476 return seed; 11477 } 11478 }; 11479 11480 template <> 11481 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShadingRateImagePropertiesNV> 11482 { operator ()std::hash11483 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShadingRateImagePropertiesNV const & physicalDeviceShadingRateImagePropertiesNV ) const 11484 VULKAN_HPP_NOEXCEPT 11485 { 11486 std::size_t seed = 0; 11487 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShadingRateImagePropertiesNV.sType ); 11488 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShadingRateImagePropertiesNV.pNext ); 11489 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShadingRateImagePropertiesNV.shadingRateTexelSize ); 11490 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShadingRateImagePropertiesNV.shadingRatePaletteSize ); 11491 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShadingRateImagePropertiesNV.shadingRateMaxCoarseSamples ); 11492 return seed; 11493 } 11494 }; 11495 11496 template <> 11497 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2> 11498 { operator ()std::hash11499 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 const & physicalDeviceSparseImageFormatInfo2 ) const VULKAN_HPP_NOEXCEPT 11500 { 11501 std::size_t seed = 0; 11502 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseImageFormatInfo2.sType ); 11503 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseImageFormatInfo2.pNext ); 11504 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseImageFormatInfo2.format ); 11505 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseImageFormatInfo2.type ); 11506 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseImageFormatInfo2.samples ); 11507 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseImageFormatInfo2.usage ); 11508 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseImageFormatInfo2.tiling ); 11509 return seed; 11510 } 11511 }; 11512 11513 template <> 11514 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupProperties> 11515 { operator ()std::hash11516 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupProperties const & physicalDeviceSubgroupProperties ) const VULKAN_HPP_NOEXCEPT 11517 { 11518 std::size_t seed = 0; 11519 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupProperties.sType ); 11520 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupProperties.pNext ); 11521 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupProperties.subgroupSize ); 11522 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupProperties.supportedStages ); 11523 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupProperties.supportedOperations ); 11524 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupProperties.quadOperationsInAllStages ); 11525 return seed; 11526 } 11527 }; 11528 11529 template <> 11530 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupSizeControlFeatures> 11531 { 11532 std::size_t operator ()std::hash11533 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupSizeControlFeatures const & physicalDeviceSubgroupSizeControlFeatures ) const VULKAN_HPP_NOEXCEPT 11534 { 11535 std::size_t seed = 0; 11536 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlFeatures.sType ); 11537 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlFeatures.pNext ); 11538 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlFeatures.subgroupSizeControl ); 11539 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlFeatures.computeFullSubgroups ); 11540 return seed; 11541 } 11542 }; 11543 11544 template <> 11545 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupSizeControlProperties> 11546 { operator ()std::hash11547 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupSizeControlProperties const & physicalDeviceSubgroupSizeControlProperties ) const 11548 VULKAN_HPP_NOEXCEPT 11549 { 11550 std::size_t seed = 0; 11551 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlProperties.sType ); 11552 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlProperties.pNext ); 11553 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlProperties.minSubgroupSize ); 11554 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlProperties.maxSubgroupSize ); 11555 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlProperties.maxComputeWorkgroupSubgroups ); 11556 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlProperties.requiredSubgroupSizeStages ); 11557 return seed; 11558 } 11559 }; 11560 11561 template <> 11562 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassMergeFeedbackFeaturesEXT> 11563 { operator ()std::hash11564 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassMergeFeedbackFeaturesEXT const & physicalDeviceSubpassMergeFeedbackFeaturesEXT ) const 11565 VULKAN_HPP_NOEXCEPT 11566 { 11567 std::size_t seed = 0; 11568 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubpassMergeFeedbackFeaturesEXT.sType ); 11569 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubpassMergeFeedbackFeaturesEXT.pNext ); 11570 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubpassMergeFeedbackFeaturesEXT.subpassMergeFeedback ); 11571 return seed; 11572 } 11573 }; 11574 11575 template <> 11576 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassShadingFeaturesHUAWEI> 11577 { operator ()std::hash11578 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassShadingFeaturesHUAWEI const & physicalDeviceSubpassShadingFeaturesHUAWEI ) const 11579 VULKAN_HPP_NOEXCEPT 11580 { 11581 std::size_t seed = 0; 11582 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubpassShadingFeaturesHUAWEI.sType ); 11583 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubpassShadingFeaturesHUAWEI.pNext ); 11584 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubpassShadingFeaturesHUAWEI.subpassShading ); 11585 return seed; 11586 } 11587 }; 11588 11589 template <> 11590 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassShadingPropertiesHUAWEI> 11591 { operator ()std::hash11592 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassShadingPropertiesHUAWEI const & physicalDeviceSubpassShadingPropertiesHUAWEI ) const 11593 VULKAN_HPP_NOEXCEPT 11594 { 11595 std::size_t seed = 0; 11596 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubpassShadingPropertiesHUAWEI.sType ); 11597 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubpassShadingPropertiesHUAWEI.pNext ); 11598 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubpassShadingPropertiesHUAWEI.maxSubpassShadingWorkgroupSizeAspectRatio ); 11599 return seed; 11600 } 11601 }; 11602 11603 template <> 11604 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR> 11605 { operator ()std::hash11606 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR const & physicalDeviceSurfaceInfo2KHR ) const VULKAN_HPP_NOEXCEPT 11607 { 11608 std::size_t seed = 0; 11609 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSurfaceInfo2KHR.sType ); 11610 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSurfaceInfo2KHR.pNext ); 11611 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSurfaceInfo2KHR.surface ); 11612 return seed; 11613 } 11614 }; 11615 11616 template <> 11617 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSwapchainMaintenance1FeaturesEXT> 11618 { operator ()std::hash11619 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSwapchainMaintenance1FeaturesEXT const & physicalDeviceSwapchainMaintenance1FeaturesEXT ) const 11620 VULKAN_HPP_NOEXCEPT 11621 { 11622 std::size_t seed = 0; 11623 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSwapchainMaintenance1FeaturesEXT.sType ); 11624 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSwapchainMaintenance1FeaturesEXT.pNext ); 11625 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSwapchainMaintenance1FeaturesEXT.swapchainMaintenance1 ); 11626 return seed; 11627 } 11628 }; 11629 11630 template <> 11631 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSynchronization2Features> 11632 { 11633 std::size_t operator ()std::hash11634 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSynchronization2Features const & physicalDeviceSynchronization2Features ) const VULKAN_HPP_NOEXCEPT 11635 { 11636 std::size_t seed = 0; 11637 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSynchronization2Features.sType ); 11638 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSynchronization2Features.pNext ); 11639 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSynchronization2Features.synchronization2 ); 11640 return seed; 11641 } 11642 }; 11643 11644 template <> 11645 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTexelBufferAlignmentFeaturesEXT> 11646 { operator ()std::hash11647 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTexelBufferAlignmentFeaturesEXT const & physicalDeviceTexelBufferAlignmentFeaturesEXT ) const 11648 VULKAN_HPP_NOEXCEPT 11649 { 11650 std::size_t seed = 0; 11651 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTexelBufferAlignmentFeaturesEXT.sType ); 11652 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTexelBufferAlignmentFeaturesEXT.pNext ); 11653 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTexelBufferAlignmentFeaturesEXT.texelBufferAlignment ); 11654 return seed; 11655 } 11656 }; 11657 11658 template <> 11659 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTexelBufferAlignmentProperties> 11660 { operator ()std::hash11661 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTexelBufferAlignmentProperties const & physicalDeviceTexelBufferAlignmentProperties ) const 11662 VULKAN_HPP_NOEXCEPT 11663 { 11664 std::size_t seed = 0; 11665 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTexelBufferAlignmentProperties.sType ); 11666 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTexelBufferAlignmentProperties.pNext ); 11667 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTexelBufferAlignmentProperties.storageTexelBufferOffsetAlignmentBytes ); 11668 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTexelBufferAlignmentProperties.storageTexelBufferOffsetSingleTexelAlignment ); 11669 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTexelBufferAlignmentProperties.uniformTexelBufferOffsetAlignmentBytes ); 11670 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTexelBufferAlignmentProperties.uniformTexelBufferOffsetSingleTexelAlignment ); 11671 return seed; 11672 } 11673 }; 11674 11675 template <> 11676 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTextureCompressionASTCHDRFeatures> 11677 { operator ()std::hash11678 std::size_t operator()( 11679 VULKAN_HPP_NAMESPACE::PhysicalDeviceTextureCompressionASTCHDRFeatures const & physicalDeviceTextureCompressionASTCHDRFeatures ) const VULKAN_HPP_NOEXCEPT 11680 { 11681 std::size_t seed = 0; 11682 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTextureCompressionASTCHDRFeatures.sType ); 11683 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTextureCompressionASTCHDRFeatures.pNext ); 11684 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTextureCompressionASTCHDRFeatures.textureCompressionASTC_HDR ); 11685 return seed; 11686 } 11687 }; 11688 11689 template <> 11690 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTilePropertiesFeaturesQCOM> 11691 { 11692 std::size_t operator ()std::hash11693 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTilePropertiesFeaturesQCOM const & physicalDeviceTilePropertiesFeaturesQCOM ) const VULKAN_HPP_NOEXCEPT 11694 { 11695 std::size_t seed = 0; 11696 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTilePropertiesFeaturesQCOM.sType ); 11697 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTilePropertiesFeaturesQCOM.pNext ); 11698 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTilePropertiesFeaturesQCOM.tileProperties ); 11699 return seed; 11700 } 11701 }; 11702 11703 template <> 11704 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTimelineSemaphoreFeatures> 11705 { 11706 std::size_t operator ()std::hash11707 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTimelineSemaphoreFeatures const & physicalDeviceTimelineSemaphoreFeatures ) const VULKAN_HPP_NOEXCEPT 11708 { 11709 std::size_t seed = 0; 11710 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTimelineSemaphoreFeatures.sType ); 11711 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTimelineSemaphoreFeatures.pNext ); 11712 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTimelineSemaphoreFeatures.timelineSemaphore ); 11713 return seed; 11714 } 11715 }; 11716 11717 template <> 11718 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTimelineSemaphoreProperties> 11719 { 11720 std::size_t operator ()std::hash11721 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTimelineSemaphoreProperties const & physicalDeviceTimelineSemaphoreProperties ) const VULKAN_HPP_NOEXCEPT 11722 { 11723 std::size_t seed = 0; 11724 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTimelineSemaphoreProperties.sType ); 11725 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTimelineSemaphoreProperties.pNext ); 11726 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTimelineSemaphoreProperties.maxTimelineSemaphoreValueDifference ); 11727 return seed; 11728 } 11729 }; 11730 11731 template <> 11732 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties> 11733 { operator ()std::hash11734 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties const & physicalDeviceToolProperties ) const VULKAN_HPP_NOEXCEPT 11735 { 11736 std::size_t seed = 0; 11737 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceToolProperties.sType ); 11738 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceToolProperties.pNext ); 11739 for ( size_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i ) 11740 { 11741 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceToolProperties.name[i] ); 11742 } 11743 for ( size_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i ) 11744 { 11745 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceToolProperties.version[i] ); 11746 } 11747 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceToolProperties.purposes ); 11748 for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) 11749 { 11750 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceToolProperties.description[i] ); 11751 } 11752 for ( size_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i ) 11753 { 11754 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceToolProperties.layer[i] ); 11755 } 11756 return seed; 11757 } 11758 }; 11759 11760 template <> 11761 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTransformFeedbackFeaturesEXT> 11762 { operator ()std::hash11763 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTransformFeedbackFeaturesEXT const & physicalDeviceTransformFeedbackFeaturesEXT ) const 11764 VULKAN_HPP_NOEXCEPT 11765 { 11766 std::size_t seed = 0; 11767 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackFeaturesEXT.sType ); 11768 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackFeaturesEXT.pNext ); 11769 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackFeaturesEXT.transformFeedback ); 11770 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackFeaturesEXT.geometryStreams ); 11771 return seed; 11772 } 11773 }; 11774 11775 template <> 11776 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTransformFeedbackPropertiesEXT> 11777 { operator ()std::hash11778 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTransformFeedbackPropertiesEXT const & physicalDeviceTransformFeedbackPropertiesEXT ) const 11779 VULKAN_HPP_NOEXCEPT 11780 { 11781 std::size_t seed = 0; 11782 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.sType ); 11783 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.pNext ); 11784 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackStreams ); 11785 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackBuffers ); 11786 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackBufferSize ); 11787 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackStreamDataSize ); 11788 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackBufferDataSize ); 11789 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackBufferDataStride ); 11790 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.transformFeedbackQueries ); 11791 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.transformFeedbackStreamsLinesTriangles ); 11792 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.transformFeedbackRasterizationStreamSelect ); 11793 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.transformFeedbackDraw ); 11794 return seed; 11795 } 11796 }; 11797 11798 template <> 11799 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceUniformBufferStandardLayoutFeatures> 11800 { operator ()std::hash11801 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceUniformBufferStandardLayoutFeatures const & physicalDeviceUniformBufferStandardLayoutFeatures ) 11802 const VULKAN_HPP_NOEXCEPT 11803 { 11804 std::size_t seed = 0; 11805 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceUniformBufferStandardLayoutFeatures.sType ); 11806 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceUniformBufferStandardLayoutFeatures.pNext ); 11807 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceUniformBufferStandardLayoutFeatures.uniformBufferStandardLayout ); 11808 return seed; 11809 } 11810 }; 11811 11812 template <> 11813 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVariablePointersFeatures> 11814 { 11815 std::size_t operator ()std::hash11816 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVariablePointersFeatures const & physicalDeviceVariablePointersFeatures ) const VULKAN_HPP_NOEXCEPT 11817 { 11818 std::size_t seed = 0; 11819 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVariablePointersFeatures.sType ); 11820 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVariablePointersFeatures.pNext ); 11821 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVariablePointersFeatures.variablePointersStorageBuffer ); 11822 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVariablePointersFeatures.variablePointers ); 11823 return seed; 11824 } 11825 }; 11826 11827 template <> 11828 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorFeaturesKHR> 11829 { operator ()std::hash11830 std::size_t operator()( 11831 VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorFeaturesKHR const & physicalDeviceVertexAttributeDivisorFeaturesKHR ) const VULKAN_HPP_NOEXCEPT 11832 { 11833 std::size_t seed = 0; 11834 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorFeaturesKHR.sType ); 11835 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorFeaturesKHR.pNext ); 11836 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorFeaturesKHR.vertexAttributeInstanceRateDivisor ); 11837 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorFeaturesKHR.vertexAttributeInstanceRateZeroDivisor ); 11838 return seed; 11839 } 11840 }; 11841 11842 template <> 11843 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorPropertiesEXT> 11844 { operator ()std::hash11845 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorPropertiesEXT const & physicalDeviceVertexAttributeDivisorPropertiesEXT ) 11846 const VULKAN_HPP_NOEXCEPT 11847 { 11848 std::size_t seed = 0; 11849 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorPropertiesEXT.sType ); 11850 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorPropertiesEXT.pNext ); 11851 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorPropertiesEXT.maxVertexAttribDivisor ); 11852 return seed; 11853 } 11854 }; 11855 11856 template <> 11857 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorPropertiesKHR> 11858 { operator ()std::hash11859 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorPropertiesKHR const & physicalDeviceVertexAttributeDivisorPropertiesKHR ) 11860 const VULKAN_HPP_NOEXCEPT 11861 { 11862 std::size_t seed = 0; 11863 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorPropertiesKHR.sType ); 11864 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorPropertiesKHR.pNext ); 11865 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorPropertiesKHR.maxVertexAttribDivisor ); 11866 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorPropertiesKHR.supportsNonZeroFirstInstance ); 11867 return seed; 11868 } 11869 }; 11870 11871 template <> 11872 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexInputDynamicStateFeaturesEXT> 11873 { operator ()std::hash11874 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexInputDynamicStateFeaturesEXT const & physicalDeviceVertexInputDynamicStateFeaturesEXT ) 11875 const VULKAN_HPP_NOEXCEPT 11876 { 11877 std::size_t seed = 0; 11878 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexInputDynamicStateFeaturesEXT.sType ); 11879 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexInputDynamicStateFeaturesEXT.pNext ); 11880 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexInputDynamicStateFeaturesEXT.vertexInputDynamicState ); 11881 return seed; 11882 } 11883 }; 11884 11885 template <> 11886 struct hash<VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR> 11887 { operator ()std::hash11888 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR const & videoProfileInfoKHR ) const VULKAN_HPP_NOEXCEPT 11889 { 11890 std::size_t seed = 0; 11891 VULKAN_HPP_HASH_COMBINE( seed, videoProfileInfoKHR.sType ); 11892 VULKAN_HPP_HASH_COMBINE( seed, videoProfileInfoKHR.pNext ); 11893 VULKAN_HPP_HASH_COMBINE( seed, videoProfileInfoKHR.videoCodecOperation ); 11894 VULKAN_HPP_HASH_COMBINE( seed, videoProfileInfoKHR.chromaSubsampling ); 11895 VULKAN_HPP_HASH_COMBINE( seed, videoProfileInfoKHR.lumaBitDepth ); 11896 VULKAN_HPP_HASH_COMBINE( seed, videoProfileInfoKHR.chromaBitDepth ); 11897 return seed; 11898 } 11899 }; 11900 11901 template <> 11902 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeQualityLevelInfoKHR> 11903 { operator ()std::hash11904 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeQualityLevelInfoKHR const & physicalDeviceVideoEncodeQualityLevelInfoKHR ) const 11905 VULKAN_HPP_NOEXCEPT 11906 { 11907 std::size_t seed = 0; 11908 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoEncodeQualityLevelInfoKHR.sType ); 11909 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoEncodeQualityLevelInfoKHR.pNext ); 11910 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoEncodeQualityLevelInfoKHR.pVideoProfile ); 11911 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoEncodeQualityLevelInfoKHR.qualityLevel ); 11912 return seed; 11913 } 11914 }; 11915 11916 template <> 11917 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR> 11918 { operator ()std::hash11919 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR const & physicalDeviceVideoFormatInfoKHR ) const VULKAN_HPP_NOEXCEPT 11920 { 11921 std::size_t seed = 0; 11922 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoFormatInfoKHR.sType ); 11923 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoFormatInfoKHR.pNext ); 11924 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoFormatInfoKHR.imageUsage ); 11925 return seed; 11926 } 11927 }; 11928 11929 template <> 11930 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoMaintenance1FeaturesKHR> 11931 { operator ()std::hash11932 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoMaintenance1FeaturesKHR const & physicalDeviceVideoMaintenance1FeaturesKHR ) const 11933 VULKAN_HPP_NOEXCEPT 11934 { 11935 std::size_t seed = 0; 11936 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoMaintenance1FeaturesKHR.sType ); 11937 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoMaintenance1FeaturesKHR.pNext ); 11938 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoMaintenance1FeaturesKHR.videoMaintenance1 ); 11939 return seed; 11940 } 11941 }; 11942 11943 template <> 11944 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan11Features> 11945 { operator ()std::hash11946 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan11Features const & physicalDeviceVulkan11Features ) const VULKAN_HPP_NOEXCEPT 11947 { 11948 std::size_t seed = 0; 11949 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.sType ); 11950 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.pNext ); 11951 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.storageBuffer16BitAccess ); 11952 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.uniformAndStorageBuffer16BitAccess ); 11953 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.storagePushConstant16 ); 11954 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.storageInputOutput16 ); 11955 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.multiview ); 11956 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.multiviewGeometryShader ); 11957 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.multiviewTessellationShader ); 11958 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.variablePointersStorageBuffer ); 11959 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.variablePointers ); 11960 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.protectedMemory ); 11961 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.samplerYcbcrConversion ); 11962 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.shaderDrawParameters ); 11963 return seed; 11964 } 11965 }; 11966 11967 template <> 11968 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan11Properties> 11969 { operator ()std::hash11970 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan11Properties const & physicalDeviceVulkan11Properties ) const VULKAN_HPP_NOEXCEPT 11971 { 11972 std::size_t seed = 0; 11973 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.sType ); 11974 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.pNext ); 11975 for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) 11976 { 11977 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.deviceUUID[i] ); 11978 } 11979 for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) 11980 { 11981 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.driverUUID[i] ); 11982 } 11983 for ( size_t i = 0; i < VK_LUID_SIZE; ++i ) 11984 { 11985 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.deviceLUID[i] ); 11986 } 11987 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.deviceNodeMask ); 11988 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.deviceLUIDValid ); 11989 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.subgroupSize ); 11990 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.subgroupSupportedStages ); 11991 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.subgroupSupportedOperations ); 11992 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.subgroupQuadOperationsInAllStages ); 11993 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.pointClippingBehavior ); 11994 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.maxMultiviewViewCount ); 11995 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.maxMultiviewInstanceIndex ); 11996 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.protectedNoFault ); 11997 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.maxPerSetDescriptors ); 11998 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.maxMemoryAllocationSize ); 11999 return seed; 12000 } 12001 }; 12002 12003 template <> 12004 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan12Features> 12005 { operator ()std::hash12006 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan12Features const & physicalDeviceVulkan12Features ) const VULKAN_HPP_NOEXCEPT 12007 { 12008 std::size_t seed = 0; 12009 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.sType ); 12010 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.pNext ); 12011 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.samplerMirrorClampToEdge ); 12012 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.drawIndirectCount ); 12013 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.storageBuffer8BitAccess ); 12014 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.uniformAndStorageBuffer8BitAccess ); 12015 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.storagePushConstant8 ); 12016 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderBufferInt64Atomics ); 12017 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderSharedInt64Atomics ); 12018 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderFloat16 ); 12019 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderInt8 ); 12020 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorIndexing ); 12021 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderInputAttachmentArrayDynamicIndexing ); 12022 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderUniformTexelBufferArrayDynamicIndexing ); 12023 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderStorageTexelBufferArrayDynamicIndexing ); 12024 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderUniformBufferArrayNonUniformIndexing ); 12025 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderSampledImageArrayNonUniformIndexing ); 12026 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderStorageBufferArrayNonUniformIndexing ); 12027 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderStorageImageArrayNonUniformIndexing ); 12028 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderInputAttachmentArrayNonUniformIndexing ); 12029 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderUniformTexelBufferArrayNonUniformIndexing ); 12030 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderStorageTexelBufferArrayNonUniformIndexing ); 12031 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorBindingUniformBufferUpdateAfterBind ); 12032 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorBindingSampledImageUpdateAfterBind ); 12033 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorBindingStorageImageUpdateAfterBind ); 12034 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorBindingStorageBufferUpdateAfterBind ); 12035 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorBindingUniformTexelBufferUpdateAfterBind ); 12036 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorBindingStorageTexelBufferUpdateAfterBind ); 12037 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorBindingUpdateUnusedWhilePending ); 12038 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorBindingPartiallyBound ); 12039 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorBindingVariableDescriptorCount ); 12040 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.runtimeDescriptorArray ); 12041 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.samplerFilterMinmax ); 12042 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.scalarBlockLayout ); 12043 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.imagelessFramebuffer ); 12044 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.uniformBufferStandardLayout ); 12045 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderSubgroupExtendedTypes ); 12046 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.separateDepthStencilLayouts ); 12047 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.hostQueryReset ); 12048 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.timelineSemaphore ); 12049 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.bufferDeviceAddress ); 12050 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.bufferDeviceAddressCaptureReplay ); 12051 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.bufferDeviceAddressMultiDevice ); 12052 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.vulkanMemoryModel ); 12053 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.vulkanMemoryModelDeviceScope ); 12054 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.vulkanMemoryModelAvailabilityVisibilityChains ); 12055 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderOutputViewportIndex ); 12056 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderOutputLayer ); 12057 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.subgroupBroadcastDynamicId ); 12058 return seed; 12059 } 12060 }; 12061 12062 template <> 12063 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan12Properties> 12064 { operator ()std::hash12065 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan12Properties const & physicalDeviceVulkan12Properties ) const VULKAN_HPP_NOEXCEPT 12066 { 12067 std::size_t seed = 0; 12068 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.sType ); 12069 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.pNext ); 12070 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.driverID ); 12071 for ( size_t i = 0; i < VK_MAX_DRIVER_NAME_SIZE; ++i ) 12072 { 12073 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.driverName[i] ); 12074 } 12075 for ( size_t i = 0; i < VK_MAX_DRIVER_INFO_SIZE; ++i ) 12076 { 12077 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.driverInfo[i] ); 12078 } 12079 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.conformanceVersion ); 12080 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.denormBehaviorIndependence ); 12081 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.roundingModeIndependence ); 12082 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderSignedZeroInfNanPreserveFloat16 ); 12083 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderSignedZeroInfNanPreserveFloat32 ); 12084 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderSignedZeroInfNanPreserveFloat64 ); 12085 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderDenormPreserveFloat16 ); 12086 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderDenormPreserveFloat32 ); 12087 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderDenormPreserveFloat64 ); 12088 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderDenormFlushToZeroFloat16 ); 12089 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderDenormFlushToZeroFloat32 ); 12090 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderDenormFlushToZeroFloat64 ); 12091 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTEFloat16 ); 12092 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTEFloat32 ); 12093 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTEFloat64 ); 12094 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTZFloat16 ); 12095 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTZFloat32 ); 12096 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTZFloat64 ); 12097 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxUpdateAfterBindDescriptorsInAllPools ); 12098 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderUniformBufferArrayNonUniformIndexingNative ); 12099 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderSampledImageArrayNonUniformIndexingNative ); 12100 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderStorageBufferArrayNonUniformIndexingNative ); 12101 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderStorageImageArrayNonUniformIndexingNative ); 12102 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderInputAttachmentArrayNonUniformIndexingNative ); 12103 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.robustBufferAccessUpdateAfterBind ); 12104 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.quadDivergentImplicitLod ); 12105 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindSamplers ); 12106 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindUniformBuffers ); 12107 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindStorageBuffers ); 12108 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindSampledImages ); 12109 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindStorageImages ); 12110 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindInputAttachments ); 12111 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxPerStageUpdateAfterBindResources ); 12112 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindSamplers ); 12113 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindUniformBuffers ); 12114 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic ); 12115 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindStorageBuffers ); 12116 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic ); 12117 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindSampledImages ); 12118 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindStorageImages ); 12119 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindInputAttachments ); 12120 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.supportedDepthResolveModes ); 12121 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.supportedStencilResolveModes ); 12122 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.independentResolveNone ); 12123 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.independentResolve ); 12124 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.filterMinmaxSingleComponentFormats ); 12125 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.filterMinmaxImageComponentMapping ); 12126 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxTimelineSemaphoreValueDifference ); 12127 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.framebufferIntegerColorSampleCounts ); 12128 return seed; 12129 } 12130 }; 12131 12132 template <> 12133 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan13Features> 12134 { operator ()std::hash12135 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan13Features const & physicalDeviceVulkan13Features ) const VULKAN_HPP_NOEXCEPT 12136 { 12137 std::size_t seed = 0; 12138 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.sType ); 12139 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.pNext ); 12140 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.robustImageAccess ); 12141 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.inlineUniformBlock ); 12142 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.descriptorBindingInlineUniformBlockUpdateAfterBind ); 12143 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.pipelineCreationCacheControl ); 12144 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.privateData ); 12145 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.shaderDemoteToHelperInvocation ); 12146 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.shaderTerminateInvocation ); 12147 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.subgroupSizeControl ); 12148 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.computeFullSubgroups ); 12149 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.synchronization2 ); 12150 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.textureCompressionASTC_HDR ); 12151 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.shaderZeroInitializeWorkgroupMemory ); 12152 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.dynamicRendering ); 12153 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.shaderIntegerDotProduct ); 12154 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.maintenance4 ); 12155 return seed; 12156 } 12157 }; 12158 12159 template <> 12160 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan13Properties> 12161 { operator ()std::hash12162 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan13Properties const & physicalDeviceVulkan13Properties ) const VULKAN_HPP_NOEXCEPT 12163 { 12164 std::size_t seed = 0; 12165 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.sType ); 12166 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.pNext ); 12167 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.minSubgroupSize ); 12168 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.maxSubgroupSize ); 12169 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.maxComputeWorkgroupSubgroups ); 12170 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.requiredSubgroupSizeStages ); 12171 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.maxInlineUniformBlockSize ); 12172 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.maxPerStageDescriptorInlineUniformBlocks ); 12173 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks ); 12174 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.maxDescriptorSetInlineUniformBlocks ); 12175 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.maxDescriptorSetUpdateAfterBindInlineUniformBlocks ); 12176 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.maxInlineUniformTotalSize ); 12177 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct8BitUnsignedAccelerated ); 12178 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct8BitSignedAccelerated ); 12179 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct8BitMixedSignednessAccelerated ); 12180 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct4x8BitPackedUnsignedAccelerated ); 12181 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct4x8BitPackedSignedAccelerated ); 12182 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct4x8BitPackedMixedSignednessAccelerated ); 12183 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct16BitUnsignedAccelerated ); 12184 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct16BitSignedAccelerated ); 12185 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct16BitMixedSignednessAccelerated ); 12186 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct32BitUnsignedAccelerated ); 12187 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct32BitSignedAccelerated ); 12188 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct32BitMixedSignednessAccelerated ); 12189 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct64BitUnsignedAccelerated ); 12190 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct64BitSignedAccelerated ); 12191 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct64BitMixedSignednessAccelerated ); 12192 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating8BitUnsignedAccelerated ); 12193 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating8BitSignedAccelerated ); 12194 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated ); 12195 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated ); 12196 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated ); 12197 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated ); 12198 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating16BitUnsignedAccelerated ); 12199 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating16BitSignedAccelerated ); 12200 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated ); 12201 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating32BitUnsignedAccelerated ); 12202 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating32BitSignedAccelerated ); 12203 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated ); 12204 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating64BitUnsignedAccelerated ); 12205 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating64BitSignedAccelerated ); 12206 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated ); 12207 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.storageTexelBufferOffsetAlignmentBytes ); 12208 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.storageTexelBufferOffsetSingleTexelAlignment ); 12209 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.uniformTexelBufferOffsetAlignmentBytes ); 12210 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.uniformTexelBufferOffsetSingleTexelAlignment ); 12211 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.maxBufferSize ); 12212 return seed; 12213 } 12214 }; 12215 12216 template <> 12217 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkanMemoryModelFeatures> 12218 { 12219 std::size_t operator ()std::hash12220 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkanMemoryModelFeatures const & physicalDeviceVulkanMemoryModelFeatures ) const VULKAN_HPP_NOEXCEPT 12221 { 12222 std::size_t seed = 0; 12223 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkanMemoryModelFeatures.sType ); 12224 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkanMemoryModelFeatures.pNext ); 12225 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkanMemoryModelFeatures.vulkanMemoryModel ); 12226 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkanMemoryModelFeatures.vulkanMemoryModelDeviceScope ); 12227 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkanMemoryModelFeatures.vulkanMemoryModelAvailabilityVisibilityChains ); 12228 return seed; 12229 } 12230 }; 12231 12232 template <> 12233 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR> 12234 { operator ()std::hash12235 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR const & 12236 physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR ) const VULKAN_HPP_NOEXCEPT 12237 { 12238 std::size_t seed = 0; 12239 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.sType ); 12240 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.pNext ); 12241 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.workgroupMemoryExplicitLayout ); 12242 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.workgroupMemoryExplicitLayoutScalarBlockLayout ); 12243 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.workgroupMemoryExplicitLayout8BitAccess ); 12244 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.workgroupMemoryExplicitLayout16BitAccess ); 12245 return seed; 12246 } 12247 }; 12248 12249 template <> 12250 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT> 12251 { operator ()std::hash12252 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT const & physicalDeviceYcbcr2Plane444FormatsFeaturesEXT ) const 12253 VULKAN_HPP_NOEXCEPT 12254 { 12255 std::size_t seed = 0; 12256 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceYcbcr2Plane444FormatsFeaturesEXT.sType ); 12257 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceYcbcr2Plane444FormatsFeaturesEXT.pNext ); 12258 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceYcbcr2Plane444FormatsFeaturesEXT.ycbcr2plane444Formats ); 12259 return seed; 12260 } 12261 }; 12262 12263 template <> 12264 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcrDegammaFeaturesQCOM> 12265 { 12266 std::size_t operator ()std::hash12267 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcrDegammaFeaturesQCOM const & physicalDeviceYcbcrDegammaFeaturesQCOM ) const VULKAN_HPP_NOEXCEPT 12268 { 12269 std::size_t seed = 0; 12270 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceYcbcrDegammaFeaturesQCOM.sType ); 12271 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceYcbcrDegammaFeaturesQCOM.pNext ); 12272 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceYcbcrDegammaFeaturesQCOM.ycbcrDegamma ); 12273 return seed; 12274 } 12275 }; 12276 12277 template <> 12278 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcrImageArraysFeaturesEXT> 12279 { 12280 std::size_t operator ()std::hash12281 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcrImageArraysFeaturesEXT const & physicalDeviceYcbcrImageArraysFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 12282 { 12283 std::size_t seed = 0; 12284 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceYcbcrImageArraysFeaturesEXT.sType ); 12285 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceYcbcrImageArraysFeaturesEXT.pNext ); 12286 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceYcbcrImageArraysFeaturesEXT.ycbcrImageArrays ); 12287 return seed; 12288 } 12289 }; 12290 12291 template <> 12292 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures> 12293 { 12294 std::size_t operator ()std::hash12295 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures const & physicalDeviceZeroInitializeWorkgroupMemoryFeatures ) const 12296 VULKAN_HPP_NOEXCEPT 12297 { 12298 std::size_t seed = 0; 12299 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceZeroInitializeWorkgroupMemoryFeatures.sType ); 12300 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceZeroInitializeWorkgroupMemoryFeatures.pNext ); 12301 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceZeroInitializeWorkgroupMemoryFeatures.shaderZeroInitializeWorkgroupMemory ); 12302 return seed; 12303 } 12304 }; 12305 12306 template <> 12307 struct hash<VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo> 12308 { operator ()std::hash12309 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo const & pipelineCacheCreateInfo ) const VULKAN_HPP_NOEXCEPT 12310 { 12311 std::size_t seed = 0; 12312 VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheCreateInfo.sType ); 12313 VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheCreateInfo.pNext ); 12314 VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheCreateInfo.flags ); 12315 VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheCreateInfo.initialDataSize ); 12316 VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheCreateInfo.pInitialData ); 12317 return seed; 12318 } 12319 }; 12320 12321 template <> 12322 struct hash<VULKAN_HPP_NAMESPACE::PipelineCacheHeaderVersionOne> 12323 { operator ()std::hash12324 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCacheHeaderVersionOne const & pipelineCacheHeaderVersionOne ) const VULKAN_HPP_NOEXCEPT 12325 { 12326 std::size_t seed = 0; 12327 VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheHeaderVersionOne.headerSize ); 12328 VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheHeaderVersionOne.headerVersion ); 12329 VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheHeaderVersionOne.vendorID ); 12330 VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheHeaderVersionOne.deviceID ); 12331 for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) 12332 { 12333 VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheHeaderVersionOne.pipelineCacheUUID[i] ); 12334 } 12335 return seed; 12336 } 12337 }; 12338 12339 template <> 12340 struct hash<VULKAN_HPP_NAMESPACE::PipelineColorBlendAdvancedStateCreateInfoEXT> 12341 { operator ()std::hash12342 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineColorBlendAdvancedStateCreateInfoEXT const & pipelineColorBlendAdvancedStateCreateInfoEXT ) const 12343 VULKAN_HPP_NOEXCEPT 12344 { 12345 std::size_t seed = 0; 12346 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAdvancedStateCreateInfoEXT.sType ); 12347 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAdvancedStateCreateInfoEXT.pNext ); 12348 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAdvancedStateCreateInfoEXT.srcPremultiplied ); 12349 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAdvancedStateCreateInfoEXT.dstPremultiplied ); 12350 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAdvancedStateCreateInfoEXT.blendOverlap ); 12351 return seed; 12352 } 12353 }; 12354 12355 template <> 12356 struct hash<VULKAN_HPP_NAMESPACE::PipelineColorWriteCreateInfoEXT> 12357 { operator ()std::hash12358 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineColorWriteCreateInfoEXT const & pipelineColorWriteCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 12359 { 12360 std::size_t seed = 0; 12361 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorWriteCreateInfoEXT.sType ); 12362 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorWriteCreateInfoEXT.pNext ); 12363 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorWriteCreateInfoEXT.attachmentCount ); 12364 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorWriteCreateInfoEXT.pColorWriteEnables ); 12365 return seed; 12366 } 12367 }; 12368 12369 template <> 12370 struct hash<VULKAN_HPP_NAMESPACE::PipelineCompilerControlCreateInfoAMD> 12371 { operator ()std::hash12372 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCompilerControlCreateInfoAMD const & pipelineCompilerControlCreateInfoAMD ) const VULKAN_HPP_NOEXCEPT 12373 { 12374 std::size_t seed = 0; 12375 VULKAN_HPP_HASH_COMBINE( seed, pipelineCompilerControlCreateInfoAMD.sType ); 12376 VULKAN_HPP_HASH_COMBINE( seed, pipelineCompilerControlCreateInfoAMD.pNext ); 12377 VULKAN_HPP_HASH_COMBINE( seed, pipelineCompilerControlCreateInfoAMD.compilerControlFlags ); 12378 return seed; 12379 } 12380 }; 12381 12382 template <> 12383 struct hash<VULKAN_HPP_NAMESPACE::PipelineCoverageModulationStateCreateInfoNV> 12384 { operator ()std::hash12385 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCoverageModulationStateCreateInfoNV const & pipelineCoverageModulationStateCreateInfoNV ) const 12386 VULKAN_HPP_NOEXCEPT 12387 { 12388 std::size_t seed = 0; 12389 VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageModulationStateCreateInfoNV.sType ); 12390 VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageModulationStateCreateInfoNV.pNext ); 12391 VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageModulationStateCreateInfoNV.flags ); 12392 VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageModulationStateCreateInfoNV.coverageModulationMode ); 12393 VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageModulationStateCreateInfoNV.coverageModulationTableEnable ); 12394 VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageModulationStateCreateInfoNV.coverageModulationTableCount ); 12395 VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageModulationStateCreateInfoNV.pCoverageModulationTable ); 12396 return seed; 12397 } 12398 }; 12399 12400 template <> 12401 struct hash<VULKAN_HPP_NAMESPACE::PipelineCoverageReductionStateCreateInfoNV> 12402 { operator ()std::hash12403 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCoverageReductionStateCreateInfoNV const & pipelineCoverageReductionStateCreateInfoNV ) const 12404 VULKAN_HPP_NOEXCEPT 12405 { 12406 std::size_t seed = 0; 12407 VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageReductionStateCreateInfoNV.sType ); 12408 VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageReductionStateCreateInfoNV.pNext ); 12409 VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageReductionStateCreateInfoNV.flags ); 12410 VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageReductionStateCreateInfoNV.coverageReductionMode ); 12411 return seed; 12412 } 12413 }; 12414 12415 template <> 12416 struct hash<VULKAN_HPP_NAMESPACE::PipelineCoverageToColorStateCreateInfoNV> 12417 { 12418 std::size_t operator ()std::hash12419 operator()( VULKAN_HPP_NAMESPACE::PipelineCoverageToColorStateCreateInfoNV const & pipelineCoverageToColorStateCreateInfoNV ) const VULKAN_HPP_NOEXCEPT 12420 { 12421 std::size_t seed = 0; 12422 VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageToColorStateCreateInfoNV.sType ); 12423 VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageToColorStateCreateInfoNV.pNext ); 12424 VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageToColorStateCreateInfoNV.flags ); 12425 VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageToColorStateCreateInfoNV.coverageToColorEnable ); 12426 VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageToColorStateCreateInfoNV.coverageToColorLocation ); 12427 return seed; 12428 } 12429 }; 12430 12431 template <> 12432 struct hash<VULKAN_HPP_NAMESPACE::PipelineCreateFlags2CreateInfoKHR> 12433 { operator ()std::hash12434 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCreateFlags2CreateInfoKHR const & pipelineCreateFlags2CreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 12435 { 12436 std::size_t seed = 0; 12437 VULKAN_HPP_HASH_COMBINE( seed, pipelineCreateFlags2CreateInfoKHR.sType ); 12438 VULKAN_HPP_HASH_COMBINE( seed, pipelineCreateFlags2CreateInfoKHR.pNext ); 12439 VULKAN_HPP_HASH_COMBINE( seed, pipelineCreateFlags2CreateInfoKHR.flags ); 12440 return seed; 12441 } 12442 }; 12443 12444 template <> 12445 struct hash<VULKAN_HPP_NAMESPACE::PipelineCreationFeedback> 12446 { operator ()std::hash12447 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCreationFeedback const & pipelineCreationFeedback ) const VULKAN_HPP_NOEXCEPT 12448 { 12449 std::size_t seed = 0; 12450 VULKAN_HPP_HASH_COMBINE( seed, pipelineCreationFeedback.flags ); 12451 VULKAN_HPP_HASH_COMBINE( seed, pipelineCreationFeedback.duration ); 12452 return seed; 12453 } 12454 }; 12455 12456 template <> 12457 struct hash<VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackCreateInfo> 12458 { operator ()std::hash12459 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackCreateInfo const & pipelineCreationFeedbackCreateInfo ) const VULKAN_HPP_NOEXCEPT 12460 { 12461 std::size_t seed = 0; 12462 VULKAN_HPP_HASH_COMBINE( seed, pipelineCreationFeedbackCreateInfo.sType ); 12463 VULKAN_HPP_HASH_COMBINE( seed, pipelineCreationFeedbackCreateInfo.pNext ); 12464 VULKAN_HPP_HASH_COMBINE( seed, pipelineCreationFeedbackCreateInfo.pPipelineCreationFeedback ); 12465 VULKAN_HPP_HASH_COMBINE( seed, pipelineCreationFeedbackCreateInfo.pipelineStageCreationFeedbackCount ); 12466 VULKAN_HPP_HASH_COMBINE( seed, pipelineCreationFeedbackCreateInfo.pPipelineStageCreationFeedbacks ); 12467 return seed; 12468 } 12469 }; 12470 12471 template <> 12472 struct hash<VULKAN_HPP_NAMESPACE::PipelineDiscardRectangleStateCreateInfoEXT> 12473 { operator ()std::hash12474 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineDiscardRectangleStateCreateInfoEXT const & pipelineDiscardRectangleStateCreateInfoEXT ) const 12475 VULKAN_HPP_NOEXCEPT 12476 { 12477 std::size_t seed = 0; 12478 VULKAN_HPP_HASH_COMBINE( seed, pipelineDiscardRectangleStateCreateInfoEXT.sType ); 12479 VULKAN_HPP_HASH_COMBINE( seed, pipelineDiscardRectangleStateCreateInfoEXT.pNext ); 12480 VULKAN_HPP_HASH_COMBINE( seed, pipelineDiscardRectangleStateCreateInfoEXT.flags ); 12481 VULKAN_HPP_HASH_COMBINE( seed, pipelineDiscardRectangleStateCreateInfoEXT.discardRectangleMode ); 12482 VULKAN_HPP_HASH_COMBINE( seed, pipelineDiscardRectangleStateCreateInfoEXT.discardRectangleCount ); 12483 VULKAN_HPP_HASH_COMBINE( seed, pipelineDiscardRectangleStateCreateInfoEXT.pDiscardRectangles ); 12484 return seed; 12485 } 12486 }; 12487 12488 template <> 12489 struct hash<VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR> 12490 { operator ()std::hash12491 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR const & pipelineExecutableInfoKHR ) const VULKAN_HPP_NOEXCEPT 12492 { 12493 std::size_t seed = 0; 12494 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInfoKHR.sType ); 12495 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInfoKHR.pNext ); 12496 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInfoKHR.pipeline ); 12497 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInfoKHR.executableIndex ); 12498 return seed; 12499 } 12500 }; 12501 12502 template <> 12503 struct hash<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR> 12504 { operator ()std::hash12505 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR const & pipelineExecutableInternalRepresentationKHR ) const 12506 VULKAN_HPP_NOEXCEPT 12507 { 12508 std::size_t seed = 0; 12509 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInternalRepresentationKHR.sType ); 12510 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInternalRepresentationKHR.pNext ); 12511 for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) 12512 { 12513 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInternalRepresentationKHR.name[i] ); 12514 } 12515 for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) 12516 { 12517 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInternalRepresentationKHR.description[i] ); 12518 } 12519 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInternalRepresentationKHR.isText ); 12520 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInternalRepresentationKHR.dataSize ); 12521 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInternalRepresentationKHR.pData ); 12522 return seed; 12523 } 12524 }; 12525 12526 template <> 12527 struct hash<VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR> 12528 { operator ()std::hash12529 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR const & pipelineExecutablePropertiesKHR ) const VULKAN_HPP_NOEXCEPT 12530 { 12531 std::size_t seed = 0; 12532 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutablePropertiesKHR.sType ); 12533 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutablePropertiesKHR.pNext ); 12534 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutablePropertiesKHR.stages ); 12535 for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) 12536 { 12537 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutablePropertiesKHR.name[i] ); 12538 } 12539 for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) 12540 { 12541 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutablePropertiesKHR.description[i] ); 12542 } 12543 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutablePropertiesKHR.subgroupSize ); 12544 return seed; 12545 } 12546 }; 12547 12548 template <> 12549 struct hash<VULKAN_HPP_NAMESPACE::PipelineFragmentShadingRateEnumStateCreateInfoNV> 12550 { operator ()std::hash12551 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineFragmentShadingRateEnumStateCreateInfoNV const & pipelineFragmentShadingRateEnumStateCreateInfoNV ) 12552 const VULKAN_HPP_NOEXCEPT 12553 { 12554 std::size_t seed = 0; 12555 VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentShadingRateEnumStateCreateInfoNV.sType ); 12556 VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentShadingRateEnumStateCreateInfoNV.pNext ); 12557 VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentShadingRateEnumStateCreateInfoNV.shadingRateType ); 12558 VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentShadingRateEnumStateCreateInfoNV.shadingRate ); 12559 for ( size_t i = 0; i < 2; ++i ) 12560 { 12561 VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentShadingRateEnumStateCreateInfoNV.combinerOps[i] ); 12562 } 12563 return seed; 12564 } 12565 }; 12566 12567 template <> 12568 struct hash<VULKAN_HPP_NAMESPACE::PipelineFragmentShadingRateStateCreateInfoKHR> 12569 { operator ()std::hash12570 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineFragmentShadingRateStateCreateInfoKHR const & pipelineFragmentShadingRateStateCreateInfoKHR ) const 12571 VULKAN_HPP_NOEXCEPT 12572 { 12573 std::size_t seed = 0; 12574 VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentShadingRateStateCreateInfoKHR.sType ); 12575 VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentShadingRateStateCreateInfoKHR.pNext ); 12576 VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentShadingRateStateCreateInfoKHR.fragmentSize ); 12577 for ( size_t i = 0; i < 2; ++i ) 12578 { 12579 VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentShadingRateStateCreateInfoKHR.combinerOps[i] ); 12580 } 12581 return seed; 12582 } 12583 }; 12584 12585 template <> 12586 struct hash<VULKAN_HPP_NAMESPACE::PipelineIndirectDeviceAddressInfoNV> 12587 { operator ()std::hash12588 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineIndirectDeviceAddressInfoNV const & pipelineIndirectDeviceAddressInfoNV ) const VULKAN_HPP_NOEXCEPT 12589 { 12590 std::size_t seed = 0; 12591 VULKAN_HPP_HASH_COMBINE( seed, pipelineIndirectDeviceAddressInfoNV.sType ); 12592 VULKAN_HPP_HASH_COMBINE( seed, pipelineIndirectDeviceAddressInfoNV.pNext ); 12593 VULKAN_HPP_HASH_COMBINE( seed, pipelineIndirectDeviceAddressInfoNV.pipelineBindPoint ); 12594 VULKAN_HPP_HASH_COMBINE( seed, pipelineIndirectDeviceAddressInfoNV.pipeline ); 12595 return seed; 12596 } 12597 }; 12598 12599 template <> 12600 struct hash<VULKAN_HPP_NAMESPACE::PipelineInfoKHR> 12601 { operator ()std::hash12602 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineInfoKHR const & pipelineInfoKHR ) const VULKAN_HPP_NOEXCEPT 12603 { 12604 std::size_t seed = 0; 12605 VULKAN_HPP_HASH_COMBINE( seed, pipelineInfoKHR.sType ); 12606 VULKAN_HPP_HASH_COMBINE( seed, pipelineInfoKHR.pNext ); 12607 VULKAN_HPP_HASH_COMBINE( seed, pipelineInfoKHR.pipeline ); 12608 return seed; 12609 } 12610 }; 12611 12612 template <> 12613 struct hash<VULKAN_HPP_NAMESPACE::PushConstantRange> 12614 { operator ()std::hash12615 std::size_t operator()( VULKAN_HPP_NAMESPACE::PushConstantRange const & pushConstantRange ) const VULKAN_HPP_NOEXCEPT 12616 { 12617 std::size_t seed = 0; 12618 VULKAN_HPP_HASH_COMBINE( seed, pushConstantRange.stageFlags ); 12619 VULKAN_HPP_HASH_COMBINE( seed, pushConstantRange.offset ); 12620 VULKAN_HPP_HASH_COMBINE( seed, pushConstantRange.size ); 12621 return seed; 12622 } 12623 }; 12624 12625 template <> 12626 struct hash<VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo> 12627 { operator ()std::hash12628 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo const & pipelineLayoutCreateInfo ) const VULKAN_HPP_NOEXCEPT 12629 { 12630 std::size_t seed = 0; 12631 VULKAN_HPP_HASH_COMBINE( seed, pipelineLayoutCreateInfo.sType ); 12632 VULKAN_HPP_HASH_COMBINE( seed, pipelineLayoutCreateInfo.pNext ); 12633 VULKAN_HPP_HASH_COMBINE( seed, pipelineLayoutCreateInfo.flags ); 12634 VULKAN_HPP_HASH_COMBINE( seed, pipelineLayoutCreateInfo.setLayoutCount ); 12635 VULKAN_HPP_HASH_COMBINE( seed, pipelineLayoutCreateInfo.pSetLayouts ); 12636 VULKAN_HPP_HASH_COMBINE( seed, pipelineLayoutCreateInfo.pushConstantRangeCount ); 12637 VULKAN_HPP_HASH_COMBINE( seed, pipelineLayoutCreateInfo.pPushConstantRanges ); 12638 return seed; 12639 } 12640 }; 12641 12642 template <> 12643 struct hash<VULKAN_HPP_NAMESPACE::PipelinePropertiesIdentifierEXT> 12644 { operator ()std::hash12645 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelinePropertiesIdentifierEXT const & pipelinePropertiesIdentifierEXT ) const VULKAN_HPP_NOEXCEPT 12646 { 12647 std::size_t seed = 0; 12648 VULKAN_HPP_HASH_COMBINE( seed, pipelinePropertiesIdentifierEXT.sType ); 12649 VULKAN_HPP_HASH_COMBINE( seed, pipelinePropertiesIdentifierEXT.pNext ); 12650 for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) 12651 { 12652 VULKAN_HPP_HASH_COMBINE( seed, pipelinePropertiesIdentifierEXT.pipelineIdentifier[i] ); 12653 } 12654 return seed; 12655 } 12656 }; 12657 12658 template <> 12659 struct hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationConservativeStateCreateInfoEXT> 12660 { 12661 std::size_t operator ()std::hash12662 operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationConservativeStateCreateInfoEXT const & pipelineRasterizationConservativeStateCreateInfoEXT ) const 12663 VULKAN_HPP_NOEXCEPT 12664 { 12665 std::size_t seed = 0; 12666 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationConservativeStateCreateInfoEXT.sType ); 12667 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationConservativeStateCreateInfoEXT.pNext ); 12668 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationConservativeStateCreateInfoEXT.flags ); 12669 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationConservativeStateCreateInfoEXT.conservativeRasterizationMode ); 12670 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationConservativeStateCreateInfoEXT.extraPrimitiveOverestimationSize ); 12671 return seed; 12672 } 12673 }; 12674 12675 template <> 12676 struct hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationDepthClipStateCreateInfoEXT> 12677 { operator ()std::hash12678 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationDepthClipStateCreateInfoEXT const & pipelineRasterizationDepthClipStateCreateInfoEXT ) 12679 const VULKAN_HPP_NOEXCEPT 12680 { 12681 std::size_t seed = 0; 12682 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationDepthClipStateCreateInfoEXT.sType ); 12683 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationDepthClipStateCreateInfoEXT.pNext ); 12684 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationDepthClipStateCreateInfoEXT.flags ); 12685 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationDepthClipStateCreateInfoEXT.depthClipEnable ); 12686 return seed; 12687 } 12688 }; 12689 12690 template <> 12691 struct hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationLineStateCreateInfoEXT> 12692 { operator ()std::hash12693 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationLineStateCreateInfoEXT const & pipelineRasterizationLineStateCreateInfoEXT ) const 12694 VULKAN_HPP_NOEXCEPT 12695 { 12696 std::size_t seed = 0; 12697 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfoEXT.sType ); 12698 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfoEXT.pNext ); 12699 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfoEXT.lineRasterizationMode ); 12700 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfoEXT.stippledLineEnable ); 12701 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfoEXT.lineStippleFactor ); 12702 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfoEXT.lineStipplePattern ); 12703 return seed; 12704 } 12705 }; 12706 12707 template <> 12708 struct hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationProvokingVertexStateCreateInfoEXT> 12709 { operator ()std::hash12710 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationProvokingVertexStateCreateInfoEXT const & 12711 pipelineRasterizationProvokingVertexStateCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 12712 { 12713 std::size_t seed = 0; 12714 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationProvokingVertexStateCreateInfoEXT.sType ); 12715 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationProvokingVertexStateCreateInfoEXT.pNext ); 12716 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationProvokingVertexStateCreateInfoEXT.provokingVertexMode ); 12717 return seed; 12718 } 12719 }; 12720 12721 template <> 12722 struct hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationStateRasterizationOrderAMD> 12723 { operator ()std::hash12724 std::size_t operator()( 12725 VULKAN_HPP_NAMESPACE::PipelineRasterizationStateRasterizationOrderAMD const & pipelineRasterizationStateRasterizationOrderAMD ) const VULKAN_HPP_NOEXCEPT 12726 { 12727 std::size_t seed = 0; 12728 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateRasterizationOrderAMD.sType ); 12729 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateRasterizationOrderAMD.pNext ); 12730 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateRasterizationOrderAMD.rasterizationOrder ); 12731 return seed; 12732 } 12733 }; 12734 12735 template <> 12736 struct hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationStateStreamCreateInfoEXT> 12737 { operator ()std::hash12738 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationStateStreamCreateInfoEXT const & pipelineRasterizationStateStreamCreateInfoEXT ) const 12739 VULKAN_HPP_NOEXCEPT 12740 { 12741 std::size_t seed = 0; 12742 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateStreamCreateInfoEXT.sType ); 12743 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateStreamCreateInfoEXT.pNext ); 12744 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateStreamCreateInfoEXT.flags ); 12745 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateStreamCreateInfoEXT.rasterizationStream ); 12746 return seed; 12747 } 12748 }; 12749 12750 template <> 12751 struct hash<VULKAN_HPP_NAMESPACE::PipelineRenderingCreateInfo> 12752 { operator ()std::hash12753 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRenderingCreateInfo const & pipelineRenderingCreateInfo ) const VULKAN_HPP_NOEXCEPT 12754 { 12755 std::size_t seed = 0; 12756 VULKAN_HPP_HASH_COMBINE( seed, pipelineRenderingCreateInfo.sType ); 12757 VULKAN_HPP_HASH_COMBINE( seed, pipelineRenderingCreateInfo.pNext ); 12758 VULKAN_HPP_HASH_COMBINE( seed, pipelineRenderingCreateInfo.viewMask ); 12759 VULKAN_HPP_HASH_COMBINE( seed, pipelineRenderingCreateInfo.colorAttachmentCount ); 12760 VULKAN_HPP_HASH_COMBINE( seed, pipelineRenderingCreateInfo.pColorAttachmentFormats ); 12761 VULKAN_HPP_HASH_COMBINE( seed, pipelineRenderingCreateInfo.depthAttachmentFormat ); 12762 VULKAN_HPP_HASH_COMBINE( seed, pipelineRenderingCreateInfo.stencilAttachmentFormat ); 12763 return seed; 12764 } 12765 }; 12766 12767 template <> 12768 struct hash<VULKAN_HPP_NAMESPACE::PipelineRepresentativeFragmentTestStateCreateInfoNV> 12769 { 12770 std::size_t operator ()std::hash12771 operator()( VULKAN_HPP_NAMESPACE::PipelineRepresentativeFragmentTestStateCreateInfoNV const & pipelineRepresentativeFragmentTestStateCreateInfoNV ) const 12772 VULKAN_HPP_NOEXCEPT 12773 { 12774 std::size_t seed = 0; 12775 VULKAN_HPP_HASH_COMBINE( seed, pipelineRepresentativeFragmentTestStateCreateInfoNV.sType ); 12776 VULKAN_HPP_HASH_COMBINE( seed, pipelineRepresentativeFragmentTestStateCreateInfoNV.pNext ); 12777 VULKAN_HPP_HASH_COMBINE( seed, pipelineRepresentativeFragmentTestStateCreateInfoNV.representativeFragmentTestEnable ); 12778 return seed; 12779 } 12780 }; 12781 12782 template <> 12783 struct hash<VULKAN_HPP_NAMESPACE::PipelineRobustnessCreateInfoEXT> 12784 { operator ()std::hash12785 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRobustnessCreateInfoEXT const & pipelineRobustnessCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 12786 { 12787 std::size_t seed = 0; 12788 VULKAN_HPP_HASH_COMBINE( seed, pipelineRobustnessCreateInfoEXT.sType ); 12789 VULKAN_HPP_HASH_COMBINE( seed, pipelineRobustnessCreateInfoEXT.pNext ); 12790 VULKAN_HPP_HASH_COMBINE( seed, pipelineRobustnessCreateInfoEXT.storageBuffers ); 12791 VULKAN_HPP_HASH_COMBINE( seed, pipelineRobustnessCreateInfoEXT.uniformBuffers ); 12792 VULKAN_HPP_HASH_COMBINE( seed, pipelineRobustnessCreateInfoEXT.vertexInputs ); 12793 VULKAN_HPP_HASH_COMBINE( seed, pipelineRobustnessCreateInfoEXT.images ); 12794 return seed; 12795 } 12796 }; 12797 12798 template <> 12799 struct hash<VULKAN_HPP_NAMESPACE::PipelineSampleLocationsStateCreateInfoEXT> 12800 { 12801 std::size_t operator ()std::hash12802 operator()( VULKAN_HPP_NAMESPACE::PipelineSampleLocationsStateCreateInfoEXT const & pipelineSampleLocationsStateCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 12803 { 12804 std::size_t seed = 0; 12805 VULKAN_HPP_HASH_COMBINE( seed, pipelineSampleLocationsStateCreateInfoEXT.sType ); 12806 VULKAN_HPP_HASH_COMBINE( seed, pipelineSampleLocationsStateCreateInfoEXT.pNext ); 12807 VULKAN_HPP_HASH_COMBINE( seed, pipelineSampleLocationsStateCreateInfoEXT.sampleLocationsEnable ); 12808 VULKAN_HPP_HASH_COMBINE( seed, pipelineSampleLocationsStateCreateInfoEXT.sampleLocationsInfo ); 12809 return seed; 12810 } 12811 }; 12812 12813 template <> 12814 struct hash<VULKAN_HPP_NAMESPACE::PipelineShaderStageModuleIdentifierCreateInfoEXT> 12815 { operator ()std::hash12816 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineShaderStageModuleIdentifierCreateInfoEXT const & pipelineShaderStageModuleIdentifierCreateInfoEXT ) 12817 const VULKAN_HPP_NOEXCEPT 12818 { 12819 std::size_t seed = 0; 12820 VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageModuleIdentifierCreateInfoEXT.sType ); 12821 VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageModuleIdentifierCreateInfoEXT.pNext ); 12822 VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageModuleIdentifierCreateInfoEXT.identifierSize ); 12823 VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageModuleIdentifierCreateInfoEXT.pIdentifier ); 12824 return seed; 12825 } 12826 }; 12827 12828 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 12829 template <> 12830 struct hash<VULKAN_HPP_NAMESPACE::PipelineShaderStageNodeCreateInfoAMDX> 12831 { 12832 std::size_t operator ()std::hash12833 operator()( VULKAN_HPP_NAMESPACE::PipelineShaderStageNodeCreateInfoAMDX const & pipelineShaderStageNodeCreateInfoAMDX ) const VULKAN_HPP_NOEXCEPT 12834 { 12835 std::size_t seed = 0; 12836 VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageNodeCreateInfoAMDX.sType ); 12837 VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageNodeCreateInfoAMDX.pNext ); 12838 for ( const char * p = pipelineShaderStageNodeCreateInfoAMDX.pName; *p != '\0'; ++p ) 12839 { 12840 VULKAN_HPP_HASH_COMBINE( seed, *p ); 12841 } 12842 VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageNodeCreateInfoAMDX.index ); 12843 return seed; 12844 } 12845 }; 12846 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 12847 12848 template <> 12849 struct hash<VULKAN_HPP_NAMESPACE::PipelineShaderStageRequiredSubgroupSizeCreateInfo> 12850 { operator ()std::hash12851 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineShaderStageRequiredSubgroupSizeCreateInfo const & pipelineShaderStageRequiredSubgroupSizeCreateInfo ) 12852 const VULKAN_HPP_NOEXCEPT 12853 { 12854 std::size_t seed = 0; 12855 VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageRequiredSubgroupSizeCreateInfo.sType ); 12856 VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageRequiredSubgroupSizeCreateInfo.pNext ); 12857 VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageRequiredSubgroupSizeCreateInfo.requiredSubgroupSize ); 12858 return seed; 12859 } 12860 }; 12861 12862 template <> 12863 struct hash<VULKAN_HPP_NAMESPACE::PipelineTessellationDomainOriginStateCreateInfo> 12864 { operator ()std::hash12865 std::size_t operator()( 12866 VULKAN_HPP_NAMESPACE::PipelineTessellationDomainOriginStateCreateInfo const & pipelineTessellationDomainOriginStateCreateInfo ) const VULKAN_HPP_NOEXCEPT 12867 { 12868 std::size_t seed = 0; 12869 VULKAN_HPP_HASH_COMBINE( seed, pipelineTessellationDomainOriginStateCreateInfo.sType ); 12870 VULKAN_HPP_HASH_COMBINE( seed, pipelineTessellationDomainOriginStateCreateInfo.pNext ); 12871 VULKAN_HPP_HASH_COMBINE( seed, pipelineTessellationDomainOriginStateCreateInfo.domainOrigin ); 12872 return seed; 12873 } 12874 }; 12875 12876 template <> 12877 struct hash<VULKAN_HPP_NAMESPACE::VertexInputBindingDivisorDescriptionKHR> 12878 { 12879 std::size_t operator ()std::hash12880 operator()( VULKAN_HPP_NAMESPACE::VertexInputBindingDivisorDescriptionKHR const & vertexInputBindingDivisorDescriptionKHR ) const VULKAN_HPP_NOEXCEPT 12881 { 12882 std::size_t seed = 0; 12883 VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDivisorDescriptionKHR.binding ); 12884 VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDivisorDescriptionKHR.divisor ); 12885 return seed; 12886 } 12887 }; 12888 12889 template <> 12890 struct hash<VULKAN_HPP_NAMESPACE::PipelineVertexInputDivisorStateCreateInfoKHR> 12891 { operator ()std::hash12892 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineVertexInputDivisorStateCreateInfoKHR const & pipelineVertexInputDivisorStateCreateInfoKHR ) const 12893 VULKAN_HPP_NOEXCEPT 12894 { 12895 std::size_t seed = 0; 12896 VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputDivisorStateCreateInfoKHR.sType ); 12897 VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputDivisorStateCreateInfoKHR.pNext ); 12898 VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputDivisorStateCreateInfoKHR.vertexBindingDivisorCount ); 12899 VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputDivisorStateCreateInfoKHR.pVertexBindingDivisors ); 12900 return seed; 12901 } 12902 }; 12903 12904 template <> 12905 struct hash<VULKAN_HPP_NAMESPACE::PipelineViewportCoarseSampleOrderStateCreateInfoNV> 12906 { 12907 std::size_t operator ()std::hash12908 operator()( VULKAN_HPP_NAMESPACE::PipelineViewportCoarseSampleOrderStateCreateInfoNV const & pipelineViewportCoarseSampleOrderStateCreateInfoNV ) const 12909 VULKAN_HPP_NOEXCEPT 12910 { 12911 std::size_t seed = 0; 12912 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportCoarseSampleOrderStateCreateInfoNV.sType ); 12913 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportCoarseSampleOrderStateCreateInfoNV.pNext ); 12914 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportCoarseSampleOrderStateCreateInfoNV.sampleOrderType ); 12915 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportCoarseSampleOrderStateCreateInfoNV.customSampleOrderCount ); 12916 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportCoarseSampleOrderStateCreateInfoNV.pCustomSampleOrders ); 12917 return seed; 12918 } 12919 }; 12920 12921 template <> 12922 struct hash<VULKAN_HPP_NAMESPACE::PipelineViewportDepthClipControlCreateInfoEXT> 12923 { operator ()std::hash12924 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineViewportDepthClipControlCreateInfoEXT const & pipelineViewportDepthClipControlCreateInfoEXT ) const 12925 VULKAN_HPP_NOEXCEPT 12926 { 12927 std::size_t seed = 0; 12928 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportDepthClipControlCreateInfoEXT.sType ); 12929 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportDepthClipControlCreateInfoEXT.pNext ); 12930 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportDepthClipControlCreateInfoEXT.negativeOneToOne ); 12931 return seed; 12932 } 12933 }; 12934 12935 template <> 12936 struct hash<VULKAN_HPP_NAMESPACE::PipelineViewportExclusiveScissorStateCreateInfoNV> 12937 { operator ()std::hash12938 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineViewportExclusiveScissorStateCreateInfoNV const & pipelineViewportExclusiveScissorStateCreateInfoNV ) 12939 const VULKAN_HPP_NOEXCEPT 12940 { 12941 std::size_t seed = 0; 12942 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportExclusiveScissorStateCreateInfoNV.sType ); 12943 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportExclusiveScissorStateCreateInfoNV.pNext ); 12944 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportExclusiveScissorStateCreateInfoNV.exclusiveScissorCount ); 12945 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportExclusiveScissorStateCreateInfoNV.pExclusiveScissors ); 12946 return seed; 12947 } 12948 }; 12949 12950 template <> 12951 struct hash<VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV> 12952 { operator ()std::hash12953 std::size_t operator()( VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV const & shadingRatePaletteNV ) const VULKAN_HPP_NOEXCEPT 12954 { 12955 std::size_t seed = 0; 12956 VULKAN_HPP_HASH_COMBINE( seed, shadingRatePaletteNV.shadingRatePaletteEntryCount ); 12957 VULKAN_HPP_HASH_COMBINE( seed, shadingRatePaletteNV.pShadingRatePaletteEntries ); 12958 return seed; 12959 } 12960 }; 12961 12962 template <> 12963 struct hash<VULKAN_HPP_NAMESPACE::PipelineViewportShadingRateImageStateCreateInfoNV> 12964 { operator ()std::hash12965 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineViewportShadingRateImageStateCreateInfoNV const & pipelineViewportShadingRateImageStateCreateInfoNV ) 12966 const VULKAN_HPP_NOEXCEPT 12967 { 12968 std::size_t seed = 0; 12969 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportShadingRateImageStateCreateInfoNV.sType ); 12970 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportShadingRateImageStateCreateInfoNV.pNext ); 12971 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportShadingRateImageStateCreateInfoNV.shadingRateImageEnable ); 12972 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportShadingRateImageStateCreateInfoNV.viewportCount ); 12973 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportShadingRateImageStateCreateInfoNV.pShadingRatePalettes ); 12974 return seed; 12975 } 12976 }; 12977 12978 template <> 12979 struct hash<VULKAN_HPP_NAMESPACE::ViewportSwizzleNV> 12980 { operator ()std::hash12981 std::size_t operator()( VULKAN_HPP_NAMESPACE::ViewportSwizzleNV const & viewportSwizzleNV ) const VULKAN_HPP_NOEXCEPT 12982 { 12983 std::size_t seed = 0; 12984 VULKAN_HPP_HASH_COMBINE( seed, viewportSwizzleNV.x ); 12985 VULKAN_HPP_HASH_COMBINE( seed, viewportSwizzleNV.y ); 12986 VULKAN_HPP_HASH_COMBINE( seed, viewportSwizzleNV.z ); 12987 VULKAN_HPP_HASH_COMBINE( seed, viewportSwizzleNV.w ); 12988 return seed; 12989 } 12990 }; 12991 12992 template <> 12993 struct hash<VULKAN_HPP_NAMESPACE::PipelineViewportSwizzleStateCreateInfoNV> 12994 { 12995 std::size_t operator ()std::hash12996 operator()( VULKAN_HPP_NAMESPACE::PipelineViewportSwizzleStateCreateInfoNV const & pipelineViewportSwizzleStateCreateInfoNV ) const VULKAN_HPP_NOEXCEPT 12997 { 12998 std::size_t seed = 0; 12999 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportSwizzleStateCreateInfoNV.sType ); 13000 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportSwizzleStateCreateInfoNV.pNext ); 13001 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportSwizzleStateCreateInfoNV.flags ); 13002 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportSwizzleStateCreateInfoNV.viewportCount ); 13003 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportSwizzleStateCreateInfoNV.pViewportSwizzles ); 13004 return seed; 13005 } 13006 }; 13007 13008 template <> 13009 struct hash<VULKAN_HPP_NAMESPACE::ViewportWScalingNV> 13010 { operator ()std::hash13011 std::size_t operator()( VULKAN_HPP_NAMESPACE::ViewportWScalingNV const & viewportWScalingNV ) const VULKAN_HPP_NOEXCEPT 13012 { 13013 std::size_t seed = 0; 13014 VULKAN_HPP_HASH_COMBINE( seed, viewportWScalingNV.xcoeff ); 13015 VULKAN_HPP_HASH_COMBINE( seed, viewportWScalingNV.ycoeff ); 13016 return seed; 13017 } 13018 }; 13019 13020 template <> 13021 struct hash<VULKAN_HPP_NAMESPACE::PipelineViewportWScalingStateCreateInfoNV> 13022 { 13023 std::size_t operator ()std::hash13024 operator()( VULKAN_HPP_NAMESPACE::PipelineViewportWScalingStateCreateInfoNV const & pipelineViewportWScalingStateCreateInfoNV ) const VULKAN_HPP_NOEXCEPT 13025 { 13026 std::size_t seed = 0; 13027 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportWScalingStateCreateInfoNV.sType ); 13028 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportWScalingStateCreateInfoNV.pNext ); 13029 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportWScalingStateCreateInfoNV.viewportWScalingEnable ); 13030 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportWScalingStateCreateInfoNV.viewportCount ); 13031 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportWScalingStateCreateInfoNV.pViewportWScalings ); 13032 return seed; 13033 } 13034 }; 13035 13036 # if defined( VK_USE_PLATFORM_GGP ) 13037 template <> 13038 struct hash<VULKAN_HPP_NAMESPACE::PresentFrameTokenGGP> 13039 { operator ()std::hash13040 std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentFrameTokenGGP const & presentFrameTokenGGP ) const VULKAN_HPP_NOEXCEPT 13041 { 13042 std::size_t seed = 0; 13043 VULKAN_HPP_HASH_COMBINE( seed, presentFrameTokenGGP.sType ); 13044 VULKAN_HPP_HASH_COMBINE( seed, presentFrameTokenGGP.pNext ); 13045 VULKAN_HPP_HASH_COMBINE( seed, presentFrameTokenGGP.frameToken ); 13046 return seed; 13047 } 13048 }; 13049 # endif /*VK_USE_PLATFORM_GGP*/ 13050 13051 template <> 13052 struct hash<VULKAN_HPP_NAMESPACE::PresentIdKHR> 13053 { operator ()std::hash13054 std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentIdKHR const & presentIdKHR ) const VULKAN_HPP_NOEXCEPT 13055 { 13056 std::size_t seed = 0; 13057 VULKAN_HPP_HASH_COMBINE( seed, presentIdKHR.sType ); 13058 VULKAN_HPP_HASH_COMBINE( seed, presentIdKHR.pNext ); 13059 VULKAN_HPP_HASH_COMBINE( seed, presentIdKHR.swapchainCount ); 13060 VULKAN_HPP_HASH_COMBINE( seed, presentIdKHR.pPresentIds ); 13061 return seed; 13062 } 13063 }; 13064 13065 template <> 13066 struct hash<VULKAN_HPP_NAMESPACE::PresentInfoKHR> 13067 { operator ()std::hash13068 std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentInfoKHR const & presentInfoKHR ) const VULKAN_HPP_NOEXCEPT 13069 { 13070 std::size_t seed = 0; 13071 VULKAN_HPP_HASH_COMBINE( seed, presentInfoKHR.sType ); 13072 VULKAN_HPP_HASH_COMBINE( seed, presentInfoKHR.pNext ); 13073 VULKAN_HPP_HASH_COMBINE( seed, presentInfoKHR.waitSemaphoreCount ); 13074 VULKAN_HPP_HASH_COMBINE( seed, presentInfoKHR.pWaitSemaphores ); 13075 VULKAN_HPP_HASH_COMBINE( seed, presentInfoKHR.swapchainCount ); 13076 VULKAN_HPP_HASH_COMBINE( seed, presentInfoKHR.pSwapchains ); 13077 VULKAN_HPP_HASH_COMBINE( seed, presentInfoKHR.pImageIndices ); 13078 VULKAN_HPP_HASH_COMBINE( seed, presentInfoKHR.pResults ); 13079 return seed; 13080 } 13081 }; 13082 13083 template <> 13084 struct hash<VULKAN_HPP_NAMESPACE::RectLayerKHR> 13085 { operator ()std::hash13086 std::size_t operator()( VULKAN_HPP_NAMESPACE::RectLayerKHR const & rectLayerKHR ) const VULKAN_HPP_NOEXCEPT 13087 { 13088 std::size_t seed = 0; 13089 VULKAN_HPP_HASH_COMBINE( seed, rectLayerKHR.offset ); 13090 VULKAN_HPP_HASH_COMBINE( seed, rectLayerKHR.extent ); 13091 VULKAN_HPP_HASH_COMBINE( seed, rectLayerKHR.layer ); 13092 return seed; 13093 } 13094 }; 13095 13096 template <> 13097 struct hash<VULKAN_HPP_NAMESPACE::PresentRegionKHR> 13098 { operator ()std::hash13099 std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentRegionKHR const & presentRegionKHR ) const VULKAN_HPP_NOEXCEPT 13100 { 13101 std::size_t seed = 0; 13102 VULKAN_HPP_HASH_COMBINE( seed, presentRegionKHR.rectangleCount ); 13103 VULKAN_HPP_HASH_COMBINE( seed, presentRegionKHR.pRectangles ); 13104 return seed; 13105 } 13106 }; 13107 13108 template <> 13109 struct hash<VULKAN_HPP_NAMESPACE::PresentRegionsKHR> 13110 { operator ()std::hash13111 std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentRegionsKHR const & presentRegionsKHR ) const VULKAN_HPP_NOEXCEPT 13112 { 13113 std::size_t seed = 0; 13114 VULKAN_HPP_HASH_COMBINE( seed, presentRegionsKHR.sType ); 13115 VULKAN_HPP_HASH_COMBINE( seed, presentRegionsKHR.pNext ); 13116 VULKAN_HPP_HASH_COMBINE( seed, presentRegionsKHR.swapchainCount ); 13117 VULKAN_HPP_HASH_COMBINE( seed, presentRegionsKHR.pRegions ); 13118 return seed; 13119 } 13120 }; 13121 13122 template <> 13123 struct hash<VULKAN_HPP_NAMESPACE::PresentTimeGOOGLE> 13124 { operator ()std::hash13125 std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentTimeGOOGLE const & presentTimeGOOGLE ) const VULKAN_HPP_NOEXCEPT 13126 { 13127 std::size_t seed = 0; 13128 VULKAN_HPP_HASH_COMBINE( seed, presentTimeGOOGLE.presentID ); 13129 VULKAN_HPP_HASH_COMBINE( seed, presentTimeGOOGLE.desiredPresentTime ); 13130 return seed; 13131 } 13132 }; 13133 13134 template <> 13135 struct hash<VULKAN_HPP_NAMESPACE::PresentTimesInfoGOOGLE> 13136 { operator ()std::hash13137 std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentTimesInfoGOOGLE const & presentTimesInfoGOOGLE ) const VULKAN_HPP_NOEXCEPT 13138 { 13139 std::size_t seed = 0; 13140 VULKAN_HPP_HASH_COMBINE( seed, presentTimesInfoGOOGLE.sType ); 13141 VULKAN_HPP_HASH_COMBINE( seed, presentTimesInfoGOOGLE.pNext ); 13142 VULKAN_HPP_HASH_COMBINE( seed, presentTimesInfoGOOGLE.swapchainCount ); 13143 VULKAN_HPP_HASH_COMBINE( seed, presentTimesInfoGOOGLE.pTimes ); 13144 return seed; 13145 } 13146 }; 13147 13148 template <> 13149 struct hash<VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo> 13150 { operator ()std::hash13151 std::size_t operator()( VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo const & privateDataSlotCreateInfo ) const VULKAN_HPP_NOEXCEPT 13152 { 13153 std::size_t seed = 0; 13154 VULKAN_HPP_HASH_COMBINE( seed, privateDataSlotCreateInfo.sType ); 13155 VULKAN_HPP_HASH_COMBINE( seed, privateDataSlotCreateInfo.pNext ); 13156 VULKAN_HPP_HASH_COMBINE( seed, privateDataSlotCreateInfo.flags ); 13157 return seed; 13158 } 13159 }; 13160 13161 template <> 13162 struct hash<VULKAN_HPP_NAMESPACE::ProtectedSubmitInfo> 13163 { operator ()std::hash13164 std::size_t operator()( VULKAN_HPP_NAMESPACE::ProtectedSubmitInfo const & protectedSubmitInfo ) const VULKAN_HPP_NOEXCEPT 13165 { 13166 std::size_t seed = 0; 13167 VULKAN_HPP_HASH_COMBINE( seed, protectedSubmitInfo.sType ); 13168 VULKAN_HPP_HASH_COMBINE( seed, protectedSubmitInfo.pNext ); 13169 VULKAN_HPP_HASH_COMBINE( seed, protectedSubmitInfo.protectedSubmit ); 13170 return seed; 13171 } 13172 }; 13173 13174 template <> 13175 struct hash<VULKAN_HPP_NAMESPACE::PushConstantsInfoKHR> 13176 { operator ()std::hash13177 std::size_t operator()( VULKAN_HPP_NAMESPACE::PushConstantsInfoKHR const & pushConstantsInfoKHR ) const VULKAN_HPP_NOEXCEPT 13178 { 13179 std::size_t seed = 0; 13180 VULKAN_HPP_HASH_COMBINE( seed, pushConstantsInfoKHR.sType ); 13181 VULKAN_HPP_HASH_COMBINE( seed, pushConstantsInfoKHR.pNext ); 13182 VULKAN_HPP_HASH_COMBINE( seed, pushConstantsInfoKHR.layout ); 13183 VULKAN_HPP_HASH_COMBINE( seed, pushConstantsInfoKHR.stageFlags ); 13184 VULKAN_HPP_HASH_COMBINE( seed, pushConstantsInfoKHR.offset ); 13185 VULKAN_HPP_HASH_COMBINE( seed, pushConstantsInfoKHR.size ); 13186 VULKAN_HPP_HASH_COMBINE( seed, pushConstantsInfoKHR.pValues ); 13187 return seed; 13188 } 13189 }; 13190 13191 template <> 13192 struct hash<VULKAN_HPP_NAMESPACE::WriteDescriptorSet> 13193 { operator ()std::hash13194 std::size_t operator()( VULKAN_HPP_NAMESPACE::WriteDescriptorSet const & writeDescriptorSet ) const VULKAN_HPP_NOEXCEPT 13195 { 13196 std::size_t seed = 0; 13197 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.sType ); 13198 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.pNext ); 13199 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.dstSet ); 13200 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.dstBinding ); 13201 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.dstArrayElement ); 13202 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.descriptorCount ); 13203 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.descriptorType ); 13204 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.pImageInfo ); 13205 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.pBufferInfo ); 13206 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.pTexelBufferView ); 13207 return seed; 13208 } 13209 }; 13210 13211 template <> 13212 struct hash<VULKAN_HPP_NAMESPACE::PushDescriptorSetInfoKHR> 13213 { operator ()std::hash13214 std::size_t operator()( VULKAN_HPP_NAMESPACE::PushDescriptorSetInfoKHR const & pushDescriptorSetInfoKHR ) const VULKAN_HPP_NOEXCEPT 13215 { 13216 std::size_t seed = 0; 13217 VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetInfoKHR.sType ); 13218 VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetInfoKHR.pNext ); 13219 VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetInfoKHR.stageFlags ); 13220 VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetInfoKHR.layout ); 13221 VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetInfoKHR.set ); 13222 VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetInfoKHR.descriptorWriteCount ); 13223 VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetInfoKHR.pDescriptorWrites ); 13224 return seed; 13225 } 13226 }; 13227 13228 template <> 13229 struct hash<VULKAN_HPP_NAMESPACE::PushDescriptorSetWithTemplateInfoKHR> 13230 { operator ()std::hash13231 std::size_t operator()( VULKAN_HPP_NAMESPACE::PushDescriptorSetWithTemplateInfoKHR const & pushDescriptorSetWithTemplateInfoKHR ) const VULKAN_HPP_NOEXCEPT 13232 { 13233 std::size_t seed = 0; 13234 VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetWithTemplateInfoKHR.sType ); 13235 VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetWithTemplateInfoKHR.pNext ); 13236 VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetWithTemplateInfoKHR.descriptorUpdateTemplate ); 13237 VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetWithTemplateInfoKHR.layout ); 13238 VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetWithTemplateInfoKHR.set ); 13239 VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetWithTemplateInfoKHR.pData ); 13240 return seed; 13241 } 13242 }; 13243 13244 template <> 13245 struct hash<VULKAN_HPP_NAMESPACE::QueryLowLatencySupportNV> 13246 { operator ()std::hash13247 std::size_t operator()( VULKAN_HPP_NAMESPACE::QueryLowLatencySupportNV const & queryLowLatencySupportNV ) const VULKAN_HPP_NOEXCEPT 13248 { 13249 std::size_t seed = 0; 13250 VULKAN_HPP_HASH_COMBINE( seed, queryLowLatencySupportNV.sType ); 13251 VULKAN_HPP_HASH_COMBINE( seed, queryLowLatencySupportNV.pNext ); 13252 VULKAN_HPP_HASH_COMBINE( seed, queryLowLatencySupportNV.pQueriedLowLatencyData ); 13253 return seed; 13254 } 13255 }; 13256 13257 template <> 13258 struct hash<VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo> 13259 { operator ()std::hash13260 std::size_t operator()( VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo const & queryPoolCreateInfo ) const VULKAN_HPP_NOEXCEPT 13261 { 13262 std::size_t seed = 0; 13263 VULKAN_HPP_HASH_COMBINE( seed, queryPoolCreateInfo.sType ); 13264 VULKAN_HPP_HASH_COMBINE( seed, queryPoolCreateInfo.pNext ); 13265 VULKAN_HPP_HASH_COMBINE( seed, queryPoolCreateInfo.flags ); 13266 VULKAN_HPP_HASH_COMBINE( seed, queryPoolCreateInfo.queryType ); 13267 VULKAN_HPP_HASH_COMBINE( seed, queryPoolCreateInfo.queryCount ); 13268 VULKAN_HPP_HASH_COMBINE( seed, queryPoolCreateInfo.pipelineStatistics ); 13269 return seed; 13270 } 13271 }; 13272 13273 template <> 13274 struct hash<VULKAN_HPP_NAMESPACE::QueryPoolPerformanceCreateInfoKHR> 13275 { operator ()std::hash13276 std::size_t operator()( VULKAN_HPP_NAMESPACE::QueryPoolPerformanceCreateInfoKHR const & queryPoolPerformanceCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 13277 { 13278 std::size_t seed = 0; 13279 VULKAN_HPP_HASH_COMBINE( seed, queryPoolPerformanceCreateInfoKHR.sType ); 13280 VULKAN_HPP_HASH_COMBINE( seed, queryPoolPerformanceCreateInfoKHR.pNext ); 13281 VULKAN_HPP_HASH_COMBINE( seed, queryPoolPerformanceCreateInfoKHR.queueFamilyIndex ); 13282 VULKAN_HPP_HASH_COMBINE( seed, queryPoolPerformanceCreateInfoKHR.counterIndexCount ); 13283 VULKAN_HPP_HASH_COMBINE( seed, queryPoolPerformanceCreateInfoKHR.pCounterIndices ); 13284 return seed; 13285 } 13286 }; 13287 13288 template <> 13289 struct hash<VULKAN_HPP_NAMESPACE::QueryPoolPerformanceQueryCreateInfoINTEL> 13290 { 13291 std::size_t operator ()std::hash13292 operator()( VULKAN_HPP_NAMESPACE::QueryPoolPerformanceQueryCreateInfoINTEL const & queryPoolPerformanceQueryCreateInfoINTEL ) const VULKAN_HPP_NOEXCEPT 13293 { 13294 std::size_t seed = 0; 13295 VULKAN_HPP_HASH_COMBINE( seed, queryPoolPerformanceQueryCreateInfoINTEL.sType ); 13296 VULKAN_HPP_HASH_COMBINE( seed, queryPoolPerformanceQueryCreateInfoINTEL.pNext ); 13297 VULKAN_HPP_HASH_COMBINE( seed, queryPoolPerformanceQueryCreateInfoINTEL.performanceCountersSampling ); 13298 return seed; 13299 } 13300 }; 13301 13302 template <> 13303 struct hash<VULKAN_HPP_NAMESPACE::QueryPoolVideoEncodeFeedbackCreateInfoKHR> 13304 { 13305 std::size_t operator ()std::hash13306 operator()( VULKAN_HPP_NAMESPACE::QueryPoolVideoEncodeFeedbackCreateInfoKHR const & queryPoolVideoEncodeFeedbackCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 13307 { 13308 std::size_t seed = 0; 13309 VULKAN_HPP_HASH_COMBINE( seed, queryPoolVideoEncodeFeedbackCreateInfoKHR.sType ); 13310 VULKAN_HPP_HASH_COMBINE( seed, queryPoolVideoEncodeFeedbackCreateInfoKHR.pNext ); 13311 VULKAN_HPP_HASH_COMBINE( seed, queryPoolVideoEncodeFeedbackCreateInfoKHR.encodeFeedbackFlags ); 13312 return seed; 13313 } 13314 }; 13315 13316 template <> 13317 struct hash<VULKAN_HPP_NAMESPACE::QueueFamilyCheckpointProperties2NV> 13318 { operator ()std::hash13319 std::size_t operator()( VULKAN_HPP_NAMESPACE::QueueFamilyCheckpointProperties2NV const & queueFamilyCheckpointProperties2NV ) const VULKAN_HPP_NOEXCEPT 13320 { 13321 std::size_t seed = 0; 13322 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyCheckpointProperties2NV.sType ); 13323 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyCheckpointProperties2NV.pNext ); 13324 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyCheckpointProperties2NV.checkpointExecutionStageMask ); 13325 return seed; 13326 } 13327 }; 13328 13329 template <> 13330 struct hash<VULKAN_HPP_NAMESPACE::QueueFamilyCheckpointPropertiesNV> 13331 { operator ()std::hash13332 std::size_t operator()( VULKAN_HPP_NAMESPACE::QueueFamilyCheckpointPropertiesNV const & queueFamilyCheckpointPropertiesNV ) const VULKAN_HPP_NOEXCEPT 13333 { 13334 std::size_t seed = 0; 13335 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyCheckpointPropertiesNV.sType ); 13336 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyCheckpointPropertiesNV.pNext ); 13337 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyCheckpointPropertiesNV.checkpointExecutionStageMask ); 13338 return seed; 13339 } 13340 }; 13341 13342 template <> 13343 struct hash<VULKAN_HPP_NAMESPACE::QueueFamilyGlobalPriorityPropertiesKHR> 13344 { 13345 std::size_t operator ()std::hash13346 operator()( VULKAN_HPP_NAMESPACE::QueueFamilyGlobalPriorityPropertiesKHR const & queueFamilyGlobalPriorityPropertiesKHR ) const VULKAN_HPP_NOEXCEPT 13347 { 13348 std::size_t seed = 0; 13349 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyGlobalPriorityPropertiesKHR.sType ); 13350 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyGlobalPriorityPropertiesKHR.pNext ); 13351 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyGlobalPriorityPropertiesKHR.priorityCount ); 13352 for ( size_t i = 0; i < VK_MAX_GLOBAL_PRIORITY_SIZE_KHR; ++i ) 13353 { 13354 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyGlobalPriorityPropertiesKHR.priorities[i] ); 13355 } 13356 return seed; 13357 } 13358 }; 13359 13360 template <> 13361 struct hash<VULKAN_HPP_NAMESPACE::QueueFamilyProperties> 13362 { operator ()std::hash13363 std::size_t operator()( VULKAN_HPP_NAMESPACE::QueueFamilyProperties const & queueFamilyProperties ) const VULKAN_HPP_NOEXCEPT 13364 { 13365 std::size_t seed = 0; 13366 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyProperties.queueFlags ); 13367 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyProperties.queueCount ); 13368 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyProperties.timestampValidBits ); 13369 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyProperties.minImageTransferGranularity ); 13370 return seed; 13371 } 13372 }; 13373 13374 template <> 13375 struct hash<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2> 13376 { operator ()std::hash13377 std::size_t operator()( VULKAN_HPP_NAMESPACE::QueueFamilyProperties2 const & queueFamilyProperties2 ) const VULKAN_HPP_NOEXCEPT 13378 { 13379 std::size_t seed = 0; 13380 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyProperties2.sType ); 13381 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyProperties2.pNext ); 13382 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyProperties2.queueFamilyProperties ); 13383 return seed; 13384 } 13385 }; 13386 13387 template <> 13388 struct hash<VULKAN_HPP_NAMESPACE::QueueFamilyQueryResultStatusPropertiesKHR> 13389 { 13390 std::size_t operator ()std::hash13391 operator()( VULKAN_HPP_NAMESPACE::QueueFamilyQueryResultStatusPropertiesKHR const & queueFamilyQueryResultStatusPropertiesKHR ) const VULKAN_HPP_NOEXCEPT 13392 { 13393 std::size_t seed = 0; 13394 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyQueryResultStatusPropertiesKHR.sType ); 13395 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyQueryResultStatusPropertiesKHR.pNext ); 13396 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyQueryResultStatusPropertiesKHR.queryResultStatusSupport ); 13397 return seed; 13398 } 13399 }; 13400 13401 template <> 13402 struct hash<VULKAN_HPP_NAMESPACE::QueueFamilyVideoPropertiesKHR> 13403 { operator ()std::hash13404 std::size_t operator()( VULKAN_HPP_NAMESPACE::QueueFamilyVideoPropertiesKHR const & queueFamilyVideoPropertiesKHR ) const VULKAN_HPP_NOEXCEPT 13405 { 13406 std::size_t seed = 0; 13407 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyVideoPropertiesKHR.sType ); 13408 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyVideoPropertiesKHR.pNext ); 13409 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyVideoPropertiesKHR.videoCodecOperations ); 13410 return seed; 13411 } 13412 }; 13413 13414 template <> 13415 struct hash<VULKAN_HPP_NAMESPACE::RayTracingShaderGroupCreateInfoKHR> 13416 { operator ()std::hash13417 std::size_t operator()( VULKAN_HPP_NAMESPACE::RayTracingShaderGroupCreateInfoKHR const & rayTracingShaderGroupCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 13418 { 13419 std::size_t seed = 0; 13420 VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoKHR.sType ); 13421 VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoKHR.pNext ); 13422 VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoKHR.type ); 13423 VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoKHR.generalShader ); 13424 VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoKHR.closestHitShader ); 13425 VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoKHR.anyHitShader ); 13426 VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoKHR.intersectionShader ); 13427 VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoKHR.pShaderGroupCaptureReplayHandle ); 13428 return seed; 13429 } 13430 }; 13431 13432 template <> 13433 struct hash<VULKAN_HPP_NAMESPACE::RayTracingPipelineInterfaceCreateInfoKHR> 13434 { 13435 std::size_t operator ()std::hash13436 operator()( VULKAN_HPP_NAMESPACE::RayTracingPipelineInterfaceCreateInfoKHR const & rayTracingPipelineInterfaceCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 13437 { 13438 std::size_t seed = 0; 13439 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineInterfaceCreateInfoKHR.sType ); 13440 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineInterfaceCreateInfoKHR.pNext ); 13441 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineInterfaceCreateInfoKHR.maxPipelineRayPayloadSize ); 13442 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineInterfaceCreateInfoKHR.maxPipelineRayHitAttributeSize ); 13443 return seed; 13444 } 13445 }; 13446 13447 template <> 13448 struct hash<VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> 13449 { operator ()std::hash13450 std::size_t operator()( VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR const & rayTracingPipelineCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 13451 { 13452 std::size_t seed = 0; 13453 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.sType ); 13454 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.pNext ); 13455 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.flags ); 13456 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.stageCount ); 13457 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.pStages ); 13458 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.groupCount ); 13459 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.pGroups ); 13460 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.maxPipelineRayRecursionDepth ); 13461 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.pLibraryInfo ); 13462 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.pLibraryInterface ); 13463 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.pDynamicState ); 13464 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.layout ); 13465 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.basePipelineHandle ); 13466 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.basePipelineIndex ); 13467 return seed; 13468 } 13469 }; 13470 13471 template <> 13472 struct hash<VULKAN_HPP_NAMESPACE::RayTracingShaderGroupCreateInfoNV> 13473 { operator ()std::hash13474 std::size_t operator()( VULKAN_HPP_NAMESPACE::RayTracingShaderGroupCreateInfoNV const & rayTracingShaderGroupCreateInfoNV ) const VULKAN_HPP_NOEXCEPT 13475 { 13476 std::size_t seed = 0; 13477 VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoNV.sType ); 13478 VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoNV.pNext ); 13479 VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoNV.type ); 13480 VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoNV.generalShader ); 13481 VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoNV.closestHitShader ); 13482 VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoNV.anyHitShader ); 13483 VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoNV.intersectionShader ); 13484 return seed; 13485 } 13486 }; 13487 13488 template <> 13489 struct hash<VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> 13490 { operator ()std::hash13491 std::size_t operator()( VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV const & rayTracingPipelineCreateInfoNV ) const VULKAN_HPP_NOEXCEPT 13492 { 13493 std::size_t seed = 0; 13494 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.sType ); 13495 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.pNext ); 13496 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.flags ); 13497 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.stageCount ); 13498 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.pStages ); 13499 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.groupCount ); 13500 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.pGroups ); 13501 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.maxRecursionDepth ); 13502 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.layout ); 13503 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.basePipelineHandle ); 13504 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.basePipelineIndex ); 13505 return seed; 13506 } 13507 }; 13508 13509 template <> 13510 struct hash<VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE> 13511 { operator ()std::hash13512 std::size_t operator()( VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE const & refreshCycleDurationGOOGLE ) const VULKAN_HPP_NOEXCEPT 13513 { 13514 std::size_t seed = 0; 13515 VULKAN_HPP_HASH_COMBINE( seed, refreshCycleDurationGOOGLE.refreshDuration ); 13516 return seed; 13517 } 13518 }; 13519 13520 template <> 13521 struct hash<VULKAN_HPP_NAMESPACE::ReleaseSwapchainImagesInfoEXT> 13522 { operator ()std::hash13523 std::size_t operator()( VULKAN_HPP_NAMESPACE::ReleaseSwapchainImagesInfoEXT const & releaseSwapchainImagesInfoEXT ) const VULKAN_HPP_NOEXCEPT 13524 { 13525 std::size_t seed = 0; 13526 VULKAN_HPP_HASH_COMBINE( seed, releaseSwapchainImagesInfoEXT.sType ); 13527 VULKAN_HPP_HASH_COMBINE( seed, releaseSwapchainImagesInfoEXT.pNext ); 13528 VULKAN_HPP_HASH_COMBINE( seed, releaseSwapchainImagesInfoEXT.swapchain ); 13529 VULKAN_HPP_HASH_COMBINE( seed, releaseSwapchainImagesInfoEXT.imageIndexCount ); 13530 VULKAN_HPP_HASH_COMBINE( seed, releaseSwapchainImagesInfoEXT.pImageIndices ); 13531 return seed; 13532 } 13533 }; 13534 13535 template <> 13536 struct hash<VULKAN_HPP_NAMESPACE::RenderPassAttachmentBeginInfo> 13537 { operator ()std::hash13538 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassAttachmentBeginInfo const & renderPassAttachmentBeginInfo ) const VULKAN_HPP_NOEXCEPT 13539 { 13540 std::size_t seed = 0; 13541 VULKAN_HPP_HASH_COMBINE( seed, renderPassAttachmentBeginInfo.sType ); 13542 VULKAN_HPP_HASH_COMBINE( seed, renderPassAttachmentBeginInfo.pNext ); 13543 VULKAN_HPP_HASH_COMBINE( seed, renderPassAttachmentBeginInfo.attachmentCount ); 13544 VULKAN_HPP_HASH_COMBINE( seed, renderPassAttachmentBeginInfo.pAttachments ); 13545 return seed; 13546 } 13547 }; 13548 13549 template <> 13550 struct hash<VULKAN_HPP_NAMESPACE::RenderPassBeginInfo> 13551 { operator ()std::hash13552 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassBeginInfo const & renderPassBeginInfo ) const VULKAN_HPP_NOEXCEPT 13553 { 13554 std::size_t seed = 0; 13555 VULKAN_HPP_HASH_COMBINE( seed, renderPassBeginInfo.sType ); 13556 VULKAN_HPP_HASH_COMBINE( seed, renderPassBeginInfo.pNext ); 13557 VULKAN_HPP_HASH_COMBINE( seed, renderPassBeginInfo.renderPass ); 13558 VULKAN_HPP_HASH_COMBINE( seed, renderPassBeginInfo.framebuffer ); 13559 VULKAN_HPP_HASH_COMBINE( seed, renderPassBeginInfo.renderArea ); 13560 VULKAN_HPP_HASH_COMBINE( seed, renderPassBeginInfo.clearValueCount ); 13561 VULKAN_HPP_HASH_COMBINE( seed, renderPassBeginInfo.pClearValues ); 13562 return seed; 13563 } 13564 }; 13565 13566 template <> 13567 struct hash<VULKAN_HPP_NAMESPACE::SubpassDescription> 13568 { operator ()std::hash13569 std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassDescription const & subpassDescription ) const VULKAN_HPP_NOEXCEPT 13570 { 13571 std::size_t seed = 0; 13572 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.flags ); 13573 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.pipelineBindPoint ); 13574 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.inputAttachmentCount ); 13575 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.pInputAttachments ); 13576 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.colorAttachmentCount ); 13577 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.pColorAttachments ); 13578 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.pResolveAttachments ); 13579 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.pDepthStencilAttachment ); 13580 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.preserveAttachmentCount ); 13581 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.pPreserveAttachments ); 13582 return seed; 13583 } 13584 }; 13585 13586 template <> 13587 struct hash<VULKAN_HPP_NAMESPACE::SubpassDependency> 13588 { operator ()std::hash13589 std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassDependency const & subpassDependency ) const VULKAN_HPP_NOEXCEPT 13590 { 13591 std::size_t seed = 0; 13592 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency.srcSubpass ); 13593 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency.dstSubpass ); 13594 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency.srcStageMask ); 13595 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency.dstStageMask ); 13596 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency.srcAccessMask ); 13597 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency.dstAccessMask ); 13598 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency.dependencyFlags ); 13599 return seed; 13600 } 13601 }; 13602 13603 template <> 13604 struct hash<VULKAN_HPP_NAMESPACE::RenderPassCreateInfo> 13605 { operator ()std::hash13606 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassCreateInfo const & renderPassCreateInfo ) const VULKAN_HPP_NOEXCEPT 13607 { 13608 std::size_t seed = 0; 13609 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo.sType ); 13610 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo.pNext ); 13611 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo.flags ); 13612 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo.attachmentCount ); 13613 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo.pAttachments ); 13614 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo.subpassCount ); 13615 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo.pSubpasses ); 13616 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo.dependencyCount ); 13617 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo.pDependencies ); 13618 return seed; 13619 } 13620 }; 13621 13622 template <> 13623 struct hash<VULKAN_HPP_NAMESPACE::SubpassDescription2> 13624 { operator ()std::hash13625 std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassDescription2 const & subpassDescription2 ) const VULKAN_HPP_NOEXCEPT 13626 { 13627 std::size_t seed = 0; 13628 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.sType ); 13629 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.pNext ); 13630 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.flags ); 13631 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.pipelineBindPoint ); 13632 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.viewMask ); 13633 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.inputAttachmentCount ); 13634 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.pInputAttachments ); 13635 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.colorAttachmentCount ); 13636 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.pColorAttachments ); 13637 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.pResolveAttachments ); 13638 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.pDepthStencilAttachment ); 13639 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.preserveAttachmentCount ); 13640 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.pPreserveAttachments ); 13641 return seed; 13642 } 13643 }; 13644 13645 template <> 13646 struct hash<VULKAN_HPP_NAMESPACE::SubpassDependency2> 13647 { operator ()std::hash13648 std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassDependency2 const & subpassDependency2 ) const VULKAN_HPP_NOEXCEPT 13649 { 13650 std::size_t seed = 0; 13651 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.sType ); 13652 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.pNext ); 13653 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.srcSubpass ); 13654 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.dstSubpass ); 13655 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.srcStageMask ); 13656 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.dstStageMask ); 13657 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.srcAccessMask ); 13658 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.dstAccessMask ); 13659 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.dependencyFlags ); 13660 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.viewOffset ); 13661 return seed; 13662 } 13663 }; 13664 13665 template <> 13666 struct hash<VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2> 13667 { operator ()std::hash13668 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 const & renderPassCreateInfo2 ) const VULKAN_HPP_NOEXCEPT 13669 { 13670 std::size_t seed = 0; 13671 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.sType ); 13672 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.pNext ); 13673 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.flags ); 13674 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.attachmentCount ); 13675 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.pAttachments ); 13676 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.subpassCount ); 13677 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.pSubpasses ); 13678 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.dependencyCount ); 13679 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.pDependencies ); 13680 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.correlatedViewMaskCount ); 13681 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.pCorrelatedViewMasks ); 13682 return seed; 13683 } 13684 }; 13685 13686 template <> 13687 struct hash<VULKAN_HPP_NAMESPACE::RenderPassCreationControlEXT> 13688 { operator ()std::hash13689 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassCreationControlEXT const & renderPassCreationControlEXT ) const VULKAN_HPP_NOEXCEPT 13690 { 13691 std::size_t seed = 0; 13692 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreationControlEXT.sType ); 13693 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreationControlEXT.pNext ); 13694 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreationControlEXT.disallowMerging ); 13695 return seed; 13696 } 13697 }; 13698 13699 template <> 13700 struct hash<VULKAN_HPP_NAMESPACE::RenderPassCreationFeedbackInfoEXT> 13701 { operator ()std::hash13702 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassCreationFeedbackInfoEXT const & renderPassCreationFeedbackInfoEXT ) const VULKAN_HPP_NOEXCEPT 13703 { 13704 std::size_t seed = 0; 13705 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreationFeedbackInfoEXT.postMergeSubpassCount ); 13706 return seed; 13707 } 13708 }; 13709 13710 template <> 13711 struct hash<VULKAN_HPP_NAMESPACE::RenderPassCreationFeedbackCreateInfoEXT> 13712 { 13713 std::size_t operator ()std::hash13714 operator()( VULKAN_HPP_NAMESPACE::RenderPassCreationFeedbackCreateInfoEXT const & renderPassCreationFeedbackCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 13715 { 13716 std::size_t seed = 0; 13717 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreationFeedbackCreateInfoEXT.sType ); 13718 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreationFeedbackCreateInfoEXT.pNext ); 13719 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreationFeedbackCreateInfoEXT.pRenderPassFeedback ); 13720 return seed; 13721 } 13722 }; 13723 13724 template <> 13725 struct hash<VULKAN_HPP_NAMESPACE::RenderPassFragmentDensityMapCreateInfoEXT> 13726 { 13727 std::size_t operator ()std::hash13728 operator()( VULKAN_HPP_NAMESPACE::RenderPassFragmentDensityMapCreateInfoEXT const & renderPassFragmentDensityMapCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 13729 { 13730 std::size_t seed = 0; 13731 VULKAN_HPP_HASH_COMBINE( seed, renderPassFragmentDensityMapCreateInfoEXT.sType ); 13732 VULKAN_HPP_HASH_COMBINE( seed, renderPassFragmentDensityMapCreateInfoEXT.pNext ); 13733 VULKAN_HPP_HASH_COMBINE( seed, renderPassFragmentDensityMapCreateInfoEXT.fragmentDensityMapAttachment ); 13734 return seed; 13735 } 13736 }; 13737 13738 template <> 13739 struct hash<VULKAN_HPP_NAMESPACE::RenderPassInputAttachmentAspectCreateInfo> 13740 { 13741 std::size_t operator ()std::hash13742 operator()( VULKAN_HPP_NAMESPACE::RenderPassInputAttachmentAspectCreateInfo const & renderPassInputAttachmentAspectCreateInfo ) const VULKAN_HPP_NOEXCEPT 13743 { 13744 std::size_t seed = 0; 13745 VULKAN_HPP_HASH_COMBINE( seed, renderPassInputAttachmentAspectCreateInfo.sType ); 13746 VULKAN_HPP_HASH_COMBINE( seed, renderPassInputAttachmentAspectCreateInfo.pNext ); 13747 VULKAN_HPP_HASH_COMBINE( seed, renderPassInputAttachmentAspectCreateInfo.aspectReferenceCount ); 13748 VULKAN_HPP_HASH_COMBINE( seed, renderPassInputAttachmentAspectCreateInfo.pAspectReferences ); 13749 return seed; 13750 } 13751 }; 13752 13753 template <> 13754 struct hash<VULKAN_HPP_NAMESPACE::RenderPassMultiviewCreateInfo> 13755 { operator ()std::hash13756 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassMultiviewCreateInfo const & renderPassMultiviewCreateInfo ) const VULKAN_HPP_NOEXCEPT 13757 { 13758 std::size_t seed = 0; 13759 VULKAN_HPP_HASH_COMBINE( seed, renderPassMultiviewCreateInfo.sType ); 13760 VULKAN_HPP_HASH_COMBINE( seed, renderPassMultiviewCreateInfo.pNext ); 13761 VULKAN_HPP_HASH_COMBINE( seed, renderPassMultiviewCreateInfo.subpassCount ); 13762 VULKAN_HPP_HASH_COMBINE( seed, renderPassMultiviewCreateInfo.pViewMasks ); 13763 VULKAN_HPP_HASH_COMBINE( seed, renderPassMultiviewCreateInfo.dependencyCount ); 13764 VULKAN_HPP_HASH_COMBINE( seed, renderPassMultiviewCreateInfo.pViewOffsets ); 13765 VULKAN_HPP_HASH_COMBINE( seed, renderPassMultiviewCreateInfo.correlationMaskCount ); 13766 VULKAN_HPP_HASH_COMBINE( seed, renderPassMultiviewCreateInfo.pCorrelationMasks ); 13767 return seed; 13768 } 13769 }; 13770 13771 template <> 13772 struct hash<VULKAN_HPP_NAMESPACE::SubpassSampleLocationsEXT> 13773 { operator ()std::hash13774 std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassSampleLocationsEXT const & subpassSampleLocationsEXT ) const VULKAN_HPP_NOEXCEPT 13775 { 13776 std::size_t seed = 0; 13777 VULKAN_HPP_HASH_COMBINE( seed, subpassSampleLocationsEXT.subpassIndex ); 13778 VULKAN_HPP_HASH_COMBINE( seed, subpassSampleLocationsEXT.sampleLocationsInfo ); 13779 return seed; 13780 } 13781 }; 13782 13783 template <> 13784 struct hash<VULKAN_HPP_NAMESPACE::RenderPassSampleLocationsBeginInfoEXT> 13785 { 13786 std::size_t operator ()std::hash13787 operator()( VULKAN_HPP_NAMESPACE::RenderPassSampleLocationsBeginInfoEXT const & renderPassSampleLocationsBeginInfoEXT ) const VULKAN_HPP_NOEXCEPT 13788 { 13789 std::size_t seed = 0; 13790 VULKAN_HPP_HASH_COMBINE( seed, renderPassSampleLocationsBeginInfoEXT.sType ); 13791 VULKAN_HPP_HASH_COMBINE( seed, renderPassSampleLocationsBeginInfoEXT.pNext ); 13792 VULKAN_HPP_HASH_COMBINE( seed, renderPassSampleLocationsBeginInfoEXT.attachmentInitialSampleLocationsCount ); 13793 VULKAN_HPP_HASH_COMBINE( seed, renderPassSampleLocationsBeginInfoEXT.pAttachmentInitialSampleLocations ); 13794 VULKAN_HPP_HASH_COMBINE( seed, renderPassSampleLocationsBeginInfoEXT.postSubpassSampleLocationsCount ); 13795 VULKAN_HPP_HASH_COMBINE( seed, renderPassSampleLocationsBeginInfoEXT.pPostSubpassSampleLocations ); 13796 return seed; 13797 } 13798 }; 13799 13800 template <> 13801 struct hash<VULKAN_HPP_NAMESPACE::RenderPassStripeInfoARM> 13802 { operator ()std::hash13803 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassStripeInfoARM const & renderPassStripeInfoARM ) const VULKAN_HPP_NOEXCEPT 13804 { 13805 std::size_t seed = 0; 13806 VULKAN_HPP_HASH_COMBINE( seed, renderPassStripeInfoARM.sType ); 13807 VULKAN_HPP_HASH_COMBINE( seed, renderPassStripeInfoARM.pNext ); 13808 VULKAN_HPP_HASH_COMBINE( seed, renderPassStripeInfoARM.stripeArea ); 13809 return seed; 13810 } 13811 }; 13812 13813 template <> 13814 struct hash<VULKAN_HPP_NAMESPACE::RenderPassStripeBeginInfoARM> 13815 { operator ()std::hash13816 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassStripeBeginInfoARM const & renderPassStripeBeginInfoARM ) const VULKAN_HPP_NOEXCEPT 13817 { 13818 std::size_t seed = 0; 13819 VULKAN_HPP_HASH_COMBINE( seed, renderPassStripeBeginInfoARM.sType ); 13820 VULKAN_HPP_HASH_COMBINE( seed, renderPassStripeBeginInfoARM.pNext ); 13821 VULKAN_HPP_HASH_COMBINE( seed, renderPassStripeBeginInfoARM.stripeInfoCount ); 13822 VULKAN_HPP_HASH_COMBINE( seed, renderPassStripeBeginInfoARM.pStripeInfos ); 13823 return seed; 13824 } 13825 }; 13826 13827 template <> 13828 struct hash<VULKAN_HPP_NAMESPACE::SemaphoreSubmitInfo> 13829 { operator ()std::hash13830 std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreSubmitInfo const & semaphoreSubmitInfo ) const VULKAN_HPP_NOEXCEPT 13831 { 13832 std::size_t seed = 0; 13833 VULKAN_HPP_HASH_COMBINE( seed, semaphoreSubmitInfo.sType ); 13834 VULKAN_HPP_HASH_COMBINE( seed, semaphoreSubmitInfo.pNext ); 13835 VULKAN_HPP_HASH_COMBINE( seed, semaphoreSubmitInfo.semaphore ); 13836 VULKAN_HPP_HASH_COMBINE( seed, semaphoreSubmitInfo.value ); 13837 VULKAN_HPP_HASH_COMBINE( seed, semaphoreSubmitInfo.stageMask ); 13838 VULKAN_HPP_HASH_COMBINE( seed, semaphoreSubmitInfo.deviceIndex ); 13839 return seed; 13840 } 13841 }; 13842 13843 template <> 13844 struct hash<VULKAN_HPP_NAMESPACE::RenderPassStripeSubmitInfoARM> 13845 { operator ()std::hash13846 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassStripeSubmitInfoARM const & renderPassStripeSubmitInfoARM ) const VULKAN_HPP_NOEXCEPT 13847 { 13848 std::size_t seed = 0; 13849 VULKAN_HPP_HASH_COMBINE( seed, renderPassStripeSubmitInfoARM.sType ); 13850 VULKAN_HPP_HASH_COMBINE( seed, renderPassStripeSubmitInfoARM.pNext ); 13851 VULKAN_HPP_HASH_COMBINE( seed, renderPassStripeSubmitInfoARM.stripeSemaphoreInfoCount ); 13852 VULKAN_HPP_HASH_COMBINE( seed, renderPassStripeSubmitInfoARM.pStripeSemaphoreInfos ); 13853 return seed; 13854 } 13855 }; 13856 13857 template <> 13858 struct hash<VULKAN_HPP_NAMESPACE::RenderPassSubpassFeedbackInfoEXT> 13859 { operator ()std::hash13860 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassSubpassFeedbackInfoEXT const & renderPassSubpassFeedbackInfoEXT ) const VULKAN_HPP_NOEXCEPT 13861 { 13862 std::size_t seed = 0; 13863 VULKAN_HPP_HASH_COMBINE( seed, renderPassSubpassFeedbackInfoEXT.subpassMergeStatus ); 13864 for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) 13865 { 13866 VULKAN_HPP_HASH_COMBINE( seed, renderPassSubpassFeedbackInfoEXT.description[i] ); 13867 } 13868 VULKAN_HPP_HASH_COMBINE( seed, renderPassSubpassFeedbackInfoEXT.postMergeIndex ); 13869 return seed; 13870 } 13871 }; 13872 13873 template <> 13874 struct hash<VULKAN_HPP_NAMESPACE::RenderPassSubpassFeedbackCreateInfoEXT> 13875 { 13876 std::size_t operator ()std::hash13877 operator()( VULKAN_HPP_NAMESPACE::RenderPassSubpassFeedbackCreateInfoEXT const & renderPassSubpassFeedbackCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 13878 { 13879 std::size_t seed = 0; 13880 VULKAN_HPP_HASH_COMBINE( seed, renderPassSubpassFeedbackCreateInfoEXT.sType ); 13881 VULKAN_HPP_HASH_COMBINE( seed, renderPassSubpassFeedbackCreateInfoEXT.pNext ); 13882 VULKAN_HPP_HASH_COMBINE( seed, renderPassSubpassFeedbackCreateInfoEXT.pSubpassFeedback ); 13883 return seed; 13884 } 13885 }; 13886 13887 template <> 13888 struct hash<VULKAN_HPP_NAMESPACE::RenderPassTransformBeginInfoQCOM> 13889 { operator ()std::hash13890 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassTransformBeginInfoQCOM const & renderPassTransformBeginInfoQCOM ) const VULKAN_HPP_NOEXCEPT 13891 { 13892 std::size_t seed = 0; 13893 VULKAN_HPP_HASH_COMBINE( seed, renderPassTransformBeginInfoQCOM.sType ); 13894 VULKAN_HPP_HASH_COMBINE( seed, renderPassTransformBeginInfoQCOM.pNext ); 13895 VULKAN_HPP_HASH_COMBINE( seed, renderPassTransformBeginInfoQCOM.transform ); 13896 return seed; 13897 } 13898 }; 13899 13900 template <> 13901 struct hash<VULKAN_HPP_NAMESPACE::RenderingAreaInfoKHR> 13902 { operator ()std::hash13903 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderingAreaInfoKHR const & renderingAreaInfoKHR ) const VULKAN_HPP_NOEXCEPT 13904 { 13905 std::size_t seed = 0; 13906 VULKAN_HPP_HASH_COMBINE( seed, renderingAreaInfoKHR.sType ); 13907 VULKAN_HPP_HASH_COMBINE( seed, renderingAreaInfoKHR.pNext ); 13908 VULKAN_HPP_HASH_COMBINE( seed, renderingAreaInfoKHR.viewMask ); 13909 VULKAN_HPP_HASH_COMBINE( seed, renderingAreaInfoKHR.colorAttachmentCount ); 13910 VULKAN_HPP_HASH_COMBINE( seed, renderingAreaInfoKHR.pColorAttachmentFormats ); 13911 VULKAN_HPP_HASH_COMBINE( seed, renderingAreaInfoKHR.depthAttachmentFormat ); 13912 VULKAN_HPP_HASH_COMBINE( seed, renderingAreaInfoKHR.stencilAttachmentFormat ); 13913 return seed; 13914 } 13915 }; 13916 13917 template <> 13918 struct hash<VULKAN_HPP_NAMESPACE::RenderingFragmentDensityMapAttachmentInfoEXT> 13919 { operator ()std::hash13920 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderingFragmentDensityMapAttachmentInfoEXT const & renderingFragmentDensityMapAttachmentInfoEXT ) const 13921 VULKAN_HPP_NOEXCEPT 13922 { 13923 std::size_t seed = 0; 13924 VULKAN_HPP_HASH_COMBINE( seed, renderingFragmentDensityMapAttachmentInfoEXT.sType ); 13925 VULKAN_HPP_HASH_COMBINE( seed, renderingFragmentDensityMapAttachmentInfoEXT.pNext ); 13926 VULKAN_HPP_HASH_COMBINE( seed, renderingFragmentDensityMapAttachmentInfoEXT.imageView ); 13927 VULKAN_HPP_HASH_COMBINE( seed, renderingFragmentDensityMapAttachmentInfoEXT.imageLayout ); 13928 return seed; 13929 } 13930 }; 13931 13932 template <> 13933 struct hash<VULKAN_HPP_NAMESPACE::RenderingFragmentShadingRateAttachmentInfoKHR> 13934 { operator ()std::hash13935 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderingFragmentShadingRateAttachmentInfoKHR const & renderingFragmentShadingRateAttachmentInfoKHR ) const 13936 VULKAN_HPP_NOEXCEPT 13937 { 13938 std::size_t seed = 0; 13939 VULKAN_HPP_HASH_COMBINE( seed, renderingFragmentShadingRateAttachmentInfoKHR.sType ); 13940 VULKAN_HPP_HASH_COMBINE( seed, renderingFragmentShadingRateAttachmentInfoKHR.pNext ); 13941 VULKAN_HPP_HASH_COMBINE( seed, renderingFragmentShadingRateAttachmentInfoKHR.imageView ); 13942 VULKAN_HPP_HASH_COMBINE( seed, renderingFragmentShadingRateAttachmentInfoKHR.imageLayout ); 13943 VULKAN_HPP_HASH_COMBINE( seed, renderingFragmentShadingRateAttachmentInfoKHR.shadingRateAttachmentTexelSize ); 13944 return seed; 13945 } 13946 }; 13947 13948 template <> 13949 struct hash<VULKAN_HPP_NAMESPACE::RenderingInfo> 13950 { operator ()std::hash13951 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderingInfo const & renderingInfo ) const VULKAN_HPP_NOEXCEPT 13952 { 13953 std::size_t seed = 0; 13954 VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.sType ); 13955 VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.pNext ); 13956 VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.flags ); 13957 VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.renderArea ); 13958 VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.layerCount ); 13959 VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.viewMask ); 13960 VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.colorAttachmentCount ); 13961 VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.pColorAttachments ); 13962 VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.pDepthAttachment ); 13963 VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.pStencilAttachment ); 13964 return seed; 13965 } 13966 }; 13967 13968 template <> 13969 struct hash<VULKAN_HPP_NAMESPACE::ResolveImageInfo2> 13970 { operator ()std::hash13971 std::size_t operator()( VULKAN_HPP_NAMESPACE::ResolveImageInfo2 const & resolveImageInfo2 ) const VULKAN_HPP_NOEXCEPT 13972 { 13973 std::size_t seed = 0; 13974 VULKAN_HPP_HASH_COMBINE( seed, resolveImageInfo2.sType ); 13975 VULKAN_HPP_HASH_COMBINE( seed, resolveImageInfo2.pNext ); 13976 VULKAN_HPP_HASH_COMBINE( seed, resolveImageInfo2.srcImage ); 13977 VULKAN_HPP_HASH_COMBINE( seed, resolveImageInfo2.srcImageLayout ); 13978 VULKAN_HPP_HASH_COMBINE( seed, resolveImageInfo2.dstImage ); 13979 VULKAN_HPP_HASH_COMBINE( seed, resolveImageInfo2.dstImageLayout ); 13980 VULKAN_HPP_HASH_COMBINE( seed, resolveImageInfo2.regionCount ); 13981 VULKAN_HPP_HASH_COMBINE( seed, resolveImageInfo2.pRegions ); 13982 return seed; 13983 } 13984 }; 13985 13986 template <> 13987 struct hash<VULKAN_HPP_NAMESPACE::SamplerBlockMatchWindowCreateInfoQCOM> 13988 { 13989 std::size_t operator ()std::hash13990 operator()( VULKAN_HPP_NAMESPACE::SamplerBlockMatchWindowCreateInfoQCOM const & samplerBlockMatchWindowCreateInfoQCOM ) const VULKAN_HPP_NOEXCEPT 13991 { 13992 std::size_t seed = 0; 13993 VULKAN_HPP_HASH_COMBINE( seed, samplerBlockMatchWindowCreateInfoQCOM.sType ); 13994 VULKAN_HPP_HASH_COMBINE( seed, samplerBlockMatchWindowCreateInfoQCOM.pNext ); 13995 VULKAN_HPP_HASH_COMBINE( seed, samplerBlockMatchWindowCreateInfoQCOM.windowExtent ); 13996 VULKAN_HPP_HASH_COMBINE( seed, samplerBlockMatchWindowCreateInfoQCOM.windowCompareMode ); 13997 return seed; 13998 } 13999 }; 14000 14001 template <> 14002 struct hash<VULKAN_HPP_NAMESPACE::SamplerBorderColorComponentMappingCreateInfoEXT> 14003 { operator ()std::hash14004 std::size_t operator()( 14005 VULKAN_HPP_NAMESPACE::SamplerBorderColorComponentMappingCreateInfoEXT const & samplerBorderColorComponentMappingCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 14006 { 14007 std::size_t seed = 0; 14008 VULKAN_HPP_HASH_COMBINE( seed, samplerBorderColorComponentMappingCreateInfoEXT.sType ); 14009 VULKAN_HPP_HASH_COMBINE( seed, samplerBorderColorComponentMappingCreateInfoEXT.pNext ); 14010 VULKAN_HPP_HASH_COMBINE( seed, samplerBorderColorComponentMappingCreateInfoEXT.components ); 14011 VULKAN_HPP_HASH_COMBINE( seed, samplerBorderColorComponentMappingCreateInfoEXT.srgb ); 14012 return seed; 14013 } 14014 }; 14015 14016 template <> 14017 struct hash<VULKAN_HPP_NAMESPACE::SamplerCaptureDescriptorDataInfoEXT> 14018 { operator ()std::hash14019 std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerCaptureDescriptorDataInfoEXT const & samplerCaptureDescriptorDataInfoEXT ) const VULKAN_HPP_NOEXCEPT 14020 { 14021 std::size_t seed = 0; 14022 VULKAN_HPP_HASH_COMBINE( seed, samplerCaptureDescriptorDataInfoEXT.sType ); 14023 VULKAN_HPP_HASH_COMBINE( seed, samplerCaptureDescriptorDataInfoEXT.pNext ); 14024 VULKAN_HPP_HASH_COMBINE( seed, samplerCaptureDescriptorDataInfoEXT.sampler ); 14025 return seed; 14026 } 14027 }; 14028 14029 template <> 14030 struct hash<VULKAN_HPP_NAMESPACE::SamplerCreateInfo> 14031 { operator ()std::hash14032 std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerCreateInfo const & samplerCreateInfo ) const VULKAN_HPP_NOEXCEPT 14033 { 14034 std::size_t seed = 0; 14035 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.sType ); 14036 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.pNext ); 14037 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.flags ); 14038 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.magFilter ); 14039 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.minFilter ); 14040 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.mipmapMode ); 14041 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.addressModeU ); 14042 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.addressModeV ); 14043 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.addressModeW ); 14044 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.mipLodBias ); 14045 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.anisotropyEnable ); 14046 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.maxAnisotropy ); 14047 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.compareEnable ); 14048 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.compareOp ); 14049 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.minLod ); 14050 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.maxLod ); 14051 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.borderColor ); 14052 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.unnormalizedCoordinates ); 14053 return seed; 14054 } 14055 }; 14056 14057 template <> 14058 struct hash<VULKAN_HPP_NAMESPACE::SamplerCubicWeightsCreateInfoQCOM> 14059 { operator ()std::hash14060 std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerCubicWeightsCreateInfoQCOM const & samplerCubicWeightsCreateInfoQCOM ) const VULKAN_HPP_NOEXCEPT 14061 { 14062 std::size_t seed = 0; 14063 VULKAN_HPP_HASH_COMBINE( seed, samplerCubicWeightsCreateInfoQCOM.sType ); 14064 VULKAN_HPP_HASH_COMBINE( seed, samplerCubicWeightsCreateInfoQCOM.pNext ); 14065 VULKAN_HPP_HASH_COMBINE( seed, samplerCubicWeightsCreateInfoQCOM.cubicWeights ); 14066 return seed; 14067 } 14068 }; 14069 14070 template <> 14071 struct hash<VULKAN_HPP_NAMESPACE::SamplerReductionModeCreateInfo> 14072 { operator ()std::hash14073 std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerReductionModeCreateInfo const & samplerReductionModeCreateInfo ) const VULKAN_HPP_NOEXCEPT 14074 { 14075 std::size_t seed = 0; 14076 VULKAN_HPP_HASH_COMBINE( seed, samplerReductionModeCreateInfo.sType ); 14077 VULKAN_HPP_HASH_COMBINE( seed, samplerReductionModeCreateInfo.pNext ); 14078 VULKAN_HPP_HASH_COMBINE( seed, samplerReductionModeCreateInfo.reductionMode ); 14079 return seed; 14080 } 14081 }; 14082 14083 template <> 14084 struct hash<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo> 14085 { operator ()std::hash14086 std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo const & samplerYcbcrConversionCreateInfo ) const VULKAN_HPP_NOEXCEPT 14087 { 14088 std::size_t seed = 0; 14089 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.sType ); 14090 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.pNext ); 14091 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.format ); 14092 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.ycbcrModel ); 14093 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.ycbcrRange ); 14094 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.components ); 14095 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.xChromaOffset ); 14096 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.yChromaOffset ); 14097 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.chromaFilter ); 14098 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.forceExplicitReconstruction ); 14099 return seed; 14100 } 14101 }; 14102 14103 template <> 14104 struct hash<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionImageFormatProperties> 14105 { operator ()std::hash14106 std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionImageFormatProperties const & samplerYcbcrConversionImageFormatProperties ) const 14107 VULKAN_HPP_NOEXCEPT 14108 { 14109 std::size_t seed = 0; 14110 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionImageFormatProperties.sType ); 14111 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionImageFormatProperties.pNext ); 14112 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionImageFormatProperties.combinedImageSamplerDescriptorCount ); 14113 return seed; 14114 } 14115 }; 14116 14117 template <> 14118 struct hash<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionInfo> 14119 { operator ()std::hash14120 std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionInfo const & samplerYcbcrConversionInfo ) const VULKAN_HPP_NOEXCEPT 14121 { 14122 std::size_t seed = 0; 14123 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionInfo.sType ); 14124 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionInfo.pNext ); 14125 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionInfo.conversion ); 14126 return seed; 14127 } 14128 }; 14129 14130 template <> 14131 struct hash<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM> 14132 { operator ()std::hash14133 std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM const & samplerYcbcrConversionYcbcrDegammaCreateInfoQCOM ) 14134 const VULKAN_HPP_NOEXCEPT 14135 { 14136 std::size_t seed = 0; 14137 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionYcbcrDegammaCreateInfoQCOM.sType ); 14138 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionYcbcrDegammaCreateInfoQCOM.pNext ); 14139 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionYcbcrDegammaCreateInfoQCOM.enableYDegamma ); 14140 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionYcbcrDegammaCreateInfoQCOM.enableCbCrDegamma ); 14141 return seed; 14142 } 14143 }; 14144 14145 # if defined( VK_USE_PLATFORM_SCREEN_QNX ) 14146 template <> 14147 struct hash<VULKAN_HPP_NAMESPACE::ScreenBufferFormatPropertiesQNX> 14148 { operator ()std::hash14149 std::size_t operator()( VULKAN_HPP_NAMESPACE::ScreenBufferFormatPropertiesQNX const & screenBufferFormatPropertiesQNX ) const VULKAN_HPP_NOEXCEPT 14150 { 14151 std::size_t seed = 0; 14152 VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.sType ); 14153 VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.pNext ); 14154 VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.format ); 14155 VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.externalFormat ); 14156 VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.screenUsage ); 14157 VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.formatFeatures ); 14158 VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.samplerYcbcrConversionComponents ); 14159 VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.suggestedYcbcrModel ); 14160 VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.suggestedYcbcrRange ); 14161 VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.suggestedXChromaOffset ); 14162 VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.suggestedYChromaOffset ); 14163 return seed; 14164 } 14165 }; 14166 # endif /*VK_USE_PLATFORM_SCREEN_QNX*/ 14167 14168 # if defined( VK_USE_PLATFORM_SCREEN_QNX ) 14169 template <> 14170 struct hash<VULKAN_HPP_NAMESPACE::ScreenBufferPropertiesQNX> 14171 { operator ()std::hash14172 std::size_t operator()( VULKAN_HPP_NAMESPACE::ScreenBufferPropertiesQNX const & screenBufferPropertiesQNX ) const VULKAN_HPP_NOEXCEPT 14173 { 14174 std::size_t seed = 0; 14175 VULKAN_HPP_HASH_COMBINE( seed, screenBufferPropertiesQNX.sType ); 14176 VULKAN_HPP_HASH_COMBINE( seed, screenBufferPropertiesQNX.pNext ); 14177 VULKAN_HPP_HASH_COMBINE( seed, screenBufferPropertiesQNX.allocationSize ); 14178 VULKAN_HPP_HASH_COMBINE( seed, screenBufferPropertiesQNX.memoryTypeBits ); 14179 return seed; 14180 } 14181 }; 14182 # endif /*VK_USE_PLATFORM_SCREEN_QNX*/ 14183 14184 # if defined( VK_USE_PLATFORM_SCREEN_QNX ) 14185 template <> 14186 struct hash<VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX> 14187 { operator ()std::hash14188 std::size_t operator()( VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX const & screenSurfaceCreateInfoQNX ) const VULKAN_HPP_NOEXCEPT 14189 { 14190 std::size_t seed = 0; 14191 VULKAN_HPP_HASH_COMBINE( seed, screenSurfaceCreateInfoQNX.sType ); 14192 VULKAN_HPP_HASH_COMBINE( seed, screenSurfaceCreateInfoQNX.pNext ); 14193 VULKAN_HPP_HASH_COMBINE( seed, screenSurfaceCreateInfoQNX.flags ); 14194 VULKAN_HPP_HASH_COMBINE( seed, screenSurfaceCreateInfoQNX.context ); 14195 VULKAN_HPP_HASH_COMBINE( seed, screenSurfaceCreateInfoQNX.window ); 14196 return seed; 14197 } 14198 }; 14199 # endif /*VK_USE_PLATFORM_SCREEN_QNX*/ 14200 14201 template <> 14202 struct hash<VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo> 14203 { operator ()std::hash14204 std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo const & semaphoreCreateInfo ) const VULKAN_HPP_NOEXCEPT 14205 { 14206 std::size_t seed = 0; 14207 VULKAN_HPP_HASH_COMBINE( seed, semaphoreCreateInfo.sType ); 14208 VULKAN_HPP_HASH_COMBINE( seed, semaphoreCreateInfo.pNext ); 14209 VULKAN_HPP_HASH_COMBINE( seed, semaphoreCreateInfo.flags ); 14210 return seed; 14211 } 14212 }; 14213 14214 template <> 14215 struct hash<VULKAN_HPP_NAMESPACE::SemaphoreGetFdInfoKHR> 14216 { operator ()std::hash14217 std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreGetFdInfoKHR const & semaphoreGetFdInfoKHR ) const VULKAN_HPP_NOEXCEPT 14218 { 14219 std::size_t seed = 0; 14220 VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetFdInfoKHR.sType ); 14221 VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetFdInfoKHR.pNext ); 14222 VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetFdInfoKHR.semaphore ); 14223 VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetFdInfoKHR.handleType ); 14224 return seed; 14225 } 14226 }; 14227 14228 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 14229 template <> 14230 struct hash<VULKAN_HPP_NAMESPACE::SemaphoreGetWin32HandleInfoKHR> 14231 { operator ()std::hash14232 std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreGetWin32HandleInfoKHR const & semaphoreGetWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT 14233 { 14234 std::size_t seed = 0; 14235 VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetWin32HandleInfoKHR.sType ); 14236 VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetWin32HandleInfoKHR.pNext ); 14237 VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetWin32HandleInfoKHR.semaphore ); 14238 VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetWin32HandleInfoKHR.handleType ); 14239 return seed; 14240 } 14241 }; 14242 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 14243 14244 # if defined( VK_USE_PLATFORM_FUCHSIA ) 14245 template <> 14246 struct hash<VULKAN_HPP_NAMESPACE::SemaphoreGetZirconHandleInfoFUCHSIA> 14247 { operator ()std::hash14248 std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreGetZirconHandleInfoFUCHSIA const & semaphoreGetZirconHandleInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT 14249 { 14250 std::size_t seed = 0; 14251 VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetZirconHandleInfoFUCHSIA.sType ); 14252 VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetZirconHandleInfoFUCHSIA.pNext ); 14253 VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetZirconHandleInfoFUCHSIA.semaphore ); 14254 VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetZirconHandleInfoFUCHSIA.handleType ); 14255 return seed; 14256 } 14257 }; 14258 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 14259 14260 template <> 14261 struct hash<VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo> 14262 { operator ()std::hash14263 std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo const & semaphoreSignalInfo ) const VULKAN_HPP_NOEXCEPT 14264 { 14265 std::size_t seed = 0; 14266 VULKAN_HPP_HASH_COMBINE( seed, semaphoreSignalInfo.sType ); 14267 VULKAN_HPP_HASH_COMBINE( seed, semaphoreSignalInfo.pNext ); 14268 VULKAN_HPP_HASH_COMBINE( seed, semaphoreSignalInfo.semaphore ); 14269 VULKAN_HPP_HASH_COMBINE( seed, semaphoreSignalInfo.value ); 14270 return seed; 14271 } 14272 }; 14273 14274 template <> 14275 struct hash<VULKAN_HPP_NAMESPACE::SemaphoreTypeCreateInfo> 14276 { operator ()std::hash14277 std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreTypeCreateInfo const & semaphoreTypeCreateInfo ) const VULKAN_HPP_NOEXCEPT 14278 { 14279 std::size_t seed = 0; 14280 VULKAN_HPP_HASH_COMBINE( seed, semaphoreTypeCreateInfo.sType ); 14281 VULKAN_HPP_HASH_COMBINE( seed, semaphoreTypeCreateInfo.pNext ); 14282 VULKAN_HPP_HASH_COMBINE( seed, semaphoreTypeCreateInfo.semaphoreType ); 14283 VULKAN_HPP_HASH_COMBINE( seed, semaphoreTypeCreateInfo.initialValue ); 14284 return seed; 14285 } 14286 }; 14287 14288 template <> 14289 struct hash<VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo> 14290 { operator ()std::hash14291 std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo const & semaphoreWaitInfo ) const VULKAN_HPP_NOEXCEPT 14292 { 14293 std::size_t seed = 0; 14294 VULKAN_HPP_HASH_COMBINE( seed, semaphoreWaitInfo.sType ); 14295 VULKAN_HPP_HASH_COMBINE( seed, semaphoreWaitInfo.pNext ); 14296 VULKAN_HPP_HASH_COMBINE( seed, semaphoreWaitInfo.flags ); 14297 VULKAN_HPP_HASH_COMBINE( seed, semaphoreWaitInfo.semaphoreCount ); 14298 VULKAN_HPP_HASH_COMBINE( seed, semaphoreWaitInfo.pSemaphores ); 14299 VULKAN_HPP_HASH_COMBINE( seed, semaphoreWaitInfo.pValues ); 14300 return seed; 14301 } 14302 }; 14303 14304 template <> 14305 struct hash<VULKAN_HPP_NAMESPACE::SetDescriptorBufferOffsetsInfoEXT> 14306 { operator ()std::hash14307 std::size_t operator()( VULKAN_HPP_NAMESPACE::SetDescriptorBufferOffsetsInfoEXT const & setDescriptorBufferOffsetsInfoEXT ) const VULKAN_HPP_NOEXCEPT 14308 { 14309 std::size_t seed = 0; 14310 VULKAN_HPP_HASH_COMBINE( seed, setDescriptorBufferOffsetsInfoEXT.sType ); 14311 VULKAN_HPP_HASH_COMBINE( seed, setDescriptorBufferOffsetsInfoEXT.pNext ); 14312 VULKAN_HPP_HASH_COMBINE( seed, setDescriptorBufferOffsetsInfoEXT.stageFlags ); 14313 VULKAN_HPP_HASH_COMBINE( seed, setDescriptorBufferOffsetsInfoEXT.layout ); 14314 VULKAN_HPP_HASH_COMBINE( seed, setDescriptorBufferOffsetsInfoEXT.firstSet ); 14315 VULKAN_HPP_HASH_COMBINE( seed, setDescriptorBufferOffsetsInfoEXT.setCount ); 14316 VULKAN_HPP_HASH_COMBINE( seed, setDescriptorBufferOffsetsInfoEXT.pBufferIndices ); 14317 VULKAN_HPP_HASH_COMBINE( seed, setDescriptorBufferOffsetsInfoEXT.pOffsets ); 14318 return seed; 14319 } 14320 }; 14321 14322 template <> 14323 struct hash<VULKAN_HPP_NAMESPACE::SetLatencyMarkerInfoNV> 14324 { operator ()std::hash14325 std::size_t operator()( VULKAN_HPP_NAMESPACE::SetLatencyMarkerInfoNV const & setLatencyMarkerInfoNV ) const VULKAN_HPP_NOEXCEPT 14326 { 14327 std::size_t seed = 0; 14328 VULKAN_HPP_HASH_COMBINE( seed, setLatencyMarkerInfoNV.sType ); 14329 VULKAN_HPP_HASH_COMBINE( seed, setLatencyMarkerInfoNV.pNext ); 14330 VULKAN_HPP_HASH_COMBINE( seed, setLatencyMarkerInfoNV.presentID ); 14331 VULKAN_HPP_HASH_COMBINE( seed, setLatencyMarkerInfoNV.marker ); 14332 return seed; 14333 } 14334 }; 14335 14336 template <> 14337 struct hash<VULKAN_HPP_NAMESPACE::SetStateFlagsIndirectCommandNV> 14338 { operator ()std::hash14339 std::size_t operator()( VULKAN_HPP_NAMESPACE::SetStateFlagsIndirectCommandNV const & setStateFlagsIndirectCommandNV ) const VULKAN_HPP_NOEXCEPT 14340 { 14341 std::size_t seed = 0; 14342 VULKAN_HPP_HASH_COMBINE( seed, setStateFlagsIndirectCommandNV.data ); 14343 return seed; 14344 } 14345 }; 14346 14347 template <> 14348 struct hash<VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT> 14349 { operator ()std::hash14350 std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT const & shaderCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 14351 { 14352 std::size_t seed = 0; 14353 VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.sType ); 14354 VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.pNext ); 14355 VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.flags ); 14356 VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.stage ); 14357 VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.nextStage ); 14358 VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.codeType ); 14359 VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.codeSize ); 14360 VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.pCode ); 14361 for ( const char * p = shaderCreateInfoEXT.pName; *p != '\0'; ++p ) 14362 { 14363 VULKAN_HPP_HASH_COMBINE( seed, *p ); 14364 } 14365 VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.setLayoutCount ); 14366 VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.pSetLayouts ); 14367 VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.pushConstantRangeCount ); 14368 VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.pPushConstantRanges ); 14369 VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.pSpecializationInfo ); 14370 return seed; 14371 } 14372 }; 14373 14374 template <> 14375 struct hash<VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo> 14376 { operator ()std::hash14377 std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo const & shaderModuleCreateInfo ) const VULKAN_HPP_NOEXCEPT 14378 { 14379 std::size_t seed = 0; 14380 VULKAN_HPP_HASH_COMBINE( seed, shaderModuleCreateInfo.sType ); 14381 VULKAN_HPP_HASH_COMBINE( seed, shaderModuleCreateInfo.pNext ); 14382 VULKAN_HPP_HASH_COMBINE( seed, shaderModuleCreateInfo.flags ); 14383 VULKAN_HPP_HASH_COMBINE( seed, shaderModuleCreateInfo.codeSize ); 14384 VULKAN_HPP_HASH_COMBINE( seed, shaderModuleCreateInfo.pCode ); 14385 return seed; 14386 } 14387 }; 14388 14389 template <> 14390 struct hash<VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT> 14391 { operator ()std::hash14392 std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT const & shaderModuleIdentifierEXT ) const VULKAN_HPP_NOEXCEPT 14393 { 14394 std::size_t seed = 0; 14395 VULKAN_HPP_HASH_COMBINE( seed, shaderModuleIdentifierEXT.sType ); 14396 VULKAN_HPP_HASH_COMBINE( seed, shaderModuleIdentifierEXT.pNext ); 14397 VULKAN_HPP_HASH_COMBINE( seed, shaderModuleIdentifierEXT.identifierSize ); 14398 for ( size_t i = 0; i < VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT; ++i ) 14399 { 14400 VULKAN_HPP_HASH_COMBINE( seed, shaderModuleIdentifierEXT.identifier[i] ); 14401 } 14402 return seed; 14403 } 14404 }; 14405 14406 template <> 14407 struct hash<VULKAN_HPP_NAMESPACE::ShaderModuleValidationCacheCreateInfoEXT> 14408 { 14409 std::size_t operator ()std::hash14410 operator()( VULKAN_HPP_NAMESPACE::ShaderModuleValidationCacheCreateInfoEXT const & shaderModuleValidationCacheCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 14411 { 14412 std::size_t seed = 0; 14413 VULKAN_HPP_HASH_COMBINE( seed, shaderModuleValidationCacheCreateInfoEXT.sType ); 14414 VULKAN_HPP_HASH_COMBINE( seed, shaderModuleValidationCacheCreateInfoEXT.pNext ); 14415 VULKAN_HPP_HASH_COMBINE( seed, shaderModuleValidationCacheCreateInfoEXT.validationCache ); 14416 return seed; 14417 } 14418 }; 14419 14420 template <> 14421 struct hash<VULKAN_HPP_NAMESPACE::ShaderResourceUsageAMD> 14422 { operator ()std::hash14423 std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderResourceUsageAMD const & shaderResourceUsageAMD ) const VULKAN_HPP_NOEXCEPT 14424 { 14425 std::size_t seed = 0; 14426 VULKAN_HPP_HASH_COMBINE( seed, shaderResourceUsageAMD.numUsedVgprs ); 14427 VULKAN_HPP_HASH_COMBINE( seed, shaderResourceUsageAMD.numUsedSgprs ); 14428 VULKAN_HPP_HASH_COMBINE( seed, shaderResourceUsageAMD.ldsSizePerLocalWorkGroup ); 14429 VULKAN_HPP_HASH_COMBINE( seed, shaderResourceUsageAMD.ldsUsageSizeInBytes ); 14430 VULKAN_HPP_HASH_COMBINE( seed, shaderResourceUsageAMD.scratchMemUsageInBytes ); 14431 return seed; 14432 } 14433 }; 14434 14435 template <> 14436 struct hash<VULKAN_HPP_NAMESPACE::ShaderStatisticsInfoAMD> 14437 { operator ()std::hash14438 std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderStatisticsInfoAMD const & shaderStatisticsInfoAMD ) const VULKAN_HPP_NOEXCEPT 14439 { 14440 std::size_t seed = 0; 14441 VULKAN_HPP_HASH_COMBINE( seed, shaderStatisticsInfoAMD.shaderStageMask ); 14442 VULKAN_HPP_HASH_COMBINE( seed, shaderStatisticsInfoAMD.resourceUsage ); 14443 VULKAN_HPP_HASH_COMBINE( seed, shaderStatisticsInfoAMD.numPhysicalVgprs ); 14444 VULKAN_HPP_HASH_COMBINE( seed, shaderStatisticsInfoAMD.numPhysicalSgprs ); 14445 VULKAN_HPP_HASH_COMBINE( seed, shaderStatisticsInfoAMD.numAvailableVgprs ); 14446 VULKAN_HPP_HASH_COMBINE( seed, shaderStatisticsInfoAMD.numAvailableSgprs ); 14447 for ( size_t i = 0; i < 3; ++i ) 14448 { 14449 VULKAN_HPP_HASH_COMBINE( seed, shaderStatisticsInfoAMD.computeWorkGroupSize[i] ); 14450 } 14451 return seed; 14452 } 14453 }; 14454 14455 template <> 14456 struct hash<VULKAN_HPP_NAMESPACE::SharedPresentSurfaceCapabilitiesKHR> 14457 { operator ()std::hash14458 std::size_t operator()( VULKAN_HPP_NAMESPACE::SharedPresentSurfaceCapabilitiesKHR const & sharedPresentSurfaceCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT 14459 { 14460 std::size_t seed = 0; 14461 VULKAN_HPP_HASH_COMBINE( seed, sharedPresentSurfaceCapabilitiesKHR.sType ); 14462 VULKAN_HPP_HASH_COMBINE( seed, sharedPresentSurfaceCapabilitiesKHR.pNext ); 14463 VULKAN_HPP_HASH_COMBINE( seed, sharedPresentSurfaceCapabilitiesKHR.sharedPresentSupportedUsageFlags ); 14464 return seed; 14465 } 14466 }; 14467 14468 template <> 14469 struct hash<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties> 14470 { operator ()std::hash14471 std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageFormatProperties const & sparseImageFormatProperties ) const VULKAN_HPP_NOEXCEPT 14472 { 14473 std::size_t seed = 0; 14474 VULKAN_HPP_HASH_COMBINE( seed, sparseImageFormatProperties.aspectMask ); 14475 VULKAN_HPP_HASH_COMBINE( seed, sparseImageFormatProperties.imageGranularity ); 14476 VULKAN_HPP_HASH_COMBINE( seed, sparseImageFormatProperties.flags ); 14477 return seed; 14478 } 14479 }; 14480 14481 template <> 14482 struct hash<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2> 14483 { operator ()std::hash14484 std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2 const & sparseImageFormatProperties2 ) const VULKAN_HPP_NOEXCEPT 14485 { 14486 std::size_t seed = 0; 14487 VULKAN_HPP_HASH_COMBINE( seed, sparseImageFormatProperties2.sType ); 14488 VULKAN_HPP_HASH_COMBINE( seed, sparseImageFormatProperties2.pNext ); 14489 VULKAN_HPP_HASH_COMBINE( seed, sparseImageFormatProperties2.properties ); 14490 return seed; 14491 } 14492 }; 14493 14494 template <> 14495 struct hash<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements> 14496 { operator ()std::hash14497 std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements const & sparseImageMemoryRequirements ) const VULKAN_HPP_NOEXCEPT 14498 { 14499 std::size_t seed = 0; 14500 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryRequirements.formatProperties ); 14501 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryRequirements.imageMipTailFirstLod ); 14502 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryRequirements.imageMipTailSize ); 14503 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryRequirements.imageMipTailOffset ); 14504 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryRequirements.imageMipTailStride ); 14505 return seed; 14506 } 14507 }; 14508 14509 template <> 14510 struct hash<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2> 14511 { operator ()std::hash14512 std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 const & sparseImageMemoryRequirements2 ) const VULKAN_HPP_NOEXCEPT 14513 { 14514 std::size_t seed = 0; 14515 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryRequirements2.sType ); 14516 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryRequirements2.pNext ); 14517 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryRequirements2.memoryRequirements ); 14518 return seed; 14519 } 14520 }; 14521 14522 # if defined( VK_USE_PLATFORM_GGP ) 14523 template <> 14524 struct hash<VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP> 14525 { operator ()std::hash14526 std::size_t operator()( VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP const & streamDescriptorSurfaceCreateInfoGGP ) const VULKAN_HPP_NOEXCEPT 14527 { 14528 std::size_t seed = 0; 14529 VULKAN_HPP_HASH_COMBINE( seed, streamDescriptorSurfaceCreateInfoGGP.sType ); 14530 VULKAN_HPP_HASH_COMBINE( seed, streamDescriptorSurfaceCreateInfoGGP.pNext ); 14531 VULKAN_HPP_HASH_COMBINE( seed, streamDescriptorSurfaceCreateInfoGGP.flags ); 14532 VULKAN_HPP_HASH_COMBINE( seed, streamDescriptorSurfaceCreateInfoGGP.streamDescriptor ); 14533 return seed; 14534 } 14535 }; 14536 # endif /*VK_USE_PLATFORM_GGP*/ 14537 14538 template <> 14539 struct hash<VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR> 14540 { operator ()std::hash14541 std::size_t operator()( VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR const & stridedDeviceAddressRegionKHR ) const VULKAN_HPP_NOEXCEPT 14542 { 14543 std::size_t seed = 0; 14544 VULKAN_HPP_HASH_COMBINE( seed, stridedDeviceAddressRegionKHR.deviceAddress ); 14545 VULKAN_HPP_HASH_COMBINE( seed, stridedDeviceAddressRegionKHR.stride ); 14546 VULKAN_HPP_HASH_COMBINE( seed, stridedDeviceAddressRegionKHR.size ); 14547 return seed; 14548 } 14549 }; 14550 14551 template <> 14552 struct hash<VULKAN_HPP_NAMESPACE::SubmitInfo> 14553 { operator ()std::hash14554 std::size_t operator()( VULKAN_HPP_NAMESPACE::SubmitInfo const & submitInfo ) const VULKAN_HPP_NOEXCEPT 14555 { 14556 std::size_t seed = 0; 14557 VULKAN_HPP_HASH_COMBINE( seed, submitInfo.sType ); 14558 VULKAN_HPP_HASH_COMBINE( seed, submitInfo.pNext ); 14559 VULKAN_HPP_HASH_COMBINE( seed, submitInfo.waitSemaphoreCount ); 14560 VULKAN_HPP_HASH_COMBINE( seed, submitInfo.pWaitSemaphores ); 14561 VULKAN_HPP_HASH_COMBINE( seed, submitInfo.pWaitDstStageMask ); 14562 VULKAN_HPP_HASH_COMBINE( seed, submitInfo.commandBufferCount ); 14563 VULKAN_HPP_HASH_COMBINE( seed, submitInfo.pCommandBuffers ); 14564 VULKAN_HPP_HASH_COMBINE( seed, submitInfo.signalSemaphoreCount ); 14565 VULKAN_HPP_HASH_COMBINE( seed, submitInfo.pSignalSemaphores ); 14566 return seed; 14567 } 14568 }; 14569 14570 template <> 14571 struct hash<VULKAN_HPP_NAMESPACE::SubmitInfo2> 14572 { operator ()std::hash14573 std::size_t operator()( VULKAN_HPP_NAMESPACE::SubmitInfo2 const & submitInfo2 ) const VULKAN_HPP_NOEXCEPT 14574 { 14575 std::size_t seed = 0; 14576 VULKAN_HPP_HASH_COMBINE( seed, submitInfo2.sType ); 14577 VULKAN_HPP_HASH_COMBINE( seed, submitInfo2.pNext ); 14578 VULKAN_HPP_HASH_COMBINE( seed, submitInfo2.flags ); 14579 VULKAN_HPP_HASH_COMBINE( seed, submitInfo2.waitSemaphoreInfoCount ); 14580 VULKAN_HPP_HASH_COMBINE( seed, submitInfo2.pWaitSemaphoreInfos ); 14581 VULKAN_HPP_HASH_COMBINE( seed, submitInfo2.commandBufferInfoCount ); 14582 VULKAN_HPP_HASH_COMBINE( seed, submitInfo2.pCommandBufferInfos ); 14583 VULKAN_HPP_HASH_COMBINE( seed, submitInfo2.signalSemaphoreInfoCount ); 14584 VULKAN_HPP_HASH_COMBINE( seed, submitInfo2.pSignalSemaphoreInfos ); 14585 return seed; 14586 } 14587 }; 14588 14589 template <> 14590 struct hash<VULKAN_HPP_NAMESPACE::SubpassBeginInfo> 14591 { operator ()std::hash14592 std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassBeginInfo const & subpassBeginInfo ) const VULKAN_HPP_NOEXCEPT 14593 { 14594 std::size_t seed = 0; 14595 VULKAN_HPP_HASH_COMBINE( seed, subpassBeginInfo.sType ); 14596 VULKAN_HPP_HASH_COMBINE( seed, subpassBeginInfo.pNext ); 14597 VULKAN_HPP_HASH_COMBINE( seed, subpassBeginInfo.contents ); 14598 return seed; 14599 } 14600 }; 14601 14602 template <> 14603 struct hash<VULKAN_HPP_NAMESPACE::SubpassDescriptionDepthStencilResolve> 14604 { 14605 std::size_t operator ()std::hash14606 operator()( VULKAN_HPP_NAMESPACE::SubpassDescriptionDepthStencilResolve const & subpassDescriptionDepthStencilResolve ) const VULKAN_HPP_NOEXCEPT 14607 { 14608 std::size_t seed = 0; 14609 VULKAN_HPP_HASH_COMBINE( seed, subpassDescriptionDepthStencilResolve.sType ); 14610 VULKAN_HPP_HASH_COMBINE( seed, subpassDescriptionDepthStencilResolve.pNext ); 14611 VULKAN_HPP_HASH_COMBINE( seed, subpassDescriptionDepthStencilResolve.depthResolveMode ); 14612 VULKAN_HPP_HASH_COMBINE( seed, subpassDescriptionDepthStencilResolve.stencilResolveMode ); 14613 VULKAN_HPP_HASH_COMBINE( seed, subpassDescriptionDepthStencilResolve.pDepthStencilResolveAttachment ); 14614 return seed; 14615 } 14616 }; 14617 14618 template <> 14619 struct hash<VULKAN_HPP_NAMESPACE::SubpassEndInfo> 14620 { operator ()std::hash14621 std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassEndInfo const & subpassEndInfo ) const VULKAN_HPP_NOEXCEPT 14622 { 14623 std::size_t seed = 0; 14624 VULKAN_HPP_HASH_COMBINE( seed, subpassEndInfo.sType ); 14625 VULKAN_HPP_HASH_COMBINE( seed, subpassEndInfo.pNext ); 14626 return seed; 14627 } 14628 }; 14629 14630 template <> 14631 struct hash<VULKAN_HPP_NAMESPACE::SubpassFragmentDensityMapOffsetEndInfoQCOM> 14632 { operator ()std::hash14633 std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassFragmentDensityMapOffsetEndInfoQCOM const & subpassFragmentDensityMapOffsetEndInfoQCOM ) const 14634 VULKAN_HPP_NOEXCEPT 14635 { 14636 std::size_t seed = 0; 14637 VULKAN_HPP_HASH_COMBINE( seed, subpassFragmentDensityMapOffsetEndInfoQCOM.sType ); 14638 VULKAN_HPP_HASH_COMBINE( seed, subpassFragmentDensityMapOffsetEndInfoQCOM.pNext ); 14639 VULKAN_HPP_HASH_COMBINE( seed, subpassFragmentDensityMapOffsetEndInfoQCOM.fragmentDensityOffsetCount ); 14640 VULKAN_HPP_HASH_COMBINE( seed, subpassFragmentDensityMapOffsetEndInfoQCOM.pFragmentDensityOffsets ); 14641 return seed; 14642 } 14643 }; 14644 14645 template <> 14646 struct hash<VULKAN_HPP_NAMESPACE::SubpassResolvePerformanceQueryEXT> 14647 { operator ()std::hash14648 std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassResolvePerformanceQueryEXT const & subpassResolvePerformanceQueryEXT ) const VULKAN_HPP_NOEXCEPT 14649 { 14650 std::size_t seed = 0; 14651 VULKAN_HPP_HASH_COMBINE( seed, subpassResolvePerformanceQueryEXT.sType ); 14652 VULKAN_HPP_HASH_COMBINE( seed, subpassResolvePerformanceQueryEXT.pNext ); 14653 VULKAN_HPP_HASH_COMBINE( seed, subpassResolvePerformanceQueryEXT.optimal ); 14654 return seed; 14655 } 14656 }; 14657 14658 template <> 14659 struct hash<VULKAN_HPP_NAMESPACE::SubpassShadingPipelineCreateInfoHUAWEI> 14660 { 14661 std::size_t operator ()std::hash14662 operator()( VULKAN_HPP_NAMESPACE::SubpassShadingPipelineCreateInfoHUAWEI const & subpassShadingPipelineCreateInfoHUAWEI ) const VULKAN_HPP_NOEXCEPT 14663 { 14664 std::size_t seed = 0; 14665 VULKAN_HPP_HASH_COMBINE( seed, subpassShadingPipelineCreateInfoHUAWEI.sType ); 14666 VULKAN_HPP_HASH_COMBINE( seed, subpassShadingPipelineCreateInfoHUAWEI.pNext ); 14667 VULKAN_HPP_HASH_COMBINE( seed, subpassShadingPipelineCreateInfoHUAWEI.renderPass ); 14668 VULKAN_HPP_HASH_COMBINE( seed, subpassShadingPipelineCreateInfoHUAWEI.subpass ); 14669 return seed; 14670 } 14671 }; 14672 14673 template <> 14674 struct hash<VULKAN_HPP_NAMESPACE::SubresourceHostMemcpySizeEXT> 14675 { operator ()std::hash14676 std::size_t operator()( VULKAN_HPP_NAMESPACE::SubresourceHostMemcpySizeEXT const & subresourceHostMemcpySizeEXT ) const VULKAN_HPP_NOEXCEPT 14677 { 14678 std::size_t seed = 0; 14679 VULKAN_HPP_HASH_COMBINE( seed, subresourceHostMemcpySizeEXT.sType ); 14680 VULKAN_HPP_HASH_COMBINE( seed, subresourceHostMemcpySizeEXT.pNext ); 14681 VULKAN_HPP_HASH_COMBINE( seed, subresourceHostMemcpySizeEXT.size ); 14682 return seed; 14683 } 14684 }; 14685 14686 template <> 14687 struct hash<VULKAN_HPP_NAMESPACE::SubresourceLayout2KHR> 14688 { operator ()std::hash14689 std::size_t operator()( VULKAN_HPP_NAMESPACE::SubresourceLayout2KHR const & subresourceLayout2KHR ) const VULKAN_HPP_NOEXCEPT 14690 { 14691 std::size_t seed = 0; 14692 VULKAN_HPP_HASH_COMBINE( seed, subresourceLayout2KHR.sType ); 14693 VULKAN_HPP_HASH_COMBINE( seed, subresourceLayout2KHR.pNext ); 14694 VULKAN_HPP_HASH_COMBINE( seed, subresourceLayout2KHR.subresourceLayout ); 14695 return seed; 14696 } 14697 }; 14698 14699 template <> 14700 struct hash<VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT> 14701 { operator ()std::hash14702 std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT const & surfaceCapabilities2EXT ) const VULKAN_HPP_NOEXCEPT 14703 { 14704 std::size_t seed = 0; 14705 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.sType ); 14706 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.pNext ); 14707 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.minImageCount ); 14708 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.maxImageCount ); 14709 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.currentExtent ); 14710 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.minImageExtent ); 14711 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.maxImageExtent ); 14712 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.maxImageArrayLayers ); 14713 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.supportedTransforms ); 14714 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.currentTransform ); 14715 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.supportedCompositeAlpha ); 14716 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.supportedUsageFlags ); 14717 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.supportedSurfaceCounters ); 14718 return seed; 14719 } 14720 }; 14721 14722 template <> 14723 struct hash<VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR> 14724 { operator ()std::hash14725 std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR const & surfaceCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT 14726 { 14727 std::size_t seed = 0; 14728 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.minImageCount ); 14729 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.maxImageCount ); 14730 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.currentExtent ); 14731 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.minImageExtent ); 14732 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.maxImageExtent ); 14733 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.maxImageArrayLayers ); 14734 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.supportedTransforms ); 14735 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.currentTransform ); 14736 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.supportedCompositeAlpha ); 14737 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.supportedUsageFlags ); 14738 return seed; 14739 } 14740 }; 14741 14742 template <> 14743 struct hash<VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR> 14744 { operator ()std::hash14745 std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR const & surfaceCapabilities2KHR ) const VULKAN_HPP_NOEXCEPT 14746 { 14747 std::size_t seed = 0; 14748 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2KHR.sType ); 14749 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2KHR.pNext ); 14750 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2KHR.surfaceCapabilities ); 14751 return seed; 14752 } 14753 }; 14754 14755 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 14756 template <> 14757 struct hash<VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesFullScreenExclusiveEXT> 14758 { 14759 std::size_t operator ()std::hash14760 operator()( VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesFullScreenExclusiveEXT const & surfaceCapabilitiesFullScreenExclusiveEXT ) const VULKAN_HPP_NOEXCEPT 14761 { 14762 std::size_t seed = 0; 14763 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesFullScreenExclusiveEXT.sType ); 14764 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesFullScreenExclusiveEXT.pNext ); 14765 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesFullScreenExclusiveEXT.fullScreenExclusiveSupported ); 14766 return seed; 14767 } 14768 }; 14769 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 14770 14771 template <> 14772 struct hash<VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesPresentBarrierNV> 14773 { operator ()std::hash14774 std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesPresentBarrierNV const & surfaceCapabilitiesPresentBarrierNV ) const VULKAN_HPP_NOEXCEPT 14775 { 14776 std::size_t seed = 0; 14777 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesPresentBarrierNV.sType ); 14778 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesPresentBarrierNV.pNext ); 14779 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesPresentBarrierNV.presentBarrierSupported ); 14780 return seed; 14781 } 14782 }; 14783 14784 template <> 14785 struct hash<VULKAN_HPP_NAMESPACE::SurfaceFormatKHR> 14786 { operator ()std::hash14787 std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceFormatKHR const & surfaceFormatKHR ) const VULKAN_HPP_NOEXCEPT 14788 { 14789 std::size_t seed = 0; 14790 VULKAN_HPP_HASH_COMBINE( seed, surfaceFormatKHR.format ); 14791 VULKAN_HPP_HASH_COMBINE( seed, surfaceFormatKHR.colorSpace ); 14792 return seed; 14793 } 14794 }; 14795 14796 template <> 14797 struct hash<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR> 14798 { operator ()std::hash14799 std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR const & surfaceFormat2KHR ) const VULKAN_HPP_NOEXCEPT 14800 { 14801 std::size_t seed = 0; 14802 VULKAN_HPP_HASH_COMBINE( seed, surfaceFormat2KHR.sType ); 14803 VULKAN_HPP_HASH_COMBINE( seed, surfaceFormat2KHR.pNext ); 14804 VULKAN_HPP_HASH_COMBINE( seed, surfaceFormat2KHR.surfaceFormat ); 14805 return seed; 14806 } 14807 }; 14808 14809 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 14810 template <> 14811 struct hash<VULKAN_HPP_NAMESPACE::SurfaceFullScreenExclusiveInfoEXT> 14812 { operator ()std::hash14813 std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceFullScreenExclusiveInfoEXT const & surfaceFullScreenExclusiveInfoEXT ) const VULKAN_HPP_NOEXCEPT 14814 { 14815 std::size_t seed = 0; 14816 VULKAN_HPP_HASH_COMBINE( seed, surfaceFullScreenExclusiveInfoEXT.sType ); 14817 VULKAN_HPP_HASH_COMBINE( seed, surfaceFullScreenExclusiveInfoEXT.pNext ); 14818 VULKAN_HPP_HASH_COMBINE( seed, surfaceFullScreenExclusiveInfoEXT.fullScreenExclusive ); 14819 return seed; 14820 } 14821 }; 14822 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 14823 14824 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 14825 template <> 14826 struct hash<VULKAN_HPP_NAMESPACE::SurfaceFullScreenExclusiveWin32InfoEXT> 14827 { 14828 std::size_t operator ()std::hash14829 operator()( VULKAN_HPP_NAMESPACE::SurfaceFullScreenExclusiveWin32InfoEXT const & surfaceFullScreenExclusiveWin32InfoEXT ) const VULKAN_HPP_NOEXCEPT 14830 { 14831 std::size_t seed = 0; 14832 VULKAN_HPP_HASH_COMBINE( seed, surfaceFullScreenExclusiveWin32InfoEXT.sType ); 14833 VULKAN_HPP_HASH_COMBINE( seed, surfaceFullScreenExclusiveWin32InfoEXT.pNext ); 14834 VULKAN_HPP_HASH_COMBINE( seed, surfaceFullScreenExclusiveWin32InfoEXT.hmonitor ); 14835 return seed; 14836 } 14837 }; 14838 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 14839 14840 template <> 14841 struct hash<VULKAN_HPP_NAMESPACE::SurfacePresentModeCompatibilityEXT> 14842 { operator ()std::hash14843 std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfacePresentModeCompatibilityEXT const & surfacePresentModeCompatibilityEXT ) const VULKAN_HPP_NOEXCEPT 14844 { 14845 std::size_t seed = 0; 14846 VULKAN_HPP_HASH_COMBINE( seed, surfacePresentModeCompatibilityEXT.sType ); 14847 VULKAN_HPP_HASH_COMBINE( seed, surfacePresentModeCompatibilityEXT.pNext ); 14848 VULKAN_HPP_HASH_COMBINE( seed, surfacePresentModeCompatibilityEXT.presentModeCount ); 14849 VULKAN_HPP_HASH_COMBINE( seed, surfacePresentModeCompatibilityEXT.pPresentModes ); 14850 return seed; 14851 } 14852 }; 14853 14854 template <> 14855 struct hash<VULKAN_HPP_NAMESPACE::SurfacePresentModeEXT> 14856 { operator ()std::hash14857 std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfacePresentModeEXT const & surfacePresentModeEXT ) const VULKAN_HPP_NOEXCEPT 14858 { 14859 std::size_t seed = 0; 14860 VULKAN_HPP_HASH_COMBINE( seed, surfacePresentModeEXT.sType ); 14861 VULKAN_HPP_HASH_COMBINE( seed, surfacePresentModeEXT.pNext ); 14862 VULKAN_HPP_HASH_COMBINE( seed, surfacePresentModeEXT.presentMode ); 14863 return seed; 14864 } 14865 }; 14866 14867 template <> 14868 struct hash<VULKAN_HPP_NAMESPACE::SurfacePresentScalingCapabilitiesEXT> 14869 { operator ()std::hash14870 std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfacePresentScalingCapabilitiesEXT const & surfacePresentScalingCapabilitiesEXT ) const VULKAN_HPP_NOEXCEPT 14871 { 14872 std::size_t seed = 0; 14873 VULKAN_HPP_HASH_COMBINE( seed, surfacePresentScalingCapabilitiesEXT.sType ); 14874 VULKAN_HPP_HASH_COMBINE( seed, surfacePresentScalingCapabilitiesEXT.pNext ); 14875 VULKAN_HPP_HASH_COMBINE( seed, surfacePresentScalingCapabilitiesEXT.supportedPresentScaling ); 14876 VULKAN_HPP_HASH_COMBINE( seed, surfacePresentScalingCapabilitiesEXT.supportedPresentGravityX ); 14877 VULKAN_HPP_HASH_COMBINE( seed, surfacePresentScalingCapabilitiesEXT.supportedPresentGravityY ); 14878 VULKAN_HPP_HASH_COMBINE( seed, surfacePresentScalingCapabilitiesEXT.minScaledImageExtent ); 14879 VULKAN_HPP_HASH_COMBINE( seed, surfacePresentScalingCapabilitiesEXT.maxScaledImageExtent ); 14880 return seed; 14881 } 14882 }; 14883 14884 template <> 14885 struct hash<VULKAN_HPP_NAMESPACE::SurfaceProtectedCapabilitiesKHR> 14886 { operator ()std::hash14887 std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceProtectedCapabilitiesKHR const & surfaceProtectedCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT 14888 { 14889 std::size_t seed = 0; 14890 VULKAN_HPP_HASH_COMBINE( seed, surfaceProtectedCapabilitiesKHR.sType ); 14891 VULKAN_HPP_HASH_COMBINE( seed, surfaceProtectedCapabilitiesKHR.pNext ); 14892 VULKAN_HPP_HASH_COMBINE( seed, surfaceProtectedCapabilitiesKHR.supportsProtected ); 14893 return seed; 14894 } 14895 }; 14896 14897 template <> 14898 struct hash<VULKAN_HPP_NAMESPACE::SwapchainCounterCreateInfoEXT> 14899 { operator ()std::hash14900 std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainCounterCreateInfoEXT const & swapchainCounterCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 14901 { 14902 std::size_t seed = 0; 14903 VULKAN_HPP_HASH_COMBINE( seed, swapchainCounterCreateInfoEXT.sType ); 14904 VULKAN_HPP_HASH_COMBINE( seed, swapchainCounterCreateInfoEXT.pNext ); 14905 VULKAN_HPP_HASH_COMBINE( seed, swapchainCounterCreateInfoEXT.surfaceCounters ); 14906 return seed; 14907 } 14908 }; 14909 14910 template <> 14911 struct hash<VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> 14912 { operator ()std::hash14913 std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR const & swapchainCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 14914 { 14915 std::size_t seed = 0; 14916 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.sType ); 14917 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.pNext ); 14918 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.flags ); 14919 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.surface ); 14920 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.minImageCount ); 14921 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.imageFormat ); 14922 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.imageColorSpace ); 14923 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.imageExtent ); 14924 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.imageArrayLayers ); 14925 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.imageUsage ); 14926 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.imageSharingMode ); 14927 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.queueFamilyIndexCount ); 14928 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.pQueueFamilyIndices ); 14929 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.preTransform ); 14930 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.compositeAlpha ); 14931 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.presentMode ); 14932 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.clipped ); 14933 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.oldSwapchain ); 14934 return seed; 14935 } 14936 }; 14937 14938 template <> 14939 struct hash<VULKAN_HPP_NAMESPACE::SwapchainDisplayNativeHdrCreateInfoAMD> 14940 { 14941 std::size_t operator ()std::hash14942 operator()( VULKAN_HPP_NAMESPACE::SwapchainDisplayNativeHdrCreateInfoAMD const & swapchainDisplayNativeHdrCreateInfoAMD ) const VULKAN_HPP_NOEXCEPT 14943 { 14944 std::size_t seed = 0; 14945 VULKAN_HPP_HASH_COMBINE( seed, swapchainDisplayNativeHdrCreateInfoAMD.sType ); 14946 VULKAN_HPP_HASH_COMBINE( seed, swapchainDisplayNativeHdrCreateInfoAMD.pNext ); 14947 VULKAN_HPP_HASH_COMBINE( seed, swapchainDisplayNativeHdrCreateInfoAMD.localDimmingEnable ); 14948 return seed; 14949 } 14950 }; 14951 14952 template <> 14953 struct hash<VULKAN_HPP_NAMESPACE::SwapchainLatencyCreateInfoNV> 14954 { operator ()std::hash14955 std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainLatencyCreateInfoNV const & swapchainLatencyCreateInfoNV ) const VULKAN_HPP_NOEXCEPT 14956 { 14957 std::size_t seed = 0; 14958 VULKAN_HPP_HASH_COMBINE( seed, swapchainLatencyCreateInfoNV.sType ); 14959 VULKAN_HPP_HASH_COMBINE( seed, swapchainLatencyCreateInfoNV.pNext ); 14960 VULKAN_HPP_HASH_COMBINE( seed, swapchainLatencyCreateInfoNV.latencyModeEnable ); 14961 return seed; 14962 } 14963 }; 14964 14965 template <> 14966 struct hash<VULKAN_HPP_NAMESPACE::SwapchainPresentBarrierCreateInfoNV> 14967 { operator ()std::hash14968 std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainPresentBarrierCreateInfoNV const & swapchainPresentBarrierCreateInfoNV ) const VULKAN_HPP_NOEXCEPT 14969 { 14970 std::size_t seed = 0; 14971 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentBarrierCreateInfoNV.sType ); 14972 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentBarrierCreateInfoNV.pNext ); 14973 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentBarrierCreateInfoNV.presentBarrierEnable ); 14974 return seed; 14975 } 14976 }; 14977 14978 template <> 14979 struct hash<VULKAN_HPP_NAMESPACE::SwapchainPresentFenceInfoEXT> 14980 { operator ()std::hash14981 std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainPresentFenceInfoEXT const & swapchainPresentFenceInfoEXT ) const VULKAN_HPP_NOEXCEPT 14982 { 14983 std::size_t seed = 0; 14984 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentFenceInfoEXT.sType ); 14985 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentFenceInfoEXT.pNext ); 14986 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentFenceInfoEXT.swapchainCount ); 14987 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentFenceInfoEXT.pFences ); 14988 return seed; 14989 } 14990 }; 14991 14992 template <> 14993 struct hash<VULKAN_HPP_NAMESPACE::SwapchainPresentModeInfoEXT> 14994 { operator ()std::hash14995 std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainPresentModeInfoEXT const & swapchainPresentModeInfoEXT ) const VULKAN_HPP_NOEXCEPT 14996 { 14997 std::size_t seed = 0; 14998 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentModeInfoEXT.sType ); 14999 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentModeInfoEXT.pNext ); 15000 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentModeInfoEXT.swapchainCount ); 15001 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentModeInfoEXT.pPresentModes ); 15002 return seed; 15003 } 15004 }; 15005 15006 template <> 15007 struct hash<VULKAN_HPP_NAMESPACE::SwapchainPresentModesCreateInfoEXT> 15008 { operator ()std::hash15009 std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainPresentModesCreateInfoEXT const & swapchainPresentModesCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 15010 { 15011 std::size_t seed = 0; 15012 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentModesCreateInfoEXT.sType ); 15013 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentModesCreateInfoEXT.pNext ); 15014 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentModesCreateInfoEXT.presentModeCount ); 15015 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentModesCreateInfoEXT.pPresentModes ); 15016 return seed; 15017 } 15018 }; 15019 15020 template <> 15021 struct hash<VULKAN_HPP_NAMESPACE::SwapchainPresentScalingCreateInfoEXT> 15022 { operator ()std::hash15023 std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainPresentScalingCreateInfoEXT const & swapchainPresentScalingCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 15024 { 15025 std::size_t seed = 0; 15026 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentScalingCreateInfoEXT.sType ); 15027 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentScalingCreateInfoEXT.pNext ); 15028 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentScalingCreateInfoEXT.scalingBehavior ); 15029 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentScalingCreateInfoEXT.presentGravityX ); 15030 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentScalingCreateInfoEXT.presentGravityY ); 15031 return seed; 15032 } 15033 }; 15034 15035 template <> 15036 struct hash<VULKAN_HPP_NAMESPACE::TextureLODGatherFormatPropertiesAMD> 15037 { operator ()std::hash15038 std::size_t operator()( VULKAN_HPP_NAMESPACE::TextureLODGatherFormatPropertiesAMD const & textureLODGatherFormatPropertiesAMD ) const VULKAN_HPP_NOEXCEPT 15039 { 15040 std::size_t seed = 0; 15041 VULKAN_HPP_HASH_COMBINE( seed, textureLODGatherFormatPropertiesAMD.sType ); 15042 VULKAN_HPP_HASH_COMBINE( seed, textureLODGatherFormatPropertiesAMD.pNext ); 15043 VULKAN_HPP_HASH_COMBINE( seed, textureLODGatherFormatPropertiesAMD.supportsTextureGatherLODBiasAMD ); 15044 return seed; 15045 } 15046 }; 15047 15048 template <> 15049 struct hash<VULKAN_HPP_NAMESPACE::TilePropertiesQCOM> 15050 { operator ()std::hash15051 std::size_t operator()( VULKAN_HPP_NAMESPACE::TilePropertiesQCOM const & tilePropertiesQCOM ) const VULKAN_HPP_NOEXCEPT 15052 { 15053 std::size_t seed = 0; 15054 VULKAN_HPP_HASH_COMBINE( seed, tilePropertiesQCOM.sType ); 15055 VULKAN_HPP_HASH_COMBINE( seed, tilePropertiesQCOM.pNext ); 15056 VULKAN_HPP_HASH_COMBINE( seed, tilePropertiesQCOM.tileSize ); 15057 VULKAN_HPP_HASH_COMBINE( seed, tilePropertiesQCOM.apronSize ); 15058 VULKAN_HPP_HASH_COMBINE( seed, tilePropertiesQCOM.origin ); 15059 return seed; 15060 } 15061 }; 15062 15063 template <> 15064 struct hash<VULKAN_HPP_NAMESPACE::TimelineSemaphoreSubmitInfo> 15065 { operator ()std::hash15066 std::size_t operator()( VULKAN_HPP_NAMESPACE::TimelineSemaphoreSubmitInfo const & timelineSemaphoreSubmitInfo ) const VULKAN_HPP_NOEXCEPT 15067 { 15068 std::size_t seed = 0; 15069 VULKAN_HPP_HASH_COMBINE( seed, timelineSemaphoreSubmitInfo.sType ); 15070 VULKAN_HPP_HASH_COMBINE( seed, timelineSemaphoreSubmitInfo.pNext ); 15071 VULKAN_HPP_HASH_COMBINE( seed, timelineSemaphoreSubmitInfo.waitSemaphoreValueCount ); 15072 VULKAN_HPP_HASH_COMBINE( seed, timelineSemaphoreSubmitInfo.pWaitSemaphoreValues ); 15073 VULKAN_HPP_HASH_COMBINE( seed, timelineSemaphoreSubmitInfo.signalSemaphoreValueCount ); 15074 VULKAN_HPP_HASH_COMBINE( seed, timelineSemaphoreSubmitInfo.pSignalSemaphoreValues ); 15075 return seed; 15076 } 15077 }; 15078 15079 template <> 15080 struct hash<VULKAN_HPP_NAMESPACE::TraceRaysIndirectCommand2KHR> 15081 { operator ()std::hash15082 std::size_t operator()( VULKAN_HPP_NAMESPACE::TraceRaysIndirectCommand2KHR const & traceRaysIndirectCommand2KHR ) const VULKAN_HPP_NOEXCEPT 15083 { 15084 std::size_t seed = 0; 15085 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.raygenShaderRecordAddress ); 15086 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.raygenShaderRecordSize ); 15087 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.missShaderBindingTableAddress ); 15088 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.missShaderBindingTableSize ); 15089 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.missShaderBindingTableStride ); 15090 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.hitShaderBindingTableAddress ); 15091 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.hitShaderBindingTableSize ); 15092 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.hitShaderBindingTableStride ); 15093 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.callableShaderBindingTableAddress ); 15094 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.callableShaderBindingTableSize ); 15095 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.callableShaderBindingTableStride ); 15096 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.width ); 15097 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.height ); 15098 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.depth ); 15099 return seed; 15100 } 15101 }; 15102 15103 template <> 15104 struct hash<VULKAN_HPP_NAMESPACE::TraceRaysIndirectCommandKHR> 15105 { operator ()std::hash15106 std::size_t operator()( VULKAN_HPP_NAMESPACE::TraceRaysIndirectCommandKHR const & traceRaysIndirectCommandKHR ) const VULKAN_HPP_NOEXCEPT 15107 { 15108 std::size_t seed = 0; 15109 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommandKHR.width ); 15110 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommandKHR.height ); 15111 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommandKHR.depth ); 15112 return seed; 15113 } 15114 }; 15115 15116 template <> 15117 struct hash<VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT> 15118 { operator ()std::hash15119 std::size_t operator()( VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT const & validationCacheCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 15120 { 15121 std::size_t seed = 0; 15122 VULKAN_HPP_HASH_COMBINE( seed, validationCacheCreateInfoEXT.sType ); 15123 VULKAN_HPP_HASH_COMBINE( seed, validationCacheCreateInfoEXT.pNext ); 15124 VULKAN_HPP_HASH_COMBINE( seed, validationCacheCreateInfoEXT.flags ); 15125 VULKAN_HPP_HASH_COMBINE( seed, validationCacheCreateInfoEXT.initialDataSize ); 15126 VULKAN_HPP_HASH_COMBINE( seed, validationCacheCreateInfoEXT.pInitialData ); 15127 return seed; 15128 } 15129 }; 15130 15131 template <> 15132 struct hash<VULKAN_HPP_NAMESPACE::ValidationFeaturesEXT> 15133 { operator ()std::hash15134 std::size_t operator()( VULKAN_HPP_NAMESPACE::ValidationFeaturesEXT const & validationFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 15135 { 15136 std::size_t seed = 0; 15137 VULKAN_HPP_HASH_COMBINE( seed, validationFeaturesEXT.sType ); 15138 VULKAN_HPP_HASH_COMBINE( seed, validationFeaturesEXT.pNext ); 15139 VULKAN_HPP_HASH_COMBINE( seed, validationFeaturesEXT.enabledValidationFeatureCount ); 15140 VULKAN_HPP_HASH_COMBINE( seed, validationFeaturesEXT.pEnabledValidationFeatures ); 15141 VULKAN_HPP_HASH_COMBINE( seed, validationFeaturesEXT.disabledValidationFeatureCount ); 15142 VULKAN_HPP_HASH_COMBINE( seed, validationFeaturesEXT.pDisabledValidationFeatures ); 15143 return seed; 15144 } 15145 }; 15146 15147 template <> 15148 struct hash<VULKAN_HPP_NAMESPACE::ValidationFlagsEXT> 15149 { operator ()std::hash15150 std::size_t operator()( VULKAN_HPP_NAMESPACE::ValidationFlagsEXT const & validationFlagsEXT ) const VULKAN_HPP_NOEXCEPT 15151 { 15152 std::size_t seed = 0; 15153 VULKAN_HPP_HASH_COMBINE( seed, validationFlagsEXT.sType ); 15154 VULKAN_HPP_HASH_COMBINE( seed, validationFlagsEXT.pNext ); 15155 VULKAN_HPP_HASH_COMBINE( seed, validationFlagsEXT.disabledValidationCheckCount ); 15156 VULKAN_HPP_HASH_COMBINE( seed, validationFlagsEXT.pDisabledValidationChecks ); 15157 return seed; 15158 } 15159 }; 15160 15161 template <> 15162 struct hash<VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT> 15163 { operator ()std::hash15164 std::size_t operator()( VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT const & vertexInputAttributeDescription2EXT ) const VULKAN_HPP_NOEXCEPT 15165 { 15166 std::size_t seed = 0; 15167 VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription2EXT.sType ); 15168 VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription2EXT.pNext ); 15169 VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription2EXT.location ); 15170 VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription2EXT.binding ); 15171 VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription2EXT.format ); 15172 VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription2EXT.offset ); 15173 return seed; 15174 } 15175 }; 15176 15177 template <> 15178 struct hash<VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT> 15179 { operator ()std::hash15180 std::size_t operator()( VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT const & vertexInputBindingDescription2EXT ) const VULKAN_HPP_NOEXCEPT 15181 { 15182 std::size_t seed = 0; 15183 VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDescription2EXT.sType ); 15184 VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDescription2EXT.pNext ); 15185 VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDescription2EXT.binding ); 15186 VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDescription2EXT.stride ); 15187 VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDescription2EXT.inputRate ); 15188 VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDescription2EXT.divisor ); 15189 return seed; 15190 } 15191 }; 15192 15193 # if defined( VK_USE_PLATFORM_VI_NN ) 15194 template <> 15195 struct hash<VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN> 15196 { operator ()std::hash15197 std::size_t operator()( VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN const & viSurfaceCreateInfoNN ) const VULKAN_HPP_NOEXCEPT 15198 { 15199 std::size_t seed = 0; 15200 VULKAN_HPP_HASH_COMBINE( seed, viSurfaceCreateInfoNN.sType ); 15201 VULKAN_HPP_HASH_COMBINE( seed, viSurfaceCreateInfoNN.pNext ); 15202 VULKAN_HPP_HASH_COMBINE( seed, viSurfaceCreateInfoNN.flags ); 15203 VULKAN_HPP_HASH_COMBINE( seed, viSurfaceCreateInfoNN.window ); 15204 return seed; 15205 } 15206 }; 15207 # endif /*VK_USE_PLATFORM_VI_NN*/ 15208 15209 template <> 15210 struct hash<VULKAN_HPP_NAMESPACE::VideoPictureResourceInfoKHR> 15211 { operator ()std::hash15212 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoPictureResourceInfoKHR const & videoPictureResourceInfoKHR ) const VULKAN_HPP_NOEXCEPT 15213 { 15214 std::size_t seed = 0; 15215 VULKAN_HPP_HASH_COMBINE( seed, videoPictureResourceInfoKHR.sType ); 15216 VULKAN_HPP_HASH_COMBINE( seed, videoPictureResourceInfoKHR.pNext ); 15217 VULKAN_HPP_HASH_COMBINE( seed, videoPictureResourceInfoKHR.codedOffset ); 15218 VULKAN_HPP_HASH_COMBINE( seed, videoPictureResourceInfoKHR.codedExtent ); 15219 VULKAN_HPP_HASH_COMBINE( seed, videoPictureResourceInfoKHR.baseArrayLayer ); 15220 VULKAN_HPP_HASH_COMBINE( seed, videoPictureResourceInfoKHR.imageViewBinding ); 15221 return seed; 15222 } 15223 }; 15224 15225 template <> 15226 struct hash<VULKAN_HPP_NAMESPACE::VideoReferenceSlotInfoKHR> 15227 { operator ()std::hash15228 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoReferenceSlotInfoKHR const & videoReferenceSlotInfoKHR ) const VULKAN_HPP_NOEXCEPT 15229 { 15230 std::size_t seed = 0; 15231 VULKAN_HPP_HASH_COMBINE( seed, videoReferenceSlotInfoKHR.sType ); 15232 VULKAN_HPP_HASH_COMBINE( seed, videoReferenceSlotInfoKHR.pNext ); 15233 VULKAN_HPP_HASH_COMBINE( seed, videoReferenceSlotInfoKHR.slotIndex ); 15234 VULKAN_HPP_HASH_COMBINE( seed, videoReferenceSlotInfoKHR.pPictureResource ); 15235 return seed; 15236 } 15237 }; 15238 15239 template <> 15240 struct hash<VULKAN_HPP_NAMESPACE::VideoBeginCodingInfoKHR> 15241 { operator ()std::hash15242 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoBeginCodingInfoKHR const & videoBeginCodingInfoKHR ) const VULKAN_HPP_NOEXCEPT 15243 { 15244 std::size_t seed = 0; 15245 VULKAN_HPP_HASH_COMBINE( seed, videoBeginCodingInfoKHR.sType ); 15246 VULKAN_HPP_HASH_COMBINE( seed, videoBeginCodingInfoKHR.pNext ); 15247 VULKAN_HPP_HASH_COMBINE( seed, videoBeginCodingInfoKHR.flags ); 15248 VULKAN_HPP_HASH_COMBINE( seed, videoBeginCodingInfoKHR.videoSession ); 15249 VULKAN_HPP_HASH_COMBINE( seed, videoBeginCodingInfoKHR.videoSessionParameters ); 15250 VULKAN_HPP_HASH_COMBINE( seed, videoBeginCodingInfoKHR.referenceSlotCount ); 15251 VULKAN_HPP_HASH_COMBINE( seed, videoBeginCodingInfoKHR.pReferenceSlots ); 15252 return seed; 15253 } 15254 }; 15255 15256 template <> 15257 struct hash<VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR> 15258 { operator ()std::hash15259 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR const & videoCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT 15260 { 15261 std::size_t seed = 0; 15262 VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.sType ); 15263 VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.pNext ); 15264 VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.flags ); 15265 VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.minBitstreamBufferOffsetAlignment ); 15266 VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.minBitstreamBufferSizeAlignment ); 15267 VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.pictureAccessGranularity ); 15268 VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.minCodedExtent ); 15269 VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.maxCodedExtent ); 15270 VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.maxDpbSlots ); 15271 VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.maxActiveReferencePictures ); 15272 VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.stdHeaderVersion ); 15273 return seed; 15274 } 15275 }; 15276 15277 template <> 15278 struct hash<VULKAN_HPP_NAMESPACE::VideoCodingControlInfoKHR> 15279 { operator ()std::hash15280 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoCodingControlInfoKHR const & videoCodingControlInfoKHR ) const VULKAN_HPP_NOEXCEPT 15281 { 15282 std::size_t seed = 0; 15283 VULKAN_HPP_HASH_COMBINE( seed, videoCodingControlInfoKHR.sType ); 15284 VULKAN_HPP_HASH_COMBINE( seed, videoCodingControlInfoKHR.pNext ); 15285 VULKAN_HPP_HASH_COMBINE( seed, videoCodingControlInfoKHR.flags ); 15286 return seed; 15287 } 15288 }; 15289 15290 template <> 15291 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeCapabilitiesKHR> 15292 { operator ()std::hash15293 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeCapabilitiesKHR const & videoDecodeCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT 15294 { 15295 std::size_t seed = 0; 15296 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeCapabilitiesKHR.sType ); 15297 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeCapabilitiesKHR.pNext ); 15298 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeCapabilitiesKHR.flags ); 15299 return seed; 15300 } 15301 }; 15302 15303 template <> 15304 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH264CapabilitiesKHR> 15305 { operator ()std::hash15306 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264CapabilitiesKHR const & videoDecodeH264CapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT 15307 { 15308 std::size_t seed = 0; 15309 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264CapabilitiesKHR.sType ); 15310 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264CapabilitiesKHR.pNext ); 15311 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264CapabilitiesKHR.maxLevelIdc ); 15312 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264CapabilitiesKHR.fieldOffsetGranularity ); 15313 return seed; 15314 } 15315 }; 15316 15317 template <> 15318 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH264DpbSlotInfoKHR> 15319 { operator ()std::hash15320 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264DpbSlotInfoKHR const & videoDecodeH264DpbSlotInfoKHR ) const VULKAN_HPP_NOEXCEPT 15321 { 15322 std::size_t seed = 0; 15323 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264DpbSlotInfoKHR.sType ); 15324 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264DpbSlotInfoKHR.pNext ); 15325 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264DpbSlotInfoKHR.pStdReferenceInfo ); 15326 return seed; 15327 } 15328 }; 15329 15330 template <> 15331 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH264PictureInfoKHR> 15332 { operator ()std::hash15333 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264PictureInfoKHR const & videoDecodeH264PictureInfoKHR ) const VULKAN_HPP_NOEXCEPT 15334 { 15335 std::size_t seed = 0; 15336 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264PictureInfoKHR.sType ); 15337 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264PictureInfoKHR.pNext ); 15338 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264PictureInfoKHR.pStdPictureInfo ); 15339 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264PictureInfoKHR.sliceCount ); 15340 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264PictureInfoKHR.pSliceOffsets ); 15341 return seed; 15342 } 15343 }; 15344 15345 template <> 15346 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH264ProfileInfoKHR> 15347 { operator ()std::hash15348 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264ProfileInfoKHR const & videoDecodeH264ProfileInfoKHR ) const VULKAN_HPP_NOEXCEPT 15349 { 15350 std::size_t seed = 0; 15351 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264ProfileInfoKHR.sType ); 15352 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264ProfileInfoKHR.pNext ); 15353 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264ProfileInfoKHR.stdProfileIdc ); 15354 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264ProfileInfoKHR.pictureLayout ); 15355 return seed; 15356 } 15357 }; 15358 15359 template <> 15360 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH264SessionParametersAddInfoKHR> 15361 { operator ()std::hash15362 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264SessionParametersAddInfoKHR const & videoDecodeH264SessionParametersAddInfoKHR ) const 15363 VULKAN_HPP_NOEXCEPT 15364 { 15365 std::size_t seed = 0; 15366 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersAddInfoKHR.sType ); 15367 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersAddInfoKHR.pNext ); 15368 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersAddInfoKHR.stdSPSCount ); 15369 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersAddInfoKHR.pStdSPSs ); 15370 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersAddInfoKHR.stdPPSCount ); 15371 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersAddInfoKHR.pStdPPSs ); 15372 return seed; 15373 } 15374 }; 15375 15376 template <> 15377 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH264SessionParametersCreateInfoKHR> 15378 { operator ()std::hash15379 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264SessionParametersCreateInfoKHR const & videoDecodeH264SessionParametersCreateInfoKHR ) const 15380 VULKAN_HPP_NOEXCEPT 15381 { 15382 std::size_t seed = 0; 15383 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersCreateInfoKHR.sType ); 15384 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersCreateInfoKHR.pNext ); 15385 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersCreateInfoKHR.maxStdSPSCount ); 15386 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersCreateInfoKHR.maxStdPPSCount ); 15387 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersCreateInfoKHR.pParametersAddInfo ); 15388 return seed; 15389 } 15390 }; 15391 15392 template <> 15393 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH265CapabilitiesKHR> 15394 { operator ()std::hash15395 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265CapabilitiesKHR const & videoDecodeH265CapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT 15396 { 15397 std::size_t seed = 0; 15398 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265CapabilitiesKHR.sType ); 15399 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265CapabilitiesKHR.pNext ); 15400 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265CapabilitiesKHR.maxLevelIdc ); 15401 return seed; 15402 } 15403 }; 15404 15405 template <> 15406 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH265DpbSlotInfoKHR> 15407 { operator ()std::hash15408 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265DpbSlotInfoKHR const & videoDecodeH265DpbSlotInfoKHR ) const VULKAN_HPP_NOEXCEPT 15409 { 15410 std::size_t seed = 0; 15411 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265DpbSlotInfoKHR.sType ); 15412 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265DpbSlotInfoKHR.pNext ); 15413 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265DpbSlotInfoKHR.pStdReferenceInfo ); 15414 return seed; 15415 } 15416 }; 15417 15418 template <> 15419 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH265PictureInfoKHR> 15420 { operator ()std::hash15421 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265PictureInfoKHR const & videoDecodeH265PictureInfoKHR ) const VULKAN_HPP_NOEXCEPT 15422 { 15423 std::size_t seed = 0; 15424 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265PictureInfoKHR.sType ); 15425 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265PictureInfoKHR.pNext ); 15426 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265PictureInfoKHR.pStdPictureInfo ); 15427 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265PictureInfoKHR.sliceSegmentCount ); 15428 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265PictureInfoKHR.pSliceSegmentOffsets ); 15429 return seed; 15430 } 15431 }; 15432 15433 template <> 15434 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH265ProfileInfoKHR> 15435 { operator ()std::hash15436 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265ProfileInfoKHR const & videoDecodeH265ProfileInfoKHR ) const VULKAN_HPP_NOEXCEPT 15437 { 15438 std::size_t seed = 0; 15439 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265ProfileInfoKHR.sType ); 15440 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265ProfileInfoKHR.pNext ); 15441 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265ProfileInfoKHR.stdProfileIdc ); 15442 return seed; 15443 } 15444 }; 15445 15446 template <> 15447 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH265SessionParametersAddInfoKHR> 15448 { operator ()std::hash15449 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265SessionParametersAddInfoKHR const & videoDecodeH265SessionParametersAddInfoKHR ) const 15450 VULKAN_HPP_NOEXCEPT 15451 { 15452 std::size_t seed = 0; 15453 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersAddInfoKHR.sType ); 15454 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersAddInfoKHR.pNext ); 15455 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersAddInfoKHR.stdVPSCount ); 15456 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersAddInfoKHR.pStdVPSs ); 15457 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersAddInfoKHR.stdSPSCount ); 15458 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersAddInfoKHR.pStdSPSs ); 15459 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersAddInfoKHR.stdPPSCount ); 15460 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersAddInfoKHR.pStdPPSs ); 15461 return seed; 15462 } 15463 }; 15464 15465 template <> 15466 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH265SessionParametersCreateInfoKHR> 15467 { operator ()std::hash15468 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265SessionParametersCreateInfoKHR const & videoDecodeH265SessionParametersCreateInfoKHR ) const 15469 VULKAN_HPP_NOEXCEPT 15470 { 15471 std::size_t seed = 0; 15472 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersCreateInfoKHR.sType ); 15473 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersCreateInfoKHR.pNext ); 15474 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersCreateInfoKHR.maxStdVPSCount ); 15475 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersCreateInfoKHR.maxStdSPSCount ); 15476 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersCreateInfoKHR.maxStdPPSCount ); 15477 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersCreateInfoKHR.pParametersAddInfo ); 15478 return seed; 15479 } 15480 }; 15481 15482 template <> 15483 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR> 15484 { operator ()std::hash15485 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR const & videoDecodeInfoKHR ) const VULKAN_HPP_NOEXCEPT 15486 { 15487 std::size_t seed = 0; 15488 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.sType ); 15489 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.pNext ); 15490 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.flags ); 15491 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.srcBuffer ); 15492 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.srcBufferOffset ); 15493 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.srcBufferRange ); 15494 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.dstPictureResource ); 15495 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.pSetupReferenceSlot ); 15496 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.referenceSlotCount ); 15497 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.pReferenceSlots ); 15498 return seed; 15499 } 15500 }; 15501 15502 template <> 15503 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeUsageInfoKHR> 15504 { operator ()std::hash15505 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeUsageInfoKHR const & videoDecodeUsageInfoKHR ) const VULKAN_HPP_NOEXCEPT 15506 { 15507 std::size_t seed = 0; 15508 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeUsageInfoKHR.sType ); 15509 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeUsageInfoKHR.pNext ); 15510 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeUsageInfoKHR.videoUsageHints ); 15511 return seed; 15512 } 15513 }; 15514 15515 template <> 15516 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeCapabilitiesKHR> 15517 { operator ()std::hash15518 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeCapabilitiesKHR const & videoEncodeCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT 15519 { 15520 std::size_t seed = 0; 15521 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.sType ); 15522 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.pNext ); 15523 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.flags ); 15524 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.rateControlModes ); 15525 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.maxRateControlLayers ); 15526 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.maxBitrate ); 15527 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.maxQualityLevels ); 15528 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.encodeInputPictureGranularity ); 15529 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.supportedEncodeFeedbackFlags ); 15530 return seed; 15531 } 15532 }; 15533 15534 template <> 15535 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilitiesKHR> 15536 { operator ()std::hash15537 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilitiesKHR const & videoEncodeH264CapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT 15538 { 15539 std::size_t seed = 0; 15540 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.sType ); 15541 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.pNext ); 15542 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.flags ); 15543 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.maxLevelIdc ); 15544 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.maxSliceCount ); 15545 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.maxPPictureL0ReferenceCount ); 15546 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.maxBPictureL0ReferenceCount ); 15547 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.maxL1ReferenceCount ); 15548 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.maxTemporalLayerCount ); 15549 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.expectDyadicTemporalLayerPattern ); 15550 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.minQp ); 15551 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.maxQp ); 15552 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.prefersGopRemainingFrames ); 15553 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.requiresGopRemainingFrames ); 15554 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.stdSyntaxFlags ); 15555 return seed; 15556 } 15557 }; 15558 15559 template <> 15560 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoKHR> 15561 { operator ()std::hash15562 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoKHR const & videoEncodeH264DpbSlotInfoKHR ) const VULKAN_HPP_NOEXCEPT 15563 { 15564 std::size_t seed = 0; 15565 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264DpbSlotInfoKHR.sType ); 15566 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264DpbSlotInfoKHR.pNext ); 15567 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264DpbSlotInfoKHR.pStdReferenceInfo ); 15568 return seed; 15569 } 15570 }; 15571 15572 template <> 15573 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264FrameSizeKHR> 15574 { operator ()std::hash15575 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264FrameSizeKHR const & videoEncodeH264FrameSizeKHR ) const VULKAN_HPP_NOEXCEPT 15576 { 15577 std::size_t seed = 0; 15578 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264FrameSizeKHR.frameISize ); 15579 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264FrameSizeKHR.framePSize ); 15580 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264FrameSizeKHR.frameBSize ); 15581 return seed; 15582 } 15583 }; 15584 15585 template <> 15586 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264GopRemainingFrameInfoKHR> 15587 { 15588 std::size_t operator ()std::hash15589 operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264GopRemainingFrameInfoKHR const & videoEncodeH264GopRemainingFrameInfoKHR ) const VULKAN_HPP_NOEXCEPT 15590 { 15591 std::size_t seed = 0; 15592 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264GopRemainingFrameInfoKHR.sType ); 15593 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264GopRemainingFrameInfoKHR.pNext ); 15594 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264GopRemainingFrameInfoKHR.useGopRemainingFrames ); 15595 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264GopRemainingFrameInfoKHR.gopRemainingI ); 15596 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264GopRemainingFrameInfoKHR.gopRemainingP ); 15597 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264GopRemainingFrameInfoKHR.gopRemainingB ); 15598 return seed; 15599 } 15600 }; 15601 15602 template <> 15603 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264NaluSliceInfoKHR> 15604 { operator ()std::hash15605 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264NaluSliceInfoKHR const & videoEncodeH264NaluSliceInfoKHR ) const VULKAN_HPP_NOEXCEPT 15606 { 15607 std::size_t seed = 0; 15608 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264NaluSliceInfoKHR.sType ); 15609 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264NaluSliceInfoKHR.pNext ); 15610 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264NaluSliceInfoKHR.constantQp ); 15611 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264NaluSliceInfoKHR.pStdSliceHeader ); 15612 return seed; 15613 } 15614 }; 15615 15616 template <> 15617 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264PictureInfoKHR> 15618 { operator ()std::hash15619 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264PictureInfoKHR const & videoEncodeH264PictureInfoKHR ) const VULKAN_HPP_NOEXCEPT 15620 { 15621 std::size_t seed = 0; 15622 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264PictureInfoKHR.sType ); 15623 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264PictureInfoKHR.pNext ); 15624 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264PictureInfoKHR.naluSliceEntryCount ); 15625 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264PictureInfoKHR.pNaluSliceEntries ); 15626 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264PictureInfoKHR.pStdPictureInfo ); 15627 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264PictureInfoKHR.generatePrefixNalu ); 15628 return seed; 15629 } 15630 }; 15631 15632 template <> 15633 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264ProfileInfoKHR> 15634 { operator ()std::hash15635 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264ProfileInfoKHR const & videoEncodeH264ProfileInfoKHR ) const VULKAN_HPP_NOEXCEPT 15636 { 15637 std::size_t seed = 0; 15638 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264ProfileInfoKHR.sType ); 15639 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264ProfileInfoKHR.pNext ); 15640 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264ProfileInfoKHR.stdProfileIdc ); 15641 return seed; 15642 } 15643 }; 15644 15645 template <> 15646 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264QpKHR> 15647 { operator ()std::hash15648 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264QpKHR const & videoEncodeH264QpKHR ) const VULKAN_HPP_NOEXCEPT 15649 { 15650 std::size_t seed = 0; 15651 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QpKHR.qpI ); 15652 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QpKHR.qpP ); 15653 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QpKHR.qpB ); 15654 return seed; 15655 } 15656 }; 15657 15658 template <> 15659 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264QualityLevelPropertiesKHR> 15660 { 15661 std::size_t operator ()std::hash15662 operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264QualityLevelPropertiesKHR const & videoEncodeH264QualityLevelPropertiesKHR ) const VULKAN_HPP_NOEXCEPT 15663 { 15664 std::size_t seed = 0; 15665 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesKHR.sType ); 15666 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesKHR.pNext ); 15667 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesKHR.preferredRateControlFlags ); 15668 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesKHR.preferredGopFrameCount ); 15669 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesKHR.preferredIdrPeriod ); 15670 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesKHR.preferredConsecutiveBFrameCount ); 15671 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesKHR.preferredTemporalLayerCount ); 15672 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesKHR.preferredConstantQp ); 15673 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesKHR.preferredMaxL0ReferenceCount ); 15674 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesKHR.preferredMaxL1ReferenceCount ); 15675 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesKHR.preferredStdEntropyCodingModeFlag ); 15676 return seed; 15677 } 15678 }; 15679 15680 template <> 15681 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlInfoKHR> 15682 { operator ()std::hash15683 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlInfoKHR const & videoEncodeH264RateControlInfoKHR ) const VULKAN_HPP_NOEXCEPT 15684 { 15685 std::size_t seed = 0; 15686 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlInfoKHR.sType ); 15687 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlInfoKHR.pNext ); 15688 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlInfoKHR.flags ); 15689 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlInfoKHR.gopFrameCount ); 15690 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlInfoKHR.idrPeriod ); 15691 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlInfoKHR.consecutiveBFrameCount ); 15692 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlInfoKHR.temporalLayerCount ); 15693 return seed; 15694 } 15695 }; 15696 15697 template <> 15698 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlLayerInfoKHR> 15699 { 15700 std::size_t operator ()std::hash15701 operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlLayerInfoKHR const & videoEncodeH264RateControlLayerInfoKHR ) const VULKAN_HPP_NOEXCEPT 15702 { 15703 std::size_t seed = 0; 15704 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoKHR.sType ); 15705 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoKHR.pNext ); 15706 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoKHR.useMinQp ); 15707 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoKHR.minQp ); 15708 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoKHR.useMaxQp ); 15709 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoKHR.maxQp ); 15710 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoKHR.useMaxFrameSize ); 15711 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoKHR.maxFrameSize ); 15712 return seed; 15713 } 15714 }; 15715 15716 template <> 15717 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionCreateInfoKHR> 15718 { operator ()std::hash15719 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionCreateInfoKHR const & videoEncodeH264SessionCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 15720 { 15721 std::size_t seed = 0; 15722 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionCreateInfoKHR.sType ); 15723 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionCreateInfoKHR.pNext ); 15724 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionCreateInfoKHR.useMaxLevelIdc ); 15725 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionCreateInfoKHR.maxLevelIdc ); 15726 return seed; 15727 } 15728 }; 15729 15730 template <> 15731 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersAddInfoKHR> 15732 { operator ()std::hash15733 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersAddInfoKHR const & videoEncodeH264SessionParametersAddInfoKHR ) const 15734 VULKAN_HPP_NOEXCEPT 15735 { 15736 std::size_t seed = 0; 15737 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersAddInfoKHR.sType ); 15738 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersAddInfoKHR.pNext ); 15739 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersAddInfoKHR.stdSPSCount ); 15740 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersAddInfoKHR.pStdSPSs ); 15741 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersAddInfoKHR.stdPPSCount ); 15742 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersAddInfoKHR.pStdPPSs ); 15743 return seed; 15744 } 15745 }; 15746 15747 template <> 15748 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersCreateInfoKHR> 15749 { operator ()std::hash15750 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersCreateInfoKHR const & videoEncodeH264SessionParametersCreateInfoKHR ) const 15751 VULKAN_HPP_NOEXCEPT 15752 { 15753 std::size_t seed = 0; 15754 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersCreateInfoKHR.sType ); 15755 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersCreateInfoKHR.pNext ); 15756 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersCreateInfoKHR.maxStdSPSCount ); 15757 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersCreateInfoKHR.maxStdPPSCount ); 15758 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersCreateInfoKHR.pParametersAddInfo ); 15759 return seed; 15760 } 15761 }; 15762 15763 template <> 15764 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersFeedbackInfoKHR> 15765 { operator ()std::hash15766 std::size_t operator()( 15767 VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersFeedbackInfoKHR const & videoEncodeH264SessionParametersFeedbackInfoKHR ) const VULKAN_HPP_NOEXCEPT 15768 { 15769 std::size_t seed = 0; 15770 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersFeedbackInfoKHR.sType ); 15771 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersFeedbackInfoKHR.pNext ); 15772 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersFeedbackInfoKHR.hasStdSPSOverrides ); 15773 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersFeedbackInfoKHR.hasStdPPSOverrides ); 15774 return seed; 15775 } 15776 }; 15777 15778 template <> 15779 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersGetInfoKHR> 15780 { operator ()std::hash15781 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersGetInfoKHR const & videoEncodeH264SessionParametersGetInfoKHR ) const 15782 VULKAN_HPP_NOEXCEPT 15783 { 15784 std::size_t seed = 0; 15785 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersGetInfoKHR.sType ); 15786 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersGetInfoKHR.pNext ); 15787 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersGetInfoKHR.writeStdSPS ); 15788 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersGetInfoKHR.writeStdPPS ); 15789 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersGetInfoKHR.stdSPSId ); 15790 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersGetInfoKHR.stdPPSId ); 15791 return seed; 15792 } 15793 }; 15794 15795 template <> 15796 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265CapabilitiesKHR> 15797 { operator ()std::hash15798 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265CapabilitiesKHR const & videoEncodeH265CapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT 15799 { 15800 std::size_t seed = 0; 15801 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.sType ); 15802 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.pNext ); 15803 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.flags ); 15804 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.maxLevelIdc ); 15805 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.maxSliceSegmentCount ); 15806 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.maxTiles ); 15807 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.ctbSizes ); 15808 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.transformBlockSizes ); 15809 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.maxPPictureL0ReferenceCount ); 15810 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.maxBPictureL0ReferenceCount ); 15811 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.maxL1ReferenceCount ); 15812 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.maxSubLayerCount ); 15813 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.expectDyadicTemporalSubLayerPattern ); 15814 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.minQp ); 15815 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.maxQp ); 15816 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.prefersGopRemainingFrames ); 15817 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.requiresGopRemainingFrames ); 15818 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.stdSyntaxFlags ); 15819 return seed; 15820 } 15821 }; 15822 15823 template <> 15824 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265DpbSlotInfoKHR> 15825 { operator ()std::hash15826 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265DpbSlotInfoKHR const & videoEncodeH265DpbSlotInfoKHR ) const VULKAN_HPP_NOEXCEPT 15827 { 15828 std::size_t seed = 0; 15829 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265DpbSlotInfoKHR.sType ); 15830 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265DpbSlotInfoKHR.pNext ); 15831 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265DpbSlotInfoKHR.pStdReferenceInfo ); 15832 return seed; 15833 } 15834 }; 15835 15836 template <> 15837 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265FrameSizeKHR> 15838 { operator ()std::hash15839 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265FrameSizeKHR const & videoEncodeH265FrameSizeKHR ) const VULKAN_HPP_NOEXCEPT 15840 { 15841 std::size_t seed = 0; 15842 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265FrameSizeKHR.frameISize ); 15843 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265FrameSizeKHR.framePSize ); 15844 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265FrameSizeKHR.frameBSize ); 15845 return seed; 15846 } 15847 }; 15848 15849 template <> 15850 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265GopRemainingFrameInfoKHR> 15851 { 15852 std::size_t operator ()std::hash15853 operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265GopRemainingFrameInfoKHR const & videoEncodeH265GopRemainingFrameInfoKHR ) const VULKAN_HPP_NOEXCEPT 15854 { 15855 std::size_t seed = 0; 15856 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265GopRemainingFrameInfoKHR.sType ); 15857 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265GopRemainingFrameInfoKHR.pNext ); 15858 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265GopRemainingFrameInfoKHR.useGopRemainingFrames ); 15859 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265GopRemainingFrameInfoKHR.gopRemainingI ); 15860 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265GopRemainingFrameInfoKHR.gopRemainingP ); 15861 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265GopRemainingFrameInfoKHR.gopRemainingB ); 15862 return seed; 15863 } 15864 }; 15865 15866 template <> 15867 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceSegmentInfoKHR> 15868 { 15869 std::size_t operator ()std::hash15870 operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceSegmentInfoKHR const & videoEncodeH265NaluSliceSegmentInfoKHR ) const VULKAN_HPP_NOEXCEPT 15871 { 15872 std::size_t seed = 0; 15873 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265NaluSliceSegmentInfoKHR.sType ); 15874 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265NaluSliceSegmentInfoKHR.pNext ); 15875 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265NaluSliceSegmentInfoKHR.constantQp ); 15876 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265NaluSliceSegmentInfoKHR.pStdSliceSegmentHeader ); 15877 return seed; 15878 } 15879 }; 15880 15881 template <> 15882 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265PictureInfoKHR> 15883 { operator ()std::hash15884 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265PictureInfoKHR const & videoEncodeH265PictureInfoKHR ) const VULKAN_HPP_NOEXCEPT 15885 { 15886 std::size_t seed = 0; 15887 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265PictureInfoKHR.sType ); 15888 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265PictureInfoKHR.pNext ); 15889 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265PictureInfoKHR.naluSliceSegmentEntryCount ); 15890 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265PictureInfoKHR.pNaluSliceSegmentEntries ); 15891 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265PictureInfoKHR.pStdPictureInfo ); 15892 return seed; 15893 } 15894 }; 15895 15896 template <> 15897 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265ProfileInfoKHR> 15898 { operator ()std::hash15899 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265ProfileInfoKHR const & videoEncodeH265ProfileInfoKHR ) const VULKAN_HPP_NOEXCEPT 15900 { 15901 std::size_t seed = 0; 15902 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265ProfileInfoKHR.sType ); 15903 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265ProfileInfoKHR.pNext ); 15904 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265ProfileInfoKHR.stdProfileIdc ); 15905 return seed; 15906 } 15907 }; 15908 15909 template <> 15910 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265QpKHR> 15911 { operator ()std::hash15912 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265QpKHR const & videoEncodeH265QpKHR ) const VULKAN_HPP_NOEXCEPT 15913 { 15914 std::size_t seed = 0; 15915 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QpKHR.qpI ); 15916 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QpKHR.qpP ); 15917 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QpKHR.qpB ); 15918 return seed; 15919 } 15920 }; 15921 15922 template <> 15923 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265QualityLevelPropertiesKHR> 15924 { 15925 std::size_t operator ()std::hash15926 operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265QualityLevelPropertiesKHR const & videoEncodeH265QualityLevelPropertiesKHR ) const VULKAN_HPP_NOEXCEPT 15927 { 15928 std::size_t seed = 0; 15929 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesKHR.sType ); 15930 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesKHR.pNext ); 15931 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesKHR.preferredRateControlFlags ); 15932 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesKHR.preferredGopFrameCount ); 15933 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesKHR.preferredIdrPeriod ); 15934 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesKHR.preferredConsecutiveBFrameCount ); 15935 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesKHR.preferredSubLayerCount ); 15936 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesKHR.preferredConstantQp ); 15937 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesKHR.preferredMaxL0ReferenceCount ); 15938 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesKHR.preferredMaxL1ReferenceCount ); 15939 return seed; 15940 } 15941 }; 15942 15943 template <> 15944 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlInfoKHR> 15945 { operator ()std::hash15946 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlInfoKHR const & videoEncodeH265RateControlInfoKHR ) const VULKAN_HPP_NOEXCEPT 15947 { 15948 std::size_t seed = 0; 15949 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlInfoKHR.sType ); 15950 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlInfoKHR.pNext ); 15951 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlInfoKHR.flags ); 15952 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlInfoKHR.gopFrameCount ); 15953 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlInfoKHR.idrPeriod ); 15954 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlInfoKHR.consecutiveBFrameCount ); 15955 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlInfoKHR.subLayerCount ); 15956 return seed; 15957 } 15958 }; 15959 15960 template <> 15961 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlLayerInfoKHR> 15962 { 15963 std::size_t operator ()std::hash15964 operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlLayerInfoKHR const & videoEncodeH265RateControlLayerInfoKHR ) const VULKAN_HPP_NOEXCEPT 15965 { 15966 std::size_t seed = 0; 15967 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoKHR.sType ); 15968 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoKHR.pNext ); 15969 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoKHR.useMinQp ); 15970 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoKHR.minQp ); 15971 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoKHR.useMaxQp ); 15972 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoKHR.maxQp ); 15973 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoKHR.useMaxFrameSize ); 15974 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoKHR.maxFrameSize ); 15975 return seed; 15976 } 15977 }; 15978 15979 template <> 15980 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionCreateInfoKHR> 15981 { operator ()std::hash15982 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionCreateInfoKHR const & videoEncodeH265SessionCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 15983 { 15984 std::size_t seed = 0; 15985 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionCreateInfoKHR.sType ); 15986 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionCreateInfoKHR.pNext ); 15987 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionCreateInfoKHR.useMaxLevelIdc ); 15988 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionCreateInfoKHR.maxLevelIdc ); 15989 return seed; 15990 } 15991 }; 15992 15993 template <> 15994 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersAddInfoKHR> 15995 { operator ()std::hash15996 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersAddInfoKHR const & videoEncodeH265SessionParametersAddInfoKHR ) const 15997 VULKAN_HPP_NOEXCEPT 15998 { 15999 std::size_t seed = 0; 16000 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersAddInfoKHR.sType ); 16001 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersAddInfoKHR.pNext ); 16002 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersAddInfoKHR.stdVPSCount ); 16003 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersAddInfoKHR.pStdVPSs ); 16004 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersAddInfoKHR.stdSPSCount ); 16005 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersAddInfoKHR.pStdSPSs ); 16006 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersAddInfoKHR.stdPPSCount ); 16007 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersAddInfoKHR.pStdPPSs ); 16008 return seed; 16009 } 16010 }; 16011 16012 template <> 16013 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersCreateInfoKHR> 16014 { operator ()std::hash16015 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersCreateInfoKHR const & videoEncodeH265SessionParametersCreateInfoKHR ) const 16016 VULKAN_HPP_NOEXCEPT 16017 { 16018 std::size_t seed = 0; 16019 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersCreateInfoKHR.sType ); 16020 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersCreateInfoKHR.pNext ); 16021 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersCreateInfoKHR.maxStdVPSCount ); 16022 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersCreateInfoKHR.maxStdSPSCount ); 16023 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersCreateInfoKHR.maxStdPPSCount ); 16024 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersCreateInfoKHR.pParametersAddInfo ); 16025 return seed; 16026 } 16027 }; 16028 16029 template <> 16030 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersFeedbackInfoKHR> 16031 { operator ()std::hash16032 std::size_t operator()( 16033 VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersFeedbackInfoKHR const & videoEncodeH265SessionParametersFeedbackInfoKHR ) const VULKAN_HPP_NOEXCEPT 16034 { 16035 std::size_t seed = 0; 16036 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersFeedbackInfoKHR.sType ); 16037 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersFeedbackInfoKHR.pNext ); 16038 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersFeedbackInfoKHR.hasStdVPSOverrides ); 16039 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersFeedbackInfoKHR.hasStdSPSOverrides ); 16040 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersFeedbackInfoKHR.hasStdPPSOverrides ); 16041 return seed; 16042 } 16043 }; 16044 16045 template <> 16046 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersGetInfoKHR> 16047 { operator ()std::hash16048 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersGetInfoKHR const & videoEncodeH265SessionParametersGetInfoKHR ) const 16049 VULKAN_HPP_NOEXCEPT 16050 { 16051 std::size_t seed = 0; 16052 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersGetInfoKHR.sType ); 16053 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersGetInfoKHR.pNext ); 16054 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersGetInfoKHR.writeStdVPS ); 16055 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersGetInfoKHR.writeStdSPS ); 16056 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersGetInfoKHR.writeStdPPS ); 16057 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersGetInfoKHR.stdVPSId ); 16058 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersGetInfoKHR.stdSPSId ); 16059 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersGetInfoKHR.stdPPSId ); 16060 return seed; 16061 } 16062 }; 16063 16064 template <> 16065 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeInfoKHR> 16066 { operator ()std::hash16067 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeInfoKHR const & videoEncodeInfoKHR ) const VULKAN_HPP_NOEXCEPT 16068 { 16069 std::size_t seed = 0; 16070 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.sType ); 16071 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.pNext ); 16072 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.flags ); 16073 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.dstBuffer ); 16074 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.dstBufferOffset ); 16075 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.dstBufferRange ); 16076 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.srcPictureResource ); 16077 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.pSetupReferenceSlot ); 16078 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.referenceSlotCount ); 16079 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.pReferenceSlots ); 16080 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.precedingExternallyEncodedBytes ); 16081 return seed; 16082 } 16083 }; 16084 16085 template <> 16086 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelInfoKHR> 16087 { operator ()std::hash16088 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelInfoKHR const & videoEncodeQualityLevelInfoKHR ) const VULKAN_HPP_NOEXCEPT 16089 { 16090 std::size_t seed = 0; 16091 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQualityLevelInfoKHR.sType ); 16092 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQualityLevelInfoKHR.pNext ); 16093 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQualityLevelInfoKHR.qualityLevel ); 16094 return seed; 16095 } 16096 }; 16097 16098 template <> 16099 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelPropertiesKHR> 16100 { operator ()std::hash16101 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelPropertiesKHR const & videoEncodeQualityLevelPropertiesKHR ) const VULKAN_HPP_NOEXCEPT 16102 { 16103 std::size_t seed = 0; 16104 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQualityLevelPropertiesKHR.sType ); 16105 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQualityLevelPropertiesKHR.pNext ); 16106 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQualityLevelPropertiesKHR.preferredRateControlMode ); 16107 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQualityLevelPropertiesKHR.preferredRateControlLayerCount ); 16108 return seed; 16109 } 16110 }; 16111 16112 template <> 16113 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeRateControlLayerInfoKHR> 16114 { operator ()std::hash16115 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeRateControlLayerInfoKHR const & videoEncodeRateControlLayerInfoKHR ) const VULKAN_HPP_NOEXCEPT 16116 { 16117 std::size_t seed = 0; 16118 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlLayerInfoKHR.sType ); 16119 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlLayerInfoKHR.pNext ); 16120 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlLayerInfoKHR.averageBitrate ); 16121 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlLayerInfoKHR.maxBitrate ); 16122 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlLayerInfoKHR.frameRateNumerator ); 16123 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlLayerInfoKHR.frameRateDenominator ); 16124 return seed; 16125 } 16126 }; 16127 16128 template <> 16129 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeRateControlInfoKHR> 16130 { operator ()std::hash16131 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeRateControlInfoKHR const & videoEncodeRateControlInfoKHR ) const VULKAN_HPP_NOEXCEPT 16132 { 16133 std::size_t seed = 0; 16134 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlInfoKHR.sType ); 16135 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlInfoKHR.pNext ); 16136 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlInfoKHR.flags ); 16137 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlInfoKHR.rateControlMode ); 16138 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlInfoKHR.layerCount ); 16139 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlInfoKHR.pLayers ); 16140 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlInfoKHR.virtualBufferSizeInMs ); 16141 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlInfoKHR.initialVirtualBufferSizeInMs ); 16142 return seed; 16143 } 16144 }; 16145 16146 template <> 16147 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersFeedbackInfoKHR> 16148 { operator ()std::hash16149 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersFeedbackInfoKHR const & videoEncodeSessionParametersFeedbackInfoKHR ) const 16150 VULKAN_HPP_NOEXCEPT 16151 { 16152 std::size_t seed = 0; 16153 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionParametersFeedbackInfoKHR.sType ); 16154 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionParametersFeedbackInfoKHR.pNext ); 16155 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionParametersFeedbackInfoKHR.hasOverrides ); 16156 return seed; 16157 } 16158 }; 16159 16160 template <> 16161 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR> 16162 { 16163 std::size_t operator ()std::hash16164 operator()( VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR const & videoEncodeSessionParametersGetInfoKHR ) const VULKAN_HPP_NOEXCEPT 16165 { 16166 std::size_t seed = 0; 16167 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionParametersGetInfoKHR.sType ); 16168 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionParametersGetInfoKHR.pNext ); 16169 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionParametersGetInfoKHR.videoSessionParameters ); 16170 return seed; 16171 } 16172 }; 16173 16174 template <> 16175 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeUsageInfoKHR> 16176 { operator ()std::hash16177 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeUsageInfoKHR const & videoEncodeUsageInfoKHR ) const VULKAN_HPP_NOEXCEPT 16178 { 16179 std::size_t seed = 0; 16180 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeUsageInfoKHR.sType ); 16181 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeUsageInfoKHR.pNext ); 16182 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeUsageInfoKHR.videoUsageHints ); 16183 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeUsageInfoKHR.videoContentHints ); 16184 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeUsageInfoKHR.tuningMode ); 16185 return seed; 16186 } 16187 }; 16188 16189 template <> 16190 struct hash<VULKAN_HPP_NAMESPACE::VideoEndCodingInfoKHR> 16191 { operator ()std::hash16192 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEndCodingInfoKHR const & videoEndCodingInfoKHR ) const VULKAN_HPP_NOEXCEPT 16193 { 16194 std::size_t seed = 0; 16195 VULKAN_HPP_HASH_COMBINE( seed, videoEndCodingInfoKHR.sType ); 16196 VULKAN_HPP_HASH_COMBINE( seed, videoEndCodingInfoKHR.pNext ); 16197 VULKAN_HPP_HASH_COMBINE( seed, videoEndCodingInfoKHR.flags ); 16198 return seed; 16199 } 16200 }; 16201 16202 template <> 16203 struct hash<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR> 16204 { operator ()std::hash16205 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR const & videoFormatPropertiesKHR ) const VULKAN_HPP_NOEXCEPT 16206 { 16207 std::size_t seed = 0; 16208 VULKAN_HPP_HASH_COMBINE( seed, videoFormatPropertiesKHR.sType ); 16209 VULKAN_HPP_HASH_COMBINE( seed, videoFormatPropertiesKHR.pNext ); 16210 VULKAN_HPP_HASH_COMBINE( seed, videoFormatPropertiesKHR.format ); 16211 VULKAN_HPP_HASH_COMBINE( seed, videoFormatPropertiesKHR.componentMapping ); 16212 VULKAN_HPP_HASH_COMBINE( seed, videoFormatPropertiesKHR.imageCreateFlags ); 16213 VULKAN_HPP_HASH_COMBINE( seed, videoFormatPropertiesKHR.imageType ); 16214 VULKAN_HPP_HASH_COMBINE( seed, videoFormatPropertiesKHR.imageTiling ); 16215 VULKAN_HPP_HASH_COMBINE( seed, videoFormatPropertiesKHR.imageUsageFlags ); 16216 return seed; 16217 } 16218 }; 16219 16220 template <> 16221 struct hash<VULKAN_HPP_NAMESPACE::VideoInlineQueryInfoKHR> 16222 { operator ()std::hash16223 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoInlineQueryInfoKHR const & videoInlineQueryInfoKHR ) const VULKAN_HPP_NOEXCEPT 16224 { 16225 std::size_t seed = 0; 16226 VULKAN_HPP_HASH_COMBINE( seed, videoInlineQueryInfoKHR.sType ); 16227 VULKAN_HPP_HASH_COMBINE( seed, videoInlineQueryInfoKHR.pNext ); 16228 VULKAN_HPP_HASH_COMBINE( seed, videoInlineQueryInfoKHR.queryPool ); 16229 VULKAN_HPP_HASH_COMBINE( seed, videoInlineQueryInfoKHR.firstQuery ); 16230 VULKAN_HPP_HASH_COMBINE( seed, videoInlineQueryInfoKHR.queryCount ); 16231 return seed; 16232 } 16233 }; 16234 16235 template <> 16236 struct hash<VULKAN_HPP_NAMESPACE::VideoProfileListInfoKHR> 16237 { operator ()std::hash16238 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoProfileListInfoKHR const & videoProfileListInfoKHR ) const VULKAN_HPP_NOEXCEPT 16239 { 16240 std::size_t seed = 0; 16241 VULKAN_HPP_HASH_COMBINE( seed, videoProfileListInfoKHR.sType ); 16242 VULKAN_HPP_HASH_COMBINE( seed, videoProfileListInfoKHR.pNext ); 16243 VULKAN_HPP_HASH_COMBINE( seed, videoProfileListInfoKHR.profileCount ); 16244 VULKAN_HPP_HASH_COMBINE( seed, videoProfileListInfoKHR.pProfiles ); 16245 return seed; 16246 } 16247 }; 16248 16249 template <> 16250 struct hash<VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR> 16251 { operator ()std::hash16252 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR const & videoSessionCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 16253 { 16254 std::size_t seed = 0; 16255 VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.sType ); 16256 VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.pNext ); 16257 VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.queueFamilyIndex ); 16258 VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.flags ); 16259 VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.pVideoProfile ); 16260 VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.pictureFormat ); 16261 VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.maxCodedExtent ); 16262 VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.referencePictureFormat ); 16263 VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.maxDpbSlots ); 16264 VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.maxActiveReferencePictures ); 16265 VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.pStdHeaderVersion ); 16266 return seed; 16267 } 16268 }; 16269 16270 template <> 16271 struct hash<VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR> 16272 { operator ()std::hash16273 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR const & videoSessionMemoryRequirementsKHR ) const VULKAN_HPP_NOEXCEPT 16274 { 16275 std::size_t seed = 0; 16276 VULKAN_HPP_HASH_COMBINE( seed, videoSessionMemoryRequirementsKHR.sType ); 16277 VULKAN_HPP_HASH_COMBINE( seed, videoSessionMemoryRequirementsKHR.pNext ); 16278 VULKAN_HPP_HASH_COMBINE( seed, videoSessionMemoryRequirementsKHR.memoryBindIndex ); 16279 VULKAN_HPP_HASH_COMBINE( seed, videoSessionMemoryRequirementsKHR.memoryRequirements ); 16280 return seed; 16281 } 16282 }; 16283 16284 template <> 16285 struct hash<VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR> 16286 { operator ()std::hash16287 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR const & videoSessionParametersCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 16288 { 16289 std::size_t seed = 0; 16290 VULKAN_HPP_HASH_COMBINE( seed, videoSessionParametersCreateInfoKHR.sType ); 16291 VULKAN_HPP_HASH_COMBINE( seed, videoSessionParametersCreateInfoKHR.pNext ); 16292 VULKAN_HPP_HASH_COMBINE( seed, videoSessionParametersCreateInfoKHR.flags ); 16293 VULKAN_HPP_HASH_COMBINE( seed, videoSessionParametersCreateInfoKHR.videoSessionParametersTemplate ); 16294 VULKAN_HPP_HASH_COMBINE( seed, videoSessionParametersCreateInfoKHR.videoSession ); 16295 return seed; 16296 } 16297 }; 16298 16299 template <> 16300 struct hash<VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR> 16301 { operator ()std::hash16302 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR const & videoSessionParametersUpdateInfoKHR ) const VULKAN_HPP_NOEXCEPT 16303 { 16304 std::size_t seed = 0; 16305 VULKAN_HPP_HASH_COMBINE( seed, videoSessionParametersUpdateInfoKHR.sType ); 16306 VULKAN_HPP_HASH_COMBINE( seed, videoSessionParametersUpdateInfoKHR.pNext ); 16307 VULKAN_HPP_HASH_COMBINE( seed, videoSessionParametersUpdateInfoKHR.updateSequenceCount ); 16308 return seed; 16309 } 16310 }; 16311 16312 # if defined( VK_USE_PLATFORM_WAYLAND_KHR ) 16313 template <> 16314 struct hash<VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR> 16315 { operator ()std::hash16316 std::size_t operator()( VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR const & waylandSurfaceCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 16317 { 16318 std::size_t seed = 0; 16319 VULKAN_HPP_HASH_COMBINE( seed, waylandSurfaceCreateInfoKHR.sType ); 16320 VULKAN_HPP_HASH_COMBINE( seed, waylandSurfaceCreateInfoKHR.pNext ); 16321 VULKAN_HPP_HASH_COMBINE( seed, waylandSurfaceCreateInfoKHR.flags ); 16322 VULKAN_HPP_HASH_COMBINE( seed, waylandSurfaceCreateInfoKHR.display ); 16323 VULKAN_HPP_HASH_COMBINE( seed, waylandSurfaceCreateInfoKHR.surface ); 16324 return seed; 16325 } 16326 }; 16327 # endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ 16328 16329 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 16330 template <> 16331 struct hash<VULKAN_HPP_NAMESPACE::Win32KeyedMutexAcquireReleaseInfoKHR> 16332 { operator ()std::hash16333 std::size_t operator()( VULKAN_HPP_NAMESPACE::Win32KeyedMutexAcquireReleaseInfoKHR const & win32KeyedMutexAcquireReleaseInfoKHR ) const VULKAN_HPP_NOEXCEPT 16334 { 16335 std::size_t seed = 0; 16336 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoKHR.sType ); 16337 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoKHR.pNext ); 16338 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoKHR.acquireCount ); 16339 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoKHR.pAcquireSyncs ); 16340 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoKHR.pAcquireKeys ); 16341 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoKHR.pAcquireTimeouts ); 16342 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoKHR.releaseCount ); 16343 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoKHR.pReleaseSyncs ); 16344 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoKHR.pReleaseKeys ); 16345 return seed; 16346 } 16347 }; 16348 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 16349 16350 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 16351 template <> 16352 struct hash<VULKAN_HPP_NAMESPACE::Win32KeyedMutexAcquireReleaseInfoNV> 16353 { operator ()std::hash16354 std::size_t operator()( VULKAN_HPP_NAMESPACE::Win32KeyedMutexAcquireReleaseInfoNV const & win32KeyedMutexAcquireReleaseInfoNV ) const VULKAN_HPP_NOEXCEPT 16355 { 16356 std::size_t seed = 0; 16357 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoNV.sType ); 16358 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoNV.pNext ); 16359 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoNV.acquireCount ); 16360 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoNV.pAcquireSyncs ); 16361 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoNV.pAcquireKeys ); 16362 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoNV.pAcquireTimeoutMilliseconds ); 16363 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoNV.releaseCount ); 16364 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoNV.pReleaseSyncs ); 16365 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoNV.pReleaseKeys ); 16366 return seed; 16367 } 16368 }; 16369 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 16370 16371 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 16372 template <> 16373 struct hash<VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR> 16374 { operator ()std::hash16375 std::size_t operator()( VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR const & win32SurfaceCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 16376 { 16377 std::size_t seed = 0; 16378 VULKAN_HPP_HASH_COMBINE( seed, win32SurfaceCreateInfoKHR.sType ); 16379 VULKAN_HPP_HASH_COMBINE( seed, win32SurfaceCreateInfoKHR.pNext ); 16380 VULKAN_HPP_HASH_COMBINE( seed, win32SurfaceCreateInfoKHR.flags ); 16381 VULKAN_HPP_HASH_COMBINE( seed, win32SurfaceCreateInfoKHR.hinstance ); 16382 VULKAN_HPP_HASH_COMBINE( seed, win32SurfaceCreateInfoKHR.hwnd ); 16383 return seed; 16384 } 16385 }; 16386 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 16387 16388 template <> 16389 struct hash<VULKAN_HPP_NAMESPACE::WriteDescriptorSetAccelerationStructureKHR> 16390 { operator ()std::hash16391 std::size_t operator()( VULKAN_HPP_NAMESPACE::WriteDescriptorSetAccelerationStructureKHR const & writeDescriptorSetAccelerationStructureKHR ) const 16392 VULKAN_HPP_NOEXCEPT 16393 { 16394 std::size_t seed = 0; 16395 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetAccelerationStructureKHR.sType ); 16396 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetAccelerationStructureKHR.pNext ); 16397 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetAccelerationStructureKHR.accelerationStructureCount ); 16398 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetAccelerationStructureKHR.pAccelerationStructures ); 16399 return seed; 16400 } 16401 }; 16402 16403 template <> 16404 struct hash<VULKAN_HPP_NAMESPACE::WriteDescriptorSetAccelerationStructureNV> 16405 { 16406 std::size_t operator ()std::hash16407 operator()( VULKAN_HPP_NAMESPACE::WriteDescriptorSetAccelerationStructureNV const & writeDescriptorSetAccelerationStructureNV ) const VULKAN_HPP_NOEXCEPT 16408 { 16409 std::size_t seed = 0; 16410 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetAccelerationStructureNV.sType ); 16411 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetAccelerationStructureNV.pNext ); 16412 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetAccelerationStructureNV.accelerationStructureCount ); 16413 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetAccelerationStructureNV.pAccelerationStructures ); 16414 return seed; 16415 } 16416 }; 16417 16418 template <> 16419 struct hash<VULKAN_HPP_NAMESPACE::WriteDescriptorSetInlineUniformBlock> 16420 { operator ()std::hash16421 std::size_t operator()( VULKAN_HPP_NAMESPACE::WriteDescriptorSetInlineUniformBlock const & writeDescriptorSetInlineUniformBlock ) const VULKAN_HPP_NOEXCEPT 16422 { 16423 std::size_t seed = 0; 16424 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetInlineUniformBlock.sType ); 16425 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetInlineUniformBlock.pNext ); 16426 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetInlineUniformBlock.dataSize ); 16427 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetInlineUniformBlock.pData ); 16428 return seed; 16429 } 16430 }; 16431 16432 # if defined( VK_USE_PLATFORM_XCB_KHR ) 16433 template <> 16434 struct hash<VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR> 16435 { operator ()std::hash16436 std::size_t operator()( VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR const & xcbSurfaceCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 16437 { 16438 std::size_t seed = 0; 16439 VULKAN_HPP_HASH_COMBINE( seed, xcbSurfaceCreateInfoKHR.sType ); 16440 VULKAN_HPP_HASH_COMBINE( seed, xcbSurfaceCreateInfoKHR.pNext ); 16441 VULKAN_HPP_HASH_COMBINE( seed, xcbSurfaceCreateInfoKHR.flags ); 16442 VULKAN_HPP_HASH_COMBINE( seed, xcbSurfaceCreateInfoKHR.connection ); 16443 VULKAN_HPP_HASH_COMBINE( seed, xcbSurfaceCreateInfoKHR.window ); 16444 return seed; 16445 } 16446 }; 16447 # endif /*VK_USE_PLATFORM_XCB_KHR*/ 16448 16449 # if defined( VK_USE_PLATFORM_XLIB_KHR ) 16450 template <> 16451 struct hash<VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR> 16452 { operator ()std::hash16453 std::size_t operator()( VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR const & xlibSurfaceCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 16454 { 16455 std::size_t seed = 0; 16456 VULKAN_HPP_HASH_COMBINE( seed, xlibSurfaceCreateInfoKHR.sType ); 16457 VULKAN_HPP_HASH_COMBINE( seed, xlibSurfaceCreateInfoKHR.pNext ); 16458 VULKAN_HPP_HASH_COMBINE( seed, xlibSurfaceCreateInfoKHR.flags ); 16459 VULKAN_HPP_HASH_COMBINE( seed, xlibSurfaceCreateInfoKHR.dpy ); 16460 VULKAN_HPP_HASH_COMBINE( seed, xlibSurfaceCreateInfoKHR.window ); 16461 return seed; 16462 } 16463 }; 16464 # endif /*VK_USE_PLATFORM_XLIB_KHR*/ 16465 16466 #endif // 14 <= VULKAN_HPP_CPP_VERSION 16467 16468 } // namespace std 16469 #endif 16470