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 //=== VK_KHR_pipeline_binary === 529 530 template <> 531 struct hash<VULKAN_HPP_NAMESPACE::PipelineBinaryKHR> 532 { operator ()std::hash533 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineBinaryKHR const & pipelineBinaryKHR ) const VULKAN_HPP_NOEXCEPT 534 { 535 return std::hash<VkPipelineBinaryKHR>{}( static_cast<VkPipelineBinaryKHR>( pipelineBinaryKHR ) ); 536 } 537 }; 538 539 #if 14 <= VULKAN_HPP_CPP_VERSION 540 //====================================== 541 //=== HASH structures for structures === 542 //====================================== 543 544 # if !defined( VULKAN_HPP_HASH_COMBINE ) 545 # define VULKAN_HPP_HASH_COMBINE( seed, value ) \ 546 seed ^= std::hash<std::decay<decltype( value )>::type>{}( value ) + 0x9e3779b9 + ( seed << 6 ) + ( seed >> 2 ) 547 # endif 548 549 template <> 550 struct hash<VULKAN_HPP_NAMESPACE::AabbPositionsKHR> 551 { operator ()std::hash552 std::size_t operator()( VULKAN_HPP_NAMESPACE::AabbPositionsKHR const & aabbPositionsKHR ) const VULKAN_HPP_NOEXCEPT 553 { 554 std::size_t seed = 0; 555 VULKAN_HPP_HASH_COMBINE( seed, aabbPositionsKHR.minX ); 556 VULKAN_HPP_HASH_COMBINE( seed, aabbPositionsKHR.minY ); 557 VULKAN_HPP_HASH_COMBINE( seed, aabbPositionsKHR.minZ ); 558 VULKAN_HPP_HASH_COMBINE( seed, aabbPositionsKHR.maxX ); 559 VULKAN_HPP_HASH_COMBINE( seed, aabbPositionsKHR.maxY ); 560 VULKAN_HPP_HASH_COMBINE( seed, aabbPositionsKHR.maxZ ); 561 return seed; 562 } 563 }; 564 565 template <> 566 struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR> 567 { 568 std::size_t operator ()std::hash569 operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR const & accelerationStructureBuildRangeInfoKHR ) const VULKAN_HPP_NOEXCEPT 570 { 571 std::size_t seed = 0; 572 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildRangeInfoKHR.primitiveCount ); 573 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildRangeInfoKHR.primitiveOffset ); 574 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildRangeInfoKHR.firstVertex ); 575 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildRangeInfoKHR.transformOffset ); 576 return seed; 577 } 578 }; 579 580 template <> 581 struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR> 582 { 583 std::size_t operator ()std::hash584 operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR const & accelerationStructureBuildSizesInfoKHR ) const VULKAN_HPP_NOEXCEPT 585 { 586 std::size_t seed = 0; 587 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildSizesInfoKHR.sType ); 588 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildSizesInfoKHR.pNext ); 589 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildSizesInfoKHR.accelerationStructureSize ); 590 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildSizesInfoKHR.updateScratchSize ); 591 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildSizesInfoKHR.buildScratchSize ); 592 return seed; 593 } 594 }; 595 596 template <> 597 struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureCaptureDescriptorDataInfoEXT> 598 { operator ()std::hash599 std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureCaptureDescriptorDataInfoEXT const & accelerationStructureCaptureDescriptorDataInfoEXT ) 600 const VULKAN_HPP_NOEXCEPT 601 { 602 std::size_t seed = 0; 603 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCaptureDescriptorDataInfoEXT.sType ); 604 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCaptureDescriptorDataInfoEXT.pNext ); 605 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCaptureDescriptorDataInfoEXT.accelerationStructure ); 606 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCaptureDescriptorDataInfoEXT.accelerationStructureNV ); 607 return seed; 608 } 609 }; 610 611 template <> 612 struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR> 613 { operator ()std::hash614 std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR const & accelerationStructureCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 615 { 616 std::size_t seed = 0; 617 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoKHR.sType ); 618 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoKHR.pNext ); 619 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoKHR.createFlags ); 620 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoKHR.buffer ); 621 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoKHR.offset ); 622 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoKHR.size ); 623 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoKHR.type ); 624 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoKHR.deviceAddress ); 625 return seed; 626 } 627 }; 628 629 template <> 630 struct hash<VULKAN_HPP_NAMESPACE::GeometryTrianglesNV> 631 { operator ()std::hash632 std::size_t operator()( VULKAN_HPP_NAMESPACE::GeometryTrianglesNV const & geometryTrianglesNV ) const VULKAN_HPP_NOEXCEPT 633 { 634 std::size_t seed = 0; 635 VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.sType ); 636 VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.pNext ); 637 VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.vertexData ); 638 VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.vertexOffset ); 639 VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.vertexCount ); 640 VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.vertexStride ); 641 VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.vertexFormat ); 642 VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.indexData ); 643 VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.indexOffset ); 644 VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.indexCount ); 645 VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.indexType ); 646 VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.transformData ); 647 VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.transformOffset ); 648 return seed; 649 } 650 }; 651 652 template <> 653 struct hash<VULKAN_HPP_NAMESPACE::GeometryAABBNV> 654 { operator ()std::hash655 std::size_t operator()( VULKAN_HPP_NAMESPACE::GeometryAABBNV const & geometryAABBNV ) const VULKAN_HPP_NOEXCEPT 656 { 657 std::size_t seed = 0; 658 VULKAN_HPP_HASH_COMBINE( seed, geometryAABBNV.sType ); 659 VULKAN_HPP_HASH_COMBINE( seed, geometryAABBNV.pNext ); 660 VULKAN_HPP_HASH_COMBINE( seed, geometryAABBNV.aabbData ); 661 VULKAN_HPP_HASH_COMBINE( seed, geometryAABBNV.numAABBs ); 662 VULKAN_HPP_HASH_COMBINE( seed, geometryAABBNV.stride ); 663 VULKAN_HPP_HASH_COMBINE( seed, geometryAABBNV.offset ); 664 return seed; 665 } 666 }; 667 668 template <> 669 struct hash<VULKAN_HPP_NAMESPACE::GeometryDataNV> 670 { operator ()std::hash671 std::size_t operator()( VULKAN_HPP_NAMESPACE::GeometryDataNV const & geometryDataNV ) const VULKAN_HPP_NOEXCEPT 672 { 673 std::size_t seed = 0; 674 VULKAN_HPP_HASH_COMBINE( seed, geometryDataNV.triangles ); 675 VULKAN_HPP_HASH_COMBINE( seed, geometryDataNV.aabbs ); 676 return seed; 677 } 678 }; 679 680 template <> 681 struct hash<VULKAN_HPP_NAMESPACE::GeometryNV> 682 { operator ()std::hash683 std::size_t operator()( VULKAN_HPP_NAMESPACE::GeometryNV const & geometryNV ) const VULKAN_HPP_NOEXCEPT 684 { 685 std::size_t seed = 0; 686 VULKAN_HPP_HASH_COMBINE( seed, geometryNV.sType ); 687 VULKAN_HPP_HASH_COMBINE( seed, geometryNV.pNext ); 688 VULKAN_HPP_HASH_COMBINE( seed, geometryNV.geometryType ); 689 VULKAN_HPP_HASH_COMBINE( seed, geometryNV.geometry ); 690 VULKAN_HPP_HASH_COMBINE( seed, geometryNV.flags ); 691 return seed; 692 } 693 }; 694 695 template <> 696 struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV> 697 { operator ()std::hash698 std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV const & accelerationStructureInfoNV ) const VULKAN_HPP_NOEXCEPT 699 { 700 std::size_t seed = 0; 701 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInfoNV.sType ); 702 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInfoNV.pNext ); 703 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInfoNV.type ); 704 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInfoNV.flags ); 705 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInfoNV.instanceCount ); 706 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInfoNV.geometryCount ); 707 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInfoNV.pGeometries ); 708 return seed; 709 } 710 }; 711 712 template <> 713 struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV> 714 { operator ()std::hash715 std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV const & accelerationStructureCreateInfoNV ) const VULKAN_HPP_NOEXCEPT 716 { 717 std::size_t seed = 0; 718 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoNV.sType ); 719 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoNV.pNext ); 720 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoNV.compactedSize ); 721 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoNV.info ); 722 return seed; 723 } 724 }; 725 726 template <> 727 struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR> 728 { 729 std::size_t operator ()std::hash730 operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR const & accelerationStructureDeviceAddressInfoKHR ) const VULKAN_HPP_NOEXCEPT 731 { 732 std::size_t seed = 0; 733 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureDeviceAddressInfoKHR.sType ); 734 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureDeviceAddressInfoKHR.pNext ); 735 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureDeviceAddressInfoKHR.accelerationStructure ); 736 return seed; 737 } 738 }; 739 740 template <> 741 struct hash<VULKAN_HPP_NAMESPACE::TransformMatrixKHR> 742 { operator ()std::hash743 std::size_t operator()( VULKAN_HPP_NAMESPACE::TransformMatrixKHR const & transformMatrixKHR ) const VULKAN_HPP_NOEXCEPT 744 { 745 std::size_t seed = 0; 746 for ( size_t i = 0; i < 3; ++i ) 747 { 748 for ( size_t j = 0; j < 4; ++j ) 749 { 750 VULKAN_HPP_HASH_COMBINE( seed, transformMatrixKHR.matrix[i][j] ); 751 } 752 } 753 return seed; 754 } 755 }; 756 757 template <> 758 struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureInstanceKHR> 759 { operator ()std::hash760 std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureInstanceKHR const & accelerationStructureInstanceKHR ) const VULKAN_HPP_NOEXCEPT 761 { 762 std::size_t seed = 0; 763 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInstanceKHR.transform ); 764 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInstanceKHR.instanceCustomIndex ); 765 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInstanceKHR.mask ); 766 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInstanceKHR.instanceShaderBindingTableRecordOffset ); 767 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInstanceKHR.flags ); 768 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInstanceKHR.accelerationStructureReference ); 769 return seed; 770 } 771 }; 772 773 template <> 774 struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureMatrixMotionInstanceNV> 775 { operator ()std::hash776 std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureMatrixMotionInstanceNV const & accelerationStructureMatrixMotionInstanceNV ) const 777 VULKAN_HPP_NOEXCEPT 778 { 779 std::size_t seed = 0; 780 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMatrixMotionInstanceNV.transformT0 ); 781 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMatrixMotionInstanceNV.transformT1 ); 782 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMatrixMotionInstanceNV.instanceCustomIndex ); 783 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMatrixMotionInstanceNV.mask ); 784 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMatrixMotionInstanceNV.instanceShaderBindingTableRecordOffset ); 785 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMatrixMotionInstanceNV.flags ); 786 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMatrixMotionInstanceNV.accelerationStructureReference ); 787 return seed; 788 } 789 }; 790 791 template <> 792 struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV> 793 { operator ()std::hash794 std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV const & accelerationStructureMemoryRequirementsInfoNV ) const 795 VULKAN_HPP_NOEXCEPT 796 { 797 std::size_t seed = 0; 798 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMemoryRequirementsInfoNV.sType ); 799 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMemoryRequirementsInfoNV.pNext ); 800 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMemoryRequirementsInfoNV.type ); 801 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMemoryRequirementsInfoNV.accelerationStructure ); 802 return seed; 803 } 804 }; 805 806 template <> 807 struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInfoNV> 808 { operator ()std::hash809 std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInfoNV const & accelerationStructureMotionInfoNV ) const VULKAN_HPP_NOEXCEPT 810 { 811 std::size_t seed = 0; 812 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMotionInfoNV.sType ); 813 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMotionInfoNV.pNext ); 814 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMotionInfoNV.maxInstances ); 815 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMotionInfoNV.flags ); 816 return seed; 817 } 818 }; 819 820 template <> 821 struct hash<VULKAN_HPP_NAMESPACE::SRTDataNV> 822 { operator ()std::hash823 std::size_t operator()( VULKAN_HPP_NAMESPACE::SRTDataNV const & sRTDataNV ) const VULKAN_HPP_NOEXCEPT 824 { 825 std::size_t seed = 0; 826 VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.sx ); 827 VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.a ); 828 VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.b ); 829 VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.pvx ); 830 VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.sy ); 831 VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.c ); 832 VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.pvy ); 833 VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.sz ); 834 VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.pvz ); 835 VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.qx ); 836 VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.qy ); 837 VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.qz ); 838 VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.qw ); 839 VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.tx ); 840 VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.ty ); 841 VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.tz ); 842 return seed; 843 } 844 }; 845 846 template <> 847 struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureSRTMotionInstanceNV> 848 { 849 std::size_t operator ()std::hash850 operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureSRTMotionInstanceNV const & accelerationStructureSRTMotionInstanceNV ) const VULKAN_HPP_NOEXCEPT 851 { 852 std::size_t seed = 0; 853 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureSRTMotionInstanceNV.transformT0 ); 854 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureSRTMotionInstanceNV.transformT1 ); 855 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureSRTMotionInstanceNV.instanceCustomIndex ); 856 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureSRTMotionInstanceNV.mask ); 857 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureSRTMotionInstanceNV.instanceShaderBindingTableRecordOffset ); 858 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureSRTMotionInstanceNV.flags ); 859 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureSRTMotionInstanceNV.accelerationStructureReference ); 860 return seed; 861 } 862 }; 863 864 template <> 865 struct hash<VULKAN_HPP_NAMESPACE::MicromapUsageEXT> 866 { operator ()std::hash867 std::size_t operator()( VULKAN_HPP_NAMESPACE::MicromapUsageEXT const & micromapUsageEXT ) const VULKAN_HPP_NOEXCEPT 868 { 869 std::size_t seed = 0; 870 VULKAN_HPP_HASH_COMBINE( seed, micromapUsageEXT.count ); 871 VULKAN_HPP_HASH_COMBINE( seed, micromapUsageEXT.subdivisionLevel ); 872 VULKAN_HPP_HASH_COMBINE( seed, micromapUsageEXT.format ); 873 return seed; 874 } 875 }; 876 877 template <> 878 struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureVersionInfoKHR> 879 { operator ()std::hash880 std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureVersionInfoKHR const & accelerationStructureVersionInfoKHR ) const VULKAN_HPP_NOEXCEPT 881 { 882 std::size_t seed = 0; 883 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureVersionInfoKHR.sType ); 884 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureVersionInfoKHR.pNext ); 885 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureVersionInfoKHR.pVersionData ); 886 return seed; 887 } 888 }; 889 890 template <> 891 struct hash<VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR> 892 { operator ()std::hash893 std::size_t operator()( VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR const & acquireNextImageInfoKHR ) const VULKAN_HPP_NOEXCEPT 894 { 895 std::size_t seed = 0; 896 VULKAN_HPP_HASH_COMBINE( seed, acquireNextImageInfoKHR.sType ); 897 VULKAN_HPP_HASH_COMBINE( seed, acquireNextImageInfoKHR.pNext ); 898 VULKAN_HPP_HASH_COMBINE( seed, acquireNextImageInfoKHR.swapchain ); 899 VULKAN_HPP_HASH_COMBINE( seed, acquireNextImageInfoKHR.timeout ); 900 VULKAN_HPP_HASH_COMBINE( seed, acquireNextImageInfoKHR.semaphore ); 901 VULKAN_HPP_HASH_COMBINE( seed, acquireNextImageInfoKHR.fence ); 902 VULKAN_HPP_HASH_COMBINE( seed, acquireNextImageInfoKHR.deviceMask ); 903 return seed; 904 } 905 }; 906 907 template <> 908 struct hash<VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR> 909 { operator ()std::hash910 std::size_t operator()( VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR const & acquireProfilingLockInfoKHR ) const VULKAN_HPP_NOEXCEPT 911 { 912 std::size_t seed = 0; 913 VULKAN_HPP_HASH_COMBINE( seed, acquireProfilingLockInfoKHR.sType ); 914 VULKAN_HPP_HASH_COMBINE( seed, acquireProfilingLockInfoKHR.pNext ); 915 VULKAN_HPP_HASH_COMBINE( seed, acquireProfilingLockInfoKHR.flags ); 916 VULKAN_HPP_HASH_COMBINE( seed, acquireProfilingLockInfoKHR.timeout ); 917 return seed; 918 } 919 }; 920 921 template <> 922 struct hash<VULKAN_HPP_NAMESPACE::AllocationCallbacks> 923 { operator ()std::hash924 std::size_t operator()( VULKAN_HPP_NAMESPACE::AllocationCallbacks const & allocationCallbacks ) const VULKAN_HPP_NOEXCEPT 925 { 926 std::size_t seed = 0; 927 VULKAN_HPP_HASH_COMBINE( seed, allocationCallbacks.pUserData ); 928 VULKAN_HPP_HASH_COMBINE( seed, allocationCallbacks.pfnAllocation ); 929 VULKAN_HPP_HASH_COMBINE( seed, allocationCallbacks.pfnReallocation ); 930 VULKAN_HPP_HASH_COMBINE( seed, allocationCallbacks.pfnFree ); 931 VULKAN_HPP_HASH_COMBINE( seed, allocationCallbacks.pfnInternalAllocation ); 932 VULKAN_HPP_HASH_COMBINE( seed, allocationCallbacks.pfnInternalFree ); 933 return seed; 934 } 935 }; 936 937 template <> 938 struct hash<VULKAN_HPP_NAMESPACE::AmigoProfilingSubmitInfoSEC> 939 { operator ()std::hash940 std::size_t operator()( VULKAN_HPP_NAMESPACE::AmigoProfilingSubmitInfoSEC const & amigoProfilingSubmitInfoSEC ) const VULKAN_HPP_NOEXCEPT 941 { 942 std::size_t seed = 0; 943 VULKAN_HPP_HASH_COMBINE( seed, amigoProfilingSubmitInfoSEC.sType ); 944 VULKAN_HPP_HASH_COMBINE( seed, amigoProfilingSubmitInfoSEC.pNext ); 945 VULKAN_HPP_HASH_COMBINE( seed, amigoProfilingSubmitInfoSEC.firstDrawTimestamp ); 946 VULKAN_HPP_HASH_COMBINE( seed, amigoProfilingSubmitInfoSEC.swapBufferTimestamp ); 947 return seed; 948 } 949 }; 950 951 template <> 952 struct hash<VULKAN_HPP_NAMESPACE::ComponentMapping> 953 { operator ()std::hash954 std::size_t operator()( VULKAN_HPP_NAMESPACE::ComponentMapping const & componentMapping ) const VULKAN_HPP_NOEXCEPT 955 { 956 std::size_t seed = 0; 957 VULKAN_HPP_HASH_COMBINE( seed, componentMapping.r ); 958 VULKAN_HPP_HASH_COMBINE( seed, componentMapping.g ); 959 VULKAN_HPP_HASH_COMBINE( seed, componentMapping.b ); 960 VULKAN_HPP_HASH_COMBINE( seed, componentMapping.a ); 961 return seed; 962 } 963 }; 964 965 # if defined( VK_USE_PLATFORM_ANDROID_KHR ) 966 template <> 967 struct hash<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatProperties2ANDROID> 968 { operator ()std::hash969 std::size_t operator()( VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatProperties2ANDROID const & androidHardwareBufferFormatProperties2ANDROID ) const 970 VULKAN_HPP_NOEXCEPT 971 { 972 std::size_t seed = 0; 973 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.sType ); 974 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.pNext ); 975 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.format ); 976 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.externalFormat ); 977 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.formatFeatures ); 978 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.samplerYcbcrConversionComponents ); 979 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.suggestedYcbcrModel ); 980 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.suggestedYcbcrRange ); 981 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.suggestedXChromaOffset ); 982 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.suggestedYChromaOffset ); 983 return seed; 984 } 985 }; 986 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ 987 988 # if defined( VK_USE_PLATFORM_ANDROID_KHR ) 989 template <> 990 struct hash<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatPropertiesANDROID> 991 { operator ()std::hash992 std::size_t operator()( VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatPropertiesANDROID const & androidHardwareBufferFormatPropertiesANDROID ) const 993 VULKAN_HPP_NOEXCEPT 994 { 995 std::size_t seed = 0; 996 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.sType ); 997 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.pNext ); 998 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.format ); 999 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.externalFormat ); 1000 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.formatFeatures ); 1001 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.samplerYcbcrConversionComponents ); 1002 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.suggestedYcbcrModel ); 1003 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.suggestedYcbcrRange ); 1004 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.suggestedXChromaOffset ); 1005 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.suggestedYChromaOffset ); 1006 return seed; 1007 } 1008 }; 1009 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ 1010 1011 # if defined( VK_USE_PLATFORM_ANDROID_KHR ) 1012 template <> 1013 struct hash<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatResolvePropertiesANDROID> 1014 { 1015 std::size_t operator ()std::hash1016 operator()( VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatResolvePropertiesANDROID const & androidHardwareBufferFormatResolvePropertiesANDROID ) const 1017 VULKAN_HPP_NOEXCEPT 1018 { 1019 std::size_t seed = 0; 1020 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatResolvePropertiesANDROID.sType ); 1021 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatResolvePropertiesANDROID.pNext ); 1022 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatResolvePropertiesANDROID.colorAttachmentFormat ); 1023 return seed; 1024 } 1025 }; 1026 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ 1027 1028 # if defined( VK_USE_PLATFORM_ANDROID_KHR ) 1029 template <> 1030 struct hash<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID> 1031 { 1032 std::size_t operator ()std::hash1033 operator()( VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID const & androidHardwareBufferPropertiesANDROID ) const VULKAN_HPP_NOEXCEPT 1034 { 1035 std::size_t seed = 0; 1036 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferPropertiesANDROID.sType ); 1037 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferPropertiesANDROID.pNext ); 1038 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferPropertiesANDROID.allocationSize ); 1039 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferPropertiesANDROID.memoryTypeBits ); 1040 return seed; 1041 } 1042 }; 1043 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ 1044 1045 # if defined( VK_USE_PLATFORM_ANDROID_KHR ) 1046 template <> 1047 struct hash<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferUsageANDROID> 1048 { operator ()std::hash1049 std::size_t operator()( VULKAN_HPP_NAMESPACE::AndroidHardwareBufferUsageANDROID const & androidHardwareBufferUsageANDROID ) const VULKAN_HPP_NOEXCEPT 1050 { 1051 std::size_t seed = 0; 1052 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferUsageANDROID.sType ); 1053 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferUsageANDROID.pNext ); 1054 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferUsageANDROID.androidHardwareBufferUsage ); 1055 return seed; 1056 } 1057 }; 1058 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ 1059 1060 # if defined( VK_USE_PLATFORM_ANDROID_KHR ) 1061 template <> 1062 struct hash<VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR> 1063 { operator ()std::hash1064 std::size_t operator()( VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR const & androidSurfaceCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 1065 { 1066 std::size_t seed = 0; 1067 VULKAN_HPP_HASH_COMBINE( seed, androidSurfaceCreateInfoKHR.sType ); 1068 VULKAN_HPP_HASH_COMBINE( seed, androidSurfaceCreateInfoKHR.pNext ); 1069 VULKAN_HPP_HASH_COMBINE( seed, androidSurfaceCreateInfoKHR.flags ); 1070 VULKAN_HPP_HASH_COMBINE( seed, androidSurfaceCreateInfoKHR.window ); 1071 return seed; 1072 } 1073 }; 1074 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ 1075 1076 template <> 1077 struct hash<VULKAN_HPP_NAMESPACE::AntiLagPresentationInfoAMD> 1078 { operator ()std::hash1079 std::size_t operator()( VULKAN_HPP_NAMESPACE::AntiLagPresentationInfoAMD const & antiLagPresentationInfoAMD ) const VULKAN_HPP_NOEXCEPT 1080 { 1081 std::size_t seed = 0; 1082 VULKAN_HPP_HASH_COMBINE( seed, antiLagPresentationInfoAMD.sType ); 1083 VULKAN_HPP_HASH_COMBINE( seed, antiLagPresentationInfoAMD.pNext ); 1084 VULKAN_HPP_HASH_COMBINE( seed, antiLagPresentationInfoAMD.stage ); 1085 VULKAN_HPP_HASH_COMBINE( seed, antiLagPresentationInfoAMD.frameIndex ); 1086 return seed; 1087 } 1088 }; 1089 1090 template <> 1091 struct hash<VULKAN_HPP_NAMESPACE::AntiLagDataAMD> 1092 { operator ()std::hash1093 std::size_t operator()( VULKAN_HPP_NAMESPACE::AntiLagDataAMD const & antiLagDataAMD ) const VULKAN_HPP_NOEXCEPT 1094 { 1095 std::size_t seed = 0; 1096 VULKAN_HPP_HASH_COMBINE( seed, antiLagDataAMD.sType ); 1097 VULKAN_HPP_HASH_COMBINE( seed, antiLagDataAMD.pNext ); 1098 VULKAN_HPP_HASH_COMBINE( seed, antiLagDataAMD.mode ); 1099 VULKAN_HPP_HASH_COMBINE( seed, antiLagDataAMD.maxFPS ); 1100 VULKAN_HPP_HASH_COMBINE( seed, antiLagDataAMD.pPresentationInfo ); 1101 return seed; 1102 } 1103 }; 1104 1105 template <> 1106 struct hash<VULKAN_HPP_NAMESPACE::ApplicationInfo> 1107 { operator ()std::hash1108 std::size_t operator()( VULKAN_HPP_NAMESPACE::ApplicationInfo const & applicationInfo ) const VULKAN_HPP_NOEXCEPT 1109 { 1110 std::size_t seed = 0; 1111 VULKAN_HPP_HASH_COMBINE( seed, applicationInfo.sType ); 1112 VULKAN_HPP_HASH_COMBINE( seed, applicationInfo.pNext ); 1113 for ( const char * p = applicationInfo.pApplicationName; *p != '\0'; ++p ) 1114 { 1115 VULKAN_HPP_HASH_COMBINE( seed, *p ); 1116 } 1117 VULKAN_HPP_HASH_COMBINE( seed, applicationInfo.applicationVersion ); 1118 for ( const char * p = applicationInfo.pEngineName; *p != '\0'; ++p ) 1119 { 1120 VULKAN_HPP_HASH_COMBINE( seed, *p ); 1121 } 1122 VULKAN_HPP_HASH_COMBINE( seed, applicationInfo.engineVersion ); 1123 VULKAN_HPP_HASH_COMBINE( seed, applicationInfo.apiVersion ); 1124 return seed; 1125 } 1126 }; 1127 1128 template <> 1129 struct hash<VULKAN_HPP_NAMESPACE::AttachmentDescription> 1130 { operator ()std::hash1131 std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentDescription const & attachmentDescription ) const VULKAN_HPP_NOEXCEPT 1132 { 1133 std::size_t seed = 0; 1134 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.flags ); 1135 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.format ); 1136 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.samples ); 1137 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.loadOp ); 1138 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.storeOp ); 1139 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.stencilLoadOp ); 1140 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.stencilStoreOp ); 1141 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.initialLayout ); 1142 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.finalLayout ); 1143 return seed; 1144 } 1145 }; 1146 1147 template <> 1148 struct hash<VULKAN_HPP_NAMESPACE::AttachmentDescription2> 1149 { operator ()std::hash1150 std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentDescription2 const & attachmentDescription2 ) const VULKAN_HPP_NOEXCEPT 1151 { 1152 std::size_t seed = 0; 1153 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.sType ); 1154 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.pNext ); 1155 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.flags ); 1156 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.format ); 1157 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.samples ); 1158 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.loadOp ); 1159 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.storeOp ); 1160 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.stencilLoadOp ); 1161 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.stencilStoreOp ); 1162 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.initialLayout ); 1163 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.finalLayout ); 1164 return seed; 1165 } 1166 }; 1167 1168 template <> 1169 struct hash<VULKAN_HPP_NAMESPACE::AttachmentDescriptionStencilLayout> 1170 { operator ()std::hash1171 std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentDescriptionStencilLayout const & attachmentDescriptionStencilLayout ) const VULKAN_HPP_NOEXCEPT 1172 { 1173 std::size_t seed = 0; 1174 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescriptionStencilLayout.sType ); 1175 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescriptionStencilLayout.pNext ); 1176 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescriptionStencilLayout.stencilInitialLayout ); 1177 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescriptionStencilLayout.stencilFinalLayout ); 1178 return seed; 1179 } 1180 }; 1181 1182 template <> 1183 struct hash<VULKAN_HPP_NAMESPACE::AttachmentReference> 1184 { operator ()std::hash1185 std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentReference const & attachmentReference ) const VULKAN_HPP_NOEXCEPT 1186 { 1187 std::size_t seed = 0; 1188 VULKAN_HPP_HASH_COMBINE( seed, attachmentReference.attachment ); 1189 VULKAN_HPP_HASH_COMBINE( seed, attachmentReference.layout ); 1190 return seed; 1191 } 1192 }; 1193 1194 template <> 1195 struct hash<VULKAN_HPP_NAMESPACE::AttachmentReference2> 1196 { operator ()std::hash1197 std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentReference2 const & attachmentReference2 ) const VULKAN_HPP_NOEXCEPT 1198 { 1199 std::size_t seed = 0; 1200 VULKAN_HPP_HASH_COMBINE( seed, attachmentReference2.sType ); 1201 VULKAN_HPP_HASH_COMBINE( seed, attachmentReference2.pNext ); 1202 VULKAN_HPP_HASH_COMBINE( seed, attachmentReference2.attachment ); 1203 VULKAN_HPP_HASH_COMBINE( seed, attachmentReference2.layout ); 1204 VULKAN_HPP_HASH_COMBINE( seed, attachmentReference2.aspectMask ); 1205 return seed; 1206 } 1207 }; 1208 1209 template <> 1210 struct hash<VULKAN_HPP_NAMESPACE::AttachmentReferenceStencilLayout> 1211 { operator ()std::hash1212 std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentReferenceStencilLayout const & attachmentReferenceStencilLayout ) const VULKAN_HPP_NOEXCEPT 1213 { 1214 std::size_t seed = 0; 1215 VULKAN_HPP_HASH_COMBINE( seed, attachmentReferenceStencilLayout.sType ); 1216 VULKAN_HPP_HASH_COMBINE( seed, attachmentReferenceStencilLayout.pNext ); 1217 VULKAN_HPP_HASH_COMBINE( seed, attachmentReferenceStencilLayout.stencilLayout ); 1218 return seed; 1219 } 1220 }; 1221 1222 template <> 1223 struct hash<VULKAN_HPP_NAMESPACE::AttachmentSampleCountInfoAMD> 1224 { operator ()std::hash1225 std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentSampleCountInfoAMD const & attachmentSampleCountInfoAMD ) const VULKAN_HPP_NOEXCEPT 1226 { 1227 std::size_t seed = 0; 1228 VULKAN_HPP_HASH_COMBINE( seed, attachmentSampleCountInfoAMD.sType ); 1229 VULKAN_HPP_HASH_COMBINE( seed, attachmentSampleCountInfoAMD.pNext ); 1230 VULKAN_HPP_HASH_COMBINE( seed, attachmentSampleCountInfoAMD.colorAttachmentCount ); 1231 VULKAN_HPP_HASH_COMBINE( seed, attachmentSampleCountInfoAMD.pColorAttachmentSamples ); 1232 VULKAN_HPP_HASH_COMBINE( seed, attachmentSampleCountInfoAMD.depthStencilAttachmentSamples ); 1233 return seed; 1234 } 1235 }; 1236 1237 template <> 1238 struct hash<VULKAN_HPP_NAMESPACE::Extent2D> 1239 { operator ()std::hash1240 std::size_t operator()( VULKAN_HPP_NAMESPACE::Extent2D const & extent2D ) const VULKAN_HPP_NOEXCEPT 1241 { 1242 std::size_t seed = 0; 1243 VULKAN_HPP_HASH_COMBINE( seed, extent2D.width ); 1244 VULKAN_HPP_HASH_COMBINE( seed, extent2D.height ); 1245 return seed; 1246 } 1247 }; 1248 1249 template <> 1250 struct hash<VULKAN_HPP_NAMESPACE::SampleLocationEXT> 1251 { operator ()std::hash1252 std::size_t operator()( VULKAN_HPP_NAMESPACE::SampleLocationEXT const & sampleLocationEXT ) const VULKAN_HPP_NOEXCEPT 1253 { 1254 std::size_t seed = 0; 1255 VULKAN_HPP_HASH_COMBINE( seed, sampleLocationEXT.x ); 1256 VULKAN_HPP_HASH_COMBINE( seed, sampleLocationEXT.y ); 1257 return seed; 1258 } 1259 }; 1260 1261 template <> 1262 struct hash<VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT> 1263 { operator ()std::hash1264 std::size_t operator()( VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT const & sampleLocationsInfoEXT ) const VULKAN_HPP_NOEXCEPT 1265 { 1266 std::size_t seed = 0; 1267 VULKAN_HPP_HASH_COMBINE( seed, sampleLocationsInfoEXT.sType ); 1268 VULKAN_HPP_HASH_COMBINE( seed, sampleLocationsInfoEXT.pNext ); 1269 VULKAN_HPP_HASH_COMBINE( seed, sampleLocationsInfoEXT.sampleLocationsPerPixel ); 1270 VULKAN_HPP_HASH_COMBINE( seed, sampleLocationsInfoEXT.sampleLocationGridSize ); 1271 VULKAN_HPP_HASH_COMBINE( seed, sampleLocationsInfoEXT.sampleLocationsCount ); 1272 VULKAN_HPP_HASH_COMBINE( seed, sampleLocationsInfoEXT.pSampleLocations ); 1273 return seed; 1274 } 1275 }; 1276 1277 template <> 1278 struct hash<VULKAN_HPP_NAMESPACE::AttachmentSampleLocationsEXT> 1279 { operator ()std::hash1280 std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentSampleLocationsEXT const & attachmentSampleLocationsEXT ) const VULKAN_HPP_NOEXCEPT 1281 { 1282 std::size_t seed = 0; 1283 VULKAN_HPP_HASH_COMBINE( seed, attachmentSampleLocationsEXT.attachmentIndex ); 1284 VULKAN_HPP_HASH_COMBINE( seed, attachmentSampleLocationsEXT.sampleLocationsInfo ); 1285 return seed; 1286 } 1287 }; 1288 1289 template <> 1290 struct hash<VULKAN_HPP_NAMESPACE::BaseInStructure> 1291 { operator ()std::hash1292 std::size_t operator()( VULKAN_HPP_NAMESPACE::BaseInStructure const & baseInStructure ) const VULKAN_HPP_NOEXCEPT 1293 { 1294 std::size_t seed = 0; 1295 VULKAN_HPP_HASH_COMBINE( seed, baseInStructure.sType ); 1296 VULKAN_HPP_HASH_COMBINE( seed, baseInStructure.pNext ); 1297 return seed; 1298 } 1299 }; 1300 1301 template <> 1302 struct hash<VULKAN_HPP_NAMESPACE::BaseOutStructure> 1303 { operator ()std::hash1304 std::size_t operator()( VULKAN_HPP_NAMESPACE::BaseOutStructure const & baseOutStructure ) const VULKAN_HPP_NOEXCEPT 1305 { 1306 std::size_t seed = 0; 1307 VULKAN_HPP_HASH_COMBINE( seed, baseOutStructure.sType ); 1308 VULKAN_HPP_HASH_COMBINE( seed, baseOutStructure.pNext ); 1309 return seed; 1310 } 1311 }; 1312 1313 template <> 1314 struct hash<VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV> 1315 { 1316 std::size_t operator ()std::hash1317 operator()( VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV const & bindAccelerationStructureMemoryInfoNV ) const VULKAN_HPP_NOEXCEPT 1318 { 1319 std::size_t seed = 0; 1320 VULKAN_HPP_HASH_COMBINE( seed, bindAccelerationStructureMemoryInfoNV.sType ); 1321 VULKAN_HPP_HASH_COMBINE( seed, bindAccelerationStructureMemoryInfoNV.pNext ); 1322 VULKAN_HPP_HASH_COMBINE( seed, bindAccelerationStructureMemoryInfoNV.accelerationStructure ); 1323 VULKAN_HPP_HASH_COMBINE( seed, bindAccelerationStructureMemoryInfoNV.memory ); 1324 VULKAN_HPP_HASH_COMBINE( seed, bindAccelerationStructureMemoryInfoNV.memoryOffset ); 1325 VULKAN_HPP_HASH_COMBINE( seed, bindAccelerationStructureMemoryInfoNV.deviceIndexCount ); 1326 VULKAN_HPP_HASH_COMBINE( seed, bindAccelerationStructureMemoryInfoNV.pDeviceIndices ); 1327 return seed; 1328 } 1329 }; 1330 1331 template <> 1332 struct hash<VULKAN_HPP_NAMESPACE::BindBufferMemoryDeviceGroupInfo> 1333 { operator ()std::hash1334 std::size_t operator()( VULKAN_HPP_NAMESPACE::BindBufferMemoryDeviceGroupInfo const & bindBufferMemoryDeviceGroupInfo ) const VULKAN_HPP_NOEXCEPT 1335 { 1336 std::size_t seed = 0; 1337 VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryDeviceGroupInfo.sType ); 1338 VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryDeviceGroupInfo.pNext ); 1339 VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryDeviceGroupInfo.deviceIndexCount ); 1340 VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryDeviceGroupInfo.pDeviceIndices ); 1341 return seed; 1342 } 1343 }; 1344 1345 template <> 1346 struct hash<VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo> 1347 { operator ()std::hash1348 std::size_t operator()( VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo const & bindBufferMemoryInfo ) const VULKAN_HPP_NOEXCEPT 1349 { 1350 std::size_t seed = 0; 1351 VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryInfo.sType ); 1352 VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryInfo.pNext ); 1353 VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryInfo.buffer ); 1354 VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryInfo.memory ); 1355 VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryInfo.memoryOffset ); 1356 return seed; 1357 } 1358 }; 1359 1360 template <> 1361 struct hash<VULKAN_HPP_NAMESPACE::BindDescriptorBufferEmbeddedSamplersInfoEXT> 1362 { operator ()std::hash1363 std::size_t operator()( VULKAN_HPP_NAMESPACE::BindDescriptorBufferEmbeddedSamplersInfoEXT const & bindDescriptorBufferEmbeddedSamplersInfoEXT ) const 1364 VULKAN_HPP_NOEXCEPT 1365 { 1366 std::size_t seed = 0; 1367 VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorBufferEmbeddedSamplersInfoEXT.sType ); 1368 VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorBufferEmbeddedSamplersInfoEXT.pNext ); 1369 VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorBufferEmbeddedSamplersInfoEXT.stageFlags ); 1370 VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorBufferEmbeddedSamplersInfoEXT.layout ); 1371 VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorBufferEmbeddedSamplersInfoEXT.set ); 1372 return seed; 1373 } 1374 }; 1375 1376 template <> 1377 struct hash<VULKAN_HPP_NAMESPACE::BindDescriptorSetsInfo> 1378 { operator ()std::hash1379 std::size_t operator()( VULKAN_HPP_NAMESPACE::BindDescriptorSetsInfo const & bindDescriptorSetsInfo ) const VULKAN_HPP_NOEXCEPT 1380 { 1381 std::size_t seed = 0; 1382 VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorSetsInfo.sType ); 1383 VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorSetsInfo.pNext ); 1384 VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorSetsInfo.stageFlags ); 1385 VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorSetsInfo.layout ); 1386 VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorSetsInfo.firstSet ); 1387 VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorSetsInfo.descriptorSetCount ); 1388 VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorSetsInfo.pDescriptorSets ); 1389 VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorSetsInfo.dynamicOffsetCount ); 1390 VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorSetsInfo.pDynamicOffsets ); 1391 return seed; 1392 } 1393 }; 1394 1395 template <> 1396 struct hash<VULKAN_HPP_NAMESPACE::Offset2D> 1397 { operator ()std::hash1398 std::size_t operator()( VULKAN_HPP_NAMESPACE::Offset2D const & offset2D ) const VULKAN_HPP_NOEXCEPT 1399 { 1400 std::size_t seed = 0; 1401 VULKAN_HPP_HASH_COMBINE( seed, offset2D.x ); 1402 VULKAN_HPP_HASH_COMBINE( seed, offset2D.y ); 1403 return seed; 1404 } 1405 }; 1406 1407 template <> 1408 struct hash<VULKAN_HPP_NAMESPACE::Rect2D> 1409 { operator ()std::hash1410 std::size_t operator()( VULKAN_HPP_NAMESPACE::Rect2D const & rect2D ) const VULKAN_HPP_NOEXCEPT 1411 { 1412 std::size_t seed = 0; 1413 VULKAN_HPP_HASH_COMBINE( seed, rect2D.offset ); 1414 VULKAN_HPP_HASH_COMBINE( seed, rect2D.extent ); 1415 return seed; 1416 } 1417 }; 1418 1419 template <> 1420 struct hash<VULKAN_HPP_NAMESPACE::BindImageMemoryDeviceGroupInfo> 1421 { operator ()std::hash1422 std::size_t operator()( VULKAN_HPP_NAMESPACE::BindImageMemoryDeviceGroupInfo const & bindImageMemoryDeviceGroupInfo ) const VULKAN_HPP_NOEXCEPT 1423 { 1424 std::size_t seed = 0; 1425 VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryDeviceGroupInfo.sType ); 1426 VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryDeviceGroupInfo.pNext ); 1427 VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryDeviceGroupInfo.deviceIndexCount ); 1428 VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryDeviceGroupInfo.pDeviceIndices ); 1429 VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryDeviceGroupInfo.splitInstanceBindRegionCount ); 1430 VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryDeviceGroupInfo.pSplitInstanceBindRegions ); 1431 return seed; 1432 } 1433 }; 1434 1435 template <> 1436 struct hash<VULKAN_HPP_NAMESPACE::BindImageMemoryInfo> 1437 { operator ()std::hash1438 std::size_t operator()( VULKAN_HPP_NAMESPACE::BindImageMemoryInfo const & bindImageMemoryInfo ) const VULKAN_HPP_NOEXCEPT 1439 { 1440 std::size_t seed = 0; 1441 VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryInfo.sType ); 1442 VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryInfo.pNext ); 1443 VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryInfo.image ); 1444 VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryInfo.memory ); 1445 VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryInfo.memoryOffset ); 1446 return seed; 1447 } 1448 }; 1449 1450 template <> 1451 struct hash<VULKAN_HPP_NAMESPACE::BindImageMemorySwapchainInfoKHR> 1452 { operator ()std::hash1453 std::size_t operator()( VULKAN_HPP_NAMESPACE::BindImageMemorySwapchainInfoKHR const & bindImageMemorySwapchainInfoKHR ) const VULKAN_HPP_NOEXCEPT 1454 { 1455 std::size_t seed = 0; 1456 VULKAN_HPP_HASH_COMBINE( seed, bindImageMemorySwapchainInfoKHR.sType ); 1457 VULKAN_HPP_HASH_COMBINE( seed, bindImageMemorySwapchainInfoKHR.pNext ); 1458 VULKAN_HPP_HASH_COMBINE( seed, bindImageMemorySwapchainInfoKHR.swapchain ); 1459 VULKAN_HPP_HASH_COMBINE( seed, bindImageMemorySwapchainInfoKHR.imageIndex ); 1460 return seed; 1461 } 1462 }; 1463 1464 template <> 1465 struct hash<VULKAN_HPP_NAMESPACE::BindImagePlaneMemoryInfo> 1466 { operator ()std::hash1467 std::size_t operator()( VULKAN_HPP_NAMESPACE::BindImagePlaneMemoryInfo const & bindImagePlaneMemoryInfo ) const VULKAN_HPP_NOEXCEPT 1468 { 1469 std::size_t seed = 0; 1470 VULKAN_HPP_HASH_COMBINE( seed, bindImagePlaneMemoryInfo.sType ); 1471 VULKAN_HPP_HASH_COMBINE( seed, bindImagePlaneMemoryInfo.pNext ); 1472 VULKAN_HPP_HASH_COMBINE( seed, bindImagePlaneMemoryInfo.planeAspect ); 1473 return seed; 1474 } 1475 }; 1476 1477 template <> 1478 struct hash<VULKAN_HPP_NAMESPACE::BindIndexBufferIndirectCommandNV> 1479 { operator ()std::hash1480 std::size_t operator()( VULKAN_HPP_NAMESPACE::BindIndexBufferIndirectCommandNV const & bindIndexBufferIndirectCommandNV ) const VULKAN_HPP_NOEXCEPT 1481 { 1482 std::size_t seed = 0; 1483 VULKAN_HPP_HASH_COMBINE( seed, bindIndexBufferIndirectCommandNV.bufferAddress ); 1484 VULKAN_HPP_HASH_COMBINE( seed, bindIndexBufferIndirectCommandNV.size ); 1485 VULKAN_HPP_HASH_COMBINE( seed, bindIndexBufferIndirectCommandNV.indexType ); 1486 return seed; 1487 } 1488 }; 1489 1490 template <> 1491 struct hash<VULKAN_HPP_NAMESPACE::BindMemoryStatus> 1492 { operator ()std::hash1493 std::size_t operator()( VULKAN_HPP_NAMESPACE::BindMemoryStatus const & bindMemoryStatus ) const VULKAN_HPP_NOEXCEPT 1494 { 1495 std::size_t seed = 0; 1496 VULKAN_HPP_HASH_COMBINE( seed, bindMemoryStatus.sType ); 1497 VULKAN_HPP_HASH_COMBINE( seed, bindMemoryStatus.pNext ); 1498 VULKAN_HPP_HASH_COMBINE( seed, bindMemoryStatus.pResult ); 1499 return seed; 1500 } 1501 }; 1502 1503 template <> 1504 struct hash<VULKAN_HPP_NAMESPACE::BindPipelineIndirectCommandNV> 1505 { operator ()std::hash1506 std::size_t operator()( VULKAN_HPP_NAMESPACE::BindPipelineIndirectCommandNV const & bindPipelineIndirectCommandNV ) const VULKAN_HPP_NOEXCEPT 1507 { 1508 std::size_t seed = 0; 1509 VULKAN_HPP_HASH_COMBINE( seed, bindPipelineIndirectCommandNV.pipelineAddress ); 1510 return seed; 1511 } 1512 }; 1513 1514 template <> 1515 struct hash<VULKAN_HPP_NAMESPACE::BindShaderGroupIndirectCommandNV> 1516 { operator ()std::hash1517 std::size_t operator()( VULKAN_HPP_NAMESPACE::BindShaderGroupIndirectCommandNV const & bindShaderGroupIndirectCommandNV ) const VULKAN_HPP_NOEXCEPT 1518 { 1519 std::size_t seed = 0; 1520 VULKAN_HPP_HASH_COMBINE( seed, bindShaderGroupIndirectCommandNV.groupIndex ); 1521 return seed; 1522 } 1523 }; 1524 1525 template <> 1526 struct hash<VULKAN_HPP_NAMESPACE::SparseMemoryBind> 1527 { operator ()std::hash1528 std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseMemoryBind const & sparseMemoryBind ) const VULKAN_HPP_NOEXCEPT 1529 { 1530 std::size_t seed = 0; 1531 VULKAN_HPP_HASH_COMBINE( seed, sparseMemoryBind.resourceOffset ); 1532 VULKAN_HPP_HASH_COMBINE( seed, sparseMemoryBind.size ); 1533 VULKAN_HPP_HASH_COMBINE( seed, sparseMemoryBind.memory ); 1534 VULKAN_HPP_HASH_COMBINE( seed, sparseMemoryBind.memoryOffset ); 1535 VULKAN_HPP_HASH_COMBINE( seed, sparseMemoryBind.flags ); 1536 return seed; 1537 } 1538 }; 1539 1540 template <> 1541 struct hash<VULKAN_HPP_NAMESPACE::SparseBufferMemoryBindInfo> 1542 { operator ()std::hash1543 std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseBufferMemoryBindInfo const & sparseBufferMemoryBindInfo ) const VULKAN_HPP_NOEXCEPT 1544 { 1545 std::size_t seed = 0; 1546 VULKAN_HPP_HASH_COMBINE( seed, sparseBufferMemoryBindInfo.buffer ); 1547 VULKAN_HPP_HASH_COMBINE( seed, sparseBufferMemoryBindInfo.bindCount ); 1548 VULKAN_HPP_HASH_COMBINE( seed, sparseBufferMemoryBindInfo.pBinds ); 1549 return seed; 1550 } 1551 }; 1552 1553 template <> 1554 struct hash<VULKAN_HPP_NAMESPACE::SparseImageOpaqueMemoryBindInfo> 1555 { operator ()std::hash1556 std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageOpaqueMemoryBindInfo const & sparseImageOpaqueMemoryBindInfo ) const VULKAN_HPP_NOEXCEPT 1557 { 1558 std::size_t seed = 0; 1559 VULKAN_HPP_HASH_COMBINE( seed, sparseImageOpaqueMemoryBindInfo.image ); 1560 VULKAN_HPP_HASH_COMBINE( seed, sparseImageOpaqueMemoryBindInfo.bindCount ); 1561 VULKAN_HPP_HASH_COMBINE( seed, sparseImageOpaqueMemoryBindInfo.pBinds ); 1562 return seed; 1563 } 1564 }; 1565 1566 template <> 1567 struct hash<VULKAN_HPP_NAMESPACE::ImageSubresource> 1568 { operator ()std::hash1569 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageSubresource const & imageSubresource ) const VULKAN_HPP_NOEXCEPT 1570 { 1571 std::size_t seed = 0; 1572 VULKAN_HPP_HASH_COMBINE( seed, imageSubresource.aspectMask ); 1573 VULKAN_HPP_HASH_COMBINE( seed, imageSubresource.mipLevel ); 1574 VULKAN_HPP_HASH_COMBINE( seed, imageSubresource.arrayLayer ); 1575 return seed; 1576 } 1577 }; 1578 1579 template <> 1580 struct hash<VULKAN_HPP_NAMESPACE::Offset3D> 1581 { operator ()std::hash1582 std::size_t operator()( VULKAN_HPP_NAMESPACE::Offset3D const & offset3D ) const VULKAN_HPP_NOEXCEPT 1583 { 1584 std::size_t seed = 0; 1585 VULKAN_HPP_HASH_COMBINE( seed, offset3D.x ); 1586 VULKAN_HPP_HASH_COMBINE( seed, offset3D.y ); 1587 VULKAN_HPP_HASH_COMBINE( seed, offset3D.z ); 1588 return seed; 1589 } 1590 }; 1591 1592 template <> 1593 struct hash<VULKAN_HPP_NAMESPACE::Extent3D> 1594 { operator ()std::hash1595 std::size_t operator()( VULKAN_HPP_NAMESPACE::Extent3D const & extent3D ) const VULKAN_HPP_NOEXCEPT 1596 { 1597 std::size_t seed = 0; 1598 VULKAN_HPP_HASH_COMBINE( seed, extent3D.width ); 1599 VULKAN_HPP_HASH_COMBINE( seed, extent3D.height ); 1600 VULKAN_HPP_HASH_COMBINE( seed, extent3D.depth ); 1601 return seed; 1602 } 1603 }; 1604 1605 template <> 1606 struct hash<VULKAN_HPP_NAMESPACE::SparseImageMemoryBind> 1607 { operator ()std::hash1608 std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageMemoryBind const & sparseImageMemoryBind ) const VULKAN_HPP_NOEXCEPT 1609 { 1610 std::size_t seed = 0; 1611 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBind.subresource ); 1612 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBind.offset ); 1613 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBind.extent ); 1614 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBind.memory ); 1615 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBind.memoryOffset ); 1616 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBind.flags ); 1617 return seed; 1618 } 1619 }; 1620 1621 template <> 1622 struct hash<VULKAN_HPP_NAMESPACE::SparseImageMemoryBindInfo> 1623 { operator ()std::hash1624 std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageMemoryBindInfo const & sparseImageMemoryBindInfo ) const VULKAN_HPP_NOEXCEPT 1625 { 1626 std::size_t seed = 0; 1627 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBindInfo.image ); 1628 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBindInfo.bindCount ); 1629 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBindInfo.pBinds ); 1630 return seed; 1631 } 1632 }; 1633 1634 template <> 1635 struct hash<VULKAN_HPP_NAMESPACE::BindSparseInfo> 1636 { operator ()std::hash1637 std::size_t operator()( VULKAN_HPP_NAMESPACE::BindSparseInfo const & bindSparseInfo ) const VULKAN_HPP_NOEXCEPT 1638 { 1639 std::size_t seed = 0; 1640 VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.sType ); 1641 VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.pNext ); 1642 VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.waitSemaphoreCount ); 1643 VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.pWaitSemaphores ); 1644 VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.bufferBindCount ); 1645 VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.pBufferBinds ); 1646 VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.imageOpaqueBindCount ); 1647 VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.pImageOpaqueBinds ); 1648 VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.imageBindCount ); 1649 VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.pImageBinds ); 1650 VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.signalSemaphoreCount ); 1651 VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.pSignalSemaphores ); 1652 return seed; 1653 } 1654 }; 1655 1656 template <> 1657 struct hash<VULKAN_HPP_NAMESPACE::BindVertexBufferIndirectCommandNV> 1658 { operator ()std::hash1659 std::size_t operator()( VULKAN_HPP_NAMESPACE::BindVertexBufferIndirectCommandNV const & bindVertexBufferIndirectCommandNV ) const VULKAN_HPP_NOEXCEPT 1660 { 1661 std::size_t seed = 0; 1662 VULKAN_HPP_HASH_COMBINE( seed, bindVertexBufferIndirectCommandNV.bufferAddress ); 1663 VULKAN_HPP_HASH_COMBINE( seed, bindVertexBufferIndirectCommandNV.size ); 1664 VULKAN_HPP_HASH_COMBINE( seed, bindVertexBufferIndirectCommandNV.stride ); 1665 return seed; 1666 } 1667 }; 1668 1669 template <> 1670 struct hash<VULKAN_HPP_NAMESPACE::BindVideoSessionMemoryInfoKHR> 1671 { operator ()std::hash1672 std::size_t operator()( VULKAN_HPP_NAMESPACE::BindVideoSessionMemoryInfoKHR const & bindVideoSessionMemoryInfoKHR ) const VULKAN_HPP_NOEXCEPT 1673 { 1674 std::size_t seed = 0; 1675 VULKAN_HPP_HASH_COMBINE( seed, bindVideoSessionMemoryInfoKHR.sType ); 1676 VULKAN_HPP_HASH_COMBINE( seed, bindVideoSessionMemoryInfoKHR.pNext ); 1677 VULKAN_HPP_HASH_COMBINE( seed, bindVideoSessionMemoryInfoKHR.memoryBindIndex ); 1678 VULKAN_HPP_HASH_COMBINE( seed, bindVideoSessionMemoryInfoKHR.memory ); 1679 VULKAN_HPP_HASH_COMBINE( seed, bindVideoSessionMemoryInfoKHR.memoryOffset ); 1680 VULKAN_HPP_HASH_COMBINE( seed, bindVideoSessionMemoryInfoKHR.memorySize ); 1681 return seed; 1682 } 1683 }; 1684 1685 template <> 1686 struct hash<VULKAN_HPP_NAMESPACE::BlitImageCubicWeightsInfoQCOM> 1687 { operator ()std::hash1688 std::size_t operator()( VULKAN_HPP_NAMESPACE::BlitImageCubicWeightsInfoQCOM const & blitImageCubicWeightsInfoQCOM ) const VULKAN_HPP_NOEXCEPT 1689 { 1690 std::size_t seed = 0; 1691 VULKAN_HPP_HASH_COMBINE( seed, blitImageCubicWeightsInfoQCOM.sType ); 1692 VULKAN_HPP_HASH_COMBINE( seed, blitImageCubicWeightsInfoQCOM.pNext ); 1693 VULKAN_HPP_HASH_COMBINE( seed, blitImageCubicWeightsInfoQCOM.cubicWeights ); 1694 return seed; 1695 } 1696 }; 1697 1698 template <> 1699 struct hash<VULKAN_HPP_NAMESPACE::ImageSubresourceLayers> 1700 { operator ()std::hash1701 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const & imageSubresourceLayers ) const VULKAN_HPP_NOEXCEPT 1702 { 1703 std::size_t seed = 0; 1704 VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceLayers.aspectMask ); 1705 VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceLayers.mipLevel ); 1706 VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceLayers.baseArrayLayer ); 1707 VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceLayers.layerCount ); 1708 return seed; 1709 } 1710 }; 1711 1712 template <> 1713 struct hash<VULKAN_HPP_NAMESPACE::ImageBlit2> 1714 { operator ()std::hash1715 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageBlit2 const & imageBlit2 ) const VULKAN_HPP_NOEXCEPT 1716 { 1717 std::size_t seed = 0; 1718 VULKAN_HPP_HASH_COMBINE( seed, imageBlit2.sType ); 1719 VULKAN_HPP_HASH_COMBINE( seed, imageBlit2.pNext ); 1720 VULKAN_HPP_HASH_COMBINE( seed, imageBlit2.srcSubresource ); 1721 for ( size_t i = 0; i < 2; ++i ) 1722 { 1723 VULKAN_HPP_HASH_COMBINE( seed, imageBlit2.srcOffsets[i] ); 1724 } 1725 VULKAN_HPP_HASH_COMBINE( seed, imageBlit2.dstSubresource ); 1726 for ( size_t i = 0; i < 2; ++i ) 1727 { 1728 VULKAN_HPP_HASH_COMBINE( seed, imageBlit2.dstOffsets[i] ); 1729 } 1730 return seed; 1731 } 1732 }; 1733 1734 template <> 1735 struct hash<VULKAN_HPP_NAMESPACE::BlitImageInfo2> 1736 { operator ()std::hash1737 std::size_t operator()( VULKAN_HPP_NAMESPACE::BlitImageInfo2 const & blitImageInfo2 ) const VULKAN_HPP_NOEXCEPT 1738 { 1739 std::size_t seed = 0; 1740 VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.sType ); 1741 VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.pNext ); 1742 VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.srcImage ); 1743 VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.srcImageLayout ); 1744 VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.dstImage ); 1745 VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.dstImageLayout ); 1746 VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.regionCount ); 1747 VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.pRegions ); 1748 VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.filter ); 1749 return seed; 1750 } 1751 }; 1752 1753 template <> 1754 struct hash<VULKAN_HPP_NAMESPACE::BufferCaptureDescriptorDataInfoEXT> 1755 { operator ()std::hash1756 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCaptureDescriptorDataInfoEXT const & bufferCaptureDescriptorDataInfoEXT ) const VULKAN_HPP_NOEXCEPT 1757 { 1758 std::size_t seed = 0; 1759 VULKAN_HPP_HASH_COMBINE( seed, bufferCaptureDescriptorDataInfoEXT.sType ); 1760 VULKAN_HPP_HASH_COMBINE( seed, bufferCaptureDescriptorDataInfoEXT.pNext ); 1761 VULKAN_HPP_HASH_COMBINE( seed, bufferCaptureDescriptorDataInfoEXT.buffer ); 1762 return seed; 1763 } 1764 }; 1765 1766 # if defined( VK_USE_PLATFORM_FUCHSIA ) 1767 template <> 1768 struct hash<VULKAN_HPP_NAMESPACE::BufferCollectionBufferCreateInfoFUCHSIA> 1769 { 1770 std::size_t operator ()std::hash1771 operator()( VULKAN_HPP_NAMESPACE::BufferCollectionBufferCreateInfoFUCHSIA const & bufferCollectionBufferCreateInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT 1772 { 1773 std::size_t seed = 0; 1774 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionBufferCreateInfoFUCHSIA.sType ); 1775 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionBufferCreateInfoFUCHSIA.pNext ); 1776 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionBufferCreateInfoFUCHSIA.collection ); 1777 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionBufferCreateInfoFUCHSIA.index ); 1778 return seed; 1779 } 1780 }; 1781 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 1782 1783 # if defined( VK_USE_PLATFORM_FUCHSIA ) 1784 template <> 1785 struct hash<VULKAN_HPP_NAMESPACE::BufferCollectionConstraintsInfoFUCHSIA> 1786 { 1787 std::size_t operator ()std::hash1788 operator()( VULKAN_HPP_NAMESPACE::BufferCollectionConstraintsInfoFUCHSIA const & bufferCollectionConstraintsInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT 1789 { 1790 std::size_t seed = 0; 1791 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionConstraintsInfoFUCHSIA.sType ); 1792 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionConstraintsInfoFUCHSIA.pNext ); 1793 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionConstraintsInfoFUCHSIA.minBufferCount ); 1794 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionConstraintsInfoFUCHSIA.maxBufferCount ); 1795 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionConstraintsInfoFUCHSIA.minBufferCountForCamping ); 1796 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionConstraintsInfoFUCHSIA.minBufferCountForDedicatedSlack ); 1797 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionConstraintsInfoFUCHSIA.minBufferCountForSharedSlack ); 1798 return seed; 1799 } 1800 }; 1801 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 1802 1803 # if defined( VK_USE_PLATFORM_FUCHSIA ) 1804 template <> 1805 struct hash<VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA> 1806 { operator ()std::hash1807 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA const & bufferCollectionCreateInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT 1808 { 1809 std::size_t seed = 0; 1810 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionCreateInfoFUCHSIA.sType ); 1811 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionCreateInfoFUCHSIA.pNext ); 1812 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionCreateInfoFUCHSIA.collectionToken ); 1813 return seed; 1814 } 1815 }; 1816 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 1817 1818 # if defined( VK_USE_PLATFORM_FUCHSIA ) 1819 template <> 1820 struct hash<VULKAN_HPP_NAMESPACE::BufferCollectionImageCreateInfoFUCHSIA> 1821 { 1822 std::size_t operator ()std::hash1823 operator()( VULKAN_HPP_NAMESPACE::BufferCollectionImageCreateInfoFUCHSIA const & bufferCollectionImageCreateInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT 1824 { 1825 std::size_t seed = 0; 1826 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionImageCreateInfoFUCHSIA.sType ); 1827 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionImageCreateInfoFUCHSIA.pNext ); 1828 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionImageCreateInfoFUCHSIA.collection ); 1829 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionImageCreateInfoFUCHSIA.index ); 1830 return seed; 1831 } 1832 }; 1833 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 1834 1835 # if defined( VK_USE_PLATFORM_FUCHSIA ) 1836 template <> 1837 struct hash<VULKAN_HPP_NAMESPACE::SysmemColorSpaceFUCHSIA> 1838 { operator ()std::hash1839 std::size_t operator()( VULKAN_HPP_NAMESPACE::SysmemColorSpaceFUCHSIA const & sysmemColorSpaceFUCHSIA ) const VULKAN_HPP_NOEXCEPT 1840 { 1841 std::size_t seed = 0; 1842 VULKAN_HPP_HASH_COMBINE( seed, sysmemColorSpaceFUCHSIA.sType ); 1843 VULKAN_HPP_HASH_COMBINE( seed, sysmemColorSpaceFUCHSIA.pNext ); 1844 VULKAN_HPP_HASH_COMBINE( seed, sysmemColorSpaceFUCHSIA.colorSpace ); 1845 return seed; 1846 } 1847 }; 1848 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 1849 1850 # if defined( VK_USE_PLATFORM_FUCHSIA ) 1851 template <> 1852 struct hash<VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA> 1853 { operator ()std::hash1854 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA const & bufferCollectionPropertiesFUCHSIA ) const VULKAN_HPP_NOEXCEPT 1855 { 1856 std::size_t seed = 0; 1857 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.sType ); 1858 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.pNext ); 1859 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.memoryTypeBits ); 1860 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.bufferCount ); 1861 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.createInfoIndex ); 1862 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.sysmemPixelFormat ); 1863 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.formatFeatures ); 1864 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.sysmemColorSpaceIndex ); 1865 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.samplerYcbcrConversionComponents ); 1866 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.suggestedYcbcrModel ); 1867 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.suggestedYcbcrRange ); 1868 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.suggestedXChromaOffset ); 1869 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.suggestedYChromaOffset ); 1870 return seed; 1871 } 1872 }; 1873 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 1874 1875 template <> 1876 struct hash<VULKAN_HPP_NAMESPACE::BufferCreateInfo> 1877 { operator ()std::hash1878 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCreateInfo const & bufferCreateInfo ) const VULKAN_HPP_NOEXCEPT 1879 { 1880 std::size_t seed = 0; 1881 VULKAN_HPP_HASH_COMBINE( seed, bufferCreateInfo.sType ); 1882 VULKAN_HPP_HASH_COMBINE( seed, bufferCreateInfo.pNext ); 1883 VULKAN_HPP_HASH_COMBINE( seed, bufferCreateInfo.flags ); 1884 VULKAN_HPP_HASH_COMBINE( seed, bufferCreateInfo.size ); 1885 VULKAN_HPP_HASH_COMBINE( seed, bufferCreateInfo.usage ); 1886 VULKAN_HPP_HASH_COMBINE( seed, bufferCreateInfo.sharingMode ); 1887 VULKAN_HPP_HASH_COMBINE( seed, bufferCreateInfo.queueFamilyIndexCount ); 1888 VULKAN_HPP_HASH_COMBINE( seed, bufferCreateInfo.pQueueFamilyIndices ); 1889 return seed; 1890 } 1891 }; 1892 1893 # if defined( VK_USE_PLATFORM_FUCHSIA ) 1894 template <> 1895 struct hash<VULKAN_HPP_NAMESPACE::BufferConstraintsInfoFUCHSIA> 1896 { operator ()std::hash1897 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferConstraintsInfoFUCHSIA const & bufferConstraintsInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT 1898 { 1899 std::size_t seed = 0; 1900 VULKAN_HPP_HASH_COMBINE( seed, bufferConstraintsInfoFUCHSIA.sType ); 1901 VULKAN_HPP_HASH_COMBINE( seed, bufferConstraintsInfoFUCHSIA.pNext ); 1902 VULKAN_HPP_HASH_COMBINE( seed, bufferConstraintsInfoFUCHSIA.createInfo ); 1903 VULKAN_HPP_HASH_COMBINE( seed, bufferConstraintsInfoFUCHSIA.requiredFormatFeatures ); 1904 VULKAN_HPP_HASH_COMBINE( seed, bufferConstraintsInfoFUCHSIA.bufferCollectionConstraints ); 1905 return seed; 1906 } 1907 }; 1908 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 1909 1910 template <> 1911 struct hash<VULKAN_HPP_NAMESPACE::BufferCopy> 1912 { operator ()std::hash1913 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCopy const & bufferCopy ) const VULKAN_HPP_NOEXCEPT 1914 { 1915 std::size_t seed = 0; 1916 VULKAN_HPP_HASH_COMBINE( seed, bufferCopy.srcOffset ); 1917 VULKAN_HPP_HASH_COMBINE( seed, bufferCopy.dstOffset ); 1918 VULKAN_HPP_HASH_COMBINE( seed, bufferCopy.size ); 1919 return seed; 1920 } 1921 }; 1922 1923 template <> 1924 struct hash<VULKAN_HPP_NAMESPACE::BufferCopy2> 1925 { operator ()std::hash1926 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCopy2 const & bufferCopy2 ) const VULKAN_HPP_NOEXCEPT 1927 { 1928 std::size_t seed = 0; 1929 VULKAN_HPP_HASH_COMBINE( seed, bufferCopy2.sType ); 1930 VULKAN_HPP_HASH_COMBINE( seed, bufferCopy2.pNext ); 1931 VULKAN_HPP_HASH_COMBINE( seed, bufferCopy2.srcOffset ); 1932 VULKAN_HPP_HASH_COMBINE( seed, bufferCopy2.dstOffset ); 1933 VULKAN_HPP_HASH_COMBINE( seed, bufferCopy2.size ); 1934 return seed; 1935 } 1936 }; 1937 1938 template <> 1939 struct hash<VULKAN_HPP_NAMESPACE::BufferDeviceAddressCreateInfoEXT> 1940 { operator ()std::hash1941 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferDeviceAddressCreateInfoEXT const & bufferDeviceAddressCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 1942 { 1943 std::size_t seed = 0; 1944 VULKAN_HPP_HASH_COMBINE( seed, bufferDeviceAddressCreateInfoEXT.sType ); 1945 VULKAN_HPP_HASH_COMBINE( seed, bufferDeviceAddressCreateInfoEXT.pNext ); 1946 VULKAN_HPP_HASH_COMBINE( seed, bufferDeviceAddressCreateInfoEXT.deviceAddress ); 1947 return seed; 1948 } 1949 }; 1950 1951 template <> 1952 struct hash<VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo> 1953 { operator ()std::hash1954 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo const & bufferDeviceAddressInfo ) const VULKAN_HPP_NOEXCEPT 1955 { 1956 std::size_t seed = 0; 1957 VULKAN_HPP_HASH_COMBINE( seed, bufferDeviceAddressInfo.sType ); 1958 VULKAN_HPP_HASH_COMBINE( seed, bufferDeviceAddressInfo.pNext ); 1959 VULKAN_HPP_HASH_COMBINE( seed, bufferDeviceAddressInfo.buffer ); 1960 return seed; 1961 } 1962 }; 1963 1964 template <> 1965 struct hash<VULKAN_HPP_NAMESPACE::BufferImageCopy> 1966 { operator ()std::hash1967 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferImageCopy const & bufferImageCopy ) const VULKAN_HPP_NOEXCEPT 1968 { 1969 std::size_t seed = 0; 1970 VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy.bufferOffset ); 1971 VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy.bufferRowLength ); 1972 VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy.bufferImageHeight ); 1973 VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy.imageSubresource ); 1974 VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy.imageOffset ); 1975 VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy.imageExtent ); 1976 return seed; 1977 } 1978 }; 1979 1980 template <> 1981 struct hash<VULKAN_HPP_NAMESPACE::BufferImageCopy2> 1982 { operator ()std::hash1983 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferImageCopy2 const & bufferImageCopy2 ) const VULKAN_HPP_NOEXCEPT 1984 { 1985 std::size_t seed = 0; 1986 VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy2.sType ); 1987 VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy2.pNext ); 1988 VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy2.bufferOffset ); 1989 VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy2.bufferRowLength ); 1990 VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy2.bufferImageHeight ); 1991 VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy2.imageSubresource ); 1992 VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy2.imageOffset ); 1993 VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy2.imageExtent ); 1994 return seed; 1995 } 1996 }; 1997 1998 template <> 1999 struct hash<VULKAN_HPP_NAMESPACE::BufferMemoryBarrier> 2000 { operator ()std::hash2001 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferMemoryBarrier const & bufferMemoryBarrier ) const VULKAN_HPP_NOEXCEPT 2002 { 2003 std::size_t seed = 0; 2004 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.sType ); 2005 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.pNext ); 2006 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.srcAccessMask ); 2007 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.dstAccessMask ); 2008 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.srcQueueFamilyIndex ); 2009 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.dstQueueFamilyIndex ); 2010 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.buffer ); 2011 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.offset ); 2012 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.size ); 2013 return seed; 2014 } 2015 }; 2016 2017 template <> 2018 struct hash<VULKAN_HPP_NAMESPACE::BufferMemoryBarrier2> 2019 { operator ()std::hash2020 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferMemoryBarrier2 const & bufferMemoryBarrier2 ) const VULKAN_HPP_NOEXCEPT 2021 { 2022 std::size_t seed = 0; 2023 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.sType ); 2024 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.pNext ); 2025 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.srcStageMask ); 2026 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.srcAccessMask ); 2027 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.dstStageMask ); 2028 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.dstAccessMask ); 2029 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.srcQueueFamilyIndex ); 2030 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.dstQueueFamilyIndex ); 2031 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.buffer ); 2032 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.offset ); 2033 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.size ); 2034 return seed; 2035 } 2036 }; 2037 2038 template <> 2039 struct hash<VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2> 2040 { operator ()std::hash2041 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 const & bufferMemoryRequirementsInfo2 ) const VULKAN_HPP_NOEXCEPT 2042 { 2043 std::size_t seed = 0; 2044 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryRequirementsInfo2.sType ); 2045 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryRequirementsInfo2.pNext ); 2046 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryRequirementsInfo2.buffer ); 2047 return seed; 2048 } 2049 }; 2050 2051 template <> 2052 struct hash<VULKAN_HPP_NAMESPACE::BufferOpaqueCaptureAddressCreateInfo> 2053 { operator ()std::hash2054 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferOpaqueCaptureAddressCreateInfo const & bufferOpaqueCaptureAddressCreateInfo ) const VULKAN_HPP_NOEXCEPT 2055 { 2056 std::size_t seed = 0; 2057 VULKAN_HPP_HASH_COMBINE( seed, bufferOpaqueCaptureAddressCreateInfo.sType ); 2058 VULKAN_HPP_HASH_COMBINE( seed, bufferOpaqueCaptureAddressCreateInfo.pNext ); 2059 VULKAN_HPP_HASH_COMBINE( seed, bufferOpaqueCaptureAddressCreateInfo.opaqueCaptureAddress ); 2060 return seed; 2061 } 2062 }; 2063 2064 template <> 2065 struct hash<VULKAN_HPP_NAMESPACE::BufferUsageFlags2CreateInfo> 2066 { operator ()std::hash2067 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferUsageFlags2CreateInfo const & bufferUsageFlags2CreateInfo ) const VULKAN_HPP_NOEXCEPT 2068 { 2069 std::size_t seed = 0; 2070 VULKAN_HPP_HASH_COMBINE( seed, bufferUsageFlags2CreateInfo.sType ); 2071 VULKAN_HPP_HASH_COMBINE( seed, bufferUsageFlags2CreateInfo.pNext ); 2072 VULKAN_HPP_HASH_COMBINE( seed, bufferUsageFlags2CreateInfo.usage ); 2073 return seed; 2074 } 2075 }; 2076 2077 template <> 2078 struct hash<VULKAN_HPP_NAMESPACE::BufferViewCreateInfo> 2079 { operator ()std::hash2080 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferViewCreateInfo const & bufferViewCreateInfo ) const VULKAN_HPP_NOEXCEPT 2081 { 2082 std::size_t seed = 0; 2083 VULKAN_HPP_HASH_COMBINE( seed, bufferViewCreateInfo.sType ); 2084 VULKAN_HPP_HASH_COMBINE( seed, bufferViewCreateInfo.pNext ); 2085 VULKAN_HPP_HASH_COMBINE( seed, bufferViewCreateInfo.flags ); 2086 VULKAN_HPP_HASH_COMBINE( seed, bufferViewCreateInfo.buffer ); 2087 VULKAN_HPP_HASH_COMBINE( seed, bufferViewCreateInfo.format ); 2088 VULKAN_HPP_HASH_COMBINE( seed, bufferViewCreateInfo.offset ); 2089 VULKAN_HPP_HASH_COMBINE( seed, bufferViewCreateInfo.range ); 2090 return seed; 2091 } 2092 }; 2093 2094 template <> 2095 struct hash<VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR> 2096 { operator ()std::hash2097 std::size_t operator()( VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR const & calibratedTimestampInfoKHR ) const VULKAN_HPP_NOEXCEPT 2098 { 2099 std::size_t seed = 0; 2100 VULKAN_HPP_HASH_COMBINE( seed, calibratedTimestampInfoKHR.sType ); 2101 VULKAN_HPP_HASH_COMBINE( seed, calibratedTimestampInfoKHR.pNext ); 2102 VULKAN_HPP_HASH_COMBINE( seed, calibratedTimestampInfoKHR.timeDomain ); 2103 return seed; 2104 } 2105 }; 2106 2107 template <> 2108 struct hash<VULKAN_HPP_NAMESPACE::CheckpointData2NV> 2109 { operator ()std::hash2110 std::size_t operator()( VULKAN_HPP_NAMESPACE::CheckpointData2NV const & checkpointData2NV ) const VULKAN_HPP_NOEXCEPT 2111 { 2112 std::size_t seed = 0; 2113 VULKAN_HPP_HASH_COMBINE( seed, checkpointData2NV.sType ); 2114 VULKAN_HPP_HASH_COMBINE( seed, checkpointData2NV.pNext ); 2115 VULKAN_HPP_HASH_COMBINE( seed, checkpointData2NV.stage ); 2116 VULKAN_HPP_HASH_COMBINE( seed, checkpointData2NV.pCheckpointMarker ); 2117 return seed; 2118 } 2119 }; 2120 2121 template <> 2122 struct hash<VULKAN_HPP_NAMESPACE::CheckpointDataNV> 2123 { operator ()std::hash2124 std::size_t operator()( VULKAN_HPP_NAMESPACE::CheckpointDataNV const & checkpointDataNV ) const VULKAN_HPP_NOEXCEPT 2125 { 2126 std::size_t seed = 0; 2127 VULKAN_HPP_HASH_COMBINE( seed, checkpointDataNV.sType ); 2128 VULKAN_HPP_HASH_COMBINE( seed, checkpointDataNV.pNext ); 2129 VULKAN_HPP_HASH_COMBINE( seed, checkpointDataNV.stage ); 2130 VULKAN_HPP_HASH_COMBINE( seed, checkpointDataNV.pCheckpointMarker ); 2131 return seed; 2132 } 2133 }; 2134 2135 template <> 2136 struct hash<VULKAN_HPP_NAMESPACE::ClearDepthStencilValue> 2137 { operator ()std::hash2138 std::size_t operator()( VULKAN_HPP_NAMESPACE::ClearDepthStencilValue const & clearDepthStencilValue ) const VULKAN_HPP_NOEXCEPT 2139 { 2140 std::size_t seed = 0; 2141 VULKAN_HPP_HASH_COMBINE( seed, clearDepthStencilValue.depth ); 2142 VULKAN_HPP_HASH_COMBINE( seed, clearDepthStencilValue.stencil ); 2143 return seed; 2144 } 2145 }; 2146 2147 template <> 2148 struct hash<VULKAN_HPP_NAMESPACE::ClearRect> 2149 { operator ()std::hash2150 std::size_t operator()( VULKAN_HPP_NAMESPACE::ClearRect const & clearRect ) const VULKAN_HPP_NOEXCEPT 2151 { 2152 std::size_t seed = 0; 2153 VULKAN_HPP_HASH_COMBINE( seed, clearRect.rect ); 2154 VULKAN_HPP_HASH_COMBINE( seed, clearRect.baseArrayLayer ); 2155 VULKAN_HPP_HASH_COMBINE( seed, clearRect.layerCount ); 2156 return seed; 2157 } 2158 }; 2159 2160 template <> 2161 struct hash<VULKAN_HPP_NAMESPACE::CoarseSampleLocationNV> 2162 { operator ()std::hash2163 std::size_t operator()( VULKAN_HPP_NAMESPACE::CoarseSampleLocationNV const & coarseSampleLocationNV ) const VULKAN_HPP_NOEXCEPT 2164 { 2165 std::size_t seed = 0; 2166 VULKAN_HPP_HASH_COMBINE( seed, coarseSampleLocationNV.pixelX ); 2167 VULKAN_HPP_HASH_COMBINE( seed, coarseSampleLocationNV.pixelY ); 2168 VULKAN_HPP_HASH_COMBINE( seed, coarseSampleLocationNV.sample ); 2169 return seed; 2170 } 2171 }; 2172 2173 template <> 2174 struct hash<VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV> 2175 { operator ()std::hash2176 std::size_t operator()( VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV const & coarseSampleOrderCustomNV ) const VULKAN_HPP_NOEXCEPT 2177 { 2178 std::size_t seed = 0; 2179 VULKAN_HPP_HASH_COMBINE( seed, coarseSampleOrderCustomNV.shadingRate ); 2180 VULKAN_HPP_HASH_COMBINE( seed, coarseSampleOrderCustomNV.sampleCount ); 2181 VULKAN_HPP_HASH_COMBINE( seed, coarseSampleOrderCustomNV.sampleLocationCount ); 2182 VULKAN_HPP_HASH_COMBINE( seed, coarseSampleOrderCustomNV.pSampleLocations ); 2183 return seed; 2184 } 2185 }; 2186 2187 template <> 2188 struct hash<VULKAN_HPP_NAMESPACE::ColorBlendAdvancedEXT> 2189 { operator ()std::hash2190 std::size_t operator()( VULKAN_HPP_NAMESPACE::ColorBlendAdvancedEXT const & colorBlendAdvancedEXT ) const VULKAN_HPP_NOEXCEPT 2191 { 2192 std::size_t seed = 0; 2193 VULKAN_HPP_HASH_COMBINE( seed, colorBlendAdvancedEXT.advancedBlendOp ); 2194 VULKAN_HPP_HASH_COMBINE( seed, colorBlendAdvancedEXT.srcPremultiplied ); 2195 VULKAN_HPP_HASH_COMBINE( seed, colorBlendAdvancedEXT.dstPremultiplied ); 2196 VULKAN_HPP_HASH_COMBINE( seed, colorBlendAdvancedEXT.blendOverlap ); 2197 VULKAN_HPP_HASH_COMBINE( seed, colorBlendAdvancedEXT.clampResults ); 2198 return seed; 2199 } 2200 }; 2201 2202 template <> 2203 struct hash<VULKAN_HPP_NAMESPACE::ColorBlendEquationEXT> 2204 { operator ()std::hash2205 std::size_t operator()( VULKAN_HPP_NAMESPACE::ColorBlendEquationEXT const & colorBlendEquationEXT ) const VULKAN_HPP_NOEXCEPT 2206 { 2207 std::size_t seed = 0; 2208 VULKAN_HPP_HASH_COMBINE( seed, colorBlendEquationEXT.srcColorBlendFactor ); 2209 VULKAN_HPP_HASH_COMBINE( seed, colorBlendEquationEXT.dstColorBlendFactor ); 2210 VULKAN_HPP_HASH_COMBINE( seed, colorBlendEquationEXT.colorBlendOp ); 2211 VULKAN_HPP_HASH_COMBINE( seed, colorBlendEquationEXT.srcAlphaBlendFactor ); 2212 VULKAN_HPP_HASH_COMBINE( seed, colorBlendEquationEXT.dstAlphaBlendFactor ); 2213 VULKAN_HPP_HASH_COMBINE( seed, colorBlendEquationEXT.alphaBlendOp ); 2214 return seed; 2215 } 2216 }; 2217 2218 template <> 2219 struct hash<VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo> 2220 { operator ()std::hash2221 std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo const & commandBufferAllocateInfo ) const VULKAN_HPP_NOEXCEPT 2222 { 2223 std::size_t seed = 0; 2224 VULKAN_HPP_HASH_COMBINE( seed, commandBufferAllocateInfo.sType ); 2225 VULKAN_HPP_HASH_COMBINE( seed, commandBufferAllocateInfo.pNext ); 2226 VULKAN_HPP_HASH_COMBINE( seed, commandBufferAllocateInfo.commandPool ); 2227 VULKAN_HPP_HASH_COMBINE( seed, commandBufferAllocateInfo.level ); 2228 VULKAN_HPP_HASH_COMBINE( seed, commandBufferAllocateInfo.commandBufferCount ); 2229 return seed; 2230 } 2231 }; 2232 2233 template <> 2234 struct hash<VULKAN_HPP_NAMESPACE::CommandBufferInheritanceInfo> 2235 { operator ()std::hash2236 std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceInfo const & commandBufferInheritanceInfo ) const VULKAN_HPP_NOEXCEPT 2237 { 2238 std::size_t seed = 0; 2239 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceInfo.sType ); 2240 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceInfo.pNext ); 2241 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceInfo.renderPass ); 2242 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceInfo.subpass ); 2243 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceInfo.framebuffer ); 2244 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceInfo.occlusionQueryEnable ); 2245 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceInfo.queryFlags ); 2246 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceInfo.pipelineStatistics ); 2247 return seed; 2248 } 2249 }; 2250 2251 template <> 2252 struct hash<VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo> 2253 { operator ()std::hash2254 std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo const & commandBufferBeginInfo ) const VULKAN_HPP_NOEXCEPT 2255 { 2256 std::size_t seed = 0; 2257 VULKAN_HPP_HASH_COMBINE( seed, commandBufferBeginInfo.sType ); 2258 VULKAN_HPP_HASH_COMBINE( seed, commandBufferBeginInfo.pNext ); 2259 VULKAN_HPP_HASH_COMBINE( seed, commandBufferBeginInfo.flags ); 2260 VULKAN_HPP_HASH_COMBINE( seed, commandBufferBeginInfo.pInheritanceInfo ); 2261 return seed; 2262 } 2263 }; 2264 2265 template <> 2266 struct hash<VULKAN_HPP_NAMESPACE::CommandBufferInheritanceConditionalRenderingInfoEXT> 2267 { 2268 std::size_t operator ()std::hash2269 operator()( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceConditionalRenderingInfoEXT const & commandBufferInheritanceConditionalRenderingInfoEXT ) const 2270 VULKAN_HPP_NOEXCEPT 2271 { 2272 std::size_t seed = 0; 2273 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceConditionalRenderingInfoEXT.sType ); 2274 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceConditionalRenderingInfoEXT.pNext ); 2275 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceConditionalRenderingInfoEXT.conditionalRenderingEnable ); 2276 return seed; 2277 } 2278 }; 2279 2280 template <> 2281 struct hash<VULKAN_HPP_NAMESPACE::CommandBufferInheritanceRenderPassTransformInfoQCOM> 2282 { 2283 std::size_t operator ()std::hash2284 operator()( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceRenderPassTransformInfoQCOM const & commandBufferInheritanceRenderPassTransformInfoQCOM ) const 2285 VULKAN_HPP_NOEXCEPT 2286 { 2287 std::size_t seed = 0; 2288 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderPassTransformInfoQCOM.sType ); 2289 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderPassTransformInfoQCOM.pNext ); 2290 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderPassTransformInfoQCOM.transform ); 2291 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderPassTransformInfoQCOM.renderArea ); 2292 return seed; 2293 } 2294 }; 2295 2296 template <> 2297 struct hash<VULKAN_HPP_NAMESPACE::CommandBufferInheritanceRenderingInfo> 2298 { 2299 std::size_t operator ()std::hash2300 operator()( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceRenderingInfo const & commandBufferInheritanceRenderingInfo ) const VULKAN_HPP_NOEXCEPT 2301 { 2302 std::size_t seed = 0; 2303 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.sType ); 2304 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.pNext ); 2305 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.flags ); 2306 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.viewMask ); 2307 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.colorAttachmentCount ); 2308 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.pColorAttachmentFormats ); 2309 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.depthAttachmentFormat ); 2310 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.stencilAttachmentFormat ); 2311 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.rasterizationSamples ); 2312 return seed; 2313 } 2314 }; 2315 2316 template <> 2317 struct hash<VULKAN_HPP_NAMESPACE::Viewport> 2318 { operator ()std::hash2319 std::size_t operator()( VULKAN_HPP_NAMESPACE::Viewport const & viewport ) const VULKAN_HPP_NOEXCEPT 2320 { 2321 std::size_t seed = 0; 2322 VULKAN_HPP_HASH_COMBINE( seed, viewport.x ); 2323 VULKAN_HPP_HASH_COMBINE( seed, viewport.y ); 2324 VULKAN_HPP_HASH_COMBINE( seed, viewport.width ); 2325 VULKAN_HPP_HASH_COMBINE( seed, viewport.height ); 2326 VULKAN_HPP_HASH_COMBINE( seed, viewport.minDepth ); 2327 VULKAN_HPP_HASH_COMBINE( seed, viewport.maxDepth ); 2328 return seed; 2329 } 2330 }; 2331 2332 template <> 2333 struct hash<VULKAN_HPP_NAMESPACE::CommandBufferInheritanceViewportScissorInfoNV> 2334 { operator ()std::hash2335 std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceViewportScissorInfoNV const & commandBufferInheritanceViewportScissorInfoNV ) const 2336 VULKAN_HPP_NOEXCEPT 2337 { 2338 std::size_t seed = 0; 2339 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceViewportScissorInfoNV.sType ); 2340 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceViewportScissorInfoNV.pNext ); 2341 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceViewportScissorInfoNV.viewportScissor2D ); 2342 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceViewportScissorInfoNV.viewportDepthCount ); 2343 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceViewportScissorInfoNV.pViewportDepths ); 2344 return seed; 2345 } 2346 }; 2347 2348 template <> 2349 struct hash<VULKAN_HPP_NAMESPACE::CommandBufferSubmitInfo> 2350 { operator ()std::hash2351 std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBufferSubmitInfo const & commandBufferSubmitInfo ) const VULKAN_HPP_NOEXCEPT 2352 { 2353 std::size_t seed = 0; 2354 VULKAN_HPP_HASH_COMBINE( seed, commandBufferSubmitInfo.sType ); 2355 VULKAN_HPP_HASH_COMBINE( seed, commandBufferSubmitInfo.pNext ); 2356 VULKAN_HPP_HASH_COMBINE( seed, commandBufferSubmitInfo.commandBuffer ); 2357 VULKAN_HPP_HASH_COMBINE( seed, commandBufferSubmitInfo.deviceMask ); 2358 return seed; 2359 } 2360 }; 2361 2362 template <> 2363 struct hash<VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo> 2364 { operator ()std::hash2365 std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo const & commandPoolCreateInfo ) const VULKAN_HPP_NOEXCEPT 2366 { 2367 std::size_t seed = 0; 2368 VULKAN_HPP_HASH_COMBINE( seed, commandPoolCreateInfo.sType ); 2369 VULKAN_HPP_HASH_COMBINE( seed, commandPoolCreateInfo.pNext ); 2370 VULKAN_HPP_HASH_COMBINE( seed, commandPoolCreateInfo.flags ); 2371 VULKAN_HPP_HASH_COMBINE( seed, commandPoolCreateInfo.queueFamilyIndex ); 2372 return seed; 2373 } 2374 }; 2375 2376 template <> 2377 struct hash<VULKAN_HPP_NAMESPACE::SpecializationMapEntry> 2378 { operator ()std::hash2379 std::size_t operator()( VULKAN_HPP_NAMESPACE::SpecializationMapEntry const & specializationMapEntry ) const VULKAN_HPP_NOEXCEPT 2380 { 2381 std::size_t seed = 0; 2382 VULKAN_HPP_HASH_COMBINE( seed, specializationMapEntry.constantID ); 2383 VULKAN_HPP_HASH_COMBINE( seed, specializationMapEntry.offset ); 2384 VULKAN_HPP_HASH_COMBINE( seed, specializationMapEntry.size ); 2385 return seed; 2386 } 2387 }; 2388 2389 template <> 2390 struct hash<VULKAN_HPP_NAMESPACE::SpecializationInfo> 2391 { operator ()std::hash2392 std::size_t operator()( VULKAN_HPP_NAMESPACE::SpecializationInfo const & specializationInfo ) const VULKAN_HPP_NOEXCEPT 2393 { 2394 std::size_t seed = 0; 2395 VULKAN_HPP_HASH_COMBINE( seed, specializationInfo.mapEntryCount ); 2396 VULKAN_HPP_HASH_COMBINE( seed, specializationInfo.pMapEntries ); 2397 VULKAN_HPP_HASH_COMBINE( seed, specializationInfo.dataSize ); 2398 VULKAN_HPP_HASH_COMBINE( seed, specializationInfo.pData ); 2399 return seed; 2400 } 2401 }; 2402 2403 template <> 2404 struct hash<VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo> 2405 { operator ()std::hash2406 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo const & pipelineShaderStageCreateInfo ) const VULKAN_HPP_NOEXCEPT 2407 { 2408 std::size_t seed = 0; 2409 VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageCreateInfo.sType ); 2410 VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageCreateInfo.pNext ); 2411 VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageCreateInfo.flags ); 2412 VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageCreateInfo.stage ); 2413 VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageCreateInfo.module ); 2414 for ( const char * p = pipelineShaderStageCreateInfo.pName; *p != '\0'; ++p ) 2415 { 2416 VULKAN_HPP_HASH_COMBINE( seed, *p ); 2417 } 2418 VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageCreateInfo.pSpecializationInfo ); 2419 return seed; 2420 } 2421 }; 2422 2423 template <> 2424 struct hash<VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> 2425 { operator ()std::hash2426 std::size_t operator()( VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo const & computePipelineCreateInfo ) const VULKAN_HPP_NOEXCEPT 2427 { 2428 std::size_t seed = 0; 2429 VULKAN_HPP_HASH_COMBINE( seed, computePipelineCreateInfo.sType ); 2430 VULKAN_HPP_HASH_COMBINE( seed, computePipelineCreateInfo.pNext ); 2431 VULKAN_HPP_HASH_COMBINE( seed, computePipelineCreateInfo.flags ); 2432 VULKAN_HPP_HASH_COMBINE( seed, computePipelineCreateInfo.stage ); 2433 VULKAN_HPP_HASH_COMBINE( seed, computePipelineCreateInfo.layout ); 2434 VULKAN_HPP_HASH_COMBINE( seed, computePipelineCreateInfo.basePipelineHandle ); 2435 VULKAN_HPP_HASH_COMBINE( seed, computePipelineCreateInfo.basePipelineIndex ); 2436 return seed; 2437 } 2438 }; 2439 2440 template <> 2441 struct hash<VULKAN_HPP_NAMESPACE::ComputePipelineIndirectBufferInfoNV> 2442 { operator ()std::hash2443 std::size_t operator()( VULKAN_HPP_NAMESPACE::ComputePipelineIndirectBufferInfoNV const & computePipelineIndirectBufferInfoNV ) const VULKAN_HPP_NOEXCEPT 2444 { 2445 std::size_t seed = 0; 2446 VULKAN_HPP_HASH_COMBINE( seed, computePipelineIndirectBufferInfoNV.sType ); 2447 VULKAN_HPP_HASH_COMBINE( seed, computePipelineIndirectBufferInfoNV.pNext ); 2448 VULKAN_HPP_HASH_COMBINE( seed, computePipelineIndirectBufferInfoNV.deviceAddress ); 2449 VULKAN_HPP_HASH_COMBINE( seed, computePipelineIndirectBufferInfoNV.size ); 2450 VULKAN_HPP_HASH_COMBINE( seed, computePipelineIndirectBufferInfoNV.pipelineDeviceAddressCaptureReplay ); 2451 return seed; 2452 } 2453 }; 2454 2455 template <> 2456 struct hash<VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfoEXT> 2457 { operator ()std::hash2458 std::size_t operator()( VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfoEXT const & conditionalRenderingBeginInfoEXT ) const VULKAN_HPP_NOEXCEPT 2459 { 2460 std::size_t seed = 0; 2461 VULKAN_HPP_HASH_COMBINE( seed, conditionalRenderingBeginInfoEXT.sType ); 2462 VULKAN_HPP_HASH_COMBINE( seed, conditionalRenderingBeginInfoEXT.pNext ); 2463 VULKAN_HPP_HASH_COMBINE( seed, conditionalRenderingBeginInfoEXT.buffer ); 2464 VULKAN_HPP_HASH_COMBINE( seed, conditionalRenderingBeginInfoEXT.offset ); 2465 VULKAN_HPP_HASH_COMBINE( seed, conditionalRenderingBeginInfoEXT.flags ); 2466 return seed; 2467 } 2468 }; 2469 2470 template <> 2471 struct hash<VULKAN_HPP_NAMESPACE::ConformanceVersion> 2472 { operator ()std::hash2473 std::size_t operator()( VULKAN_HPP_NAMESPACE::ConformanceVersion const & conformanceVersion ) const VULKAN_HPP_NOEXCEPT 2474 { 2475 std::size_t seed = 0; 2476 VULKAN_HPP_HASH_COMBINE( seed, conformanceVersion.major ); 2477 VULKAN_HPP_HASH_COMBINE( seed, conformanceVersion.minor ); 2478 VULKAN_HPP_HASH_COMBINE( seed, conformanceVersion.subminor ); 2479 VULKAN_HPP_HASH_COMBINE( seed, conformanceVersion.patch ); 2480 return seed; 2481 } 2482 }; 2483 2484 template <> 2485 struct hash<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR> 2486 { operator ()std::hash2487 std::size_t operator()( VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR const & cooperativeMatrixPropertiesKHR ) const VULKAN_HPP_NOEXCEPT 2488 { 2489 std::size_t seed = 0; 2490 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.sType ); 2491 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.pNext ); 2492 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.MSize ); 2493 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.NSize ); 2494 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.KSize ); 2495 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.AType ); 2496 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.BType ); 2497 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.CType ); 2498 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.ResultType ); 2499 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.saturatingAccumulation ); 2500 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.scope ); 2501 return seed; 2502 } 2503 }; 2504 2505 template <> 2506 struct hash<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV> 2507 { operator ()std::hash2508 std::size_t operator()( VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV const & cooperativeMatrixPropertiesNV ) const VULKAN_HPP_NOEXCEPT 2509 { 2510 std::size_t seed = 0; 2511 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.sType ); 2512 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.pNext ); 2513 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.MSize ); 2514 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.NSize ); 2515 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.KSize ); 2516 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.AType ); 2517 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.BType ); 2518 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.CType ); 2519 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.DType ); 2520 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.scope ); 2521 return seed; 2522 } 2523 }; 2524 2525 template <> 2526 struct hash<VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR> 2527 { operator ()std::hash2528 std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR const & copyAccelerationStructureInfoKHR ) const VULKAN_HPP_NOEXCEPT 2529 { 2530 std::size_t seed = 0; 2531 VULKAN_HPP_HASH_COMBINE( seed, copyAccelerationStructureInfoKHR.sType ); 2532 VULKAN_HPP_HASH_COMBINE( seed, copyAccelerationStructureInfoKHR.pNext ); 2533 VULKAN_HPP_HASH_COMBINE( seed, copyAccelerationStructureInfoKHR.src ); 2534 VULKAN_HPP_HASH_COMBINE( seed, copyAccelerationStructureInfoKHR.dst ); 2535 VULKAN_HPP_HASH_COMBINE( seed, copyAccelerationStructureInfoKHR.mode ); 2536 return seed; 2537 } 2538 }; 2539 2540 template <> 2541 struct hash<VULKAN_HPP_NAMESPACE::CopyBufferInfo2> 2542 { operator ()std::hash2543 std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyBufferInfo2 const & copyBufferInfo2 ) const VULKAN_HPP_NOEXCEPT 2544 { 2545 std::size_t seed = 0; 2546 VULKAN_HPP_HASH_COMBINE( seed, copyBufferInfo2.sType ); 2547 VULKAN_HPP_HASH_COMBINE( seed, copyBufferInfo2.pNext ); 2548 VULKAN_HPP_HASH_COMBINE( seed, copyBufferInfo2.srcBuffer ); 2549 VULKAN_HPP_HASH_COMBINE( seed, copyBufferInfo2.dstBuffer ); 2550 VULKAN_HPP_HASH_COMBINE( seed, copyBufferInfo2.regionCount ); 2551 VULKAN_HPP_HASH_COMBINE( seed, copyBufferInfo2.pRegions ); 2552 return seed; 2553 } 2554 }; 2555 2556 template <> 2557 struct hash<VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2> 2558 { operator ()std::hash2559 std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 const & copyBufferToImageInfo2 ) const VULKAN_HPP_NOEXCEPT 2560 { 2561 std::size_t seed = 0; 2562 VULKAN_HPP_HASH_COMBINE( seed, copyBufferToImageInfo2.sType ); 2563 VULKAN_HPP_HASH_COMBINE( seed, copyBufferToImageInfo2.pNext ); 2564 VULKAN_HPP_HASH_COMBINE( seed, copyBufferToImageInfo2.srcBuffer ); 2565 VULKAN_HPP_HASH_COMBINE( seed, copyBufferToImageInfo2.dstImage ); 2566 VULKAN_HPP_HASH_COMBINE( seed, copyBufferToImageInfo2.dstImageLayout ); 2567 VULKAN_HPP_HASH_COMBINE( seed, copyBufferToImageInfo2.regionCount ); 2568 VULKAN_HPP_HASH_COMBINE( seed, copyBufferToImageInfo2.pRegions ); 2569 return seed; 2570 } 2571 }; 2572 2573 template <> 2574 struct hash<VULKAN_HPP_NAMESPACE::CopyCommandTransformInfoQCOM> 2575 { operator ()std::hash2576 std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyCommandTransformInfoQCOM const & copyCommandTransformInfoQCOM ) const VULKAN_HPP_NOEXCEPT 2577 { 2578 std::size_t seed = 0; 2579 VULKAN_HPP_HASH_COMBINE( seed, copyCommandTransformInfoQCOM.sType ); 2580 VULKAN_HPP_HASH_COMBINE( seed, copyCommandTransformInfoQCOM.pNext ); 2581 VULKAN_HPP_HASH_COMBINE( seed, copyCommandTransformInfoQCOM.transform ); 2582 return seed; 2583 } 2584 }; 2585 2586 template <> 2587 struct hash<VULKAN_HPP_NAMESPACE::CopyDescriptorSet> 2588 { operator ()std::hash2589 std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyDescriptorSet const & copyDescriptorSet ) const VULKAN_HPP_NOEXCEPT 2590 { 2591 std::size_t seed = 0; 2592 VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.sType ); 2593 VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.pNext ); 2594 VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.srcSet ); 2595 VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.srcBinding ); 2596 VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.srcArrayElement ); 2597 VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.dstSet ); 2598 VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.dstBinding ); 2599 VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.dstArrayElement ); 2600 VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.descriptorCount ); 2601 return seed; 2602 } 2603 }; 2604 2605 template <> 2606 struct hash<VULKAN_HPP_NAMESPACE::ImageCopy2> 2607 { operator ()std::hash2608 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageCopy2 const & imageCopy2 ) const VULKAN_HPP_NOEXCEPT 2609 { 2610 std::size_t seed = 0; 2611 VULKAN_HPP_HASH_COMBINE( seed, imageCopy2.sType ); 2612 VULKAN_HPP_HASH_COMBINE( seed, imageCopy2.pNext ); 2613 VULKAN_HPP_HASH_COMBINE( seed, imageCopy2.srcSubresource ); 2614 VULKAN_HPP_HASH_COMBINE( seed, imageCopy2.srcOffset ); 2615 VULKAN_HPP_HASH_COMBINE( seed, imageCopy2.dstSubresource ); 2616 VULKAN_HPP_HASH_COMBINE( seed, imageCopy2.dstOffset ); 2617 VULKAN_HPP_HASH_COMBINE( seed, imageCopy2.extent ); 2618 return seed; 2619 } 2620 }; 2621 2622 template <> 2623 struct hash<VULKAN_HPP_NAMESPACE::CopyImageInfo2> 2624 { operator ()std::hash2625 std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyImageInfo2 const & copyImageInfo2 ) const VULKAN_HPP_NOEXCEPT 2626 { 2627 std::size_t seed = 0; 2628 VULKAN_HPP_HASH_COMBINE( seed, copyImageInfo2.sType ); 2629 VULKAN_HPP_HASH_COMBINE( seed, copyImageInfo2.pNext ); 2630 VULKAN_HPP_HASH_COMBINE( seed, copyImageInfo2.srcImage ); 2631 VULKAN_HPP_HASH_COMBINE( seed, copyImageInfo2.srcImageLayout ); 2632 VULKAN_HPP_HASH_COMBINE( seed, copyImageInfo2.dstImage ); 2633 VULKAN_HPP_HASH_COMBINE( seed, copyImageInfo2.dstImageLayout ); 2634 VULKAN_HPP_HASH_COMBINE( seed, copyImageInfo2.regionCount ); 2635 VULKAN_HPP_HASH_COMBINE( seed, copyImageInfo2.pRegions ); 2636 return seed; 2637 } 2638 }; 2639 2640 template <> 2641 struct hash<VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2> 2642 { operator ()std::hash2643 std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 const & copyImageToBufferInfo2 ) const VULKAN_HPP_NOEXCEPT 2644 { 2645 std::size_t seed = 0; 2646 VULKAN_HPP_HASH_COMBINE( seed, copyImageToBufferInfo2.sType ); 2647 VULKAN_HPP_HASH_COMBINE( seed, copyImageToBufferInfo2.pNext ); 2648 VULKAN_HPP_HASH_COMBINE( seed, copyImageToBufferInfo2.srcImage ); 2649 VULKAN_HPP_HASH_COMBINE( seed, copyImageToBufferInfo2.srcImageLayout ); 2650 VULKAN_HPP_HASH_COMBINE( seed, copyImageToBufferInfo2.dstBuffer ); 2651 VULKAN_HPP_HASH_COMBINE( seed, copyImageToBufferInfo2.regionCount ); 2652 VULKAN_HPP_HASH_COMBINE( seed, copyImageToBufferInfo2.pRegions ); 2653 return seed; 2654 } 2655 }; 2656 2657 template <> 2658 struct hash<VULKAN_HPP_NAMESPACE::CopyImageToImageInfo> 2659 { operator ()std::hash2660 std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyImageToImageInfo const & copyImageToImageInfo ) const VULKAN_HPP_NOEXCEPT 2661 { 2662 std::size_t seed = 0; 2663 VULKAN_HPP_HASH_COMBINE( seed, copyImageToImageInfo.sType ); 2664 VULKAN_HPP_HASH_COMBINE( seed, copyImageToImageInfo.pNext ); 2665 VULKAN_HPP_HASH_COMBINE( seed, copyImageToImageInfo.flags ); 2666 VULKAN_HPP_HASH_COMBINE( seed, copyImageToImageInfo.srcImage ); 2667 VULKAN_HPP_HASH_COMBINE( seed, copyImageToImageInfo.srcImageLayout ); 2668 VULKAN_HPP_HASH_COMBINE( seed, copyImageToImageInfo.dstImage ); 2669 VULKAN_HPP_HASH_COMBINE( seed, copyImageToImageInfo.dstImageLayout ); 2670 VULKAN_HPP_HASH_COMBINE( seed, copyImageToImageInfo.regionCount ); 2671 VULKAN_HPP_HASH_COMBINE( seed, copyImageToImageInfo.pRegions ); 2672 return seed; 2673 } 2674 }; 2675 2676 template <> 2677 struct hash<VULKAN_HPP_NAMESPACE::ImageToMemoryCopy> 2678 { operator ()std::hash2679 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageToMemoryCopy const & imageToMemoryCopy ) const VULKAN_HPP_NOEXCEPT 2680 { 2681 std::size_t seed = 0; 2682 VULKAN_HPP_HASH_COMBINE( seed, imageToMemoryCopy.sType ); 2683 VULKAN_HPP_HASH_COMBINE( seed, imageToMemoryCopy.pNext ); 2684 VULKAN_HPP_HASH_COMBINE( seed, imageToMemoryCopy.pHostPointer ); 2685 VULKAN_HPP_HASH_COMBINE( seed, imageToMemoryCopy.memoryRowLength ); 2686 VULKAN_HPP_HASH_COMBINE( seed, imageToMemoryCopy.memoryImageHeight ); 2687 VULKAN_HPP_HASH_COMBINE( seed, imageToMemoryCopy.imageSubresource ); 2688 VULKAN_HPP_HASH_COMBINE( seed, imageToMemoryCopy.imageOffset ); 2689 VULKAN_HPP_HASH_COMBINE( seed, imageToMemoryCopy.imageExtent ); 2690 return seed; 2691 } 2692 }; 2693 2694 template <> 2695 struct hash<VULKAN_HPP_NAMESPACE::CopyImageToMemoryInfo> 2696 { operator ()std::hash2697 std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyImageToMemoryInfo const & copyImageToMemoryInfo ) const VULKAN_HPP_NOEXCEPT 2698 { 2699 std::size_t seed = 0; 2700 VULKAN_HPP_HASH_COMBINE( seed, copyImageToMemoryInfo.sType ); 2701 VULKAN_HPP_HASH_COMBINE( seed, copyImageToMemoryInfo.pNext ); 2702 VULKAN_HPP_HASH_COMBINE( seed, copyImageToMemoryInfo.flags ); 2703 VULKAN_HPP_HASH_COMBINE( seed, copyImageToMemoryInfo.srcImage ); 2704 VULKAN_HPP_HASH_COMBINE( seed, copyImageToMemoryInfo.srcImageLayout ); 2705 VULKAN_HPP_HASH_COMBINE( seed, copyImageToMemoryInfo.regionCount ); 2706 VULKAN_HPP_HASH_COMBINE( seed, copyImageToMemoryInfo.pRegions ); 2707 return seed; 2708 } 2709 }; 2710 2711 template <> 2712 struct hash<VULKAN_HPP_NAMESPACE::CopyMemoryIndirectCommandNV> 2713 { operator ()std::hash2714 std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyMemoryIndirectCommandNV const & copyMemoryIndirectCommandNV ) const VULKAN_HPP_NOEXCEPT 2715 { 2716 std::size_t seed = 0; 2717 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryIndirectCommandNV.srcAddress ); 2718 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryIndirectCommandNV.dstAddress ); 2719 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryIndirectCommandNV.size ); 2720 return seed; 2721 } 2722 }; 2723 2724 template <> 2725 struct hash<VULKAN_HPP_NAMESPACE::CopyMemoryToImageIndirectCommandNV> 2726 { operator ()std::hash2727 std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyMemoryToImageIndirectCommandNV const & copyMemoryToImageIndirectCommandNV ) const VULKAN_HPP_NOEXCEPT 2728 { 2729 std::size_t seed = 0; 2730 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectCommandNV.srcAddress ); 2731 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectCommandNV.bufferRowLength ); 2732 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectCommandNV.bufferImageHeight ); 2733 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectCommandNV.imageSubresource ); 2734 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectCommandNV.imageOffset ); 2735 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectCommandNV.imageExtent ); 2736 return seed; 2737 } 2738 }; 2739 2740 template <> 2741 struct hash<VULKAN_HPP_NAMESPACE::MemoryToImageCopy> 2742 { operator ()std::hash2743 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryToImageCopy const & memoryToImageCopy ) const VULKAN_HPP_NOEXCEPT 2744 { 2745 std::size_t seed = 0; 2746 VULKAN_HPP_HASH_COMBINE( seed, memoryToImageCopy.sType ); 2747 VULKAN_HPP_HASH_COMBINE( seed, memoryToImageCopy.pNext ); 2748 VULKAN_HPP_HASH_COMBINE( seed, memoryToImageCopy.pHostPointer ); 2749 VULKAN_HPP_HASH_COMBINE( seed, memoryToImageCopy.memoryRowLength ); 2750 VULKAN_HPP_HASH_COMBINE( seed, memoryToImageCopy.memoryImageHeight ); 2751 VULKAN_HPP_HASH_COMBINE( seed, memoryToImageCopy.imageSubresource ); 2752 VULKAN_HPP_HASH_COMBINE( seed, memoryToImageCopy.imageOffset ); 2753 VULKAN_HPP_HASH_COMBINE( seed, memoryToImageCopy.imageExtent ); 2754 return seed; 2755 } 2756 }; 2757 2758 template <> 2759 struct hash<VULKAN_HPP_NAMESPACE::CopyMemoryToImageInfo> 2760 { operator ()std::hash2761 std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyMemoryToImageInfo const & copyMemoryToImageInfo ) const VULKAN_HPP_NOEXCEPT 2762 { 2763 std::size_t seed = 0; 2764 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageInfo.sType ); 2765 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageInfo.pNext ); 2766 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageInfo.flags ); 2767 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageInfo.dstImage ); 2768 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageInfo.dstImageLayout ); 2769 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageInfo.regionCount ); 2770 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageInfo.pRegions ); 2771 return seed; 2772 } 2773 }; 2774 2775 template <> 2776 struct hash<VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT> 2777 { operator ()std::hash2778 std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT const & copyMicromapInfoEXT ) const VULKAN_HPP_NOEXCEPT 2779 { 2780 std::size_t seed = 0; 2781 VULKAN_HPP_HASH_COMBINE( seed, copyMicromapInfoEXT.sType ); 2782 VULKAN_HPP_HASH_COMBINE( seed, copyMicromapInfoEXT.pNext ); 2783 VULKAN_HPP_HASH_COMBINE( seed, copyMicromapInfoEXT.src ); 2784 VULKAN_HPP_HASH_COMBINE( seed, copyMicromapInfoEXT.dst ); 2785 VULKAN_HPP_HASH_COMBINE( seed, copyMicromapInfoEXT.mode ); 2786 return seed; 2787 } 2788 }; 2789 2790 template <> 2791 struct hash<VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX> 2792 { operator ()std::hash2793 std::size_t operator()( VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX const & cuFunctionCreateInfoNVX ) const VULKAN_HPP_NOEXCEPT 2794 { 2795 std::size_t seed = 0; 2796 VULKAN_HPP_HASH_COMBINE( seed, cuFunctionCreateInfoNVX.sType ); 2797 VULKAN_HPP_HASH_COMBINE( seed, cuFunctionCreateInfoNVX.pNext ); 2798 VULKAN_HPP_HASH_COMBINE( seed, cuFunctionCreateInfoNVX.module ); 2799 for ( const char * p = cuFunctionCreateInfoNVX.pName; *p != '\0'; ++p ) 2800 { 2801 VULKAN_HPP_HASH_COMBINE( seed, *p ); 2802 } 2803 return seed; 2804 } 2805 }; 2806 2807 template <> 2808 struct hash<VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX> 2809 { operator ()std::hash2810 std::size_t operator()( VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX const & cuLaunchInfoNVX ) const VULKAN_HPP_NOEXCEPT 2811 { 2812 std::size_t seed = 0; 2813 VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.sType ); 2814 VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.pNext ); 2815 VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.function ); 2816 VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.gridDimX ); 2817 VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.gridDimY ); 2818 VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.gridDimZ ); 2819 VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.blockDimX ); 2820 VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.blockDimY ); 2821 VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.blockDimZ ); 2822 VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.sharedMemBytes ); 2823 VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.paramCount ); 2824 VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.pParams ); 2825 VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.extraCount ); 2826 VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.pExtras ); 2827 return seed; 2828 } 2829 }; 2830 2831 template <> 2832 struct hash<VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX> 2833 { operator ()std::hash2834 std::size_t operator()( VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX const & cuModuleCreateInfoNVX ) const VULKAN_HPP_NOEXCEPT 2835 { 2836 std::size_t seed = 0; 2837 VULKAN_HPP_HASH_COMBINE( seed, cuModuleCreateInfoNVX.sType ); 2838 VULKAN_HPP_HASH_COMBINE( seed, cuModuleCreateInfoNVX.pNext ); 2839 VULKAN_HPP_HASH_COMBINE( seed, cuModuleCreateInfoNVX.dataSize ); 2840 VULKAN_HPP_HASH_COMBINE( seed, cuModuleCreateInfoNVX.pData ); 2841 return seed; 2842 } 2843 }; 2844 2845 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 2846 template <> 2847 struct hash<VULKAN_HPP_NAMESPACE::CudaFunctionCreateInfoNV> 2848 { operator ()std::hash2849 std::size_t operator()( VULKAN_HPP_NAMESPACE::CudaFunctionCreateInfoNV const & cudaFunctionCreateInfoNV ) const VULKAN_HPP_NOEXCEPT 2850 { 2851 std::size_t seed = 0; 2852 VULKAN_HPP_HASH_COMBINE( seed, cudaFunctionCreateInfoNV.sType ); 2853 VULKAN_HPP_HASH_COMBINE( seed, cudaFunctionCreateInfoNV.pNext ); 2854 VULKAN_HPP_HASH_COMBINE( seed, cudaFunctionCreateInfoNV.module ); 2855 for ( const char * p = cudaFunctionCreateInfoNV.pName; *p != '\0'; ++p ) 2856 { 2857 VULKAN_HPP_HASH_COMBINE( seed, *p ); 2858 } 2859 return seed; 2860 } 2861 }; 2862 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 2863 2864 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 2865 template <> 2866 struct hash<VULKAN_HPP_NAMESPACE::CudaLaunchInfoNV> 2867 { operator ()std::hash2868 std::size_t operator()( VULKAN_HPP_NAMESPACE::CudaLaunchInfoNV const & cudaLaunchInfoNV ) const VULKAN_HPP_NOEXCEPT 2869 { 2870 std::size_t seed = 0; 2871 VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.sType ); 2872 VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.pNext ); 2873 VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.function ); 2874 VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.gridDimX ); 2875 VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.gridDimY ); 2876 VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.gridDimZ ); 2877 VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.blockDimX ); 2878 VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.blockDimY ); 2879 VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.blockDimZ ); 2880 VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.sharedMemBytes ); 2881 VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.paramCount ); 2882 VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.pParams ); 2883 VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.extraCount ); 2884 VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.pExtras ); 2885 return seed; 2886 } 2887 }; 2888 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 2889 2890 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 2891 template <> 2892 struct hash<VULKAN_HPP_NAMESPACE::CudaModuleCreateInfoNV> 2893 { operator ()std::hash2894 std::size_t operator()( VULKAN_HPP_NAMESPACE::CudaModuleCreateInfoNV const & cudaModuleCreateInfoNV ) const VULKAN_HPP_NOEXCEPT 2895 { 2896 std::size_t seed = 0; 2897 VULKAN_HPP_HASH_COMBINE( seed, cudaModuleCreateInfoNV.sType ); 2898 VULKAN_HPP_HASH_COMBINE( seed, cudaModuleCreateInfoNV.pNext ); 2899 VULKAN_HPP_HASH_COMBINE( seed, cudaModuleCreateInfoNV.dataSize ); 2900 VULKAN_HPP_HASH_COMBINE( seed, cudaModuleCreateInfoNV.pData ); 2901 return seed; 2902 } 2903 }; 2904 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 2905 2906 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 2907 template <> 2908 struct hash<VULKAN_HPP_NAMESPACE::D3D12FenceSubmitInfoKHR> 2909 { operator ()std::hash2910 std::size_t operator()( VULKAN_HPP_NAMESPACE::D3D12FenceSubmitInfoKHR const & d3D12FenceSubmitInfoKHR ) const VULKAN_HPP_NOEXCEPT 2911 { 2912 std::size_t seed = 0; 2913 VULKAN_HPP_HASH_COMBINE( seed, d3D12FenceSubmitInfoKHR.sType ); 2914 VULKAN_HPP_HASH_COMBINE( seed, d3D12FenceSubmitInfoKHR.pNext ); 2915 VULKAN_HPP_HASH_COMBINE( seed, d3D12FenceSubmitInfoKHR.waitSemaphoreValuesCount ); 2916 VULKAN_HPP_HASH_COMBINE( seed, d3D12FenceSubmitInfoKHR.pWaitSemaphoreValues ); 2917 VULKAN_HPP_HASH_COMBINE( seed, d3D12FenceSubmitInfoKHR.signalSemaphoreValuesCount ); 2918 VULKAN_HPP_HASH_COMBINE( seed, d3D12FenceSubmitInfoKHR.pSignalSemaphoreValues ); 2919 return seed; 2920 } 2921 }; 2922 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 2923 2924 template <> 2925 struct hash<VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT> 2926 { operator ()std::hash2927 std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT const & debugMarkerMarkerInfoEXT ) const VULKAN_HPP_NOEXCEPT 2928 { 2929 std::size_t seed = 0; 2930 VULKAN_HPP_HASH_COMBINE( seed, debugMarkerMarkerInfoEXT.sType ); 2931 VULKAN_HPP_HASH_COMBINE( seed, debugMarkerMarkerInfoEXT.pNext ); 2932 for ( const char * p = debugMarkerMarkerInfoEXT.pMarkerName; *p != '\0'; ++p ) 2933 { 2934 VULKAN_HPP_HASH_COMBINE( seed, *p ); 2935 } 2936 for ( size_t i = 0; i < 4; ++i ) 2937 { 2938 VULKAN_HPP_HASH_COMBINE( seed, debugMarkerMarkerInfoEXT.color[i] ); 2939 } 2940 return seed; 2941 } 2942 }; 2943 2944 template <> 2945 struct hash<VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT> 2946 { operator ()std::hash2947 std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT const & debugMarkerObjectNameInfoEXT ) const VULKAN_HPP_NOEXCEPT 2948 { 2949 std::size_t seed = 0; 2950 VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectNameInfoEXT.sType ); 2951 VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectNameInfoEXT.pNext ); 2952 VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectNameInfoEXT.objectType ); 2953 VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectNameInfoEXT.object ); 2954 for ( const char * p = debugMarkerObjectNameInfoEXT.pObjectName; *p != '\0'; ++p ) 2955 { 2956 VULKAN_HPP_HASH_COMBINE( seed, *p ); 2957 } 2958 return seed; 2959 } 2960 }; 2961 2962 template <> 2963 struct hash<VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT> 2964 { operator ()std::hash2965 std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT const & debugMarkerObjectTagInfoEXT ) const VULKAN_HPP_NOEXCEPT 2966 { 2967 std::size_t seed = 0; 2968 VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectTagInfoEXT.sType ); 2969 VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectTagInfoEXT.pNext ); 2970 VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectTagInfoEXT.objectType ); 2971 VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectTagInfoEXT.object ); 2972 VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectTagInfoEXT.tagName ); 2973 VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectTagInfoEXT.tagSize ); 2974 VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectTagInfoEXT.pTag ); 2975 return seed; 2976 } 2977 }; 2978 2979 template <> 2980 struct hash<VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT> 2981 { operator ()std::hash2982 std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT const & debugReportCallbackCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 2983 { 2984 std::size_t seed = 0; 2985 VULKAN_HPP_HASH_COMBINE( seed, debugReportCallbackCreateInfoEXT.sType ); 2986 VULKAN_HPP_HASH_COMBINE( seed, debugReportCallbackCreateInfoEXT.pNext ); 2987 VULKAN_HPP_HASH_COMBINE( seed, debugReportCallbackCreateInfoEXT.flags ); 2988 VULKAN_HPP_HASH_COMBINE( seed, debugReportCallbackCreateInfoEXT.pfnCallback ); 2989 VULKAN_HPP_HASH_COMBINE( seed, debugReportCallbackCreateInfoEXT.pUserData ); 2990 return seed; 2991 } 2992 }; 2993 2994 template <> 2995 struct hash<VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT> 2996 { operator ()std::hash2997 std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT const & debugUtilsLabelEXT ) const VULKAN_HPP_NOEXCEPT 2998 { 2999 std::size_t seed = 0; 3000 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsLabelEXT.sType ); 3001 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsLabelEXT.pNext ); 3002 for ( const char * p = debugUtilsLabelEXT.pLabelName; *p != '\0'; ++p ) 3003 { 3004 VULKAN_HPP_HASH_COMBINE( seed, *p ); 3005 } 3006 for ( size_t i = 0; i < 4; ++i ) 3007 { 3008 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsLabelEXT.color[i] ); 3009 } 3010 return seed; 3011 } 3012 }; 3013 3014 template <> 3015 struct hash<VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT> 3016 { operator ()std::hash3017 std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT const & debugUtilsObjectNameInfoEXT ) const VULKAN_HPP_NOEXCEPT 3018 { 3019 std::size_t seed = 0; 3020 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectNameInfoEXT.sType ); 3021 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectNameInfoEXT.pNext ); 3022 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectNameInfoEXT.objectType ); 3023 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectNameInfoEXT.objectHandle ); 3024 for ( const char * p = debugUtilsObjectNameInfoEXT.pObjectName; *p != '\0'; ++p ) 3025 { 3026 VULKAN_HPP_HASH_COMBINE( seed, *p ); 3027 } 3028 return seed; 3029 } 3030 }; 3031 3032 template <> 3033 struct hash<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataEXT> 3034 { operator ()std::hash3035 std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataEXT const & debugUtilsMessengerCallbackDataEXT ) const VULKAN_HPP_NOEXCEPT 3036 { 3037 std::size_t seed = 0; 3038 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.sType ); 3039 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.pNext ); 3040 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.flags ); 3041 for ( const char * p = debugUtilsMessengerCallbackDataEXT.pMessageIdName; *p != '\0'; ++p ) 3042 { 3043 VULKAN_HPP_HASH_COMBINE( seed, *p ); 3044 } 3045 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.messageIdNumber ); 3046 for ( const char * p = debugUtilsMessengerCallbackDataEXT.pMessage; *p != '\0'; ++p ) 3047 { 3048 VULKAN_HPP_HASH_COMBINE( seed, *p ); 3049 } 3050 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.queueLabelCount ); 3051 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.pQueueLabels ); 3052 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.cmdBufLabelCount ); 3053 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.pCmdBufLabels ); 3054 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.objectCount ); 3055 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.pObjects ); 3056 return seed; 3057 } 3058 }; 3059 3060 template <> 3061 struct hash<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT> 3062 { operator ()std::hash3063 std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT const & debugUtilsMessengerCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 3064 { 3065 std::size_t seed = 0; 3066 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCreateInfoEXT.sType ); 3067 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCreateInfoEXT.pNext ); 3068 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCreateInfoEXT.flags ); 3069 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCreateInfoEXT.messageSeverity ); 3070 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCreateInfoEXT.messageType ); 3071 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCreateInfoEXT.pfnUserCallback ); 3072 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCreateInfoEXT.pUserData ); 3073 return seed; 3074 } 3075 }; 3076 3077 template <> 3078 struct hash<VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT> 3079 { operator ()std::hash3080 std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT const & debugUtilsObjectTagInfoEXT ) const VULKAN_HPP_NOEXCEPT 3081 { 3082 std::size_t seed = 0; 3083 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectTagInfoEXT.sType ); 3084 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectTagInfoEXT.pNext ); 3085 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectTagInfoEXT.objectType ); 3086 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectTagInfoEXT.objectHandle ); 3087 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectTagInfoEXT.tagName ); 3088 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectTagInfoEXT.tagSize ); 3089 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectTagInfoEXT.pTag ); 3090 return seed; 3091 } 3092 }; 3093 3094 template <> 3095 struct hash<VULKAN_HPP_NAMESPACE::DecompressMemoryRegionNV> 3096 { operator ()std::hash3097 std::size_t operator()( VULKAN_HPP_NAMESPACE::DecompressMemoryRegionNV const & decompressMemoryRegionNV ) const VULKAN_HPP_NOEXCEPT 3098 { 3099 std::size_t seed = 0; 3100 VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryRegionNV.srcAddress ); 3101 VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryRegionNV.dstAddress ); 3102 VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryRegionNV.compressedSize ); 3103 VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryRegionNV.decompressedSize ); 3104 VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryRegionNV.decompressionMethod ); 3105 return seed; 3106 } 3107 }; 3108 3109 template <> 3110 struct hash<VULKAN_HPP_NAMESPACE::DedicatedAllocationBufferCreateInfoNV> 3111 { 3112 std::size_t operator ()std::hash3113 operator()( VULKAN_HPP_NAMESPACE::DedicatedAllocationBufferCreateInfoNV const & dedicatedAllocationBufferCreateInfoNV ) const VULKAN_HPP_NOEXCEPT 3114 { 3115 std::size_t seed = 0; 3116 VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationBufferCreateInfoNV.sType ); 3117 VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationBufferCreateInfoNV.pNext ); 3118 VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationBufferCreateInfoNV.dedicatedAllocation ); 3119 return seed; 3120 } 3121 }; 3122 3123 template <> 3124 struct hash<VULKAN_HPP_NAMESPACE::DedicatedAllocationImageCreateInfoNV> 3125 { operator ()std::hash3126 std::size_t operator()( VULKAN_HPP_NAMESPACE::DedicatedAllocationImageCreateInfoNV const & dedicatedAllocationImageCreateInfoNV ) const VULKAN_HPP_NOEXCEPT 3127 { 3128 std::size_t seed = 0; 3129 VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationImageCreateInfoNV.sType ); 3130 VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationImageCreateInfoNV.pNext ); 3131 VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationImageCreateInfoNV.dedicatedAllocation ); 3132 return seed; 3133 } 3134 }; 3135 3136 template <> 3137 struct hash<VULKAN_HPP_NAMESPACE::DedicatedAllocationMemoryAllocateInfoNV> 3138 { 3139 std::size_t operator ()std::hash3140 operator()( VULKAN_HPP_NAMESPACE::DedicatedAllocationMemoryAllocateInfoNV const & dedicatedAllocationMemoryAllocateInfoNV ) const VULKAN_HPP_NOEXCEPT 3141 { 3142 std::size_t seed = 0; 3143 VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationMemoryAllocateInfoNV.sType ); 3144 VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationMemoryAllocateInfoNV.pNext ); 3145 VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationMemoryAllocateInfoNV.image ); 3146 VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationMemoryAllocateInfoNV.buffer ); 3147 return seed; 3148 } 3149 }; 3150 3151 template <> 3152 struct hash<VULKAN_HPP_NAMESPACE::MemoryBarrier2> 3153 { operator ()std::hash3154 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryBarrier2 const & memoryBarrier2 ) const VULKAN_HPP_NOEXCEPT 3155 { 3156 std::size_t seed = 0; 3157 VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier2.sType ); 3158 VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier2.pNext ); 3159 VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier2.srcStageMask ); 3160 VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier2.srcAccessMask ); 3161 VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier2.dstStageMask ); 3162 VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier2.dstAccessMask ); 3163 return seed; 3164 } 3165 }; 3166 3167 template <> 3168 struct hash<VULKAN_HPP_NAMESPACE::ImageSubresourceRange> 3169 { operator ()std::hash3170 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageSubresourceRange const & imageSubresourceRange ) const VULKAN_HPP_NOEXCEPT 3171 { 3172 std::size_t seed = 0; 3173 VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceRange.aspectMask ); 3174 VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceRange.baseMipLevel ); 3175 VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceRange.levelCount ); 3176 VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceRange.baseArrayLayer ); 3177 VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceRange.layerCount ); 3178 return seed; 3179 } 3180 }; 3181 3182 template <> 3183 struct hash<VULKAN_HPP_NAMESPACE::ImageMemoryBarrier2> 3184 { operator ()std::hash3185 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageMemoryBarrier2 const & imageMemoryBarrier2 ) const VULKAN_HPP_NOEXCEPT 3186 { 3187 std::size_t seed = 0; 3188 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.sType ); 3189 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.pNext ); 3190 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.srcStageMask ); 3191 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.srcAccessMask ); 3192 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.dstStageMask ); 3193 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.dstAccessMask ); 3194 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.oldLayout ); 3195 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.newLayout ); 3196 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.srcQueueFamilyIndex ); 3197 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.dstQueueFamilyIndex ); 3198 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.image ); 3199 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.subresourceRange ); 3200 return seed; 3201 } 3202 }; 3203 3204 template <> 3205 struct hash<VULKAN_HPP_NAMESPACE::DependencyInfo> 3206 { operator ()std::hash3207 std::size_t operator()( VULKAN_HPP_NAMESPACE::DependencyInfo const & dependencyInfo ) const VULKAN_HPP_NOEXCEPT 3208 { 3209 std::size_t seed = 0; 3210 VULKAN_HPP_HASH_COMBINE( seed, dependencyInfo.sType ); 3211 VULKAN_HPP_HASH_COMBINE( seed, dependencyInfo.pNext ); 3212 VULKAN_HPP_HASH_COMBINE( seed, dependencyInfo.dependencyFlags ); 3213 VULKAN_HPP_HASH_COMBINE( seed, dependencyInfo.memoryBarrierCount ); 3214 VULKAN_HPP_HASH_COMBINE( seed, dependencyInfo.pMemoryBarriers ); 3215 VULKAN_HPP_HASH_COMBINE( seed, dependencyInfo.bufferMemoryBarrierCount ); 3216 VULKAN_HPP_HASH_COMBINE( seed, dependencyInfo.pBufferMemoryBarriers ); 3217 VULKAN_HPP_HASH_COMBINE( seed, dependencyInfo.imageMemoryBarrierCount ); 3218 VULKAN_HPP_HASH_COMBINE( seed, dependencyInfo.pImageMemoryBarriers ); 3219 return seed; 3220 } 3221 }; 3222 3223 template <> 3224 struct hash<VULKAN_HPP_NAMESPACE::DepthBiasInfoEXT> 3225 { operator ()std::hash3226 std::size_t operator()( VULKAN_HPP_NAMESPACE::DepthBiasInfoEXT const & depthBiasInfoEXT ) const VULKAN_HPP_NOEXCEPT 3227 { 3228 std::size_t seed = 0; 3229 VULKAN_HPP_HASH_COMBINE( seed, depthBiasInfoEXT.sType ); 3230 VULKAN_HPP_HASH_COMBINE( seed, depthBiasInfoEXT.pNext ); 3231 VULKAN_HPP_HASH_COMBINE( seed, depthBiasInfoEXT.depthBiasConstantFactor ); 3232 VULKAN_HPP_HASH_COMBINE( seed, depthBiasInfoEXT.depthBiasClamp ); 3233 VULKAN_HPP_HASH_COMBINE( seed, depthBiasInfoEXT.depthBiasSlopeFactor ); 3234 return seed; 3235 } 3236 }; 3237 3238 template <> 3239 struct hash<VULKAN_HPP_NAMESPACE::DepthBiasRepresentationInfoEXT> 3240 { operator ()std::hash3241 std::size_t operator()( VULKAN_HPP_NAMESPACE::DepthBiasRepresentationInfoEXT const & depthBiasRepresentationInfoEXT ) const VULKAN_HPP_NOEXCEPT 3242 { 3243 std::size_t seed = 0; 3244 VULKAN_HPP_HASH_COMBINE( seed, depthBiasRepresentationInfoEXT.sType ); 3245 VULKAN_HPP_HASH_COMBINE( seed, depthBiasRepresentationInfoEXT.pNext ); 3246 VULKAN_HPP_HASH_COMBINE( seed, depthBiasRepresentationInfoEXT.depthBiasRepresentation ); 3247 VULKAN_HPP_HASH_COMBINE( seed, depthBiasRepresentationInfoEXT.depthBiasExact ); 3248 return seed; 3249 } 3250 }; 3251 3252 template <> 3253 struct hash<VULKAN_HPP_NAMESPACE::DescriptorAddressInfoEXT> 3254 { operator ()std::hash3255 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorAddressInfoEXT const & descriptorAddressInfoEXT ) const VULKAN_HPP_NOEXCEPT 3256 { 3257 std::size_t seed = 0; 3258 VULKAN_HPP_HASH_COMBINE( seed, descriptorAddressInfoEXT.sType ); 3259 VULKAN_HPP_HASH_COMBINE( seed, descriptorAddressInfoEXT.pNext ); 3260 VULKAN_HPP_HASH_COMBINE( seed, descriptorAddressInfoEXT.address ); 3261 VULKAN_HPP_HASH_COMBINE( seed, descriptorAddressInfoEXT.range ); 3262 VULKAN_HPP_HASH_COMBINE( seed, descriptorAddressInfoEXT.format ); 3263 return seed; 3264 } 3265 }; 3266 3267 template <> 3268 struct hash<VULKAN_HPP_NAMESPACE::DescriptorBufferBindingInfoEXT> 3269 { operator ()std::hash3270 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorBufferBindingInfoEXT const & descriptorBufferBindingInfoEXT ) const VULKAN_HPP_NOEXCEPT 3271 { 3272 std::size_t seed = 0; 3273 VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferBindingInfoEXT.sType ); 3274 VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferBindingInfoEXT.pNext ); 3275 VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferBindingInfoEXT.address ); 3276 VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferBindingInfoEXT.usage ); 3277 return seed; 3278 } 3279 }; 3280 3281 template <> 3282 struct hash<VULKAN_HPP_NAMESPACE::DescriptorBufferBindingPushDescriptorBufferHandleEXT> 3283 { operator ()std::hash3284 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorBufferBindingPushDescriptorBufferHandleEXT const & 3285 descriptorBufferBindingPushDescriptorBufferHandleEXT ) const VULKAN_HPP_NOEXCEPT 3286 { 3287 std::size_t seed = 0; 3288 VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferBindingPushDescriptorBufferHandleEXT.sType ); 3289 VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferBindingPushDescriptorBufferHandleEXT.pNext ); 3290 VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferBindingPushDescriptorBufferHandleEXT.buffer ); 3291 return seed; 3292 } 3293 }; 3294 3295 template <> 3296 struct hash<VULKAN_HPP_NAMESPACE::DescriptorBufferInfo> 3297 { operator ()std::hash3298 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorBufferInfo const & descriptorBufferInfo ) const VULKAN_HPP_NOEXCEPT 3299 { 3300 std::size_t seed = 0; 3301 VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferInfo.buffer ); 3302 VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferInfo.offset ); 3303 VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferInfo.range ); 3304 return seed; 3305 } 3306 }; 3307 3308 template <> 3309 struct hash<VULKAN_HPP_NAMESPACE::DescriptorImageInfo> 3310 { operator ()std::hash3311 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorImageInfo const & descriptorImageInfo ) const VULKAN_HPP_NOEXCEPT 3312 { 3313 std::size_t seed = 0; 3314 VULKAN_HPP_HASH_COMBINE( seed, descriptorImageInfo.sampler ); 3315 VULKAN_HPP_HASH_COMBINE( seed, descriptorImageInfo.imageView ); 3316 VULKAN_HPP_HASH_COMBINE( seed, descriptorImageInfo.imageLayout ); 3317 return seed; 3318 } 3319 }; 3320 3321 template <> 3322 struct hash<VULKAN_HPP_NAMESPACE::DescriptorPoolSize> 3323 { operator ()std::hash3324 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorPoolSize const & descriptorPoolSize ) const VULKAN_HPP_NOEXCEPT 3325 { 3326 std::size_t seed = 0; 3327 VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolSize.type ); 3328 VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolSize.descriptorCount ); 3329 return seed; 3330 } 3331 }; 3332 3333 template <> 3334 struct hash<VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo> 3335 { operator ()std::hash3336 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo const & descriptorPoolCreateInfo ) const VULKAN_HPP_NOEXCEPT 3337 { 3338 std::size_t seed = 0; 3339 VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolCreateInfo.sType ); 3340 VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolCreateInfo.pNext ); 3341 VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolCreateInfo.flags ); 3342 VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolCreateInfo.maxSets ); 3343 VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolCreateInfo.poolSizeCount ); 3344 VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolCreateInfo.pPoolSizes ); 3345 return seed; 3346 } 3347 }; 3348 3349 template <> 3350 struct hash<VULKAN_HPP_NAMESPACE::DescriptorPoolInlineUniformBlockCreateInfo> 3351 { operator ()std::hash3352 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorPoolInlineUniformBlockCreateInfo const & descriptorPoolInlineUniformBlockCreateInfo ) const 3353 VULKAN_HPP_NOEXCEPT 3354 { 3355 std::size_t seed = 0; 3356 VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolInlineUniformBlockCreateInfo.sType ); 3357 VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolInlineUniformBlockCreateInfo.pNext ); 3358 VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolInlineUniformBlockCreateInfo.maxInlineUniformBlockBindings ); 3359 return seed; 3360 } 3361 }; 3362 3363 template <> 3364 struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo> 3365 { operator ()std::hash3366 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo const & descriptorSetAllocateInfo ) const VULKAN_HPP_NOEXCEPT 3367 { 3368 std::size_t seed = 0; 3369 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetAllocateInfo.sType ); 3370 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetAllocateInfo.pNext ); 3371 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetAllocateInfo.descriptorPool ); 3372 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetAllocateInfo.descriptorSetCount ); 3373 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetAllocateInfo.pSetLayouts ); 3374 return seed; 3375 } 3376 }; 3377 3378 template <> 3379 struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetBindingReferenceVALVE> 3380 { operator ()std::hash3381 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetBindingReferenceVALVE const & descriptorSetBindingReferenceVALVE ) const VULKAN_HPP_NOEXCEPT 3382 { 3383 std::size_t seed = 0; 3384 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetBindingReferenceVALVE.sType ); 3385 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetBindingReferenceVALVE.pNext ); 3386 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetBindingReferenceVALVE.descriptorSetLayout ); 3387 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetBindingReferenceVALVE.binding ); 3388 return seed; 3389 } 3390 }; 3391 3392 template <> 3393 struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBinding> 3394 { operator ()std::hash3395 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBinding const & descriptorSetLayoutBinding ) const VULKAN_HPP_NOEXCEPT 3396 { 3397 std::size_t seed = 0; 3398 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutBinding.binding ); 3399 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutBinding.descriptorType ); 3400 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutBinding.descriptorCount ); 3401 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutBinding.stageFlags ); 3402 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutBinding.pImmutableSamplers ); 3403 return seed; 3404 } 3405 }; 3406 3407 template <> 3408 struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBindingFlagsCreateInfo> 3409 { 3410 std::size_t operator ()std::hash3411 operator()( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBindingFlagsCreateInfo const & descriptorSetLayoutBindingFlagsCreateInfo ) const VULKAN_HPP_NOEXCEPT 3412 { 3413 std::size_t seed = 0; 3414 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutBindingFlagsCreateInfo.sType ); 3415 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutBindingFlagsCreateInfo.pNext ); 3416 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutBindingFlagsCreateInfo.bindingCount ); 3417 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutBindingFlagsCreateInfo.pBindingFlags ); 3418 return seed; 3419 } 3420 }; 3421 3422 template <> 3423 struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo> 3424 { operator ()std::hash3425 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo const & descriptorSetLayoutCreateInfo ) const VULKAN_HPP_NOEXCEPT 3426 { 3427 std::size_t seed = 0; 3428 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutCreateInfo.sType ); 3429 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutCreateInfo.pNext ); 3430 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutCreateInfo.flags ); 3431 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutCreateInfo.bindingCount ); 3432 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutCreateInfo.pBindings ); 3433 return seed; 3434 } 3435 }; 3436 3437 template <> 3438 struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutHostMappingInfoVALVE> 3439 { 3440 std::size_t operator ()std::hash3441 operator()( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutHostMappingInfoVALVE const & descriptorSetLayoutHostMappingInfoVALVE ) const VULKAN_HPP_NOEXCEPT 3442 { 3443 std::size_t seed = 0; 3444 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutHostMappingInfoVALVE.sType ); 3445 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutHostMappingInfoVALVE.pNext ); 3446 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutHostMappingInfoVALVE.descriptorOffset ); 3447 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutHostMappingInfoVALVE.descriptorSize ); 3448 return seed; 3449 } 3450 }; 3451 3452 template <> 3453 struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport> 3454 { operator ()std::hash3455 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport const & descriptorSetLayoutSupport ) const VULKAN_HPP_NOEXCEPT 3456 { 3457 std::size_t seed = 0; 3458 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutSupport.sType ); 3459 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutSupport.pNext ); 3460 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutSupport.supported ); 3461 return seed; 3462 } 3463 }; 3464 3465 template <> 3466 struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetVariableDescriptorCountAllocateInfo> 3467 { operator ()std::hash3468 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetVariableDescriptorCountAllocateInfo const & descriptorSetVariableDescriptorCountAllocateInfo ) 3469 const VULKAN_HPP_NOEXCEPT 3470 { 3471 std::size_t seed = 0; 3472 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetVariableDescriptorCountAllocateInfo.sType ); 3473 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetVariableDescriptorCountAllocateInfo.pNext ); 3474 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetVariableDescriptorCountAllocateInfo.descriptorSetCount ); 3475 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetVariableDescriptorCountAllocateInfo.pDescriptorCounts ); 3476 return seed; 3477 } 3478 }; 3479 3480 template <> 3481 struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetVariableDescriptorCountLayoutSupport> 3482 { operator ()std::hash3483 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetVariableDescriptorCountLayoutSupport const & descriptorSetVariableDescriptorCountLayoutSupport ) 3484 const VULKAN_HPP_NOEXCEPT 3485 { 3486 std::size_t seed = 0; 3487 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetVariableDescriptorCountLayoutSupport.sType ); 3488 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetVariableDescriptorCountLayoutSupport.pNext ); 3489 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetVariableDescriptorCountLayoutSupport.maxVariableDescriptorCount ); 3490 return seed; 3491 } 3492 }; 3493 3494 template <> 3495 struct hash<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateEntry> 3496 { operator ()std::hash3497 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateEntry const & descriptorUpdateTemplateEntry ) const VULKAN_HPP_NOEXCEPT 3498 { 3499 std::size_t seed = 0; 3500 VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateEntry.dstBinding ); 3501 VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateEntry.dstArrayElement ); 3502 VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateEntry.descriptorCount ); 3503 VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateEntry.descriptorType ); 3504 VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateEntry.offset ); 3505 VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateEntry.stride ); 3506 return seed; 3507 } 3508 }; 3509 3510 template <> 3511 struct hash<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo> 3512 { operator ()std::hash3513 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo const & descriptorUpdateTemplateCreateInfo ) const VULKAN_HPP_NOEXCEPT 3514 { 3515 std::size_t seed = 0; 3516 VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.sType ); 3517 VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.pNext ); 3518 VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.flags ); 3519 VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.descriptorUpdateEntryCount ); 3520 VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.pDescriptorUpdateEntries ); 3521 VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.templateType ); 3522 VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.descriptorSetLayout ); 3523 VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.pipelineBindPoint ); 3524 VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.pipelineLayout ); 3525 VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.set ); 3526 return seed; 3527 } 3528 }; 3529 3530 template <> 3531 struct hash<VULKAN_HPP_NAMESPACE::DeviceAddressBindingCallbackDataEXT> 3532 { operator ()std::hash3533 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceAddressBindingCallbackDataEXT const & deviceAddressBindingCallbackDataEXT ) const VULKAN_HPP_NOEXCEPT 3534 { 3535 std::size_t seed = 0; 3536 VULKAN_HPP_HASH_COMBINE( seed, deviceAddressBindingCallbackDataEXT.sType ); 3537 VULKAN_HPP_HASH_COMBINE( seed, deviceAddressBindingCallbackDataEXT.pNext ); 3538 VULKAN_HPP_HASH_COMBINE( seed, deviceAddressBindingCallbackDataEXT.flags ); 3539 VULKAN_HPP_HASH_COMBINE( seed, deviceAddressBindingCallbackDataEXT.baseAddress ); 3540 VULKAN_HPP_HASH_COMBINE( seed, deviceAddressBindingCallbackDataEXT.size ); 3541 VULKAN_HPP_HASH_COMBINE( seed, deviceAddressBindingCallbackDataEXT.bindingType ); 3542 return seed; 3543 } 3544 }; 3545 3546 template <> 3547 struct hash<VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements> 3548 { operator ()std::hash3549 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements const & deviceBufferMemoryRequirements ) const VULKAN_HPP_NOEXCEPT 3550 { 3551 std::size_t seed = 0; 3552 VULKAN_HPP_HASH_COMBINE( seed, deviceBufferMemoryRequirements.sType ); 3553 VULKAN_HPP_HASH_COMBINE( seed, deviceBufferMemoryRequirements.pNext ); 3554 VULKAN_HPP_HASH_COMBINE( seed, deviceBufferMemoryRequirements.pCreateInfo ); 3555 return seed; 3556 } 3557 }; 3558 3559 template <> 3560 struct hash<VULKAN_HPP_NAMESPACE::DeviceQueueCreateInfo> 3561 { operator ()std::hash3562 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceQueueCreateInfo const & deviceQueueCreateInfo ) const VULKAN_HPP_NOEXCEPT 3563 { 3564 std::size_t seed = 0; 3565 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueCreateInfo.sType ); 3566 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueCreateInfo.pNext ); 3567 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueCreateInfo.flags ); 3568 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueCreateInfo.queueFamilyIndex ); 3569 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueCreateInfo.queueCount ); 3570 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueCreateInfo.pQueuePriorities ); 3571 return seed; 3572 } 3573 }; 3574 3575 template <> 3576 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures> 3577 { operator ()std::hash3578 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures const & physicalDeviceFeatures ) const VULKAN_HPP_NOEXCEPT 3579 { 3580 std::size_t seed = 0; 3581 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.robustBufferAccess ); 3582 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.fullDrawIndexUint32 ); 3583 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.imageCubeArray ); 3584 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.independentBlend ); 3585 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.geometryShader ); 3586 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.tessellationShader ); 3587 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sampleRateShading ); 3588 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.dualSrcBlend ); 3589 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.logicOp ); 3590 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.multiDrawIndirect ); 3591 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.drawIndirectFirstInstance ); 3592 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.depthClamp ); 3593 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.depthBiasClamp ); 3594 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.fillModeNonSolid ); 3595 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.depthBounds ); 3596 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.wideLines ); 3597 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.largePoints ); 3598 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.alphaToOne ); 3599 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.multiViewport ); 3600 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.samplerAnisotropy ); 3601 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.textureCompressionETC2 ); 3602 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.textureCompressionASTC_LDR ); 3603 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.textureCompressionBC ); 3604 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.occlusionQueryPrecise ); 3605 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.pipelineStatisticsQuery ); 3606 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.vertexPipelineStoresAndAtomics ); 3607 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.fragmentStoresAndAtomics ); 3608 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderTessellationAndGeometryPointSize ); 3609 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderImageGatherExtended ); 3610 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderStorageImageExtendedFormats ); 3611 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderStorageImageMultisample ); 3612 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderStorageImageReadWithoutFormat ); 3613 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderStorageImageWriteWithoutFormat ); 3614 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderUniformBufferArrayDynamicIndexing ); 3615 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderSampledImageArrayDynamicIndexing ); 3616 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderStorageBufferArrayDynamicIndexing ); 3617 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderStorageImageArrayDynamicIndexing ); 3618 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderClipDistance ); 3619 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderCullDistance ); 3620 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderFloat64 ); 3621 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderInt64 ); 3622 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderInt16 ); 3623 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderResourceResidency ); 3624 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderResourceMinLod ); 3625 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sparseBinding ); 3626 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sparseResidencyBuffer ); 3627 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sparseResidencyImage2D ); 3628 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sparseResidencyImage3D ); 3629 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sparseResidency2Samples ); 3630 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sparseResidency4Samples ); 3631 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sparseResidency8Samples ); 3632 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sparseResidency16Samples ); 3633 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sparseResidencyAliased ); 3634 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.variableMultisampleRate ); 3635 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.inheritedQueries ); 3636 return seed; 3637 } 3638 }; 3639 3640 template <> 3641 struct hash<VULKAN_HPP_NAMESPACE::DeviceCreateInfo> 3642 { operator ()std::hash3643 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceCreateInfo const & deviceCreateInfo ) const VULKAN_HPP_NOEXCEPT 3644 { 3645 std::size_t seed = 0; 3646 VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.sType ); 3647 VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.pNext ); 3648 VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.flags ); 3649 VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.queueCreateInfoCount ); 3650 VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.pQueueCreateInfos ); 3651 VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.enabledLayerCount ); 3652 for ( size_t i = 0; i < deviceCreateInfo.enabledLayerCount; ++i ) 3653 { 3654 for ( const char * p = deviceCreateInfo.ppEnabledLayerNames[i]; *p != '\0'; ++p ) 3655 { 3656 VULKAN_HPP_HASH_COMBINE( seed, *p ); 3657 } 3658 } 3659 VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.enabledExtensionCount ); 3660 for ( size_t i = 0; i < deviceCreateInfo.enabledExtensionCount; ++i ) 3661 { 3662 for ( const char * p = deviceCreateInfo.ppEnabledExtensionNames[i]; *p != '\0'; ++p ) 3663 { 3664 VULKAN_HPP_HASH_COMBINE( seed, *p ); 3665 } 3666 } 3667 VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.pEnabledFeatures ); 3668 return seed; 3669 } 3670 }; 3671 3672 template <> 3673 struct hash<VULKAN_HPP_NAMESPACE::DeviceDeviceMemoryReportCreateInfoEXT> 3674 { 3675 std::size_t operator ()std::hash3676 operator()( VULKAN_HPP_NAMESPACE::DeviceDeviceMemoryReportCreateInfoEXT const & deviceDeviceMemoryReportCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 3677 { 3678 std::size_t seed = 0; 3679 VULKAN_HPP_HASH_COMBINE( seed, deviceDeviceMemoryReportCreateInfoEXT.sType ); 3680 VULKAN_HPP_HASH_COMBINE( seed, deviceDeviceMemoryReportCreateInfoEXT.pNext ); 3681 VULKAN_HPP_HASH_COMBINE( seed, deviceDeviceMemoryReportCreateInfoEXT.flags ); 3682 VULKAN_HPP_HASH_COMBINE( seed, deviceDeviceMemoryReportCreateInfoEXT.pfnUserCallback ); 3683 VULKAN_HPP_HASH_COMBINE( seed, deviceDeviceMemoryReportCreateInfoEXT.pUserData ); 3684 return seed; 3685 } 3686 }; 3687 3688 template <> 3689 struct hash<VULKAN_HPP_NAMESPACE::DeviceDiagnosticsConfigCreateInfoNV> 3690 { operator ()std::hash3691 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceDiagnosticsConfigCreateInfoNV const & deviceDiagnosticsConfigCreateInfoNV ) const VULKAN_HPP_NOEXCEPT 3692 { 3693 std::size_t seed = 0; 3694 VULKAN_HPP_HASH_COMBINE( seed, deviceDiagnosticsConfigCreateInfoNV.sType ); 3695 VULKAN_HPP_HASH_COMBINE( seed, deviceDiagnosticsConfigCreateInfoNV.pNext ); 3696 VULKAN_HPP_HASH_COMBINE( seed, deviceDiagnosticsConfigCreateInfoNV.flags ); 3697 return seed; 3698 } 3699 }; 3700 3701 template <> 3702 struct hash<VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT> 3703 { operator ()std::hash3704 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT const & deviceEventInfoEXT ) const VULKAN_HPP_NOEXCEPT 3705 { 3706 std::size_t seed = 0; 3707 VULKAN_HPP_HASH_COMBINE( seed, deviceEventInfoEXT.sType ); 3708 VULKAN_HPP_HASH_COMBINE( seed, deviceEventInfoEXT.pNext ); 3709 VULKAN_HPP_HASH_COMBINE( seed, deviceEventInfoEXT.deviceEvent ); 3710 return seed; 3711 } 3712 }; 3713 3714 template <> 3715 struct hash<VULKAN_HPP_NAMESPACE::DeviceFaultAddressInfoEXT> 3716 { operator ()std::hash3717 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceFaultAddressInfoEXT const & deviceFaultAddressInfoEXT ) const VULKAN_HPP_NOEXCEPT 3718 { 3719 std::size_t seed = 0; 3720 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultAddressInfoEXT.addressType ); 3721 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultAddressInfoEXT.reportedAddress ); 3722 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultAddressInfoEXT.addressPrecision ); 3723 return seed; 3724 } 3725 }; 3726 3727 template <> 3728 struct hash<VULKAN_HPP_NAMESPACE::DeviceFaultCountsEXT> 3729 { operator ()std::hash3730 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceFaultCountsEXT const & deviceFaultCountsEXT ) const VULKAN_HPP_NOEXCEPT 3731 { 3732 std::size_t seed = 0; 3733 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultCountsEXT.sType ); 3734 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultCountsEXT.pNext ); 3735 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultCountsEXT.addressInfoCount ); 3736 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultCountsEXT.vendorInfoCount ); 3737 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultCountsEXT.vendorBinarySize ); 3738 return seed; 3739 } 3740 }; 3741 3742 template <> 3743 struct hash<VULKAN_HPP_NAMESPACE::DeviceFaultVendorInfoEXT> 3744 { operator ()std::hash3745 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceFaultVendorInfoEXT const & deviceFaultVendorInfoEXT ) const VULKAN_HPP_NOEXCEPT 3746 { 3747 std::size_t seed = 0; 3748 for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) 3749 { 3750 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorInfoEXT.description[i] ); 3751 } 3752 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorInfoEXT.vendorFaultCode ); 3753 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorInfoEXT.vendorFaultData ); 3754 return seed; 3755 } 3756 }; 3757 3758 template <> 3759 struct hash<VULKAN_HPP_NAMESPACE::DeviceFaultInfoEXT> 3760 { operator ()std::hash3761 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceFaultInfoEXT const & deviceFaultInfoEXT ) const VULKAN_HPP_NOEXCEPT 3762 { 3763 std::size_t seed = 0; 3764 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultInfoEXT.sType ); 3765 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultInfoEXT.pNext ); 3766 for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) 3767 { 3768 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultInfoEXT.description[i] ); 3769 } 3770 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultInfoEXT.pAddressInfos ); 3771 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultInfoEXT.pVendorInfos ); 3772 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultInfoEXT.pVendorBinaryData ); 3773 return seed; 3774 } 3775 }; 3776 3777 template <> 3778 struct hash<VULKAN_HPP_NAMESPACE::DeviceFaultVendorBinaryHeaderVersionOneEXT> 3779 { operator ()std::hash3780 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceFaultVendorBinaryHeaderVersionOneEXT const & deviceFaultVendorBinaryHeaderVersionOneEXT ) const 3781 VULKAN_HPP_NOEXCEPT 3782 { 3783 std::size_t seed = 0; 3784 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.headerSize ); 3785 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.headerVersion ); 3786 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.vendorID ); 3787 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.deviceID ); 3788 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.driverVersion ); 3789 for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) 3790 { 3791 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.pipelineCacheUUID[i] ); 3792 } 3793 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.applicationNameOffset ); 3794 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.applicationVersion ); 3795 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.engineNameOffset ); 3796 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.engineVersion ); 3797 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.apiVersion ); 3798 return seed; 3799 } 3800 }; 3801 3802 template <> 3803 struct hash<VULKAN_HPP_NAMESPACE::DeviceGroupBindSparseInfo> 3804 { operator ()std::hash3805 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupBindSparseInfo const & deviceGroupBindSparseInfo ) const VULKAN_HPP_NOEXCEPT 3806 { 3807 std::size_t seed = 0; 3808 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupBindSparseInfo.sType ); 3809 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupBindSparseInfo.pNext ); 3810 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupBindSparseInfo.resourceDeviceIndex ); 3811 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupBindSparseInfo.memoryDeviceIndex ); 3812 return seed; 3813 } 3814 }; 3815 3816 template <> 3817 struct hash<VULKAN_HPP_NAMESPACE::DeviceGroupCommandBufferBeginInfo> 3818 { operator ()std::hash3819 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupCommandBufferBeginInfo const & deviceGroupCommandBufferBeginInfo ) const VULKAN_HPP_NOEXCEPT 3820 { 3821 std::size_t seed = 0; 3822 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupCommandBufferBeginInfo.sType ); 3823 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupCommandBufferBeginInfo.pNext ); 3824 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupCommandBufferBeginInfo.deviceMask ); 3825 return seed; 3826 } 3827 }; 3828 3829 template <> 3830 struct hash<VULKAN_HPP_NAMESPACE::DeviceGroupDeviceCreateInfo> 3831 { operator ()std::hash3832 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupDeviceCreateInfo const & deviceGroupDeviceCreateInfo ) const VULKAN_HPP_NOEXCEPT 3833 { 3834 std::size_t seed = 0; 3835 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupDeviceCreateInfo.sType ); 3836 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupDeviceCreateInfo.pNext ); 3837 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupDeviceCreateInfo.physicalDeviceCount ); 3838 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupDeviceCreateInfo.pPhysicalDevices ); 3839 return seed; 3840 } 3841 }; 3842 3843 template <> 3844 struct hash<VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR> 3845 { operator ()std::hash3846 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR const & deviceGroupPresentCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT 3847 { 3848 std::size_t seed = 0; 3849 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupPresentCapabilitiesKHR.sType ); 3850 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupPresentCapabilitiesKHR.pNext ); 3851 for ( size_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; ++i ) 3852 { 3853 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupPresentCapabilitiesKHR.presentMask[i] ); 3854 } 3855 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupPresentCapabilitiesKHR.modes ); 3856 return seed; 3857 } 3858 }; 3859 3860 template <> 3861 struct hash<VULKAN_HPP_NAMESPACE::DeviceGroupPresentInfoKHR> 3862 { operator ()std::hash3863 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupPresentInfoKHR const & deviceGroupPresentInfoKHR ) const VULKAN_HPP_NOEXCEPT 3864 { 3865 std::size_t seed = 0; 3866 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupPresentInfoKHR.sType ); 3867 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupPresentInfoKHR.pNext ); 3868 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupPresentInfoKHR.swapchainCount ); 3869 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupPresentInfoKHR.pDeviceMasks ); 3870 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupPresentInfoKHR.mode ); 3871 return seed; 3872 } 3873 }; 3874 3875 template <> 3876 struct hash<VULKAN_HPP_NAMESPACE::DeviceGroupRenderPassBeginInfo> 3877 { operator ()std::hash3878 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupRenderPassBeginInfo const & deviceGroupRenderPassBeginInfo ) const VULKAN_HPP_NOEXCEPT 3879 { 3880 std::size_t seed = 0; 3881 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupRenderPassBeginInfo.sType ); 3882 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupRenderPassBeginInfo.pNext ); 3883 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupRenderPassBeginInfo.deviceMask ); 3884 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupRenderPassBeginInfo.deviceRenderAreaCount ); 3885 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupRenderPassBeginInfo.pDeviceRenderAreas ); 3886 return seed; 3887 } 3888 }; 3889 3890 template <> 3891 struct hash<VULKAN_HPP_NAMESPACE::DeviceGroupSubmitInfo> 3892 { operator ()std::hash3893 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupSubmitInfo const & deviceGroupSubmitInfo ) const VULKAN_HPP_NOEXCEPT 3894 { 3895 std::size_t seed = 0; 3896 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSubmitInfo.sType ); 3897 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSubmitInfo.pNext ); 3898 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSubmitInfo.waitSemaphoreCount ); 3899 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSubmitInfo.pWaitSemaphoreDeviceIndices ); 3900 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSubmitInfo.commandBufferCount ); 3901 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSubmitInfo.pCommandBufferDeviceMasks ); 3902 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSubmitInfo.signalSemaphoreCount ); 3903 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSubmitInfo.pSignalSemaphoreDeviceIndices ); 3904 return seed; 3905 } 3906 }; 3907 3908 template <> 3909 struct hash<VULKAN_HPP_NAMESPACE::DeviceGroupSwapchainCreateInfoKHR> 3910 { operator ()std::hash3911 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupSwapchainCreateInfoKHR const & deviceGroupSwapchainCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 3912 { 3913 std::size_t seed = 0; 3914 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSwapchainCreateInfoKHR.sType ); 3915 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSwapchainCreateInfoKHR.pNext ); 3916 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSwapchainCreateInfoKHR.modes ); 3917 return seed; 3918 } 3919 }; 3920 3921 template <> 3922 struct hash<VULKAN_HPP_NAMESPACE::ImageCreateInfo> 3923 { operator ()std::hash3924 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageCreateInfo const & imageCreateInfo ) const VULKAN_HPP_NOEXCEPT 3925 { 3926 std::size_t seed = 0; 3927 VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.sType ); 3928 VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.pNext ); 3929 VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.flags ); 3930 VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.imageType ); 3931 VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.format ); 3932 VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.extent ); 3933 VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.mipLevels ); 3934 VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.arrayLayers ); 3935 VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.samples ); 3936 VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.tiling ); 3937 VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.usage ); 3938 VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.sharingMode ); 3939 VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.queueFamilyIndexCount ); 3940 VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.pQueueFamilyIndices ); 3941 VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.initialLayout ); 3942 return seed; 3943 } 3944 }; 3945 3946 template <> 3947 struct hash<VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements> 3948 { operator ()std::hash3949 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements const & deviceImageMemoryRequirements ) const VULKAN_HPP_NOEXCEPT 3950 { 3951 std::size_t seed = 0; 3952 VULKAN_HPP_HASH_COMBINE( seed, deviceImageMemoryRequirements.sType ); 3953 VULKAN_HPP_HASH_COMBINE( seed, deviceImageMemoryRequirements.pNext ); 3954 VULKAN_HPP_HASH_COMBINE( seed, deviceImageMemoryRequirements.pCreateInfo ); 3955 VULKAN_HPP_HASH_COMBINE( seed, deviceImageMemoryRequirements.planeAspect ); 3956 return seed; 3957 } 3958 }; 3959 3960 template <> 3961 struct hash<VULKAN_HPP_NAMESPACE::ImageSubresource2> 3962 { operator ()std::hash3963 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageSubresource2 const & imageSubresource2 ) const VULKAN_HPP_NOEXCEPT 3964 { 3965 std::size_t seed = 0; 3966 VULKAN_HPP_HASH_COMBINE( seed, imageSubresource2.sType ); 3967 VULKAN_HPP_HASH_COMBINE( seed, imageSubresource2.pNext ); 3968 VULKAN_HPP_HASH_COMBINE( seed, imageSubresource2.imageSubresource ); 3969 return seed; 3970 } 3971 }; 3972 3973 template <> 3974 struct hash<VULKAN_HPP_NAMESPACE::DeviceImageSubresourceInfo> 3975 { operator ()std::hash3976 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceImageSubresourceInfo const & deviceImageSubresourceInfo ) const VULKAN_HPP_NOEXCEPT 3977 { 3978 std::size_t seed = 0; 3979 VULKAN_HPP_HASH_COMBINE( seed, deviceImageSubresourceInfo.sType ); 3980 VULKAN_HPP_HASH_COMBINE( seed, deviceImageSubresourceInfo.pNext ); 3981 VULKAN_HPP_HASH_COMBINE( seed, deviceImageSubresourceInfo.pCreateInfo ); 3982 VULKAN_HPP_HASH_COMBINE( seed, deviceImageSubresourceInfo.pSubresource ); 3983 return seed; 3984 } 3985 }; 3986 3987 template <> 3988 struct hash<VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo> 3989 { operator ()std::hash3990 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo const & deviceMemoryOpaqueCaptureAddressInfo ) const VULKAN_HPP_NOEXCEPT 3991 { 3992 std::size_t seed = 0; 3993 VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryOpaqueCaptureAddressInfo.sType ); 3994 VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryOpaqueCaptureAddressInfo.pNext ); 3995 VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryOpaqueCaptureAddressInfo.memory ); 3996 return seed; 3997 } 3998 }; 3999 4000 template <> 4001 struct hash<VULKAN_HPP_NAMESPACE::DeviceMemoryOverallocationCreateInfoAMD> 4002 { 4003 std::size_t operator ()std::hash4004 operator()( VULKAN_HPP_NAMESPACE::DeviceMemoryOverallocationCreateInfoAMD const & deviceMemoryOverallocationCreateInfoAMD ) const VULKAN_HPP_NOEXCEPT 4005 { 4006 std::size_t seed = 0; 4007 VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryOverallocationCreateInfoAMD.sType ); 4008 VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryOverallocationCreateInfoAMD.pNext ); 4009 VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryOverallocationCreateInfoAMD.overallocationBehavior ); 4010 return seed; 4011 } 4012 }; 4013 4014 template <> 4015 struct hash<VULKAN_HPP_NAMESPACE::DeviceMemoryReportCallbackDataEXT> 4016 { operator ()std::hash4017 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceMemoryReportCallbackDataEXT const & deviceMemoryReportCallbackDataEXT ) const VULKAN_HPP_NOEXCEPT 4018 { 4019 std::size_t seed = 0; 4020 VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryReportCallbackDataEXT.sType ); 4021 VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryReportCallbackDataEXT.pNext ); 4022 VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryReportCallbackDataEXT.flags ); 4023 VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryReportCallbackDataEXT.type ); 4024 VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryReportCallbackDataEXT.memoryObjectId ); 4025 VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryReportCallbackDataEXT.size ); 4026 VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryReportCallbackDataEXT.objectType ); 4027 VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryReportCallbackDataEXT.objectHandle ); 4028 VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryReportCallbackDataEXT.heapIndex ); 4029 return seed; 4030 } 4031 }; 4032 4033 template <> 4034 struct hash<VULKAN_HPP_NAMESPACE::DevicePipelineBinaryInternalCacheControlKHR> 4035 { operator ()std::hash4036 std::size_t operator()( VULKAN_HPP_NAMESPACE::DevicePipelineBinaryInternalCacheControlKHR const & devicePipelineBinaryInternalCacheControlKHR ) const 4037 VULKAN_HPP_NOEXCEPT 4038 { 4039 std::size_t seed = 0; 4040 VULKAN_HPP_HASH_COMBINE( seed, devicePipelineBinaryInternalCacheControlKHR.sType ); 4041 VULKAN_HPP_HASH_COMBINE( seed, devicePipelineBinaryInternalCacheControlKHR.pNext ); 4042 VULKAN_HPP_HASH_COMBINE( seed, devicePipelineBinaryInternalCacheControlKHR.disableInternalCache ); 4043 return seed; 4044 } 4045 }; 4046 4047 template <> 4048 struct hash<VULKAN_HPP_NAMESPACE::DevicePrivateDataCreateInfo> 4049 { operator ()std::hash4050 std::size_t operator()( VULKAN_HPP_NAMESPACE::DevicePrivateDataCreateInfo const & devicePrivateDataCreateInfo ) const VULKAN_HPP_NOEXCEPT 4051 { 4052 std::size_t seed = 0; 4053 VULKAN_HPP_HASH_COMBINE( seed, devicePrivateDataCreateInfo.sType ); 4054 VULKAN_HPP_HASH_COMBINE( seed, devicePrivateDataCreateInfo.pNext ); 4055 VULKAN_HPP_HASH_COMBINE( seed, devicePrivateDataCreateInfo.privateDataSlotRequestCount ); 4056 return seed; 4057 } 4058 }; 4059 4060 template <> 4061 struct hash<VULKAN_HPP_NAMESPACE::DeviceQueueGlobalPriorityCreateInfo> 4062 { operator ()std::hash4063 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceQueueGlobalPriorityCreateInfo const & deviceQueueGlobalPriorityCreateInfo ) const VULKAN_HPP_NOEXCEPT 4064 { 4065 std::size_t seed = 0; 4066 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueGlobalPriorityCreateInfo.sType ); 4067 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueGlobalPriorityCreateInfo.pNext ); 4068 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueGlobalPriorityCreateInfo.globalPriority ); 4069 return seed; 4070 } 4071 }; 4072 4073 template <> 4074 struct hash<VULKAN_HPP_NAMESPACE::DeviceQueueInfo2> 4075 { operator ()std::hash4076 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceQueueInfo2 const & deviceQueueInfo2 ) const VULKAN_HPP_NOEXCEPT 4077 { 4078 std::size_t seed = 0; 4079 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueInfo2.sType ); 4080 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueInfo2.pNext ); 4081 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueInfo2.flags ); 4082 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueInfo2.queueFamilyIndex ); 4083 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueInfo2.queueIndex ); 4084 return seed; 4085 } 4086 }; 4087 4088 template <> 4089 struct hash<VULKAN_HPP_NAMESPACE::DeviceQueueShaderCoreControlCreateInfoARM> 4090 { 4091 std::size_t operator ()std::hash4092 operator()( VULKAN_HPP_NAMESPACE::DeviceQueueShaderCoreControlCreateInfoARM const & deviceQueueShaderCoreControlCreateInfoARM ) const VULKAN_HPP_NOEXCEPT 4093 { 4094 std::size_t seed = 0; 4095 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueShaderCoreControlCreateInfoARM.sType ); 4096 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueShaderCoreControlCreateInfoARM.pNext ); 4097 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueShaderCoreControlCreateInfoARM.shaderCoreCount ); 4098 return seed; 4099 } 4100 }; 4101 4102 template <> 4103 struct hash<VULKAN_HPP_NAMESPACE::DirectDriverLoadingInfoLUNARG> 4104 { operator ()std::hash4105 std::size_t operator()( VULKAN_HPP_NAMESPACE::DirectDriverLoadingInfoLUNARG const & directDriverLoadingInfoLUNARG ) const VULKAN_HPP_NOEXCEPT 4106 { 4107 std::size_t seed = 0; 4108 VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingInfoLUNARG.sType ); 4109 VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingInfoLUNARG.pNext ); 4110 VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingInfoLUNARG.flags ); 4111 VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingInfoLUNARG.pfnGetInstanceProcAddr ); 4112 return seed; 4113 } 4114 }; 4115 4116 template <> 4117 struct hash<VULKAN_HPP_NAMESPACE::DirectDriverLoadingListLUNARG> 4118 { operator ()std::hash4119 std::size_t operator()( VULKAN_HPP_NAMESPACE::DirectDriverLoadingListLUNARG const & directDriverLoadingListLUNARG ) const VULKAN_HPP_NOEXCEPT 4120 { 4121 std::size_t seed = 0; 4122 VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingListLUNARG.sType ); 4123 VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingListLUNARG.pNext ); 4124 VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingListLUNARG.mode ); 4125 VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingListLUNARG.driverCount ); 4126 VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingListLUNARG.pDrivers ); 4127 return seed; 4128 } 4129 }; 4130 4131 # if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) 4132 template <> 4133 struct hash<VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT> 4134 { operator ()std::hash4135 std::size_t operator()( VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT const & directFBSurfaceCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 4136 { 4137 std::size_t seed = 0; 4138 VULKAN_HPP_HASH_COMBINE( seed, directFBSurfaceCreateInfoEXT.sType ); 4139 VULKAN_HPP_HASH_COMBINE( seed, directFBSurfaceCreateInfoEXT.pNext ); 4140 VULKAN_HPP_HASH_COMBINE( seed, directFBSurfaceCreateInfoEXT.flags ); 4141 VULKAN_HPP_HASH_COMBINE( seed, directFBSurfaceCreateInfoEXT.dfb ); 4142 VULKAN_HPP_HASH_COMBINE( seed, directFBSurfaceCreateInfoEXT.surface ); 4143 return seed; 4144 } 4145 }; 4146 # endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ 4147 4148 template <> 4149 struct hash<VULKAN_HPP_NAMESPACE::DispatchIndirectCommand> 4150 { operator ()std::hash4151 std::size_t operator()( VULKAN_HPP_NAMESPACE::DispatchIndirectCommand const & dispatchIndirectCommand ) const VULKAN_HPP_NOEXCEPT 4152 { 4153 std::size_t seed = 0; 4154 VULKAN_HPP_HASH_COMBINE( seed, dispatchIndirectCommand.x ); 4155 VULKAN_HPP_HASH_COMBINE( seed, dispatchIndirectCommand.y ); 4156 VULKAN_HPP_HASH_COMBINE( seed, dispatchIndirectCommand.z ); 4157 return seed; 4158 } 4159 }; 4160 4161 template <> 4162 struct hash<VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT> 4163 { operator ()std::hash4164 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT const & displayEventInfoEXT ) const VULKAN_HPP_NOEXCEPT 4165 { 4166 std::size_t seed = 0; 4167 VULKAN_HPP_HASH_COMBINE( seed, displayEventInfoEXT.sType ); 4168 VULKAN_HPP_HASH_COMBINE( seed, displayEventInfoEXT.pNext ); 4169 VULKAN_HPP_HASH_COMBINE( seed, displayEventInfoEXT.displayEvent ); 4170 return seed; 4171 } 4172 }; 4173 4174 template <> 4175 struct hash<VULKAN_HPP_NAMESPACE::DisplayModeParametersKHR> 4176 { operator ()std::hash4177 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayModeParametersKHR const & displayModeParametersKHR ) const VULKAN_HPP_NOEXCEPT 4178 { 4179 std::size_t seed = 0; 4180 VULKAN_HPP_HASH_COMBINE( seed, displayModeParametersKHR.visibleRegion ); 4181 VULKAN_HPP_HASH_COMBINE( seed, displayModeParametersKHR.refreshRate ); 4182 return seed; 4183 } 4184 }; 4185 4186 template <> 4187 struct hash<VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR> 4188 { operator ()std::hash4189 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR const & displayModeCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 4190 { 4191 std::size_t seed = 0; 4192 VULKAN_HPP_HASH_COMBINE( seed, displayModeCreateInfoKHR.sType ); 4193 VULKAN_HPP_HASH_COMBINE( seed, displayModeCreateInfoKHR.pNext ); 4194 VULKAN_HPP_HASH_COMBINE( seed, displayModeCreateInfoKHR.flags ); 4195 VULKAN_HPP_HASH_COMBINE( seed, displayModeCreateInfoKHR.parameters ); 4196 return seed; 4197 } 4198 }; 4199 4200 template <> 4201 struct hash<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR> 4202 { operator ()std::hash4203 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR const & displayModePropertiesKHR ) const VULKAN_HPP_NOEXCEPT 4204 { 4205 std::size_t seed = 0; 4206 VULKAN_HPP_HASH_COMBINE( seed, displayModePropertiesKHR.displayMode ); 4207 VULKAN_HPP_HASH_COMBINE( seed, displayModePropertiesKHR.parameters ); 4208 return seed; 4209 } 4210 }; 4211 4212 template <> 4213 struct hash<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR> 4214 { operator ()std::hash4215 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR const & displayModeProperties2KHR ) const VULKAN_HPP_NOEXCEPT 4216 { 4217 std::size_t seed = 0; 4218 VULKAN_HPP_HASH_COMBINE( seed, displayModeProperties2KHR.sType ); 4219 VULKAN_HPP_HASH_COMBINE( seed, displayModeProperties2KHR.pNext ); 4220 VULKAN_HPP_HASH_COMBINE( seed, displayModeProperties2KHR.displayModeProperties ); 4221 return seed; 4222 } 4223 }; 4224 4225 template <> 4226 struct hash<VULKAN_HPP_NAMESPACE::DisplayNativeHdrSurfaceCapabilitiesAMD> 4227 { 4228 std::size_t operator ()std::hash4229 operator()( VULKAN_HPP_NAMESPACE::DisplayNativeHdrSurfaceCapabilitiesAMD const & displayNativeHdrSurfaceCapabilitiesAMD ) const VULKAN_HPP_NOEXCEPT 4230 { 4231 std::size_t seed = 0; 4232 VULKAN_HPP_HASH_COMBINE( seed, displayNativeHdrSurfaceCapabilitiesAMD.sType ); 4233 VULKAN_HPP_HASH_COMBINE( seed, displayNativeHdrSurfaceCapabilitiesAMD.pNext ); 4234 VULKAN_HPP_HASH_COMBINE( seed, displayNativeHdrSurfaceCapabilitiesAMD.localDimmingSupport ); 4235 return seed; 4236 } 4237 }; 4238 4239 template <> 4240 struct hash<VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR> 4241 { operator ()std::hash4242 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR const & displayPlaneCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT 4243 { 4244 std::size_t seed = 0; 4245 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilitiesKHR.supportedAlpha ); 4246 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilitiesKHR.minSrcPosition ); 4247 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilitiesKHR.maxSrcPosition ); 4248 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilitiesKHR.minSrcExtent ); 4249 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilitiesKHR.maxSrcExtent ); 4250 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilitiesKHR.minDstPosition ); 4251 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilitiesKHR.maxDstPosition ); 4252 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilitiesKHR.minDstExtent ); 4253 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilitiesKHR.maxDstExtent ); 4254 return seed; 4255 } 4256 }; 4257 4258 template <> 4259 struct hash<VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR> 4260 { operator ()std::hash4261 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR const & displayPlaneCapabilities2KHR ) const VULKAN_HPP_NOEXCEPT 4262 { 4263 std::size_t seed = 0; 4264 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilities2KHR.sType ); 4265 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilities2KHR.pNext ); 4266 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilities2KHR.capabilities ); 4267 return seed; 4268 } 4269 }; 4270 4271 template <> 4272 struct hash<VULKAN_HPP_NAMESPACE::DisplayPlaneInfo2KHR> 4273 { operator ()std::hash4274 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPlaneInfo2KHR const & displayPlaneInfo2KHR ) const VULKAN_HPP_NOEXCEPT 4275 { 4276 std::size_t seed = 0; 4277 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneInfo2KHR.sType ); 4278 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneInfo2KHR.pNext ); 4279 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneInfo2KHR.mode ); 4280 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneInfo2KHR.planeIndex ); 4281 return seed; 4282 } 4283 }; 4284 4285 template <> 4286 struct hash<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR> 4287 { operator ()std::hash4288 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR const & displayPlanePropertiesKHR ) const VULKAN_HPP_NOEXCEPT 4289 { 4290 std::size_t seed = 0; 4291 VULKAN_HPP_HASH_COMBINE( seed, displayPlanePropertiesKHR.currentDisplay ); 4292 VULKAN_HPP_HASH_COMBINE( seed, displayPlanePropertiesKHR.currentStackIndex ); 4293 return seed; 4294 } 4295 }; 4296 4297 template <> 4298 struct hash<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR> 4299 { operator ()std::hash4300 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR const & displayPlaneProperties2KHR ) const VULKAN_HPP_NOEXCEPT 4301 { 4302 std::size_t seed = 0; 4303 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneProperties2KHR.sType ); 4304 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneProperties2KHR.pNext ); 4305 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneProperties2KHR.displayPlaneProperties ); 4306 return seed; 4307 } 4308 }; 4309 4310 template <> 4311 struct hash<VULKAN_HPP_NAMESPACE::DisplayPowerInfoEXT> 4312 { operator ()std::hash4313 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPowerInfoEXT const & displayPowerInfoEXT ) const VULKAN_HPP_NOEXCEPT 4314 { 4315 std::size_t seed = 0; 4316 VULKAN_HPP_HASH_COMBINE( seed, displayPowerInfoEXT.sType ); 4317 VULKAN_HPP_HASH_COMBINE( seed, displayPowerInfoEXT.pNext ); 4318 VULKAN_HPP_HASH_COMBINE( seed, displayPowerInfoEXT.powerState ); 4319 return seed; 4320 } 4321 }; 4322 4323 template <> 4324 struct hash<VULKAN_HPP_NAMESPACE::DisplayPresentInfoKHR> 4325 { operator ()std::hash4326 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPresentInfoKHR const & displayPresentInfoKHR ) const VULKAN_HPP_NOEXCEPT 4327 { 4328 std::size_t seed = 0; 4329 VULKAN_HPP_HASH_COMBINE( seed, displayPresentInfoKHR.sType ); 4330 VULKAN_HPP_HASH_COMBINE( seed, displayPresentInfoKHR.pNext ); 4331 VULKAN_HPP_HASH_COMBINE( seed, displayPresentInfoKHR.srcRect ); 4332 VULKAN_HPP_HASH_COMBINE( seed, displayPresentInfoKHR.dstRect ); 4333 VULKAN_HPP_HASH_COMBINE( seed, displayPresentInfoKHR.persistent ); 4334 return seed; 4335 } 4336 }; 4337 4338 template <> 4339 struct hash<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR> 4340 { operator ()std::hash4341 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR const & displayPropertiesKHR ) const VULKAN_HPP_NOEXCEPT 4342 { 4343 std::size_t seed = 0; 4344 VULKAN_HPP_HASH_COMBINE( seed, displayPropertiesKHR.display ); 4345 for ( const char * p = displayPropertiesKHR.displayName; *p != '\0'; ++p ) 4346 { 4347 VULKAN_HPP_HASH_COMBINE( seed, *p ); 4348 } 4349 VULKAN_HPP_HASH_COMBINE( seed, displayPropertiesKHR.physicalDimensions ); 4350 VULKAN_HPP_HASH_COMBINE( seed, displayPropertiesKHR.physicalResolution ); 4351 VULKAN_HPP_HASH_COMBINE( seed, displayPropertiesKHR.supportedTransforms ); 4352 VULKAN_HPP_HASH_COMBINE( seed, displayPropertiesKHR.planeReorderPossible ); 4353 VULKAN_HPP_HASH_COMBINE( seed, displayPropertiesKHR.persistentContent ); 4354 return seed; 4355 } 4356 }; 4357 4358 template <> 4359 struct hash<VULKAN_HPP_NAMESPACE::DisplayProperties2KHR> 4360 { operator ()std::hash4361 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayProperties2KHR const & displayProperties2KHR ) const VULKAN_HPP_NOEXCEPT 4362 { 4363 std::size_t seed = 0; 4364 VULKAN_HPP_HASH_COMBINE( seed, displayProperties2KHR.sType ); 4365 VULKAN_HPP_HASH_COMBINE( seed, displayProperties2KHR.pNext ); 4366 VULKAN_HPP_HASH_COMBINE( seed, displayProperties2KHR.displayProperties ); 4367 return seed; 4368 } 4369 }; 4370 4371 template <> 4372 struct hash<VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR> 4373 { operator ()std::hash4374 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR const & displaySurfaceCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 4375 { 4376 std::size_t seed = 0; 4377 VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.sType ); 4378 VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.pNext ); 4379 VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.flags ); 4380 VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.displayMode ); 4381 VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.planeIndex ); 4382 VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.planeStackIndex ); 4383 VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.transform ); 4384 VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.globalAlpha ); 4385 VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.alphaMode ); 4386 VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.imageExtent ); 4387 return seed; 4388 } 4389 }; 4390 4391 template <> 4392 struct hash<VULKAN_HPP_NAMESPACE::DrawIndexedIndirectCommand> 4393 { operator ()std::hash4394 std::size_t operator()( VULKAN_HPP_NAMESPACE::DrawIndexedIndirectCommand const & drawIndexedIndirectCommand ) const VULKAN_HPP_NOEXCEPT 4395 { 4396 std::size_t seed = 0; 4397 VULKAN_HPP_HASH_COMBINE( seed, drawIndexedIndirectCommand.indexCount ); 4398 VULKAN_HPP_HASH_COMBINE( seed, drawIndexedIndirectCommand.instanceCount ); 4399 VULKAN_HPP_HASH_COMBINE( seed, drawIndexedIndirectCommand.firstIndex ); 4400 VULKAN_HPP_HASH_COMBINE( seed, drawIndexedIndirectCommand.vertexOffset ); 4401 VULKAN_HPP_HASH_COMBINE( seed, drawIndexedIndirectCommand.firstInstance ); 4402 return seed; 4403 } 4404 }; 4405 4406 template <> 4407 struct hash<VULKAN_HPP_NAMESPACE::DrawIndirectCommand> 4408 { operator ()std::hash4409 std::size_t operator()( VULKAN_HPP_NAMESPACE::DrawIndirectCommand const & drawIndirectCommand ) const VULKAN_HPP_NOEXCEPT 4410 { 4411 std::size_t seed = 0; 4412 VULKAN_HPP_HASH_COMBINE( seed, drawIndirectCommand.vertexCount ); 4413 VULKAN_HPP_HASH_COMBINE( seed, drawIndirectCommand.instanceCount ); 4414 VULKAN_HPP_HASH_COMBINE( seed, drawIndirectCommand.firstVertex ); 4415 VULKAN_HPP_HASH_COMBINE( seed, drawIndirectCommand.firstInstance ); 4416 return seed; 4417 } 4418 }; 4419 4420 template <> 4421 struct hash<VULKAN_HPP_NAMESPACE::DrawMeshTasksIndirectCommandEXT> 4422 { operator ()std::hash4423 std::size_t operator()( VULKAN_HPP_NAMESPACE::DrawMeshTasksIndirectCommandEXT const & drawMeshTasksIndirectCommandEXT ) const VULKAN_HPP_NOEXCEPT 4424 { 4425 std::size_t seed = 0; 4426 VULKAN_HPP_HASH_COMBINE( seed, drawMeshTasksIndirectCommandEXT.groupCountX ); 4427 VULKAN_HPP_HASH_COMBINE( seed, drawMeshTasksIndirectCommandEXT.groupCountY ); 4428 VULKAN_HPP_HASH_COMBINE( seed, drawMeshTasksIndirectCommandEXT.groupCountZ ); 4429 return seed; 4430 } 4431 }; 4432 4433 template <> 4434 struct hash<VULKAN_HPP_NAMESPACE::DrawMeshTasksIndirectCommandNV> 4435 { operator ()std::hash4436 std::size_t operator()( VULKAN_HPP_NAMESPACE::DrawMeshTasksIndirectCommandNV const & drawMeshTasksIndirectCommandNV ) const VULKAN_HPP_NOEXCEPT 4437 { 4438 std::size_t seed = 0; 4439 VULKAN_HPP_HASH_COMBINE( seed, drawMeshTasksIndirectCommandNV.taskCount ); 4440 VULKAN_HPP_HASH_COMBINE( seed, drawMeshTasksIndirectCommandNV.firstTask ); 4441 return seed; 4442 } 4443 }; 4444 4445 template <> 4446 struct hash<VULKAN_HPP_NAMESPACE::DrmFormatModifierProperties2EXT> 4447 { operator ()std::hash4448 std::size_t operator()( VULKAN_HPP_NAMESPACE::DrmFormatModifierProperties2EXT const & drmFormatModifierProperties2EXT ) const VULKAN_HPP_NOEXCEPT 4449 { 4450 std::size_t seed = 0; 4451 VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierProperties2EXT.drmFormatModifier ); 4452 VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierProperties2EXT.drmFormatModifierPlaneCount ); 4453 VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierProperties2EXT.drmFormatModifierTilingFeatures ); 4454 return seed; 4455 } 4456 }; 4457 4458 template <> 4459 struct hash<VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesEXT> 4460 { operator ()std::hash4461 std::size_t operator()( VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesEXT const & drmFormatModifierPropertiesEXT ) const VULKAN_HPP_NOEXCEPT 4462 { 4463 std::size_t seed = 0; 4464 VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesEXT.drmFormatModifier ); 4465 VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesEXT.drmFormatModifierPlaneCount ); 4466 VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesEXT.drmFormatModifierTilingFeatures ); 4467 return seed; 4468 } 4469 }; 4470 4471 template <> 4472 struct hash<VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesList2EXT> 4473 { operator ()std::hash4474 std::size_t operator()( VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesList2EXT const & drmFormatModifierPropertiesList2EXT ) const VULKAN_HPP_NOEXCEPT 4475 { 4476 std::size_t seed = 0; 4477 VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesList2EXT.sType ); 4478 VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesList2EXT.pNext ); 4479 VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesList2EXT.drmFormatModifierCount ); 4480 VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesList2EXT.pDrmFormatModifierProperties ); 4481 return seed; 4482 } 4483 }; 4484 4485 template <> 4486 struct hash<VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesListEXT> 4487 { operator ()std::hash4488 std::size_t operator()( VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesListEXT const & drmFormatModifierPropertiesListEXT ) const VULKAN_HPP_NOEXCEPT 4489 { 4490 std::size_t seed = 0; 4491 VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesListEXT.sType ); 4492 VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesListEXT.pNext ); 4493 VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesListEXT.drmFormatModifierCount ); 4494 VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesListEXT.pDrmFormatModifierProperties ); 4495 return seed; 4496 } 4497 }; 4498 4499 template <> 4500 struct hash<VULKAN_HPP_NAMESPACE::EventCreateInfo> 4501 { operator ()std::hash4502 std::size_t operator()( VULKAN_HPP_NAMESPACE::EventCreateInfo const & eventCreateInfo ) const VULKAN_HPP_NOEXCEPT 4503 { 4504 std::size_t seed = 0; 4505 VULKAN_HPP_HASH_COMBINE( seed, eventCreateInfo.sType ); 4506 VULKAN_HPP_HASH_COMBINE( seed, eventCreateInfo.pNext ); 4507 VULKAN_HPP_HASH_COMBINE( seed, eventCreateInfo.flags ); 4508 return seed; 4509 } 4510 }; 4511 4512 template <> 4513 struct hash<VULKAN_HPP_NAMESPACE::PipelineLibraryCreateInfoKHR> 4514 { operator ()std::hash4515 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineLibraryCreateInfoKHR const & pipelineLibraryCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 4516 { 4517 std::size_t seed = 0; 4518 VULKAN_HPP_HASH_COMBINE( seed, pipelineLibraryCreateInfoKHR.sType ); 4519 VULKAN_HPP_HASH_COMBINE( seed, pipelineLibraryCreateInfoKHR.pNext ); 4520 VULKAN_HPP_HASH_COMBINE( seed, pipelineLibraryCreateInfoKHR.libraryCount ); 4521 VULKAN_HPP_HASH_COMBINE( seed, pipelineLibraryCreateInfoKHR.pLibraries ); 4522 return seed; 4523 } 4524 }; 4525 4526 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 4527 template <> 4528 struct hash<VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX> 4529 { operator ()std::hash4530 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX const & executionGraphPipelineCreateInfoAMDX ) const VULKAN_HPP_NOEXCEPT 4531 { 4532 std::size_t seed = 0; 4533 VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineCreateInfoAMDX.sType ); 4534 VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineCreateInfoAMDX.pNext ); 4535 VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineCreateInfoAMDX.flags ); 4536 VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineCreateInfoAMDX.stageCount ); 4537 VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineCreateInfoAMDX.pStages ); 4538 VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineCreateInfoAMDX.pLibraryInfo ); 4539 VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineCreateInfoAMDX.layout ); 4540 VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineCreateInfoAMDX.basePipelineHandle ); 4541 VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineCreateInfoAMDX.basePipelineIndex ); 4542 return seed; 4543 } 4544 }; 4545 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 4546 4547 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 4548 template <> 4549 struct hash<VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineScratchSizeAMDX> 4550 { 4551 std::size_t operator ()std::hash4552 operator()( VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineScratchSizeAMDX const & executionGraphPipelineScratchSizeAMDX ) const VULKAN_HPP_NOEXCEPT 4553 { 4554 std::size_t seed = 0; 4555 VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineScratchSizeAMDX.sType ); 4556 VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineScratchSizeAMDX.pNext ); 4557 VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineScratchSizeAMDX.size ); 4558 return seed; 4559 } 4560 }; 4561 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 4562 4563 template <> 4564 struct hash<VULKAN_HPP_NAMESPACE::ExportFenceCreateInfo> 4565 { operator ()std::hash4566 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportFenceCreateInfo const & exportFenceCreateInfo ) const VULKAN_HPP_NOEXCEPT 4567 { 4568 std::size_t seed = 0; 4569 VULKAN_HPP_HASH_COMBINE( seed, exportFenceCreateInfo.sType ); 4570 VULKAN_HPP_HASH_COMBINE( seed, exportFenceCreateInfo.pNext ); 4571 VULKAN_HPP_HASH_COMBINE( seed, exportFenceCreateInfo.handleTypes ); 4572 return seed; 4573 } 4574 }; 4575 4576 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 4577 template <> 4578 struct hash<VULKAN_HPP_NAMESPACE::ExportFenceWin32HandleInfoKHR> 4579 { operator ()std::hash4580 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportFenceWin32HandleInfoKHR const & exportFenceWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT 4581 { 4582 std::size_t seed = 0; 4583 VULKAN_HPP_HASH_COMBINE( seed, exportFenceWin32HandleInfoKHR.sType ); 4584 VULKAN_HPP_HASH_COMBINE( seed, exportFenceWin32HandleInfoKHR.pNext ); 4585 VULKAN_HPP_HASH_COMBINE( seed, exportFenceWin32HandleInfoKHR.pAttributes ); 4586 VULKAN_HPP_HASH_COMBINE( seed, exportFenceWin32HandleInfoKHR.dwAccess ); 4587 VULKAN_HPP_HASH_COMBINE( seed, exportFenceWin32HandleInfoKHR.name ); 4588 return seed; 4589 } 4590 }; 4591 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 4592 4593 template <> 4594 struct hash<VULKAN_HPP_NAMESPACE::ExportMemoryAllocateInfo> 4595 { operator ()std::hash4596 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMemoryAllocateInfo const & exportMemoryAllocateInfo ) const VULKAN_HPP_NOEXCEPT 4597 { 4598 std::size_t seed = 0; 4599 VULKAN_HPP_HASH_COMBINE( seed, exportMemoryAllocateInfo.sType ); 4600 VULKAN_HPP_HASH_COMBINE( seed, exportMemoryAllocateInfo.pNext ); 4601 VULKAN_HPP_HASH_COMBINE( seed, exportMemoryAllocateInfo.handleTypes ); 4602 return seed; 4603 } 4604 }; 4605 4606 template <> 4607 struct hash<VULKAN_HPP_NAMESPACE::ExportMemoryAllocateInfoNV> 4608 { operator ()std::hash4609 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMemoryAllocateInfoNV const & exportMemoryAllocateInfoNV ) const VULKAN_HPP_NOEXCEPT 4610 { 4611 std::size_t seed = 0; 4612 VULKAN_HPP_HASH_COMBINE( seed, exportMemoryAllocateInfoNV.sType ); 4613 VULKAN_HPP_HASH_COMBINE( seed, exportMemoryAllocateInfoNV.pNext ); 4614 VULKAN_HPP_HASH_COMBINE( seed, exportMemoryAllocateInfoNV.handleTypes ); 4615 return seed; 4616 } 4617 }; 4618 4619 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 4620 template <> 4621 struct hash<VULKAN_HPP_NAMESPACE::ExportMemoryWin32HandleInfoKHR> 4622 { operator ()std::hash4623 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMemoryWin32HandleInfoKHR const & exportMemoryWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT 4624 { 4625 std::size_t seed = 0; 4626 VULKAN_HPP_HASH_COMBINE( seed, exportMemoryWin32HandleInfoKHR.sType ); 4627 VULKAN_HPP_HASH_COMBINE( seed, exportMemoryWin32HandleInfoKHR.pNext ); 4628 VULKAN_HPP_HASH_COMBINE( seed, exportMemoryWin32HandleInfoKHR.pAttributes ); 4629 VULKAN_HPP_HASH_COMBINE( seed, exportMemoryWin32HandleInfoKHR.dwAccess ); 4630 VULKAN_HPP_HASH_COMBINE( seed, exportMemoryWin32HandleInfoKHR.name ); 4631 return seed; 4632 } 4633 }; 4634 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 4635 4636 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 4637 template <> 4638 struct hash<VULKAN_HPP_NAMESPACE::ExportMemoryWin32HandleInfoNV> 4639 { operator ()std::hash4640 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMemoryWin32HandleInfoNV const & exportMemoryWin32HandleInfoNV ) const VULKAN_HPP_NOEXCEPT 4641 { 4642 std::size_t seed = 0; 4643 VULKAN_HPP_HASH_COMBINE( seed, exportMemoryWin32HandleInfoNV.sType ); 4644 VULKAN_HPP_HASH_COMBINE( seed, exportMemoryWin32HandleInfoNV.pNext ); 4645 VULKAN_HPP_HASH_COMBINE( seed, exportMemoryWin32HandleInfoNV.pAttributes ); 4646 VULKAN_HPP_HASH_COMBINE( seed, exportMemoryWin32HandleInfoNV.dwAccess ); 4647 return seed; 4648 } 4649 }; 4650 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 4651 4652 # if defined( VK_USE_PLATFORM_METAL_EXT ) 4653 template <> 4654 struct hash<VULKAN_HPP_NAMESPACE::ExportMetalBufferInfoEXT> 4655 { operator ()std::hash4656 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMetalBufferInfoEXT const & exportMetalBufferInfoEXT ) const VULKAN_HPP_NOEXCEPT 4657 { 4658 std::size_t seed = 0; 4659 VULKAN_HPP_HASH_COMBINE( seed, exportMetalBufferInfoEXT.sType ); 4660 VULKAN_HPP_HASH_COMBINE( seed, exportMetalBufferInfoEXT.pNext ); 4661 VULKAN_HPP_HASH_COMBINE( seed, exportMetalBufferInfoEXT.memory ); 4662 VULKAN_HPP_HASH_COMBINE( seed, exportMetalBufferInfoEXT.mtlBuffer ); 4663 return seed; 4664 } 4665 }; 4666 # endif /*VK_USE_PLATFORM_METAL_EXT*/ 4667 4668 # if defined( VK_USE_PLATFORM_METAL_EXT ) 4669 template <> 4670 struct hash<VULKAN_HPP_NAMESPACE::ExportMetalCommandQueueInfoEXT> 4671 { operator ()std::hash4672 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMetalCommandQueueInfoEXT const & exportMetalCommandQueueInfoEXT ) const VULKAN_HPP_NOEXCEPT 4673 { 4674 std::size_t seed = 0; 4675 VULKAN_HPP_HASH_COMBINE( seed, exportMetalCommandQueueInfoEXT.sType ); 4676 VULKAN_HPP_HASH_COMBINE( seed, exportMetalCommandQueueInfoEXT.pNext ); 4677 VULKAN_HPP_HASH_COMBINE( seed, exportMetalCommandQueueInfoEXT.queue ); 4678 VULKAN_HPP_HASH_COMBINE( seed, exportMetalCommandQueueInfoEXT.mtlCommandQueue ); 4679 return seed; 4680 } 4681 }; 4682 # endif /*VK_USE_PLATFORM_METAL_EXT*/ 4683 4684 # if defined( VK_USE_PLATFORM_METAL_EXT ) 4685 template <> 4686 struct hash<VULKAN_HPP_NAMESPACE::ExportMetalDeviceInfoEXT> 4687 { operator ()std::hash4688 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMetalDeviceInfoEXT const & exportMetalDeviceInfoEXT ) const VULKAN_HPP_NOEXCEPT 4689 { 4690 std::size_t seed = 0; 4691 VULKAN_HPP_HASH_COMBINE( seed, exportMetalDeviceInfoEXT.sType ); 4692 VULKAN_HPP_HASH_COMBINE( seed, exportMetalDeviceInfoEXT.pNext ); 4693 VULKAN_HPP_HASH_COMBINE( seed, exportMetalDeviceInfoEXT.mtlDevice ); 4694 return seed; 4695 } 4696 }; 4697 # endif /*VK_USE_PLATFORM_METAL_EXT*/ 4698 4699 # if defined( VK_USE_PLATFORM_METAL_EXT ) 4700 template <> 4701 struct hash<VULKAN_HPP_NAMESPACE::ExportMetalIOSurfaceInfoEXT> 4702 { operator ()std::hash4703 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMetalIOSurfaceInfoEXT const & exportMetalIOSurfaceInfoEXT ) const VULKAN_HPP_NOEXCEPT 4704 { 4705 std::size_t seed = 0; 4706 VULKAN_HPP_HASH_COMBINE( seed, exportMetalIOSurfaceInfoEXT.sType ); 4707 VULKAN_HPP_HASH_COMBINE( seed, exportMetalIOSurfaceInfoEXT.pNext ); 4708 VULKAN_HPP_HASH_COMBINE( seed, exportMetalIOSurfaceInfoEXT.image ); 4709 VULKAN_HPP_HASH_COMBINE( seed, exportMetalIOSurfaceInfoEXT.ioSurface ); 4710 return seed; 4711 } 4712 }; 4713 # endif /*VK_USE_PLATFORM_METAL_EXT*/ 4714 4715 # if defined( VK_USE_PLATFORM_METAL_EXT ) 4716 template <> 4717 struct hash<VULKAN_HPP_NAMESPACE::ExportMetalObjectCreateInfoEXT> 4718 { operator ()std::hash4719 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMetalObjectCreateInfoEXT const & exportMetalObjectCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 4720 { 4721 std::size_t seed = 0; 4722 VULKAN_HPP_HASH_COMBINE( seed, exportMetalObjectCreateInfoEXT.sType ); 4723 VULKAN_HPP_HASH_COMBINE( seed, exportMetalObjectCreateInfoEXT.pNext ); 4724 VULKAN_HPP_HASH_COMBINE( seed, exportMetalObjectCreateInfoEXT.exportObjectType ); 4725 return seed; 4726 } 4727 }; 4728 # endif /*VK_USE_PLATFORM_METAL_EXT*/ 4729 4730 # if defined( VK_USE_PLATFORM_METAL_EXT ) 4731 template <> 4732 struct hash<VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT> 4733 { operator ()std::hash4734 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT const & exportMetalObjectsInfoEXT ) const VULKAN_HPP_NOEXCEPT 4735 { 4736 std::size_t seed = 0; 4737 VULKAN_HPP_HASH_COMBINE( seed, exportMetalObjectsInfoEXT.sType ); 4738 VULKAN_HPP_HASH_COMBINE( seed, exportMetalObjectsInfoEXT.pNext ); 4739 return seed; 4740 } 4741 }; 4742 # endif /*VK_USE_PLATFORM_METAL_EXT*/ 4743 4744 # if defined( VK_USE_PLATFORM_METAL_EXT ) 4745 template <> 4746 struct hash<VULKAN_HPP_NAMESPACE::ExportMetalSharedEventInfoEXT> 4747 { operator ()std::hash4748 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMetalSharedEventInfoEXT const & exportMetalSharedEventInfoEXT ) const VULKAN_HPP_NOEXCEPT 4749 { 4750 std::size_t seed = 0; 4751 VULKAN_HPP_HASH_COMBINE( seed, exportMetalSharedEventInfoEXT.sType ); 4752 VULKAN_HPP_HASH_COMBINE( seed, exportMetalSharedEventInfoEXT.pNext ); 4753 VULKAN_HPP_HASH_COMBINE( seed, exportMetalSharedEventInfoEXT.semaphore ); 4754 VULKAN_HPP_HASH_COMBINE( seed, exportMetalSharedEventInfoEXT.event ); 4755 VULKAN_HPP_HASH_COMBINE( seed, exportMetalSharedEventInfoEXT.mtlSharedEvent ); 4756 return seed; 4757 } 4758 }; 4759 # endif /*VK_USE_PLATFORM_METAL_EXT*/ 4760 4761 # if defined( VK_USE_PLATFORM_METAL_EXT ) 4762 template <> 4763 struct hash<VULKAN_HPP_NAMESPACE::ExportMetalTextureInfoEXT> 4764 { operator ()std::hash4765 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMetalTextureInfoEXT const & exportMetalTextureInfoEXT ) const VULKAN_HPP_NOEXCEPT 4766 { 4767 std::size_t seed = 0; 4768 VULKAN_HPP_HASH_COMBINE( seed, exportMetalTextureInfoEXT.sType ); 4769 VULKAN_HPP_HASH_COMBINE( seed, exportMetalTextureInfoEXT.pNext ); 4770 VULKAN_HPP_HASH_COMBINE( seed, exportMetalTextureInfoEXT.image ); 4771 VULKAN_HPP_HASH_COMBINE( seed, exportMetalTextureInfoEXT.imageView ); 4772 VULKAN_HPP_HASH_COMBINE( seed, exportMetalTextureInfoEXT.bufferView ); 4773 VULKAN_HPP_HASH_COMBINE( seed, exportMetalTextureInfoEXT.plane ); 4774 VULKAN_HPP_HASH_COMBINE( seed, exportMetalTextureInfoEXT.mtlTexture ); 4775 return seed; 4776 } 4777 }; 4778 # endif /*VK_USE_PLATFORM_METAL_EXT*/ 4779 4780 template <> 4781 struct hash<VULKAN_HPP_NAMESPACE::ExportSemaphoreCreateInfo> 4782 { operator ()std::hash4783 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportSemaphoreCreateInfo const & exportSemaphoreCreateInfo ) const VULKAN_HPP_NOEXCEPT 4784 { 4785 std::size_t seed = 0; 4786 VULKAN_HPP_HASH_COMBINE( seed, exportSemaphoreCreateInfo.sType ); 4787 VULKAN_HPP_HASH_COMBINE( seed, exportSemaphoreCreateInfo.pNext ); 4788 VULKAN_HPP_HASH_COMBINE( seed, exportSemaphoreCreateInfo.handleTypes ); 4789 return seed; 4790 } 4791 }; 4792 4793 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 4794 template <> 4795 struct hash<VULKAN_HPP_NAMESPACE::ExportSemaphoreWin32HandleInfoKHR> 4796 { operator ()std::hash4797 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportSemaphoreWin32HandleInfoKHR const & exportSemaphoreWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT 4798 { 4799 std::size_t seed = 0; 4800 VULKAN_HPP_HASH_COMBINE( seed, exportSemaphoreWin32HandleInfoKHR.sType ); 4801 VULKAN_HPP_HASH_COMBINE( seed, exportSemaphoreWin32HandleInfoKHR.pNext ); 4802 VULKAN_HPP_HASH_COMBINE( seed, exportSemaphoreWin32HandleInfoKHR.pAttributes ); 4803 VULKAN_HPP_HASH_COMBINE( seed, exportSemaphoreWin32HandleInfoKHR.dwAccess ); 4804 VULKAN_HPP_HASH_COMBINE( seed, exportSemaphoreWin32HandleInfoKHR.name ); 4805 return seed; 4806 } 4807 }; 4808 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 4809 4810 template <> 4811 struct hash<VULKAN_HPP_NAMESPACE::ExtensionProperties> 4812 { operator ()std::hash4813 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExtensionProperties const & extensionProperties ) const VULKAN_HPP_NOEXCEPT 4814 { 4815 std::size_t seed = 0; 4816 for ( size_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i ) 4817 { 4818 VULKAN_HPP_HASH_COMBINE( seed, extensionProperties.extensionName[i] ); 4819 } 4820 VULKAN_HPP_HASH_COMBINE( seed, extensionProperties.specVersion ); 4821 return seed; 4822 } 4823 }; 4824 4825 template <> 4826 struct hash<VULKAN_HPP_NAMESPACE::ExternalMemoryProperties> 4827 { operator ()std::hash4828 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalMemoryProperties const & externalMemoryProperties ) const VULKAN_HPP_NOEXCEPT 4829 { 4830 std::size_t seed = 0; 4831 VULKAN_HPP_HASH_COMBINE( seed, externalMemoryProperties.externalMemoryFeatures ); 4832 VULKAN_HPP_HASH_COMBINE( seed, externalMemoryProperties.exportFromImportedHandleTypes ); 4833 VULKAN_HPP_HASH_COMBINE( seed, externalMemoryProperties.compatibleHandleTypes ); 4834 return seed; 4835 } 4836 }; 4837 4838 template <> 4839 struct hash<VULKAN_HPP_NAMESPACE::ExternalBufferProperties> 4840 { operator ()std::hash4841 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalBufferProperties const & externalBufferProperties ) const VULKAN_HPP_NOEXCEPT 4842 { 4843 std::size_t seed = 0; 4844 VULKAN_HPP_HASH_COMBINE( seed, externalBufferProperties.sType ); 4845 VULKAN_HPP_HASH_COMBINE( seed, externalBufferProperties.pNext ); 4846 VULKAN_HPP_HASH_COMBINE( seed, externalBufferProperties.externalMemoryProperties ); 4847 return seed; 4848 } 4849 }; 4850 4851 template <> 4852 struct hash<VULKAN_HPP_NAMESPACE::ExternalFenceProperties> 4853 { operator ()std::hash4854 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalFenceProperties const & externalFenceProperties ) const VULKAN_HPP_NOEXCEPT 4855 { 4856 std::size_t seed = 0; 4857 VULKAN_HPP_HASH_COMBINE( seed, externalFenceProperties.sType ); 4858 VULKAN_HPP_HASH_COMBINE( seed, externalFenceProperties.pNext ); 4859 VULKAN_HPP_HASH_COMBINE( seed, externalFenceProperties.exportFromImportedHandleTypes ); 4860 VULKAN_HPP_HASH_COMBINE( seed, externalFenceProperties.compatibleHandleTypes ); 4861 VULKAN_HPP_HASH_COMBINE( seed, externalFenceProperties.externalFenceFeatures ); 4862 return seed; 4863 } 4864 }; 4865 4866 # if defined( VK_USE_PLATFORM_ANDROID_KHR ) 4867 template <> 4868 struct hash<VULKAN_HPP_NAMESPACE::ExternalFormatANDROID> 4869 { operator ()std::hash4870 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalFormatANDROID const & externalFormatANDROID ) const VULKAN_HPP_NOEXCEPT 4871 { 4872 std::size_t seed = 0; 4873 VULKAN_HPP_HASH_COMBINE( seed, externalFormatANDROID.sType ); 4874 VULKAN_HPP_HASH_COMBINE( seed, externalFormatANDROID.pNext ); 4875 VULKAN_HPP_HASH_COMBINE( seed, externalFormatANDROID.externalFormat ); 4876 return seed; 4877 } 4878 }; 4879 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ 4880 4881 # if defined( VK_USE_PLATFORM_SCREEN_QNX ) 4882 template <> 4883 struct hash<VULKAN_HPP_NAMESPACE::ExternalFormatQNX> 4884 { operator ()std::hash4885 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalFormatQNX const & externalFormatQNX ) const VULKAN_HPP_NOEXCEPT 4886 { 4887 std::size_t seed = 0; 4888 VULKAN_HPP_HASH_COMBINE( seed, externalFormatQNX.sType ); 4889 VULKAN_HPP_HASH_COMBINE( seed, externalFormatQNX.pNext ); 4890 VULKAN_HPP_HASH_COMBINE( seed, externalFormatQNX.externalFormat ); 4891 return seed; 4892 } 4893 }; 4894 # endif /*VK_USE_PLATFORM_SCREEN_QNX*/ 4895 4896 template <> 4897 struct hash<VULKAN_HPP_NAMESPACE::ExternalImageFormatProperties> 4898 { operator ()std::hash4899 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalImageFormatProperties const & externalImageFormatProperties ) const VULKAN_HPP_NOEXCEPT 4900 { 4901 std::size_t seed = 0; 4902 VULKAN_HPP_HASH_COMBINE( seed, externalImageFormatProperties.sType ); 4903 VULKAN_HPP_HASH_COMBINE( seed, externalImageFormatProperties.pNext ); 4904 VULKAN_HPP_HASH_COMBINE( seed, externalImageFormatProperties.externalMemoryProperties ); 4905 return seed; 4906 } 4907 }; 4908 4909 template <> 4910 struct hash<VULKAN_HPP_NAMESPACE::ImageFormatProperties> 4911 { operator ()std::hash4912 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageFormatProperties const & imageFormatProperties ) const VULKAN_HPP_NOEXCEPT 4913 { 4914 std::size_t seed = 0; 4915 VULKAN_HPP_HASH_COMBINE( seed, imageFormatProperties.maxExtent ); 4916 VULKAN_HPP_HASH_COMBINE( seed, imageFormatProperties.maxMipLevels ); 4917 VULKAN_HPP_HASH_COMBINE( seed, imageFormatProperties.maxArrayLayers ); 4918 VULKAN_HPP_HASH_COMBINE( seed, imageFormatProperties.sampleCounts ); 4919 VULKAN_HPP_HASH_COMBINE( seed, imageFormatProperties.maxResourceSize ); 4920 return seed; 4921 } 4922 }; 4923 4924 template <> 4925 struct hash<VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV> 4926 { operator ()std::hash4927 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV const & externalImageFormatPropertiesNV ) const VULKAN_HPP_NOEXCEPT 4928 { 4929 std::size_t seed = 0; 4930 VULKAN_HPP_HASH_COMBINE( seed, externalImageFormatPropertiesNV.imageFormatProperties ); 4931 VULKAN_HPP_HASH_COMBINE( seed, externalImageFormatPropertiesNV.externalMemoryFeatures ); 4932 VULKAN_HPP_HASH_COMBINE( seed, externalImageFormatPropertiesNV.exportFromImportedHandleTypes ); 4933 VULKAN_HPP_HASH_COMBINE( seed, externalImageFormatPropertiesNV.compatibleHandleTypes ); 4934 return seed; 4935 } 4936 }; 4937 4938 template <> 4939 struct hash<VULKAN_HPP_NAMESPACE::ExternalMemoryAcquireUnmodifiedEXT> 4940 { operator ()std::hash4941 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalMemoryAcquireUnmodifiedEXT const & externalMemoryAcquireUnmodifiedEXT ) const VULKAN_HPP_NOEXCEPT 4942 { 4943 std::size_t seed = 0; 4944 VULKAN_HPP_HASH_COMBINE( seed, externalMemoryAcquireUnmodifiedEXT.sType ); 4945 VULKAN_HPP_HASH_COMBINE( seed, externalMemoryAcquireUnmodifiedEXT.pNext ); 4946 VULKAN_HPP_HASH_COMBINE( seed, externalMemoryAcquireUnmodifiedEXT.acquireUnmodifiedMemory ); 4947 return seed; 4948 } 4949 }; 4950 4951 template <> 4952 struct hash<VULKAN_HPP_NAMESPACE::ExternalMemoryBufferCreateInfo> 4953 { operator ()std::hash4954 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalMemoryBufferCreateInfo const & externalMemoryBufferCreateInfo ) const VULKAN_HPP_NOEXCEPT 4955 { 4956 std::size_t seed = 0; 4957 VULKAN_HPP_HASH_COMBINE( seed, externalMemoryBufferCreateInfo.sType ); 4958 VULKAN_HPP_HASH_COMBINE( seed, externalMemoryBufferCreateInfo.pNext ); 4959 VULKAN_HPP_HASH_COMBINE( seed, externalMemoryBufferCreateInfo.handleTypes ); 4960 return seed; 4961 } 4962 }; 4963 4964 template <> 4965 struct hash<VULKAN_HPP_NAMESPACE::ExternalMemoryImageCreateInfo> 4966 { operator ()std::hash4967 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalMemoryImageCreateInfo const & externalMemoryImageCreateInfo ) const VULKAN_HPP_NOEXCEPT 4968 { 4969 std::size_t seed = 0; 4970 VULKAN_HPP_HASH_COMBINE( seed, externalMemoryImageCreateInfo.sType ); 4971 VULKAN_HPP_HASH_COMBINE( seed, externalMemoryImageCreateInfo.pNext ); 4972 VULKAN_HPP_HASH_COMBINE( seed, externalMemoryImageCreateInfo.handleTypes ); 4973 return seed; 4974 } 4975 }; 4976 4977 template <> 4978 struct hash<VULKAN_HPP_NAMESPACE::ExternalMemoryImageCreateInfoNV> 4979 { operator ()std::hash4980 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalMemoryImageCreateInfoNV const & externalMemoryImageCreateInfoNV ) const VULKAN_HPP_NOEXCEPT 4981 { 4982 std::size_t seed = 0; 4983 VULKAN_HPP_HASH_COMBINE( seed, externalMemoryImageCreateInfoNV.sType ); 4984 VULKAN_HPP_HASH_COMBINE( seed, externalMemoryImageCreateInfoNV.pNext ); 4985 VULKAN_HPP_HASH_COMBINE( seed, externalMemoryImageCreateInfoNV.handleTypes ); 4986 return seed; 4987 } 4988 }; 4989 4990 template <> 4991 struct hash<VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties> 4992 { operator ()std::hash4993 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties const & externalSemaphoreProperties ) const VULKAN_HPP_NOEXCEPT 4994 { 4995 std::size_t seed = 0; 4996 VULKAN_HPP_HASH_COMBINE( seed, externalSemaphoreProperties.sType ); 4997 VULKAN_HPP_HASH_COMBINE( seed, externalSemaphoreProperties.pNext ); 4998 VULKAN_HPP_HASH_COMBINE( seed, externalSemaphoreProperties.exportFromImportedHandleTypes ); 4999 VULKAN_HPP_HASH_COMBINE( seed, externalSemaphoreProperties.compatibleHandleTypes ); 5000 VULKAN_HPP_HASH_COMBINE( seed, externalSemaphoreProperties.externalSemaphoreFeatures ); 5001 return seed; 5002 } 5003 }; 5004 5005 template <> 5006 struct hash<VULKAN_HPP_NAMESPACE::FenceCreateInfo> 5007 { operator ()std::hash5008 std::size_t operator()( VULKAN_HPP_NAMESPACE::FenceCreateInfo const & fenceCreateInfo ) const VULKAN_HPP_NOEXCEPT 5009 { 5010 std::size_t seed = 0; 5011 VULKAN_HPP_HASH_COMBINE( seed, fenceCreateInfo.sType ); 5012 VULKAN_HPP_HASH_COMBINE( seed, fenceCreateInfo.pNext ); 5013 VULKAN_HPP_HASH_COMBINE( seed, fenceCreateInfo.flags ); 5014 return seed; 5015 } 5016 }; 5017 5018 template <> 5019 struct hash<VULKAN_HPP_NAMESPACE::FenceGetFdInfoKHR> 5020 { operator ()std::hash5021 std::size_t operator()( VULKAN_HPP_NAMESPACE::FenceGetFdInfoKHR const & fenceGetFdInfoKHR ) const VULKAN_HPP_NOEXCEPT 5022 { 5023 std::size_t seed = 0; 5024 VULKAN_HPP_HASH_COMBINE( seed, fenceGetFdInfoKHR.sType ); 5025 VULKAN_HPP_HASH_COMBINE( seed, fenceGetFdInfoKHR.pNext ); 5026 VULKAN_HPP_HASH_COMBINE( seed, fenceGetFdInfoKHR.fence ); 5027 VULKAN_HPP_HASH_COMBINE( seed, fenceGetFdInfoKHR.handleType ); 5028 return seed; 5029 } 5030 }; 5031 5032 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 5033 template <> 5034 struct hash<VULKAN_HPP_NAMESPACE::FenceGetWin32HandleInfoKHR> 5035 { operator ()std::hash5036 std::size_t operator()( VULKAN_HPP_NAMESPACE::FenceGetWin32HandleInfoKHR const & fenceGetWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT 5037 { 5038 std::size_t seed = 0; 5039 VULKAN_HPP_HASH_COMBINE( seed, fenceGetWin32HandleInfoKHR.sType ); 5040 VULKAN_HPP_HASH_COMBINE( seed, fenceGetWin32HandleInfoKHR.pNext ); 5041 VULKAN_HPP_HASH_COMBINE( seed, fenceGetWin32HandleInfoKHR.fence ); 5042 VULKAN_HPP_HASH_COMBINE( seed, fenceGetWin32HandleInfoKHR.handleType ); 5043 return seed; 5044 } 5045 }; 5046 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 5047 5048 template <> 5049 struct hash<VULKAN_HPP_NAMESPACE::FilterCubicImageViewImageFormatPropertiesEXT> 5050 { operator ()std::hash5051 std::size_t operator()( VULKAN_HPP_NAMESPACE::FilterCubicImageViewImageFormatPropertiesEXT const & filterCubicImageViewImageFormatPropertiesEXT ) const 5052 VULKAN_HPP_NOEXCEPT 5053 { 5054 std::size_t seed = 0; 5055 VULKAN_HPP_HASH_COMBINE( seed, filterCubicImageViewImageFormatPropertiesEXT.sType ); 5056 VULKAN_HPP_HASH_COMBINE( seed, filterCubicImageViewImageFormatPropertiesEXT.pNext ); 5057 VULKAN_HPP_HASH_COMBINE( seed, filterCubicImageViewImageFormatPropertiesEXT.filterCubic ); 5058 VULKAN_HPP_HASH_COMBINE( seed, filterCubicImageViewImageFormatPropertiesEXT.filterCubicMinmax ); 5059 return seed; 5060 } 5061 }; 5062 5063 template <> 5064 struct hash<VULKAN_HPP_NAMESPACE::FormatProperties> 5065 { operator ()std::hash5066 std::size_t operator()( VULKAN_HPP_NAMESPACE::FormatProperties const & formatProperties ) const VULKAN_HPP_NOEXCEPT 5067 { 5068 std::size_t seed = 0; 5069 VULKAN_HPP_HASH_COMBINE( seed, formatProperties.linearTilingFeatures ); 5070 VULKAN_HPP_HASH_COMBINE( seed, formatProperties.optimalTilingFeatures ); 5071 VULKAN_HPP_HASH_COMBINE( seed, formatProperties.bufferFeatures ); 5072 return seed; 5073 } 5074 }; 5075 5076 template <> 5077 struct hash<VULKAN_HPP_NAMESPACE::FormatProperties2> 5078 { operator ()std::hash5079 std::size_t operator()( VULKAN_HPP_NAMESPACE::FormatProperties2 const & formatProperties2 ) const VULKAN_HPP_NOEXCEPT 5080 { 5081 std::size_t seed = 0; 5082 VULKAN_HPP_HASH_COMBINE( seed, formatProperties2.sType ); 5083 VULKAN_HPP_HASH_COMBINE( seed, formatProperties2.pNext ); 5084 VULKAN_HPP_HASH_COMBINE( seed, formatProperties2.formatProperties ); 5085 return seed; 5086 } 5087 }; 5088 5089 template <> 5090 struct hash<VULKAN_HPP_NAMESPACE::FormatProperties3> 5091 { operator ()std::hash5092 std::size_t operator()( VULKAN_HPP_NAMESPACE::FormatProperties3 const & formatProperties3 ) const VULKAN_HPP_NOEXCEPT 5093 { 5094 std::size_t seed = 0; 5095 VULKAN_HPP_HASH_COMBINE( seed, formatProperties3.sType ); 5096 VULKAN_HPP_HASH_COMBINE( seed, formatProperties3.pNext ); 5097 VULKAN_HPP_HASH_COMBINE( seed, formatProperties3.linearTilingFeatures ); 5098 VULKAN_HPP_HASH_COMBINE( seed, formatProperties3.optimalTilingFeatures ); 5099 VULKAN_HPP_HASH_COMBINE( seed, formatProperties3.bufferFeatures ); 5100 return seed; 5101 } 5102 }; 5103 5104 template <> 5105 struct hash<VULKAN_HPP_NAMESPACE::FragmentShadingRateAttachmentInfoKHR> 5106 { operator ()std::hash5107 std::size_t operator()( VULKAN_HPP_NAMESPACE::FragmentShadingRateAttachmentInfoKHR const & fragmentShadingRateAttachmentInfoKHR ) const VULKAN_HPP_NOEXCEPT 5108 { 5109 std::size_t seed = 0; 5110 VULKAN_HPP_HASH_COMBINE( seed, fragmentShadingRateAttachmentInfoKHR.sType ); 5111 VULKAN_HPP_HASH_COMBINE( seed, fragmentShadingRateAttachmentInfoKHR.pNext ); 5112 VULKAN_HPP_HASH_COMBINE( seed, fragmentShadingRateAttachmentInfoKHR.pFragmentShadingRateAttachment ); 5113 VULKAN_HPP_HASH_COMBINE( seed, fragmentShadingRateAttachmentInfoKHR.shadingRateAttachmentTexelSize ); 5114 return seed; 5115 } 5116 }; 5117 5118 template <> 5119 struct hash<VULKAN_HPP_NAMESPACE::FrameBoundaryEXT> 5120 { operator ()std::hash5121 std::size_t operator()( VULKAN_HPP_NAMESPACE::FrameBoundaryEXT const & frameBoundaryEXT ) const VULKAN_HPP_NOEXCEPT 5122 { 5123 std::size_t seed = 0; 5124 VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.sType ); 5125 VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.pNext ); 5126 VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.flags ); 5127 VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.frameID ); 5128 VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.imageCount ); 5129 VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.pImages ); 5130 VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.bufferCount ); 5131 VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.pBuffers ); 5132 VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.tagName ); 5133 VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.tagSize ); 5134 VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.pTag ); 5135 return seed; 5136 } 5137 }; 5138 5139 template <> 5140 struct hash<VULKAN_HPP_NAMESPACE::FramebufferAttachmentImageInfo> 5141 { operator ()std::hash5142 std::size_t operator()( VULKAN_HPP_NAMESPACE::FramebufferAttachmentImageInfo const & framebufferAttachmentImageInfo ) const VULKAN_HPP_NOEXCEPT 5143 { 5144 std::size_t seed = 0; 5145 VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentImageInfo.sType ); 5146 VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentImageInfo.pNext ); 5147 VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentImageInfo.flags ); 5148 VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentImageInfo.usage ); 5149 VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentImageInfo.width ); 5150 VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentImageInfo.height ); 5151 VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentImageInfo.layerCount ); 5152 VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentImageInfo.viewFormatCount ); 5153 VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentImageInfo.pViewFormats ); 5154 return seed; 5155 } 5156 }; 5157 5158 template <> 5159 struct hash<VULKAN_HPP_NAMESPACE::FramebufferAttachmentsCreateInfo> 5160 { operator ()std::hash5161 std::size_t operator()( VULKAN_HPP_NAMESPACE::FramebufferAttachmentsCreateInfo const & framebufferAttachmentsCreateInfo ) const VULKAN_HPP_NOEXCEPT 5162 { 5163 std::size_t seed = 0; 5164 VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentsCreateInfo.sType ); 5165 VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentsCreateInfo.pNext ); 5166 VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentsCreateInfo.attachmentImageInfoCount ); 5167 VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentsCreateInfo.pAttachmentImageInfos ); 5168 return seed; 5169 } 5170 }; 5171 5172 template <> 5173 struct hash<VULKAN_HPP_NAMESPACE::FramebufferCreateInfo> 5174 { operator ()std::hash5175 std::size_t operator()( VULKAN_HPP_NAMESPACE::FramebufferCreateInfo const & framebufferCreateInfo ) const VULKAN_HPP_NOEXCEPT 5176 { 5177 std::size_t seed = 0; 5178 VULKAN_HPP_HASH_COMBINE( seed, framebufferCreateInfo.sType ); 5179 VULKAN_HPP_HASH_COMBINE( seed, framebufferCreateInfo.pNext ); 5180 VULKAN_HPP_HASH_COMBINE( seed, framebufferCreateInfo.flags ); 5181 VULKAN_HPP_HASH_COMBINE( seed, framebufferCreateInfo.renderPass ); 5182 VULKAN_HPP_HASH_COMBINE( seed, framebufferCreateInfo.attachmentCount ); 5183 VULKAN_HPP_HASH_COMBINE( seed, framebufferCreateInfo.pAttachments ); 5184 VULKAN_HPP_HASH_COMBINE( seed, framebufferCreateInfo.width ); 5185 VULKAN_HPP_HASH_COMBINE( seed, framebufferCreateInfo.height ); 5186 VULKAN_HPP_HASH_COMBINE( seed, framebufferCreateInfo.layers ); 5187 return seed; 5188 } 5189 }; 5190 5191 template <> 5192 struct hash<VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV> 5193 { operator ()std::hash5194 std::size_t operator()( VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV const & framebufferMixedSamplesCombinationNV ) const VULKAN_HPP_NOEXCEPT 5195 { 5196 std::size_t seed = 0; 5197 VULKAN_HPP_HASH_COMBINE( seed, framebufferMixedSamplesCombinationNV.sType ); 5198 VULKAN_HPP_HASH_COMBINE( seed, framebufferMixedSamplesCombinationNV.pNext ); 5199 VULKAN_HPP_HASH_COMBINE( seed, framebufferMixedSamplesCombinationNV.coverageReductionMode ); 5200 VULKAN_HPP_HASH_COMBINE( seed, framebufferMixedSamplesCombinationNV.rasterizationSamples ); 5201 VULKAN_HPP_HASH_COMBINE( seed, framebufferMixedSamplesCombinationNV.depthStencilSamples ); 5202 VULKAN_HPP_HASH_COMBINE( seed, framebufferMixedSamplesCombinationNV.colorSamples ); 5203 return seed; 5204 } 5205 }; 5206 5207 template <> 5208 struct hash<VULKAN_HPP_NAMESPACE::IndirectCommandsStreamNV> 5209 { operator ()std::hash5210 std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectCommandsStreamNV const & indirectCommandsStreamNV ) const VULKAN_HPP_NOEXCEPT 5211 { 5212 std::size_t seed = 0; 5213 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsStreamNV.buffer ); 5214 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsStreamNV.offset ); 5215 return seed; 5216 } 5217 }; 5218 5219 template <> 5220 struct hash<VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV> 5221 { operator ()std::hash5222 std::size_t operator()( VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV const & generatedCommandsInfoNV ) const VULKAN_HPP_NOEXCEPT 5223 { 5224 std::size_t seed = 0; 5225 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.sType ); 5226 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.pNext ); 5227 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.pipelineBindPoint ); 5228 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.pipeline ); 5229 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.indirectCommandsLayout ); 5230 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.streamCount ); 5231 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.pStreams ); 5232 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.sequencesCount ); 5233 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.preprocessBuffer ); 5234 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.preprocessOffset ); 5235 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.preprocessSize ); 5236 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.sequencesCountBuffer ); 5237 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.sequencesCountOffset ); 5238 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.sequencesIndexBuffer ); 5239 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.sequencesIndexOffset ); 5240 return seed; 5241 } 5242 }; 5243 5244 template <> 5245 struct hash<VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV> 5246 { 5247 std::size_t operator ()std::hash5248 operator()( VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV const & generatedCommandsMemoryRequirementsInfoNV ) const VULKAN_HPP_NOEXCEPT 5249 { 5250 std::size_t seed = 0; 5251 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsMemoryRequirementsInfoNV.sType ); 5252 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsMemoryRequirementsInfoNV.pNext ); 5253 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsMemoryRequirementsInfoNV.pipelineBindPoint ); 5254 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsMemoryRequirementsInfoNV.pipeline ); 5255 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsMemoryRequirementsInfoNV.indirectCommandsLayout ); 5256 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsMemoryRequirementsInfoNV.maxSequencesCount ); 5257 return seed; 5258 } 5259 }; 5260 5261 template <> 5262 struct hash<VULKAN_HPP_NAMESPACE::LatencyTimingsFrameReportNV> 5263 { operator ()std::hash5264 std::size_t operator()( VULKAN_HPP_NAMESPACE::LatencyTimingsFrameReportNV const & latencyTimingsFrameReportNV ) const VULKAN_HPP_NOEXCEPT 5265 { 5266 std::size_t seed = 0; 5267 VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.sType ); 5268 VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.pNext ); 5269 VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.presentID ); 5270 VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.inputSampleTimeUs ); 5271 VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.simStartTimeUs ); 5272 VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.simEndTimeUs ); 5273 VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.renderSubmitStartTimeUs ); 5274 VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.renderSubmitEndTimeUs ); 5275 VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.presentStartTimeUs ); 5276 VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.presentEndTimeUs ); 5277 VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.driverStartTimeUs ); 5278 VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.driverEndTimeUs ); 5279 VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.osRenderQueueStartTimeUs ); 5280 VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.osRenderQueueEndTimeUs ); 5281 VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.gpuRenderStartTimeUs ); 5282 VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.gpuRenderEndTimeUs ); 5283 return seed; 5284 } 5285 }; 5286 5287 template <> 5288 struct hash<VULKAN_HPP_NAMESPACE::GetLatencyMarkerInfoNV> 5289 { operator ()std::hash5290 std::size_t operator()( VULKAN_HPP_NAMESPACE::GetLatencyMarkerInfoNV const & getLatencyMarkerInfoNV ) const VULKAN_HPP_NOEXCEPT 5291 { 5292 std::size_t seed = 0; 5293 VULKAN_HPP_HASH_COMBINE( seed, getLatencyMarkerInfoNV.sType ); 5294 VULKAN_HPP_HASH_COMBINE( seed, getLatencyMarkerInfoNV.pNext ); 5295 VULKAN_HPP_HASH_COMBINE( seed, getLatencyMarkerInfoNV.timingCount ); 5296 VULKAN_HPP_HASH_COMBINE( seed, getLatencyMarkerInfoNV.pTimings ); 5297 return seed; 5298 } 5299 }; 5300 5301 template <> 5302 struct hash<VULKAN_HPP_NAMESPACE::VertexInputBindingDescription> 5303 { operator ()std::hash5304 std::size_t operator()( VULKAN_HPP_NAMESPACE::VertexInputBindingDescription const & vertexInputBindingDescription ) const VULKAN_HPP_NOEXCEPT 5305 { 5306 std::size_t seed = 0; 5307 VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDescription.binding ); 5308 VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDescription.stride ); 5309 VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDescription.inputRate ); 5310 return seed; 5311 } 5312 }; 5313 5314 template <> 5315 struct hash<VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription> 5316 { operator ()std::hash5317 std::size_t operator()( VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription const & vertexInputAttributeDescription ) const VULKAN_HPP_NOEXCEPT 5318 { 5319 std::size_t seed = 0; 5320 VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription.location ); 5321 VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription.binding ); 5322 VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription.format ); 5323 VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription.offset ); 5324 return seed; 5325 } 5326 }; 5327 5328 template <> 5329 struct hash<VULKAN_HPP_NAMESPACE::PipelineVertexInputStateCreateInfo> 5330 { operator ()std::hash5331 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineVertexInputStateCreateInfo const & pipelineVertexInputStateCreateInfo ) const VULKAN_HPP_NOEXCEPT 5332 { 5333 std::size_t seed = 0; 5334 VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputStateCreateInfo.sType ); 5335 VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputStateCreateInfo.pNext ); 5336 VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputStateCreateInfo.flags ); 5337 VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputStateCreateInfo.vertexBindingDescriptionCount ); 5338 VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputStateCreateInfo.pVertexBindingDescriptions ); 5339 VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputStateCreateInfo.vertexAttributeDescriptionCount ); 5340 VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputStateCreateInfo.pVertexAttributeDescriptions ); 5341 return seed; 5342 } 5343 }; 5344 5345 template <> 5346 struct hash<VULKAN_HPP_NAMESPACE::PipelineInputAssemblyStateCreateInfo> 5347 { operator ()std::hash5348 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineInputAssemblyStateCreateInfo const & pipelineInputAssemblyStateCreateInfo ) const VULKAN_HPP_NOEXCEPT 5349 { 5350 std::size_t seed = 0; 5351 VULKAN_HPP_HASH_COMBINE( seed, pipelineInputAssemblyStateCreateInfo.sType ); 5352 VULKAN_HPP_HASH_COMBINE( seed, pipelineInputAssemblyStateCreateInfo.pNext ); 5353 VULKAN_HPP_HASH_COMBINE( seed, pipelineInputAssemblyStateCreateInfo.flags ); 5354 VULKAN_HPP_HASH_COMBINE( seed, pipelineInputAssemblyStateCreateInfo.topology ); 5355 VULKAN_HPP_HASH_COMBINE( seed, pipelineInputAssemblyStateCreateInfo.primitiveRestartEnable ); 5356 return seed; 5357 } 5358 }; 5359 5360 template <> 5361 struct hash<VULKAN_HPP_NAMESPACE::PipelineTessellationStateCreateInfo> 5362 { operator ()std::hash5363 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineTessellationStateCreateInfo const & pipelineTessellationStateCreateInfo ) const VULKAN_HPP_NOEXCEPT 5364 { 5365 std::size_t seed = 0; 5366 VULKAN_HPP_HASH_COMBINE( seed, pipelineTessellationStateCreateInfo.sType ); 5367 VULKAN_HPP_HASH_COMBINE( seed, pipelineTessellationStateCreateInfo.pNext ); 5368 VULKAN_HPP_HASH_COMBINE( seed, pipelineTessellationStateCreateInfo.flags ); 5369 VULKAN_HPP_HASH_COMBINE( seed, pipelineTessellationStateCreateInfo.patchControlPoints ); 5370 return seed; 5371 } 5372 }; 5373 5374 template <> 5375 struct hash<VULKAN_HPP_NAMESPACE::PipelineViewportStateCreateInfo> 5376 { operator ()std::hash5377 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineViewportStateCreateInfo const & pipelineViewportStateCreateInfo ) const VULKAN_HPP_NOEXCEPT 5378 { 5379 std::size_t seed = 0; 5380 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportStateCreateInfo.sType ); 5381 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportStateCreateInfo.pNext ); 5382 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportStateCreateInfo.flags ); 5383 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportStateCreateInfo.viewportCount ); 5384 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportStateCreateInfo.pViewports ); 5385 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportStateCreateInfo.scissorCount ); 5386 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportStateCreateInfo.pScissors ); 5387 return seed; 5388 } 5389 }; 5390 5391 template <> 5392 struct hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationStateCreateInfo> 5393 { operator ()std::hash5394 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationStateCreateInfo const & pipelineRasterizationStateCreateInfo ) const VULKAN_HPP_NOEXCEPT 5395 { 5396 std::size_t seed = 0; 5397 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.sType ); 5398 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.pNext ); 5399 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.flags ); 5400 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.depthClampEnable ); 5401 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.rasterizerDiscardEnable ); 5402 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.polygonMode ); 5403 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.cullMode ); 5404 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.frontFace ); 5405 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.depthBiasEnable ); 5406 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.depthBiasConstantFactor ); 5407 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.depthBiasClamp ); 5408 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.depthBiasSlopeFactor ); 5409 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.lineWidth ); 5410 return seed; 5411 } 5412 }; 5413 5414 template <> 5415 struct hash<VULKAN_HPP_NAMESPACE::PipelineMultisampleStateCreateInfo> 5416 { operator ()std::hash5417 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineMultisampleStateCreateInfo const & pipelineMultisampleStateCreateInfo ) const VULKAN_HPP_NOEXCEPT 5418 { 5419 std::size_t seed = 0; 5420 VULKAN_HPP_HASH_COMBINE( seed, pipelineMultisampleStateCreateInfo.sType ); 5421 VULKAN_HPP_HASH_COMBINE( seed, pipelineMultisampleStateCreateInfo.pNext ); 5422 VULKAN_HPP_HASH_COMBINE( seed, pipelineMultisampleStateCreateInfo.flags ); 5423 VULKAN_HPP_HASH_COMBINE( seed, pipelineMultisampleStateCreateInfo.rasterizationSamples ); 5424 VULKAN_HPP_HASH_COMBINE( seed, pipelineMultisampleStateCreateInfo.sampleShadingEnable ); 5425 VULKAN_HPP_HASH_COMBINE( seed, pipelineMultisampleStateCreateInfo.minSampleShading ); 5426 VULKAN_HPP_HASH_COMBINE( seed, pipelineMultisampleStateCreateInfo.pSampleMask ); 5427 VULKAN_HPP_HASH_COMBINE( seed, pipelineMultisampleStateCreateInfo.alphaToCoverageEnable ); 5428 VULKAN_HPP_HASH_COMBINE( seed, pipelineMultisampleStateCreateInfo.alphaToOneEnable ); 5429 return seed; 5430 } 5431 }; 5432 5433 template <> 5434 struct hash<VULKAN_HPP_NAMESPACE::StencilOpState> 5435 { operator ()std::hash5436 std::size_t operator()( VULKAN_HPP_NAMESPACE::StencilOpState const & stencilOpState ) const VULKAN_HPP_NOEXCEPT 5437 { 5438 std::size_t seed = 0; 5439 VULKAN_HPP_HASH_COMBINE( seed, stencilOpState.failOp ); 5440 VULKAN_HPP_HASH_COMBINE( seed, stencilOpState.passOp ); 5441 VULKAN_HPP_HASH_COMBINE( seed, stencilOpState.depthFailOp ); 5442 VULKAN_HPP_HASH_COMBINE( seed, stencilOpState.compareOp ); 5443 VULKAN_HPP_HASH_COMBINE( seed, stencilOpState.compareMask ); 5444 VULKAN_HPP_HASH_COMBINE( seed, stencilOpState.writeMask ); 5445 VULKAN_HPP_HASH_COMBINE( seed, stencilOpState.reference ); 5446 return seed; 5447 } 5448 }; 5449 5450 template <> 5451 struct hash<VULKAN_HPP_NAMESPACE::PipelineDepthStencilStateCreateInfo> 5452 { operator ()std::hash5453 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineDepthStencilStateCreateInfo const & pipelineDepthStencilStateCreateInfo ) const VULKAN_HPP_NOEXCEPT 5454 { 5455 std::size_t seed = 0; 5456 VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.sType ); 5457 VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.pNext ); 5458 VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.flags ); 5459 VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.depthTestEnable ); 5460 VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.depthWriteEnable ); 5461 VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.depthCompareOp ); 5462 VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.depthBoundsTestEnable ); 5463 VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.stencilTestEnable ); 5464 VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.front ); 5465 VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.back ); 5466 VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.minDepthBounds ); 5467 VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.maxDepthBounds ); 5468 return seed; 5469 } 5470 }; 5471 5472 template <> 5473 struct hash<VULKAN_HPP_NAMESPACE::PipelineColorBlendAttachmentState> 5474 { operator ()std::hash5475 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineColorBlendAttachmentState const & pipelineColorBlendAttachmentState ) const VULKAN_HPP_NOEXCEPT 5476 { 5477 std::size_t seed = 0; 5478 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAttachmentState.blendEnable ); 5479 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAttachmentState.srcColorBlendFactor ); 5480 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAttachmentState.dstColorBlendFactor ); 5481 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAttachmentState.colorBlendOp ); 5482 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAttachmentState.srcAlphaBlendFactor ); 5483 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAttachmentState.dstAlphaBlendFactor ); 5484 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAttachmentState.alphaBlendOp ); 5485 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAttachmentState.colorWriteMask ); 5486 return seed; 5487 } 5488 }; 5489 5490 template <> 5491 struct hash<VULKAN_HPP_NAMESPACE::PipelineColorBlendStateCreateInfo> 5492 { operator ()std::hash5493 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineColorBlendStateCreateInfo const & pipelineColorBlendStateCreateInfo ) const VULKAN_HPP_NOEXCEPT 5494 { 5495 std::size_t seed = 0; 5496 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendStateCreateInfo.sType ); 5497 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendStateCreateInfo.pNext ); 5498 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendStateCreateInfo.flags ); 5499 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendStateCreateInfo.logicOpEnable ); 5500 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendStateCreateInfo.logicOp ); 5501 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendStateCreateInfo.attachmentCount ); 5502 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendStateCreateInfo.pAttachments ); 5503 for ( size_t i = 0; i < 4; ++i ) 5504 { 5505 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendStateCreateInfo.blendConstants[i] ); 5506 } 5507 return seed; 5508 } 5509 }; 5510 5511 template <> 5512 struct hash<VULKAN_HPP_NAMESPACE::PipelineDynamicStateCreateInfo> 5513 { operator ()std::hash5514 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineDynamicStateCreateInfo const & pipelineDynamicStateCreateInfo ) const VULKAN_HPP_NOEXCEPT 5515 { 5516 std::size_t seed = 0; 5517 VULKAN_HPP_HASH_COMBINE( seed, pipelineDynamicStateCreateInfo.sType ); 5518 VULKAN_HPP_HASH_COMBINE( seed, pipelineDynamicStateCreateInfo.pNext ); 5519 VULKAN_HPP_HASH_COMBINE( seed, pipelineDynamicStateCreateInfo.flags ); 5520 VULKAN_HPP_HASH_COMBINE( seed, pipelineDynamicStateCreateInfo.dynamicStateCount ); 5521 VULKAN_HPP_HASH_COMBINE( seed, pipelineDynamicStateCreateInfo.pDynamicStates ); 5522 return seed; 5523 } 5524 }; 5525 5526 template <> 5527 struct hash<VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> 5528 { operator ()std::hash5529 std::size_t operator()( VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo const & graphicsPipelineCreateInfo ) const VULKAN_HPP_NOEXCEPT 5530 { 5531 std::size_t seed = 0; 5532 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.sType ); 5533 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pNext ); 5534 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.flags ); 5535 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.stageCount ); 5536 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pStages ); 5537 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pVertexInputState ); 5538 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pInputAssemblyState ); 5539 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pTessellationState ); 5540 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pViewportState ); 5541 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pRasterizationState ); 5542 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pMultisampleState ); 5543 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pDepthStencilState ); 5544 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pColorBlendState ); 5545 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pDynamicState ); 5546 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.layout ); 5547 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.renderPass ); 5548 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.subpass ); 5549 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.basePipelineHandle ); 5550 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.basePipelineIndex ); 5551 return seed; 5552 } 5553 }; 5554 5555 template <> 5556 struct hash<VULKAN_HPP_NAMESPACE::GraphicsPipelineLibraryCreateInfoEXT> 5557 { operator ()std::hash5558 std::size_t operator()( VULKAN_HPP_NAMESPACE::GraphicsPipelineLibraryCreateInfoEXT const & graphicsPipelineLibraryCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 5559 { 5560 std::size_t seed = 0; 5561 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineLibraryCreateInfoEXT.sType ); 5562 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineLibraryCreateInfoEXT.pNext ); 5563 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineLibraryCreateInfoEXT.flags ); 5564 return seed; 5565 } 5566 }; 5567 5568 template <> 5569 struct hash<VULKAN_HPP_NAMESPACE::GraphicsShaderGroupCreateInfoNV> 5570 { operator ()std::hash5571 std::size_t operator()( VULKAN_HPP_NAMESPACE::GraphicsShaderGroupCreateInfoNV const & graphicsShaderGroupCreateInfoNV ) const VULKAN_HPP_NOEXCEPT 5572 { 5573 std::size_t seed = 0; 5574 VULKAN_HPP_HASH_COMBINE( seed, graphicsShaderGroupCreateInfoNV.sType ); 5575 VULKAN_HPP_HASH_COMBINE( seed, graphicsShaderGroupCreateInfoNV.pNext ); 5576 VULKAN_HPP_HASH_COMBINE( seed, graphicsShaderGroupCreateInfoNV.stageCount ); 5577 VULKAN_HPP_HASH_COMBINE( seed, graphicsShaderGroupCreateInfoNV.pStages ); 5578 VULKAN_HPP_HASH_COMBINE( seed, graphicsShaderGroupCreateInfoNV.pVertexInputState ); 5579 VULKAN_HPP_HASH_COMBINE( seed, graphicsShaderGroupCreateInfoNV.pTessellationState ); 5580 return seed; 5581 } 5582 }; 5583 5584 template <> 5585 struct hash<VULKAN_HPP_NAMESPACE::GraphicsPipelineShaderGroupsCreateInfoNV> 5586 { 5587 std::size_t operator ()std::hash5588 operator()( VULKAN_HPP_NAMESPACE::GraphicsPipelineShaderGroupsCreateInfoNV const & graphicsPipelineShaderGroupsCreateInfoNV ) const VULKAN_HPP_NOEXCEPT 5589 { 5590 std::size_t seed = 0; 5591 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineShaderGroupsCreateInfoNV.sType ); 5592 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineShaderGroupsCreateInfoNV.pNext ); 5593 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineShaderGroupsCreateInfoNV.groupCount ); 5594 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineShaderGroupsCreateInfoNV.pGroups ); 5595 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineShaderGroupsCreateInfoNV.pipelineCount ); 5596 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineShaderGroupsCreateInfoNV.pPipelines ); 5597 return seed; 5598 } 5599 }; 5600 5601 template <> 5602 struct hash<VULKAN_HPP_NAMESPACE::XYColorEXT> 5603 { operator ()std::hash5604 std::size_t operator()( VULKAN_HPP_NAMESPACE::XYColorEXT const & xYColorEXT ) const VULKAN_HPP_NOEXCEPT 5605 { 5606 std::size_t seed = 0; 5607 VULKAN_HPP_HASH_COMBINE( seed, xYColorEXT.x ); 5608 VULKAN_HPP_HASH_COMBINE( seed, xYColorEXT.y ); 5609 return seed; 5610 } 5611 }; 5612 5613 template <> 5614 struct hash<VULKAN_HPP_NAMESPACE::HdrMetadataEXT> 5615 { operator ()std::hash5616 std::size_t operator()( VULKAN_HPP_NAMESPACE::HdrMetadataEXT const & hdrMetadataEXT ) const VULKAN_HPP_NOEXCEPT 5617 { 5618 std::size_t seed = 0; 5619 VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.sType ); 5620 VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.pNext ); 5621 VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.displayPrimaryRed ); 5622 VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.displayPrimaryGreen ); 5623 VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.displayPrimaryBlue ); 5624 VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.whitePoint ); 5625 VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.maxLuminance ); 5626 VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.minLuminance ); 5627 VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.maxContentLightLevel ); 5628 VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.maxFrameAverageLightLevel ); 5629 return seed; 5630 } 5631 }; 5632 5633 template <> 5634 struct hash<VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT> 5635 { operator ()std::hash5636 std::size_t operator()( VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT const & headlessSurfaceCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 5637 { 5638 std::size_t seed = 0; 5639 VULKAN_HPP_HASH_COMBINE( seed, headlessSurfaceCreateInfoEXT.sType ); 5640 VULKAN_HPP_HASH_COMBINE( seed, headlessSurfaceCreateInfoEXT.pNext ); 5641 VULKAN_HPP_HASH_COMBINE( seed, headlessSurfaceCreateInfoEXT.flags ); 5642 return seed; 5643 } 5644 }; 5645 5646 template <> 5647 struct hash<VULKAN_HPP_NAMESPACE::HostImageCopyDevicePerformanceQuery> 5648 { operator ()std::hash5649 std::size_t operator()( VULKAN_HPP_NAMESPACE::HostImageCopyDevicePerformanceQuery const & hostImageCopyDevicePerformanceQuery ) const VULKAN_HPP_NOEXCEPT 5650 { 5651 std::size_t seed = 0; 5652 VULKAN_HPP_HASH_COMBINE( seed, hostImageCopyDevicePerformanceQuery.sType ); 5653 VULKAN_HPP_HASH_COMBINE( seed, hostImageCopyDevicePerformanceQuery.pNext ); 5654 VULKAN_HPP_HASH_COMBINE( seed, hostImageCopyDevicePerformanceQuery.optimalDeviceAccess ); 5655 VULKAN_HPP_HASH_COMBINE( seed, hostImageCopyDevicePerformanceQuery.identicalMemoryLayout ); 5656 return seed; 5657 } 5658 }; 5659 5660 template <> 5661 struct hash<VULKAN_HPP_NAMESPACE::HostImageLayoutTransitionInfo> 5662 { operator ()std::hash5663 std::size_t operator()( VULKAN_HPP_NAMESPACE::HostImageLayoutTransitionInfo const & hostImageLayoutTransitionInfo ) const VULKAN_HPP_NOEXCEPT 5664 { 5665 std::size_t seed = 0; 5666 VULKAN_HPP_HASH_COMBINE( seed, hostImageLayoutTransitionInfo.sType ); 5667 VULKAN_HPP_HASH_COMBINE( seed, hostImageLayoutTransitionInfo.pNext ); 5668 VULKAN_HPP_HASH_COMBINE( seed, hostImageLayoutTransitionInfo.image ); 5669 VULKAN_HPP_HASH_COMBINE( seed, hostImageLayoutTransitionInfo.oldLayout ); 5670 VULKAN_HPP_HASH_COMBINE( seed, hostImageLayoutTransitionInfo.newLayout ); 5671 VULKAN_HPP_HASH_COMBINE( seed, hostImageLayoutTransitionInfo.subresourceRange ); 5672 return seed; 5673 } 5674 }; 5675 5676 # if defined( VK_USE_PLATFORM_IOS_MVK ) 5677 template <> 5678 struct hash<VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK> 5679 { operator ()std::hash5680 std::size_t operator()( VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK const & iOSSurfaceCreateInfoMVK ) const VULKAN_HPP_NOEXCEPT 5681 { 5682 std::size_t seed = 0; 5683 VULKAN_HPP_HASH_COMBINE( seed, iOSSurfaceCreateInfoMVK.sType ); 5684 VULKAN_HPP_HASH_COMBINE( seed, iOSSurfaceCreateInfoMVK.pNext ); 5685 VULKAN_HPP_HASH_COMBINE( seed, iOSSurfaceCreateInfoMVK.flags ); 5686 VULKAN_HPP_HASH_COMBINE( seed, iOSSurfaceCreateInfoMVK.pView ); 5687 return seed; 5688 } 5689 }; 5690 # endif /*VK_USE_PLATFORM_IOS_MVK*/ 5691 5692 template <> 5693 struct hash<VULKAN_HPP_NAMESPACE::ImageAlignmentControlCreateInfoMESA> 5694 { operator ()std::hash5695 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageAlignmentControlCreateInfoMESA const & imageAlignmentControlCreateInfoMESA ) const VULKAN_HPP_NOEXCEPT 5696 { 5697 std::size_t seed = 0; 5698 VULKAN_HPP_HASH_COMBINE( seed, imageAlignmentControlCreateInfoMESA.sType ); 5699 VULKAN_HPP_HASH_COMBINE( seed, imageAlignmentControlCreateInfoMESA.pNext ); 5700 VULKAN_HPP_HASH_COMBINE( seed, imageAlignmentControlCreateInfoMESA.maximumRequestedAlignment ); 5701 return seed; 5702 } 5703 }; 5704 5705 template <> 5706 struct hash<VULKAN_HPP_NAMESPACE::ImageBlit> 5707 { operator ()std::hash5708 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageBlit const & imageBlit ) const VULKAN_HPP_NOEXCEPT 5709 { 5710 std::size_t seed = 0; 5711 VULKAN_HPP_HASH_COMBINE( seed, imageBlit.srcSubresource ); 5712 for ( size_t i = 0; i < 2; ++i ) 5713 { 5714 VULKAN_HPP_HASH_COMBINE( seed, imageBlit.srcOffsets[i] ); 5715 } 5716 VULKAN_HPP_HASH_COMBINE( seed, imageBlit.dstSubresource ); 5717 for ( size_t i = 0; i < 2; ++i ) 5718 { 5719 VULKAN_HPP_HASH_COMBINE( seed, imageBlit.dstOffsets[i] ); 5720 } 5721 return seed; 5722 } 5723 }; 5724 5725 template <> 5726 struct hash<VULKAN_HPP_NAMESPACE::ImageCaptureDescriptorDataInfoEXT> 5727 { operator ()std::hash5728 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageCaptureDescriptorDataInfoEXT const & imageCaptureDescriptorDataInfoEXT ) const VULKAN_HPP_NOEXCEPT 5729 { 5730 std::size_t seed = 0; 5731 VULKAN_HPP_HASH_COMBINE( seed, imageCaptureDescriptorDataInfoEXT.sType ); 5732 VULKAN_HPP_HASH_COMBINE( seed, imageCaptureDescriptorDataInfoEXT.pNext ); 5733 VULKAN_HPP_HASH_COMBINE( seed, imageCaptureDescriptorDataInfoEXT.image ); 5734 return seed; 5735 } 5736 }; 5737 5738 template <> 5739 struct hash<VULKAN_HPP_NAMESPACE::ImageCompressionControlEXT> 5740 { operator ()std::hash5741 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageCompressionControlEXT const & imageCompressionControlEXT ) const VULKAN_HPP_NOEXCEPT 5742 { 5743 std::size_t seed = 0; 5744 VULKAN_HPP_HASH_COMBINE( seed, imageCompressionControlEXT.sType ); 5745 VULKAN_HPP_HASH_COMBINE( seed, imageCompressionControlEXT.pNext ); 5746 VULKAN_HPP_HASH_COMBINE( seed, imageCompressionControlEXT.flags ); 5747 VULKAN_HPP_HASH_COMBINE( seed, imageCompressionControlEXT.compressionControlPlaneCount ); 5748 VULKAN_HPP_HASH_COMBINE( seed, imageCompressionControlEXT.pFixedRateFlags ); 5749 return seed; 5750 } 5751 }; 5752 5753 template <> 5754 struct hash<VULKAN_HPP_NAMESPACE::ImageCompressionPropertiesEXT> 5755 { operator ()std::hash5756 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageCompressionPropertiesEXT const & imageCompressionPropertiesEXT ) const VULKAN_HPP_NOEXCEPT 5757 { 5758 std::size_t seed = 0; 5759 VULKAN_HPP_HASH_COMBINE( seed, imageCompressionPropertiesEXT.sType ); 5760 VULKAN_HPP_HASH_COMBINE( seed, imageCompressionPropertiesEXT.pNext ); 5761 VULKAN_HPP_HASH_COMBINE( seed, imageCompressionPropertiesEXT.imageCompressionFlags ); 5762 VULKAN_HPP_HASH_COMBINE( seed, imageCompressionPropertiesEXT.imageCompressionFixedRateFlags ); 5763 return seed; 5764 } 5765 }; 5766 5767 # if defined( VK_USE_PLATFORM_FUCHSIA ) 5768 template <> 5769 struct hash<VULKAN_HPP_NAMESPACE::ImageFormatConstraintsInfoFUCHSIA> 5770 { operator ()std::hash5771 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageFormatConstraintsInfoFUCHSIA const & imageFormatConstraintsInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT 5772 { 5773 std::size_t seed = 0; 5774 VULKAN_HPP_HASH_COMBINE( seed, imageFormatConstraintsInfoFUCHSIA.sType ); 5775 VULKAN_HPP_HASH_COMBINE( seed, imageFormatConstraintsInfoFUCHSIA.pNext ); 5776 VULKAN_HPP_HASH_COMBINE( seed, imageFormatConstraintsInfoFUCHSIA.imageCreateInfo ); 5777 VULKAN_HPP_HASH_COMBINE( seed, imageFormatConstraintsInfoFUCHSIA.requiredFormatFeatures ); 5778 VULKAN_HPP_HASH_COMBINE( seed, imageFormatConstraintsInfoFUCHSIA.flags ); 5779 VULKAN_HPP_HASH_COMBINE( seed, imageFormatConstraintsInfoFUCHSIA.sysmemPixelFormat ); 5780 VULKAN_HPP_HASH_COMBINE( seed, imageFormatConstraintsInfoFUCHSIA.colorSpaceCount ); 5781 VULKAN_HPP_HASH_COMBINE( seed, imageFormatConstraintsInfoFUCHSIA.pColorSpaces ); 5782 return seed; 5783 } 5784 }; 5785 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 5786 5787 # if defined( VK_USE_PLATFORM_FUCHSIA ) 5788 template <> 5789 struct hash<VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFUCHSIA> 5790 { operator ()std::hash5791 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFUCHSIA const & imageConstraintsInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT 5792 { 5793 std::size_t seed = 0; 5794 VULKAN_HPP_HASH_COMBINE( seed, imageConstraintsInfoFUCHSIA.sType ); 5795 VULKAN_HPP_HASH_COMBINE( seed, imageConstraintsInfoFUCHSIA.pNext ); 5796 VULKAN_HPP_HASH_COMBINE( seed, imageConstraintsInfoFUCHSIA.formatConstraintsCount ); 5797 VULKAN_HPP_HASH_COMBINE( seed, imageConstraintsInfoFUCHSIA.pFormatConstraints ); 5798 VULKAN_HPP_HASH_COMBINE( seed, imageConstraintsInfoFUCHSIA.bufferCollectionConstraints ); 5799 VULKAN_HPP_HASH_COMBINE( seed, imageConstraintsInfoFUCHSIA.flags ); 5800 return seed; 5801 } 5802 }; 5803 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 5804 5805 template <> 5806 struct hash<VULKAN_HPP_NAMESPACE::ImageCopy> 5807 { operator ()std::hash5808 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageCopy const & imageCopy ) const VULKAN_HPP_NOEXCEPT 5809 { 5810 std::size_t seed = 0; 5811 VULKAN_HPP_HASH_COMBINE( seed, imageCopy.srcSubresource ); 5812 VULKAN_HPP_HASH_COMBINE( seed, imageCopy.srcOffset ); 5813 VULKAN_HPP_HASH_COMBINE( seed, imageCopy.dstSubresource ); 5814 VULKAN_HPP_HASH_COMBINE( seed, imageCopy.dstOffset ); 5815 VULKAN_HPP_HASH_COMBINE( seed, imageCopy.extent ); 5816 return seed; 5817 } 5818 }; 5819 5820 template <> 5821 struct hash<VULKAN_HPP_NAMESPACE::SubresourceLayout> 5822 { operator ()std::hash5823 std::size_t operator()( VULKAN_HPP_NAMESPACE::SubresourceLayout const & subresourceLayout ) const VULKAN_HPP_NOEXCEPT 5824 { 5825 std::size_t seed = 0; 5826 VULKAN_HPP_HASH_COMBINE( seed, subresourceLayout.offset ); 5827 VULKAN_HPP_HASH_COMBINE( seed, subresourceLayout.size ); 5828 VULKAN_HPP_HASH_COMBINE( seed, subresourceLayout.rowPitch ); 5829 VULKAN_HPP_HASH_COMBINE( seed, subresourceLayout.arrayPitch ); 5830 VULKAN_HPP_HASH_COMBINE( seed, subresourceLayout.depthPitch ); 5831 return seed; 5832 } 5833 }; 5834 5835 template <> 5836 struct hash<VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierExplicitCreateInfoEXT> 5837 { operator ()std::hash5838 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierExplicitCreateInfoEXT const & imageDrmFormatModifierExplicitCreateInfoEXT ) const 5839 VULKAN_HPP_NOEXCEPT 5840 { 5841 std::size_t seed = 0; 5842 VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierExplicitCreateInfoEXT.sType ); 5843 VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierExplicitCreateInfoEXT.pNext ); 5844 VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierExplicitCreateInfoEXT.drmFormatModifier ); 5845 VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierExplicitCreateInfoEXT.drmFormatModifierPlaneCount ); 5846 VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierExplicitCreateInfoEXT.pPlaneLayouts ); 5847 return seed; 5848 } 5849 }; 5850 5851 template <> 5852 struct hash<VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierListCreateInfoEXT> 5853 { 5854 std::size_t operator ()std::hash5855 operator()( VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierListCreateInfoEXT const & imageDrmFormatModifierListCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 5856 { 5857 std::size_t seed = 0; 5858 VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierListCreateInfoEXT.sType ); 5859 VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierListCreateInfoEXT.pNext ); 5860 VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierListCreateInfoEXT.drmFormatModifierCount ); 5861 VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierListCreateInfoEXT.pDrmFormatModifiers ); 5862 return seed; 5863 } 5864 }; 5865 5866 template <> 5867 struct hash<VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT> 5868 { operator ()std::hash5869 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT const & imageDrmFormatModifierPropertiesEXT ) const VULKAN_HPP_NOEXCEPT 5870 { 5871 std::size_t seed = 0; 5872 VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierPropertiesEXT.sType ); 5873 VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierPropertiesEXT.pNext ); 5874 VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierPropertiesEXT.drmFormatModifier ); 5875 return seed; 5876 } 5877 }; 5878 5879 template <> 5880 struct hash<VULKAN_HPP_NAMESPACE::ImageFormatListCreateInfo> 5881 { operator ()std::hash5882 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageFormatListCreateInfo const & imageFormatListCreateInfo ) const VULKAN_HPP_NOEXCEPT 5883 { 5884 std::size_t seed = 0; 5885 VULKAN_HPP_HASH_COMBINE( seed, imageFormatListCreateInfo.sType ); 5886 VULKAN_HPP_HASH_COMBINE( seed, imageFormatListCreateInfo.pNext ); 5887 VULKAN_HPP_HASH_COMBINE( seed, imageFormatListCreateInfo.viewFormatCount ); 5888 VULKAN_HPP_HASH_COMBINE( seed, imageFormatListCreateInfo.pViewFormats ); 5889 return seed; 5890 } 5891 }; 5892 5893 template <> 5894 struct hash<VULKAN_HPP_NAMESPACE::ImageFormatProperties2> 5895 { operator ()std::hash5896 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageFormatProperties2 const & imageFormatProperties2 ) const VULKAN_HPP_NOEXCEPT 5897 { 5898 std::size_t seed = 0; 5899 VULKAN_HPP_HASH_COMBINE( seed, imageFormatProperties2.sType ); 5900 VULKAN_HPP_HASH_COMBINE( seed, imageFormatProperties2.pNext ); 5901 VULKAN_HPP_HASH_COMBINE( seed, imageFormatProperties2.imageFormatProperties ); 5902 return seed; 5903 } 5904 }; 5905 5906 template <> 5907 struct hash<VULKAN_HPP_NAMESPACE::ImageMemoryBarrier> 5908 { operator ()std::hash5909 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageMemoryBarrier const & imageMemoryBarrier ) const VULKAN_HPP_NOEXCEPT 5910 { 5911 std::size_t seed = 0; 5912 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.sType ); 5913 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.pNext ); 5914 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.srcAccessMask ); 5915 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.dstAccessMask ); 5916 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.oldLayout ); 5917 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.newLayout ); 5918 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.srcQueueFamilyIndex ); 5919 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.dstQueueFamilyIndex ); 5920 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.image ); 5921 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.subresourceRange ); 5922 return seed; 5923 } 5924 }; 5925 5926 template <> 5927 struct hash<VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2> 5928 { operator ()std::hash5929 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 const & imageMemoryRequirementsInfo2 ) const VULKAN_HPP_NOEXCEPT 5930 { 5931 std::size_t seed = 0; 5932 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryRequirementsInfo2.sType ); 5933 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryRequirementsInfo2.pNext ); 5934 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryRequirementsInfo2.image ); 5935 return seed; 5936 } 5937 }; 5938 5939 # if defined( VK_USE_PLATFORM_FUCHSIA ) 5940 template <> 5941 struct hash<VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA> 5942 { operator ()std::hash5943 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA const & imagePipeSurfaceCreateInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT 5944 { 5945 std::size_t seed = 0; 5946 VULKAN_HPP_HASH_COMBINE( seed, imagePipeSurfaceCreateInfoFUCHSIA.sType ); 5947 VULKAN_HPP_HASH_COMBINE( seed, imagePipeSurfaceCreateInfoFUCHSIA.pNext ); 5948 VULKAN_HPP_HASH_COMBINE( seed, imagePipeSurfaceCreateInfoFUCHSIA.flags ); 5949 VULKAN_HPP_HASH_COMBINE( seed, imagePipeSurfaceCreateInfoFUCHSIA.imagePipeHandle ); 5950 return seed; 5951 } 5952 }; 5953 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 5954 5955 template <> 5956 struct hash<VULKAN_HPP_NAMESPACE::ImagePlaneMemoryRequirementsInfo> 5957 { operator ()std::hash5958 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImagePlaneMemoryRequirementsInfo const & imagePlaneMemoryRequirementsInfo ) const VULKAN_HPP_NOEXCEPT 5959 { 5960 std::size_t seed = 0; 5961 VULKAN_HPP_HASH_COMBINE( seed, imagePlaneMemoryRequirementsInfo.sType ); 5962 VULKAN_HPP_HASH_COMBINE( seed, imagePlaneMemoryRequirementsInfo.pNext ); 5963 VULKAN_HPP_HASH_COMBINE( seed, imagePlaneMemoryRequirementsInfo.planeAspect ); 5964 return seed; 5965 } 5966 }; 5967 5968 template <> 5969 struct hash<VULKAN_HPP_NAMESPACE::ImageResolve> 5970 { operator ()std::hash5971 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageResolve const & imageResolve ) const VULKAN_HPP_NOEXCEPT 5972 { 5973 std::size_t seed = 0; 5974 VULKAN_HPP_HASH_COMBINE( seed, imageResolve.srcSubresource ); 5975 VULKAN_HPP_HASH_COMBINE( seed, imageResolve.srcOffset ); 5976 VULKAN_HPP_HASH_COMBINE( seed, imageResolve.dstSubresource ); 5977 VULKAN_HPP_HASH_COMBINE( seed, imageResolve.dstOffset ); 5978 VULKAN_HPP_HASH_COMBINE( seed, imageResolve.extent ); 5979 return seed; 5980 } 5981 }; 5982 5983 template <> 5984 struct hash<VULKAN_HPP_NAMESPACE::ImageResolve2> 5985 { operator ()std::hash5986 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageResolve2 const & imageResolve2 ) const VULKAN_HPP_NOEXCEPT 5987 { 5988 std::size_t seed = 0; 5989 VULKAN_HPP_HASH_COMBINE( seed, imageResolve2.sType ); 5990 VULKAN_HPP_HASH_COMBINE( seed, imageResolve2.pNext ); 5991 VULKAN_HPP_HASH_COMBINE( seed, imageResolve2.srcSubresource ); 5992 VULKAN_HPP_HASH_COMBINE( seed, imageResolve2.srcOffset ); 5993 VULKAN_HPP_HASH_COMBINE( seed, imageResolve2.dstSubresource ); 5994 VULKAN_HPP_HASH_COMBINE( seed, imageResolve2.dstOffset ); 5995 VULKAN_HPP_HASH_COMBINE( seed, imageResolve2.extent ); 5996 return seed; 5997 } 5998 }; 5999 6000 template <> 6001 struct hash<VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2> 6002 { operator ()std::hash6003 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 const & imageSparseMemoryRequirementsInfo2 ) const VULKAN_HPP_NOEXCEPT 6004 { 6005 std::size_t seed = 0; 6006 VULKAN_HPP_HASH_COMBINE( seed, imageSparseMemoryRequirementsInfo2.sType ); 6007 VULKAN_HPP_HASH_COMBINE( seed, imageSparseMemoryRequirementsInfo2.pNext ); 6008 VULKAN_HPP_HASH_COMBINE( seed, imageSparseMemoryRequirementsInfo2.image ); 6009 return seed; 6010 } 6011 }; 6012 6013 template <> 6014 struct hash<VULKAN_HPP_NAMESPACE::ImageStencilUsageCreateInfo> 6015 { operator ()std::hash6016 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageStencilUsageCreateInfo const & imageStencilUsageCreateInfo ) const VULKAN_HPP_NOEXCEPT 6017 { 6018 std::size_t seed = 0; 6019 VULKAN_HPP_HASH_COMBINE( seed, imageStencilUsageCreateInfo.sType ); 6020 VULKAN_HPP_HASH_COMBINE( seed, imageStencilUsageCreateInfo.pNext ); 6021 VULKAN_HPP_HASH_COMBINE( seed, imageStencilUsageCreateInfo.stencilUsage ); 6022 return seed; 6023 } 6024 }; 6025 6026 template <> 6027 struct hash<VULKAN_HPP_NAMESPACE::ImageSwapchainCreateInfoKHR> 6028 { operator ()std::hash6029 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageSwapchainCreateInfoKHR const & imageSwapchainCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 6030 { 6031 std::size_t seed = 0; 6032 VULKAN_HPP_HASH_COMBINE( seed, imageSwapchainCreateInfoKHR.sType ); 6033 VULKAN_HPP_HASH_COMBINE( seed, imageSwapchainCreateInfoKHR.pNext ); 6034 VULKAN_HPP_HASH_COMBINE( seed, imageSwapchainCreateInfoKHR.swapchain ); 6035 return seed; 6036 } 6037 }; 6038 6039 template <> 6040 struct hash<VULKAN_HPP_NAMESPACE::ImageViewASTCDecodeModeEXT> 6041 { operator ()std::hash6042 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewASTCDecodeModeEXT const & imageViewASTCDecodeModeEXT ) const VULKAN_HPP_NOEXCEPT 6043 { 6044 std::size_t seed = 0; 6045 VULKAN_HPP_HASH_COMBINE( seed, imageViewASTCDecodeModeEXT.sType ); 6046 VULKAN_HPP_HASH_COMBINE( seed, imageViewASTCDecodeModeEXT.pNext ); 6047 VULKAN_HPP_HASH_COMBINE( seed, imageViewASTCDecodeModeEXT.decodeMode ); 6048 return seed; 6049 } 6050 }; 6051 6052 template <> 6053 struct hash<VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX> 6054 { operator ()std::hash6055 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX const & imageViewAddressPropertiesNVX ) const VULKAN_HPP_NOEXCEPT 6056 { 6057 std::size_t seed = 0; 6058 VULKAN_HPP_HASH_COMBINE( seed, imageViewAddressPropertiesNVX.sType ); 6059 VULKAN_HPP_HASH_COMBINE( seed, imageViewAddressPropertiesNVX.pNext ); 6060 VULKAN_HPP_HASH_COMBINE( seed, imageViewAddressPropertiesNVX.deviceAddress ); 6061 VULKAN_HPP_HASH_COMBINE( seed, imageViewAddressPropertiesNVX.size ); 6062 return seed; 6063 } 6064 }; 6065 6066 template <> 6067 struct hash<VULKAN_HPP_NAMESPACE::ImageViewCaptureDescriptorDataInfoEXT> 6068 { 6069 std::size_t operator ()std::hash6070 operator()( VULKAN_HPP_NAMESPACE::ImageViewCaptureDescriptorDataInfoEXT const & imageViewCaptureDescriptorDataInfoEXT ) const VULKAN_HPP_NOEXCEPT 6071 { 6072 std::size_t seed = 0; 6073 VULKAN_HPP_HASH_COMBINE( seed, imageViewCaptureDescriptorDataInfoEXT.sType ); 6074 VULKAN_HPP_HASH_COMBINE( seed, imageViewCaptureDescriptorDataInfoEXT.pNext ); 6075 VULKAN_HPP_HASH_COMBINE( seed, imageViewCaptureDescriptorDataInfoEXT.imageView ); 6076 return seed; 6077 } 6078 }; 6079 6080 template <> 6081 struct hash<VULKAN_HPP_NAMESPACE::ImageViewCreateInfo> 6082 { operator ()std::hash6083 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewCreateInfo const & imageViewCreateInfo ) const VULKAN_HPP_NOEXCEPT 6084 { 6085 std::size_t seed = 0; 6086 VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.sType ); 6087 VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.pNext ); 6088 VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.flags ); 6089 VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.image ); 6090 VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.viewType ); 6091 VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.format ); 6092 VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.components ); 6093 VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.subresourceRange ); 6094 return seed; 6095 } 6096 }; 6097 6098 template <> 6099 struct hash<VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX> 6100 { operator ()std::hash6101 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX const & imageViewHandleInfoNVX ) const VULKAN_HPP_NOEXCEPT 6102 { 6103 std::size_t seed = 0; 6104 VULKAN_HPP_HASH_COMBINE( seed, imageViewHandleInfoNVX.sType ); 6105 VULKAN_HPP_HASH_COMBINE( seed, imageViewHandleInfoNVX.pNext ); 6106 VULKAN_HPP_HASH_COMBINE( seed, imageViewHandleInfoNVX.imageView ); 6107 VULKAN_HPP_HASH_COMBINE( seed, imageViewHandleInfoNVX.descriptorType ); 6108 VULKAN_HPP_HASH_COMBINE( seed, imageViewHandleInfoNVX.sampler ); 6109 return seed; 6110 } 6111 }; 6112 6113 template <> 6114 struct hash<VULKAN_HPP_NAMESPACE::ImageViewMinLodCreateInfoEXT> 6115 { operator ()std::hash6116 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewMinLodCreateInfoEXT const & imageViewMinLodCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 6117 { 6118 std::size_t seed = 0; 6119 VULKAN_HPP_HASH_COMBINE( seed, imageViewMinLodCreateInfoEXT.sType ); 6120 VULKAN_HPP_HASH_COMBINE( seed, imageViewMinLodCreateInfoEXT.pNext ); 6121 VULKAN_HPP_HASH_COMBINE( seed, imageViewMinLodCreateInfoEXT.minLod ); 6122 return seed; 6123 } 6124 }; 6125 6126 template <> 6127 struct hash<VULKAN_HPP_NAMESPACE::ImageViewSampleWeightCreateInfoQCOM> 6128 { operator ()std::hash6129 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewSampleWeightCreateInfoQCOM const & imageViewSampleWeightCreateInfoQCOM ) const VULKAN_HPP_NOEXCEPT 6130 { 6131 std::size_t seed = 0; 6132 VULKAN_HPP_HASH_COMBINE( seed, imageViewSampleWeightCreateInfoQCOM.sType ); 6133 VULKAN_HPP_HASH_COMBINE( seed, imageViewSampleWeightCreateInfoQCOM.pNext ); 6134 VULKAN_HPP_HASH_COMBINE( seed, imageViewSampleWeightCreateInfoQCOM.filterCenter ); 6135 VULKAN_HPP_HASH_COMBINE( seed, imageViewSampleWeightCreateInfoQCOM.filterSize ); 6136 VULKAN_HPP_HASH_COMBINE( seed, imageViewSampleWeightCreateInfoQCOM.numPhases ); 6137 return seed; 6138 } 6139 }; 6140 6141 template <> 6142 struct hash<VULKAN_HPP_NAMESPACE::ImageViewSlicedCreateInfoEXT> 6143 { operator ()std::hash6144 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewSlicedCreateInfoEXT const & imageViewSlicedCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 6145 { 6146 std::size_t seed = 0; 6147 VULKAN_HPP_HASH_COMBINE( seed, imageViewSlicedCreateInfoEXT.sType ); 6148 VULKAN_HPP_HASH_COMBINE( seed, imageViewSlicedCreateInfoEXT.pNext ); 6149 VULKAN_HPP_HASH_COMBINE( seed, imageViewSlicedCreateInfoEXT.sliceOffset ); 6150 VULKAN_HPP_HASH_COMBINE( seed, imageViewSlicedCreateInfoEXT.sliceCount ); 6151 return seed; 6152 } 6153 }; 6154 6155 template <> 6156 struct hash<VULKAN_HPP_NAMESPACE::ImageViewUsageCreateInfo> 6157 { operator ()std::hash6158 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewUsageCreateInfo const & imageViewUsageCreateInfo ) const VULKAN_HPP_NOEXCEPT 6159 { 6160 std::size_t seed = 0; 6161 VULKAN_HPP_HASH_COMBINE( seed, imageViewUsageCreateInfo.sType ); 6162 VULKAN_HPP_HASH_COMBINE( seed, imageViewUsageCreateInfo.pNext ); 6163 VULKAN_HPP_HASH_COMBINE( seed, imageViewUsageCreateInfo.usage ); 6164 return seed; 6165 } 6166 }; 6167 6168 # if defined( VK_USE_PLATFORM_ANDROID_KHR ) 6169 template <> 6170 struct hash<VULKAN_HPP_NAMESPACE::ImportAndroidHardwareBufferInfoANDROID> 6171 { 6172 std::size_t operator ()std::hash6173 operator()( VULKAN_HPP_NAMESPACE::ImportAndroidHardwareBufferInfoANDROID const & importAndroidHardwareBufferInfoANDROID ) const VULKAN_HPP_NOEXCEPT 6174 { 6175 std::size_t seed = 0; 6176 VULKAN_HPP_HASH_COMBINE( seed, importAndroidHardwareBufferInfoANDROID.sType ); 6177 VULKAN_HPP_HASH_COMBINE( seed, importAndroidHardwareBufferInfoANDROID.pNext ); 6178 VULKAN_HPP_HASH_COMBINE( seed, importAndroidHardwareBufferInfoANDROID.buffer ); 6179 return seed; 6180 } 6181 }; 6182 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ 6183 6184 template <> 6185 struct hash<VULKAN_HPP_NAMESPACE::ImportFenceFdInfoKHR> 6186 { operator ()std::hash6187 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportFenceFdInfoKHR const & importFenceFdInfoKHR ) const VULKAN_HPP_NOEXCEPT 6188 { 6189 std::size_t seed = 0; 6190 VULKAN_HPP_HASH_COMBINE( seed, importFenceFdInfoKHR.sType ); 6191 VULKAN_HPP_HASH_COMBINE( seed, importFenceFdInfoKHR.pNext ); 6192 VULKAN_HPP_HASH_COMBINE( seed, importFenceFdInfoKHR.fence ); 6193 VULKAN_HPP_HASH_COMBINE( seed, importFenceFdInfoKHR.flags ); 6194 VULKAN_HPP_HASH_COMBINE( seed, importFenceFdInfoKHR.handleType ); 6195 VULKAN_HPP_HASH_COMBINE( seed, importFenceFdInfoKHR.fd ); 6196 return seed; 6197 } 6198 }; 6199 6200 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 6201 template <> 6202 struct hash<VULKAN_HPP_NAMESPACE::ImportFenceWin32HandleInfoKHR> 6203 { operator ()std::hash6204 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportFenceWin32HandleInfoKHR const & importFenceWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT 6205 { 6206 std::size_t seed = 0; 6207 VULKAN_HPP_HASH_COMBINE( seed, importFenceWin32HandleInfoKHR.sType ); 6208 VULKAN_HPP_HASH_COMBINE( seed, importFenceWin32HandleInfoKHR.pNext ); 6209 VULKAN_HPP_HASH_COMBINE( seed, importFenceWin32HandleInfoKHR.fence ); 6210 VULKAN_HPP_HASH_COMBINE( seed, importFenceWin32HandleInfoKHR.flags ); 6211 VULKAN_HPP_HASH_COMBINE( seed, importFenceWin32HandleInfoKHR.handleType ); 6212 VULKAN_HPP_HASH_COMBINE( seed, importFenceWin32HandleInfoKHR.handle ); 6213 VULKAN_HPP_HASH_COMBINE( seed, importFenceWin32HandleInfoKHR.name ); 6214 return seed; 6215 } 6216 }; 6217 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 6218 6219 # if defined( VK_USE_PLATFORM_FUCHSIA ) 6220 template <> 6221 struct hash<VULKAN_HPP_NAMESPACE::ImportMemoryBufferCollectionFUCHSIA> 6222 { operator ()std::hash6223 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMemoryBufferCollectionFUCHSIA const & importMemoryBufferCollectionFUCHSIA ) const VULKAN_HPP_NOEXCEPT 6224 { 6225 std::size_t seed = 0; 6226 VULKAN_HPP_HASH_COMBINE( seed, importMemoryBufferCollectionFUCHSIA.sType ); 6227 VULKAN_HPP_HASH_COMBINE( seed, importMemoryBufferCollectionFUCHSIA.pNext ); 6228 VULKAN_HPP_HASH_COMBINE( seed, importMemoryBufferCollectionFUCHSIA.collection ); 6229 VULKAN_HPP_HASH_COMBINE( seed, importMemoryBufferCollectionFUCHSIA.index ); 6230 return seed; 6231 } 6232 }; 6233 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 6234 6235 template <> 6236 struct hash<VULKAN_HPP_NAMESPACE::ImportMemoryFdInfoKHR> 6237 { operator ()std::hash6238 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMemoryFdInfoKHR const & importMemoryFdInfoKHR ) const VULKAN_HPP_NOEXCEPT 6239 { 6240 std::size_t seed = 0; 6241 VULKAN_HPP_HASH_COMBINE( seed, importMemoryFdInfoKHR.sType ); 6242 VULKAN_HPP_HASH_COMBINE( seed, importMemoryFdInfoKHR.pNext ); 6243 VULKAN_HPP_HASH_COMBINE( seed, importMemoryFdInfoKHR.handleType ); 6244 VULKAN_HPP_HASH_COMBINE( seed, importMemoryFdInfoKHR.fd ); 6245 return seed; 6246 } 6247 }; 6248 6249 template <> 6250 struct hash<VULKAN_HPP_NAMESPACE::ImportMemoryHostPointerInfoEXT> 6251 { operator ()std::hash6252 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMemoryHostPointerInfoEXT const & importMemoryHostPointerInfoEXT ) const VULKAN_HPP_NOEXCEPT 6253 { 6254 std::size_t seed = 0; 6255 VULKAN_HPP_HASH_COMBINE( seed, importMemoryHostPointerInfoEXT.sType ); 6256 VULKAN_HPP_HASH_COMBINE( seed, importMemoryHostPointerInfoEXT.pNext ); 6257 VULKAN_HPP_HASH_COMBINE( seed, importMemoryHostPointerInfoEXT.handleType ); 6258 VULKAN_HPP_HASH_COMBINE( seed, importMemoryHostPointerInfoEXT.pHostPointer ); 6259 return seed; 6260 } 6261 }; 6262 6263 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 6264 template <> 6265 struct hash<VULKAN_HPP_NAMESPACE::ImportMemoryWin32HandleInfoKHR> 6266 { operator ()std::hash6267 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMemoryWin32HandleInfoKHR const & importMemoryWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT 6268 { 6269 std::size_t seed = 0; 6270 VULKAN_HPP_HASH_COMBINE( seed, importMemoryWin32HandleInfoKHR.sType ); 6271 VULKAN_HPP_HASH_COMBINE( seed, importMemoryWin32HandleInfoKHR.pNext ); 6272 VULKAN_HPP_HASH_COMBINE( seed, importMemoryWin32HandleInfoKHR.handleType ); 6273 VULKAN_HPP_HASH_COMBINE( seed, importMemoryWin32HandleInfoKHR.handle ); 6274 VULKAN_HPP_HASH_COMBINE( seed, importMemoryWin32HandleInfoKHR.name ); 6275 return seed; 6276 } 6277 }; 6278 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 6279 6280 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 6281 template <> 6282 struct hash<VULKAN_HPP_NAMESPACE::ImportMemoryWin32HandleInfoNV> 6283 { operator ()std::hash6284 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMemoryWin32HandleInfoNV const & importMemoryWin32HandleInfoNV ) const VULKAN_HPP_NOEXCEPT 6285 { 6286 std::size_t seed = 0; 6287 VULKAN_HPP_HASH_COMBINE( seed, importMemoryWin32HandleInfoNV.sType ); 6288 VULKAN_HPP_HASH_COMBINE( seed, importMemoryWin32HandleInfoNV.pNext ); 6289 VULKAN_HPP_HASH_COMBINE( seed, importMemoryWin32HandleInfoNV.handleType ); 6290 VULKAN_HPP_HASH_COMBINE( seed, importMemoryWin32HandleInfoNV.handle ); 6291 return seed; 6292 } 6293 }; 6294 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 6295 6296 # if defined( VK_USE_PLATFORM_FUCHSIA ) 6297 template <> 6298 struct hash<VULKAN_HPP_NAMESPACE::ImportMemoryZirconHandleInfoFUCHSIA> 6299 { operator ()std::hash6300 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMemoryZirconHandleInfoFUCHSIA const & importMemoryZirconHandleInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT 6301 { 6302 std::size_t seed = 0; 6303 VULKAN_HPP_HASH_COMBINE( seed, importMemoryZirconHandleInfoFUCHSIA.sType ); 6304 VULKAN_HPP_HASH_COMBINE( seed, importMemoryZirconHandleInfoFUCHSIA.pNext ); 6305 VULKAN_HPP_HASH_COMBINE( seed, importMemoryZirconHandleInfoFUCHSIA.handleType ); 6306 VULKAN_HPP_HASH_COMBINE( seed, importMemoryZirconHandleInfoFUCHSIA.handle ); 6307 return seed; 6308 } 6309 }; 6310 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 6311 6312 # if defined( VK_USE_PLATFORM_METAL_EXT ) 6313 template <> 6314 struct hash<VULKAN_HPP_NAMESPACE::ImportMetalBufferInfoEXT> 6315 { operator ()std::hash6316 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMetalBufferInfoEXT const & importMetalBufferInfoEXT ) const VULKAN_HPP_NOEXCEPT 6317 { 6318 std::size_t seed = 0; 6319 VULKAN_HPP_HASH_COMBINE( seed, importMetalBufferInfoEXT.sType ); 6320 VULKAN_HPP_HASH_COMBINE( seed, importMetalBufferInfoEXT.pNext ); 6321 VULKAN_HPP_HASH_COMBINE( seed, importMetalBufferInfoEXT.mtlBuffer ); 6322 return seed; 6323 } 6324 }; 6325 # endif /*VK_USE_PLATFORM_METAL_EXT*/ 6326 6327 # if defined( VK_USE_PLATFORM_METAL_EXT ) 6328 template <> 6329 struct hash<VULKAN_HPP_NAMESPACE::ImportMetalIOSurfaceInfoEXT> 6330 { operator ()std::hash6331 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMetalIOSurfaceInfoEXT const & importMetalIOSurfaceInfoEXT ) const VULKAN_HPP_NOEXCEPT 6332 { 6333 std::size_t seed = 0; 6334 VULKAN_HPP_HASH_COMBINE( seed, importMetalIOSurfaceInfoEXT.sType ); 6335 VULKAN_HPP_HASH_COMBINE( seed, importMetalIOSurfaceInfoEXT.pNext ); 6336 VULKAN_HPP_HASH_COMBINE( seed, importMetalIOSurfaceInfoEXT.ioSurface ); 6337 return seed; 6338 } 6339 }; 6340 # endif /*VK_USE_PLATFORM_METAL_EXT*/ 6341 6342 # if defined( VK_USE_PLATFORM_METAL_EXT ) 6343 template <> 6344 struct hash<VULKAN_HPP_NAMESPACE::ImportMetalSharedEventInfoEXT> 6345 { operator ()std::hash6346 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMetalSharedEventInfoEXT const & importMetalSharedEventInfoEXT ) const VULKAN_HPP_NOEXCEPT 6347 { 6348 std::size_t seed = 0; 6349 VULKAN_HPP_HASH_COMBINE( seed, importMetalSharedEventInfoEXT.sType ); 6350 VULKAN_HPP_HASH_COMBINE( seed, importMetalSharedEventInfoEXT.pNext ); 6351 VULKAN_HPP_HASH_COMBINE( seed, importMetalSharedEventInfoEXT.mtlSharedEvent ); 6352 return seed; 6353 } 6354 }; 6355 # endif /*VK_USE_PLATFORM_METAL_EXT*/ 6356 6357 # if defined( VK_USE_PLATFORM_METAL_EXT ) 6358 template <> 6359 struct hash<VULKAN_HPP_NAMESPACE::ImportMetalTextureInfoEXT> 6360 { operator ()std::hash6361 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMetalTextureInfoEXT const & importMetalTextureInfoEXT ) const VULKAN_HPP_NOEXCEPT 6362 { 6363 std::size_t seed = 0; 6364 VULKAN_HPP_HASH_COMBINE( seed, importMetalTextureInfoEXT.sType ); 6365 VULKAN_HPP_HASH_COMBINE( seed, importMetalTextureInfoEXT.pNext ); 6366 VULKAN_HPP_HASH_COMBINE( seed, importMetalTextureInfoEXT.plane ); 6367 VULKAN_HPP_HASH_COMBINE( seed, importMetalTextureInfoEXT.mtlTexture ); 6368 return seed; 6369 } 6370 }; 6371 # endif /*VK_USE_PLATFORM_METAL_EXT*/ 6372 6373 # if defined( VK_USE_PLATFORM_SCREEN_QNX ) 6374 template <> 6375 struct hash<VULKAN_HPP_NAMESPACE::ImportScreenBufferInfoQNX> 6376 { operator ()std::hash6377 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportScreenBufferInfoQNX const & importScreenBufferInfoQNX ) const VULKAN_HPP_NOEXCEPT 6378 { 6379 std::size_t seed = 0; 6380 VULKAN_HPP_HASH_COMBINE( seed, importScreenBufferInfoQNX.sType ); 6381 VULKAN_HPP_HASH_COMBINE( seed, importScreenBufferInfoQNX.pNext ); 6382 VULKAN_HPP_HASH_COMBINE( seed, importScreenBufferInfoQNX.buffer ); 6383 return seed; 6384 } 6385 }; 6386 # endif /*VK_USE_PLATFORM_SCREEN_QNX*/ 6387 6388 template <> 6389 struct hash<VULKAN_HPP_NAMESPACE::ImportSemaphoreFdInfoKHR> 6390 { operator ()std::hash6391 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportSemaphoreFdInfoKHR const & importSemaphoreFdInfoKHR ) const VULKAN_HPP_NOEXCEPT 6392 { 6393 std::size_t seed = 0; 6394 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreFdInfoKHR.sType ); 6395 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreFdInfoKHR.pNext ); 6396 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreFdInfoKHR.semaphore ); 6397 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreFdInfoKHR.flags ); 6398 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreFdInfoKHR.handleType ); 6399 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreFdInfoKHR.fd ); 6400 return seed; 6401 } 6402 }; 6403 6404 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 6405 template <> 6406 struct hash<VULKAN_HPP_NAMESPACE::ImportSemaphoreWin32HandleInfoKHR> 6407 { operator ()std::hash6408 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportSemaphoreWin32HandleInfoKHR const & importSemaphoreWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT 6409 { 6410 std::size_t seed = 0; 6411 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreWin32HandleInfoKHR.sType ); 6412 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreWin32HandleInfoKHR.pNext ); 6413 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreWin32HandleInfoKHR.semaphore ); 6414 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreWin32HandleInfoKHR.flags ); 6415 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreWin32HandleInfoKHR.handleType ); 6416 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreWin32HandleInfoKHR.handle ); 6417 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreWin32HandleInfoKHR.name ); 6418 return seed; 6419 } 6420 }; 6421 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 6422 6423 # if defined( VK_USE_PLATFORM_FUCHSIA ) 6424 template <> 6425 struct hash<VULKAN_HPP_NAMESPACE::ImportSemaphoreZirconHandleInfoFUCHSIA> 6426 { 6427 std::size_t operator ()std::hash6428 operator()( VULKAN_HPP_NAMESPACE::ImportSemaphoreZirconHandleInfoFUCHSIA const & importSemaphoreZirconHandleInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT 6429 { 6430 std::size_t seed = 0; 6431 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreZirconHandleInfoFUCHSIA.sType ); 6432 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreZirconHandleInfoFUCHSIA.pNext ); 6433 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreZirconHandleInfoFUCHSIA.semaphore ); 6434 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreZirconHandleInfoFUCHSIA.flags ); 6435 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreZirconHandleInfoFUCHSIA.handleType ); 6436 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreZirconHandleInfoFUCHSIA.zirconHandle ); 6437 return seed; 6438 } 6439 }; 6440 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 6441 6442 template <> 6443 struct hash<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutTokenNV> 6444 { operator ()std::hash6445 std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutTokenNV const & indirectCommandsLayoutTokenNV ) const VULKAN_HPP_NOEXCEPT 6446 { 6447 std::size_t seed = 0; 6448 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.sType ); 6449 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.pNext ); 6450 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.tokenType ); 6451 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.stream ); 6452 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.offset ); 6453 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.vertexBindingUnit ); 6454 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.vertexDynamicStride ); 6455 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.pushconstantPipelineLayout ); 6456 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.pushconstantShaderStageFlags ); 6457 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.pushconstantOffset ); 6458 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.pushconstantSize ); 6459 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.indirectStateFlags ); 6460 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.indexTypeCount ); 6461 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.pIndexTypes ); 6462 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.pIndexTypeValues ); 6463 return seed; 6464 } 6465 }; 6466 6467 template <> 6468 struct hash<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV> 6469 { operator ()std::hash6470 std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV const & indirectCommandsLayoutCreateInfoNV ) const VULKAN_HPP_NOEXCEPT 6471 { 6472 std::size_t seed = 0; 6473 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoNV.sType ); 6474 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoNV.pNext ); 6475 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoNV.flags ); 6476 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoNV.pipelineBindPoint ); 6477 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoNV.tokenCount ); 6478 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoNV.pTokens ); 6479 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoNV.streamCount ); 6480 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoNV.pStreamStrides ); 6481 return seed; 6482 } 6483 }; 6484 6485 template <> 6486 struct hash<VULKAN_HPP_NAMESPACE::InitializePerformanceApiInfoINTEL> 6487 { operator ()std::hash6488 std::size_t operator()( VULKAN_HPP_NAMESPACE::InitializePerformanceApiInfoINTEL const & initializePerformanceApiInfoINTEL ) const VULKAN_HPP_NOEXCEPT 6489 { 6490 std::size_t seed = 0; 6491 VULKAN_HPP_HASH_COMBINE( seed, initializePerformanceApiInfoINTEL.sType ); 6492 VULKAN_HPP_HASH_COMBINE( seed, initializePerformanceApiInfoINTEL.pNext ); 6493 VULKAN_HPP_HASH_COMBINE( seed, initializePerformanceApiInfoINTEL.pUserData ); 6494 return seed; 6495 } 6496 }; 6497 6498 template <> 6499 struct hash<VULKAN_HPP_NAMESPACE::InputAttachmentAspectReference> 6500 { operator ()std::hash6501 std::size_t operator()( VULKAN_HPP_NAMESPACE::InputAttachmentAspectReference const & inputAttachmentAspectReference ) const VULKAN_HPP_NOEXCEPT 6502 { 6503 std::size_t seed = 0; 6504 VULKAN_HPP_HASH_COMBINE( seed, inputAttachmentAspectReference.subpass ); 6505 VULKAN_HPP_HASH_COMBINE( seed, inputAttachmentAspectReference.inputAttachmentIndex ); 6506 VULKAN_HPP_HASH_COMBINE( seed, inputAttachmentAspectReference.aspectMask ); 6507 return seed; 6508 } 6509 }; 6510 6511 template <> 6512 struct hash<VULKAN_HPP_NAMESPACE::InstanceCreateInfo> 6513 { operator ()std::hash6514 std::size_t operator()( VULKAN_HPP_NAMESPACE::InstanceCreateInfo const & instanceCreateInfo ) const VULKAN_HPP_NOEXCEPT 6515 { 6516 std::size_t seed = 0; 6517 VULKAN_HPP_HASH_COMBINE( seed, instanceCreateInfo.sType ); 6518 VULKAN_HPP_HASH_COMBINE( seed, instanceCreateInfo.pNext ); 6519 VULKAN_HPP_HASH_COMBINE( seed, instanceCreateInfo.flags ); 6520 VULKAN_HPP_HASH_COMBINE( seed, instanceCreateInfo.pApplicationInfo ); 6521 VULKAN_HPP_HASH_COMBINE( seed, instanceCreateInfo.enabledLayerCount ); 6522 for ( size_t i = 0; i < instanceCreateInfo.enabledLayerCount; ++i ) 6523 { 6524 for ( const char * p = instanceCreateInfo.ppEnabledLayerNames[i]; *p != '\0'; ++p ) 6525 { 6526 VULKAN_HPP_HASH_COMBINE( seed, *p ); 6527 } 6528 } 6529 VULKAN_HPP_HASH_COMBINE( seed, instanceCreateInfo.enabledExtensionCount ); 6530 for ( size_t i = 0; i < instanceCreateInfo.enabledExtensionCount; ++i ) 6531 { 6532 for ( const char * p = instanceCreateInfo.ppEnabledExtensionNames[i]; *p != '\0'; ++p ) 6533 { 6534 VULKAN_HPP_HASH_COMBINE( seed, *p ); 6535 } 6536 } 6537 return seed; 6538 } 6539 }; 6540 6541 template <> 6542 struct hash<VULKAN_HPP_NAMESPACE::LatencySleepInfoNV> 6543 { operator ()std::hash6544 std::size_t operator()( VULKAN_HPP_NAMESPACE::LatencySleepInfoNV const & latencySleepInfoNV ) const VULKAN_HPP_NOEXCEPT 6545 { 6546 std::size_t seed = 0; 6547 VULKAN_HPP_HASH_COMBINE( seed, latencySleepInfoNV.sType ); 6548 VULKAN_HPP_HASH_COMBINE( seed, latencySleepInfoNV.pNext ); 6549 VULKAN_HPP_HASH_COMBINE( seed, latencySleepInfoNV.signalSemaphore ); 6550 VULKAN_HPP_HASH_COMBINE( seed, latencySleepInfoNV.value ); 6551 return seed; 6552 } 6553 }; 6554 6555 template <> 6556 struct hash<VULKAN_HPP_NAMESPACE::LatencySleepModeInfoNV> 6557 { operator ()std::hash6558 std::size_t operator()( VULKAN_HPP_NAMESPACE::LatencySleepModeInfoNV const & latencySleepModeInfoNV ) const VULKAN_HPP_NOEXCEPT 6559 { 6560 std::size_t seed = 0; 6561 VULKAN_HPP_HASH_COMBINE( seed, latencySleepModeInfoNV.sType ); 6562 VULKAN_HPP_HASH_COMBINE( seed, latencySleepModeInfoNV.pNext ); 6563 VULKAN_HPP_HASH_COMBINE( seed, latencySleepModeInfoNV.lowLatencyMode ); 6564 VULKAN_HPP_HASH_COMBINE( seed, latencySleepModeInfoNV.lowLatencyBoost ); 6565 VULKAN_HPP_HASH_COMBINE( seed, latencySleepModeInfoNV.minimumIntervalUs ); 6566 return seed; 6567 } 6568 }; 6569 6570 template <> 6571 struct hash<VULKAN_HPP_NAMESPACE::LatencySubmissionPresentIdNV> 6572 { operator ()std::hash6573 std::size_t operator()( VULKAN_HPP_NAMESPACE::LatencySubmissionPresentIdNV const & latencySubmissionPresentIdNV ) const VULKAN_HPP_NOEXCEPT 6574 { 6575 std::size_t seed = 0; 6576 VULKAN_HPP_HASH_COMBINE( seed, latencySubmissionPresentIdNV.sType ); 6577 VULKAN_HPP_HASH_COMBINE( seed, latencySubmissionPresentIdNV.pNext ); 6578 VULKAN_HPP_HASH_COMBINE( seed, latencySubmissionPresentIdNV.presentID ); 6579 return seed; 6580 } 6581 }; 6582 6583 template <> 6584 struct hash<VULKAN_HPP_NAMESPACE::LatencySurfaceCapabilitiesNV> 6585 { operator ()std::hash6586 std::size_t operator()( VULKAN_HPP_NAMESPACE::LatencySurfaceCapabilitiesNV const & latencySurfaceCapabilitiesNV ) const VULKAN_HPP_NOEXCEPT 6587 { 6588 std::size_t seed = 0; 6589 VULKAN_HPP_HASH_COMBINE( seed, latencySurfaceCapabilitiesNV.sType ); 6590 VULKAN_HPP_HASH_COMBINE( seed, latencySurfaceCapabilitiesNV.pNext ); 6591 VULKAN_HPP_HASH_COMBINE( seed, latencySurfaceCapabilitiesNV.presentModeCount ); 6592 VULKAN_HPP_HASH_COMBINE( seed, latencySurfaceCapabilitiesNV.pPresentModes ); 6593 return seed; 6594 } 6595 }; 6596 6597 template <> 6598 struct hash<VULKAN_HPP_NAMESPACE::LayerProperties> 6599 { operator ()std::hash6600 std::size_t operator()( VULKAN_HPP_NAMESPACE::LayerProperties const & layerProperties ) const VULKAN_HPP_NOEXCEPT 6601 { 6602 std::size_t seed = 0; 6603 for ( size_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i ) 6604 { 6605 VULKAN_HPP_HASH_COMBINE( seed, layerProperties.layerName[i] ); 6606 } 6607 VULKAN_HPP_HASH_COMBINE( seed, layerProperties.specVersion ); 6608 VULKAN_HPP_HASH_COMBINE( seed, layerProperties.implementationVersion ); 6609 for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) 6610 { 6611 VULKAN_HPP_HASH_COMBINE( seed, layerProperties.description[i] ); 6612 } 6613 return seed; 6614 } 6615 }; 6616 6617 template <> 6618 struct hash<VULKAN_HPP_NAMESPACE::LayerSettingEXT> 6619 { operator ()std::hash6620 std::size_t operator()( VULKAN_HPP_NAMESPACE::LayerSettingEXT const & layerSettingEXT ) const VULKAN_HPP_NOEXCEPT 6621 { 6622 std::size_t seed = 0; 6623 for ( const char * p = layerSettingEXT.pLayerName; *p != '\0'; ++p ) 6624 { 6625 VULKAN_HPP_HASH_COMBINE( seed, *p ); 6626 } 6627 for ( const char * p = layerSettingEXT.pSettingName; *p != '\0'; ++p ) 6628 { 6629 VULKAN_HPP_HASH_COMBINE( seed, *p ); 6630 } 6631 VULKAN_HPP_HASH_COMBINE( seed, layerSettingEXT.type ); 6632 VULKAN_HPP_HASH_COMBINE( seed, layerSettingEXT.valueCount ); 6633 VULKAN_HPP_HASH_COMBINE( seed, layerSettingEXT.pValues ); 6634 return seed; 6635 } 6636 }; 6637 6638 template <> 6639 struct hash<VULKAN_HPP_NAMESPACE::LayerSettingsCreateInfoEXT> 6640 { operator ()std::hash6641 std::size_t operator()( VULKAN_HPP_NAMESPACE::LayerSettingsCreateInfoEXT const & layerSettingsCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 6642 { 6643 std::size_t seed = 0; 6644 VULKAN_HPP_HASH_COMBINE( seed, layerSettingsCreateInfoEXT.sType ); 6645 VULKAN_HPP_HASH_COMBINE( seed, layerSettingsCreateInfoEXT.pNext ); 6646 VULKAN_HPP_HASH_COMBINE( seed, layerSettingsCreateInfoEXT.settingCount ); 6647 VULKAN_HPP_HASH_COMBINE( seed, layerSettingsCreateInfoEXT.pSettings ); 6648 return seed; 6649 } 6650 }; 6651 6652 # if defined( VK_USE_PLATFORM_MACOS_MVK ) 6653 template <> 6654 struct hash<VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK> 6655 { operator ()std::hash6656 std::size_t operator()( VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK const & macOSSurfaceCreateInfoMVK ) const VULKAN_HPP_NOEXCEPT 6657 { 6658 std::size_t seed = 0; 6659 VULKAN_HPP_HASH_COMBINE( seed, macOSSurfaceCreateInfoMVK.sType ); 6660 VULKAN_HPP_HASH_COMBINE( seed, macOSSurfaceCreateInfoMVK.pNext ); 6661 VULKAN_HPP_HASH_COMBINE( seed, macOSSurfaceCreateInfoMVK.flags ); 6662 VULKAN_HPP_HASH_COMBINE( seed, macOSSurfaceCreateInfoMVK.pView ); 6663 return seed; 6664 } 6665 }; 6666 # endif /*VK_USE_PLATFORM_MACOS_MVK*/ 6667 6668 template <> 6669 struct hash<VULKAN_HPP_NAMESPACE::MappedMemoryRange> 6670 { operator ()std::hash6671 std::size_t operator()( VULKAN_HPP_NAMESPACE::MappedMemoryRange const & mappedMemoryRange ) const VULKAN_HPP_NOEXCEPT 6672 { 6673 std::size_t seed = 0; 6674 VULKAN_HPP_HASH_COMBINE( seed, mappedMemoryRange.sType ); 6675 VULKAN_HPP_HASH_COMBINE( seed, mappedMemoryRange.pNext ); 6676 VULKAN_HPP_HASH_COMBINE( seed, mappedMemoryRange.memory ); 6677 VULKAN_HPP_HASH_COMBINE( seed, mappedMemoryRange.offset ); 6678 VULKAN_HPP_HASH_COMBINE( seed, mappedMemoryRange.size ); 6679 return seed; 6680 } 6681 }; 6682 6683 template <> 6684 struct hash<VULKAN_HPP_NAMESPACE::MemoryAllocateFlagsInfo> 6685 { operator ()std::hash6686 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryAllocateFlagsInfo const & memoryAllocateFlagsInfo ) const VULKAN_HPP_NOEXCEPT 6687 { 6688 std::size_t seed = 0; 6689 VULKAN_HPP_HASH_COMBINE( seed, memoryAllocateFlagsInfo.sType ); 6690 VULKAN_HPP_HASH_COMBINE( seed, memoryAllocateFlagsInfo.pNext ); 6691 VULKAN_HPP_HASH_COMBINE( seed, memoryAllocateFlagsInfo.flags ); 6692 VULKAN_HPP_HASH_COMBINE( seed, memoryAllocateFlagsInfo.deviceMask ); 6693 return seed; 6694 } 6695 }; 6696 6697 template <> 6698 struct hash<VULKAN_HPP_NAMESPACE::MemoryAllocateInfo> 6699 { operator ()std::hash6700 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryAllocateInfo const & memoryAllocateInfo ) const VULKAN_HPP_NOEXCEPT 6701 { 6702 std::size_t seed = 0; 6703 VULKAN_HPP_HASH_COMBINE( seed, memoryAllocateInfo.sType ); 6704 VULKAN_HPP_HASH_COMBINE( seed, memoryAllocateInfo.pNext ); 6705 VULKAN_HPP_HASH_COMBINE( seed, memoryAllocateInfo.allocationSize ); 6706 VULKAN_HPP_HASH_COMBINE( seed, memoryAllocateInfo.memoryTypeIndex ); 6707 return seed; 6708 } 6709 }; 6710 6711 template <> 6712 struct hash<VULKAN_HPP_NAMESPACE::MemoryBarrier> 6713 { operator ()std::hash6714 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryBarrier const & memoryBarrier ) const VULKAN_HPP_NOEXCEPT 6715 { 6716 std::size_t seed = 0; 6717 VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier.sType ); 6718 VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier.pNext ); 6719 VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier.srcAccessMask ); 6720 VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier.dstAccessMask ); 6721 return seed; 6722 } 6723 }; 6724 6725 template <> 6726 struct hash<VULKAN_HPP_NAMESPACE::MemoryDedicatedAllocateInfo> 6727 { operator ()std::hash6728 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryDedicatedAllocateInfo const & memoryDedicatedAllocateInfo ) const VULKAN_HPP_NOEXCEPT 6729 { 6730 std::size_t seed = 0; 6731 VULKAN_HPP_HASH_COMBINE( seed, memoryDedicatedAllocateInfo.sType ); 6732 VULKAN_HPP_HASH_COMBINE( seed, memoryDedicatedAllocateInfo.pNext ); 6733 VULKAN_HPP_HASH_COMBINE( seed, memoryDedicatedAllocateInfo.image ); 6734 VULKAN_HPP_HASH_COMBINE( seed, memoryDedicatedAllocateInfo.buffer ); 6735 return seed; 6736 } 6737 }; 6738 6739 template <> 6740 struct hash<VULKAN_HPP_NAMESPACE::MemoryDedicatedRequirements> 6741 { operator ()std::hash6742 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryDedicatedRequirements const & memoryDedicatedRequirements ) const VULKAN_HPP_NOEXCEPT 6743 { 6744 std::size_t seed = 0; 6745 VULKAN_HPP_HASH_COMBINE( seed, memoryDedicatedRequirements.sType ); 6746 VULKAN_HPP_HASH_COMBINE( seed, memoryDedicatedRequirements.pNext ); 6747 VULKAN_HPP_HASH_COMBINE( seed, memoryDedicatedRequirements.prefersDedicatedAllocation ); 6748 VULKAN_HPP_HASH_COMBINE( seed, memoryDedicatedRequirements.requiresDedicatedAllocation ); 6749 return seed; 6750 } 6751 }; 6752 6753 template <> 6754 struct hash<VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR> 6755 { operator ()std::hash6756 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR const & memoryFdPropertiesKHR ) const VULKAN_HPP_NOEXCEPT 6757 { 6758 std::size_t seed = 0; 6759 VULKAN_HPP_HASH_COMBINE( seed, memoryFdPropertiesKHR.sType ); 6760 VULKAN_HPP_HASH_COMBINE( seed, memoryFdPropertiesKHR.pNext ); 6761 VULKAN_HPP_HASH_COMBINE( seed, memoryFdPropertiesKHR.memoryTypeBits ); 6762 return seed; 6763 } 6764 }; 6765 6766 # if defined( VK_USE_PLATFORM_ANDROID_KHR ) 6767 template <> 6768 struct hash<VULKAN_HPP_NAMESPACE::MemoryGetAndroidHardwareBufferInfoANDROID> 6769 { 6770 std::size_t operator ()std::hash6771 operator()( VULKAN_HPP_NAMESPACE::MemoryGetAndroidHardwareBufferInfoANDROID const & memoryGetAndroidHardwareBufferInfoANDROID ) const VULKAN_HPP_NOEXCEPT 6772 { 6773 std::size_t seed = 0; 6774 VULKAN_HPP_HASH_COMBINE( seed, memoryGetAndroidHardwareBufferInfoANDROID.sType ); 6775 VULKAN_HPP_HASH_COMBINE( seed, memoryGetAndroidHardwareBufferInfoANDROID.pNext ); 6776 VULKAN_HPP_HASH_COMBINE( seed, memoryGetAndroidHardwareBufferInfoANDROID.memory ); 6777 return seed; 6778 } 6779 }; 6780 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ 6781 6782 template <> 6783 struct hash<VULKAN_HPP_NAMESPACE::MemoryGetFdInfoKHR> 6784 { operator ()std::hash6785 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryGetFdInfoKHR const & memoryGetFdInfoKHR ) const VULKAN_HPP_NOEXCEPT 6786 { 6787 std::size_t seed = 0; 6788 VULKAN_HPP_HASH_COMBINE( seed, memoryGetFdInfoKHR.sType ); 6789 VULKAN_HPP_HASH_COMBINE( seed, memoryGetFdInfoKHR.pNext ); 6790 VULKAN_HPP_HASH_COMBINE( seed, memoryGetFdInfoKHR.memory ); 6791 VULKAN_HPP_HASH_COMBINE( seed, memoryGetFdInfoKHR.handleType ); 6792 return seed; 6793 } 6794 }; 6795 6796 template <> 6797 struct hash<VULKAN_HPP_NAMESPACE::MemoryGetRemoteAddressInfoNV> 6798 { operator ()std::hash6799 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryGetRemoteAddressInfoNV const & memoryGetRemoteAddressInfoNV ) const VULKAN_HPP_NOEXCEPT 6800 { 6801 std::size_t seed = 0; 6802 VULKAN_HPP_HASH_COMBINE( seed, memoryGetRemoteAddressInfoNV.sType ); 6803 VULKAN_HPP_HASH_COMBINE( seed, memoryGetRemoteAddressInfoNV.pNext ); 6804 VULKAN_HPP_HASH_COMBINE( seed, memoryGetRemoteAddressInfoNV.memory ); 6805 VULKAN_HPP_HASH_COMBINE( seed, memoryGetRemoteAddressInfoNV.handleType ); 6806 return seed; 6807 } 6808 }; 6809 6810 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 6811 template <> 6812 struct hash<VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR> 6813 { operator ()std::hash6814 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR const & memoryGetWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT 6815 { 6816 std::size_t seed = 0; 6817 VULKAN_HPP_HASH_COMBINE( seed, memoryGetWin32HandleInfoKHR.sType ); 6818 VULKAN_HPP_HASH_COMBINE( seed, memoryGetWin32HandleInfoKHR.pNext ); 6819 VULKAN_HPP_HASH_COMBINE( seed, memoryGetWin32HandleInfoKHR.memory ); 6820 VULKAN_HPP_HASH_COMBINE( seed, memoryGetWin32HandleInfoKHR.handleType ); 6821 return seed; 6822 } 6823 }; 6824 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 6825 6826 # if defined( VK_USE_PLATFORM_FUCHSIA ) 6827 template <> 6828 struct hash<VULKAN_HPP_NAMESPACE::MemoryGetZirconHandleInfoFUCHSIA> 6829 { operator ()std::hash6830 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryGetZirconHandleInfoFUCHSIA const & memoryGetZirconHandleInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT 6831 { 6832 std::size_t seed = 0; 6833 VULKAN_HPP_HASH_COMBINE( seed, memoryGetZirconHandleInfoFUCHSIA.sType ); 6834 VULKAN_HPP_HASH_COMBINE( seed, memoryGetZirconHandleInfoFUCHSIA.pNext ); 6835 VULKAN_HPP_HASH_COMBINE( seed, memoryGetZirconHandleInfoFUCHSIA.memory ); 6836 VULKAN_HPP_HASH_COMBINE( seed, memoryGetZirconHandleInfoFUCHSIA.handleType ); 6837 return seed; 6838 } 6839 }; 6840 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 6841 6842 template <> 6843 struct hash<VULKAN_HPP_NAMESPACE::MemoryHeap> 6844 { operator ()std::hash6845 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryHeap const & memoryHeap ) const VULKAN_HPP_NOEXCEPT 6846 { 6847 std::size_t seed = 0; 6848 VULKAN_HPP_HASH_COMBINE( seed, memoryHeap.size ); 6849 VULKAN_HPP_HASH_COMBINE( seed, memoryHeap.flags ); 6850 return seed; 6851 } 6852 }; 6853 6854 template <> 6855 struct hash<VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT> 6856 { operator ()std::hash6857 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT const & memoryHostPointerPropertiesEXT ) const VULKAN_HPP_NOEXCEPT 6858 { 6859 std::size_t seed = 0; 6860 VULKAN_HPP_HASH_COMBINE( seed, memoryHostPointerPropertiesEXT.sType ); 6861 VULKAN_HPP_HASH_COMBINE( seed, memoryHostPointerPropertiesEXT.pNext ); 6862 VULKAN_HPP_HASH_COMBINE( seed, memoryHostPointerPropertiesEXT.memoryTypeBits ); 6863 return seed; 6864 } 6865 }; 6866 6867 template <> 6868 struct hash<VULKAN_HPP_NAMESPACE::MemoryMapInfo> 6869 { operator ()std::hash6870 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryMapInfo const & memoryMapInfo ) const VULKAN_HPP_NOEXCEPT 6871 { 6872 std::size_t seed = 0; 6873 VULKAN_HPP_HASH_COMBINE( seed, memoryMapInfo.sType ); 6874 VULKAN_HPP_HASH_COMBINE( seed, memoryMapInfo.pNext ); 6875 VULKAN_HPP_HASH_COMBINE( seed, memoryMapInfo.flags ); 6876 VULKAN_HPP_HASH_COMBINE( seed, memoryMapInfo.memory ); 6877 VULKAN_HPP_HASH_COMBINE( seed, memoryMapInfo.offset ); 6878 VULKAN_HPP_HASH_COMBINE( seed, memoryMapInfo.size ); 6879 return seed; 6880 } 6881 }; 6882 6883 template <> 6884 struct hash<VULKAN_HPP_NAMESPACE::MemoryMapPlacedInfoEXT> 6885 { operator ()std::hash6886 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryMapPlacedInfoEXT const & memoryMapPlacedInfoEXT ) const VULKAN_HPP_NOEXCEPT 6887 { 6888 std::size_t seed = 0; 6889 VULKAN_HPP_HASH_COMBINE( seed, memoryMapPlacedInfoEXT.sType ); 6890 VULKAN_HPP_HASH_COMBINE( seed, memoryMapPlacedInfoEXT.pNext ); 6891 VULKAN_HPP_HASH_COMBINE( seed, memoryMapPlacedInfoEXT.pPlacedAddress ); 6892 return seed; 6893 } 6894 }; 6895 6896 template <> 6897 struct hash<VULKAN_HPP_NAMESPACE::MemoryOpaqueCaptureAddressAllocateInfo> 6898 { 6899 std::size_t operator ()std::hash6900 operator()( VULKAN_HPP_NAMESPACE::MemoryOpaqueCaptureAddressAllocateInfo const & memoryOpaqueCaptureAddressAllocateInfo ) const VULKAN_HPP_NOEXCEPT 6901 { 6902 std::size_t seed = 0; 6903 VULKAN_HPP_HASH_COMBINE( seed, memoryOpaqueCaptureAddressAllocateInfo.sType ); 6904 VULKAN_HPP_HASH_COMBINE( seed, memoryOpaqueCaptureAddressAllocateInfo.pNext ); 6905 VULKAN_HPP_HASH_COMBINE( seed, memoryOpaqueCaptureAddressAllocateInfo.opaqueCaptureAddress ); 6906 return seed; 6907 } 6908 }; 6909 6910 template <> 6911 struct hash<VULKAN_HPP_NAMESPACE::MemoryPriorityAllocateInfoEXT> 6912 { operator ()std::hash6913 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryPriorityAllocateInfoEXT const & memoryPriorityAllocateInfoEXT ) const VULKAN_HPP_NOEXCEPT 6914 { 6915 std::size_t seed = 0; 6916 VULKAN_HPP_HASH_COMBINE( seed, memoryPriorityAllocateInfoEXT.sType ); 6917 VULKAN_HPP_HASH_COMBINE( seed, memoryPriorityAllocateInfoEXT.pNext ); 6918 VULKAN_HPP_HASH_COMBINE( seed, memoryPriorityAllocateInfoEXT.priority ); 6919 return seed; 6920 } 6921 }; 6922 6923 template <> 6924 struct hash<VULKAN_HPP_NAMESPACE::MemoryRequirements> 6925 { operator ()std::hash6926 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryRequirements const & memoryRequirements ) const VULKAN_HPP_NOEXCEPT 6927 { 6928 std::size_t seed = 0; 6929 VULKAN_HPP_HASH_COMBINE( seed, memoryRequirements.size ); 6930 VULKAN_HPP_HASH_COMBINE( seed, memoryRequirements.alignment ); 6931 VULKAN_HPP_HASH_COMBINE( seed, memoryRequirements.memoryTypeBits ); 6932 return seed; 6933 } 6934 }; 6935 6936 template <> 6937 struct hash<VULKAN_HPP_NAMESPACE::MemoryRequirements2> 6938 { operator ()std::hash6939 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryRequirements2 const & memoryRequirements2 ) const VULKAN_HPP_NOEXCEPT 6940 { 6941 std::size_t seed = 0; 6942 VULKAN_HPP_HASH_COMBINE( seed, memoryRequirements2.sType ); 6943 VULKAN_HPP_HASH_COMBINE( seed, memoryRequirements2.pNext ); 6944 VULKAN_HPP_HASH_COMBINE( seed, memoryRequirements2.memoryRequirements ); 6945 return seed; 6946 } 6947 }; 6948 6949 template <> 6950 struct hash<VULKAN_HPP_NAMESPACE::MemoryType> 6951 { operator ()std::hash6952 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryType const & memoryType ) const VULKAN_HPP_NOEXCEPT 6953 { 6954 std::size_t seed = 0; 6955 VULKAN_HPP_HASH_COMBINE( seed, memoryType.propertyFlags ); 6956 VULKAN_HPP_HASH_COMBINE( seed, memoryType.heapIndex ); 6957 return seed; 6958 } 6959 }; 6960 6961 template <> 6962 struct hash<VULKAN_HPP_NAMESPACE::MemoryUnmapInfo> 6963 { operator ()std::hash6964 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryUnmapInfo const & memoryUnmapInfo ) const VULKAN_HPP_NOEXCEPT 6965 { 6966 std::size_t seed = 0; 6967 VULKAN_HPP_HASH_COMBINE( seed, memoryUnmapInfo.sType ); 6968 VULKAN_HPP_HASH_COMBINE( seed, memoryUnmapInfo.pNext ); 6969 VULKAN_HPP_HASH_COMBINE( seed, memoryUnmapInfo.flags ); 6970 VULKAN_HPP_HASH_COMBINE( seed, memoryUnmapInfo.memory ); 6971 return seed; 6972 } 6973 }; 6974 6975 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 6976 template <> 6977 struct hash<VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR> 6978 { operator ()std::hash6979 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR const & memoryWin32HandlePropertiesKHR ) const VULKAN_HPP_NOEXCEPT 6980 { 6981 std::size_t seed = 0; 6982 VULKAN_HPP_HASH_COMBINE( seed, memoryWin32HandlePropertiesKHR.sType ); 6983 VULKAN_HPP_HASH_COMBINE( seed, memoryWin32HandlePropertiesKHR.pNext ); 6984 VULKAN_HPP_HASH_COMBINE( seed, memoryWin32HandlePropertiesKHR.memoryTypeBits ); 6985 return seed; 6986 } 6987 }; 6988 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 6989 6990 # if defined( VK_USE_PLATFORM_FUCHSIA ) 6991 template <> 6992 struct hash<VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA> 6993 { operator ()std::hash6994 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA const & memoryZirconHandlePropertiesFUCHSIA ) const VULKAN_HPP_NOEXCEPT 6995 { 6996 std::size_t seed = 0; 6997 VULKAN_HPP_HASH_COMBINE( seed, memoryZirconHandlePropertiesFUCHSIA.sType ); 6998 VULKAN_HPP_HASH_COMBINE( seed, memoryZirconHandlePropertiesFUCHSIA.pNext ); 6999 VULKAN_HPP_HASH_COMBINE( seed, memoryZirconHandlePropertiesFUCHSIA.memoryTypeBits ); 7000 return seed; 7001 } 7002 }; 7003 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 7004 7005 # if defined( VK_USE_PLATFORM_METAL_EXT ) 7006 template <> 7007 struct hash<VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT> 7008 { operator ()std::hash7009 std::size_t operator()( VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT const & metalSurfaceCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 7010 { 7011 std::size_t seed = 0; 7012 VULKAN_HPP_HASH_COMBINE( seed, metalSurfaceCreateInfoEXT.sType ); 7013 VULKAN_HPP_HASH_COMBINE( seed, metalSurfaceCreateInfoEXT.pNext ); 7014 VULKAN_HPP_HASH_COMBINE( seed, metalSurfaceCreateInfoEXT.flags ); 7015 VULKAN_HPP_HASH_COMBINE( seed, metalSurfaceCreateInfoEXT.pLayer ); 7016 return seed; 7017 } 7018 }; 7019 # endif /*VK_USE_PLATFORM_METAL_EXT*/ 7020 7021 template <> 7022 struct hash<VULKAN_HPP_NAMESPACE::MicromapBuildSizesInfoEXT> 7023 { operator ()std::hash7024 std::size_t operator()( VULKAN_HPP_NAMESPACE::MicromapBuildSizesInfoEXT const & micromapBuildSizesInfoEXT ) const VULKAN_HPP_NOEXCEPT 7025 { 7026 std::size_t seed = 0; 7027 VULKAN_HPP_HASH_COMBINE( seed, micromapBuildSizesInfoEXT.sType ); 7028 VULKAN_HPP_HASH_COMBINE( seed, micromapBuildSizesInfoEXT.pNext ); 7029 VULKAN_HPP_HASH_COMBINE( seed, micromapBuildSizesInfoEXT.micromapSize ); 7030 VULKAN_HPP_HASH_COMBINE( seed, micromapBuildSizesInfoEXT.buildScratchSize ); 7031 VULKAN_HPP_HASH_COMBINE( seed, micromapBuildSizesInfoEXT.discardable ); 7032 return seed; 7033 } 7034 }; 7035 7036 template <> 7037 struct hash<VULKAN_HPP_NAMESPACE::MicromapCreateInfoEXT> 7038 { operator ()std::hash7039 std::size_t operator()( VULKAN_HPP_NAMESPACE::MicromapCreateInfoEXT const & micromapCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 7040 { 7041 std::size_t seed = 0; 7042 VULKAN_HPP_HASH_COMBINE( seed, micromapCreateInfoEXT.sType ); 7043 VULKAN_HPP_HASH_COMBINE( seed, micromapCreateInfoEXT.pNext ); 7044 VULKAN_HPP_HASH_COMBINE( seed, micromapCreateInfoEXT.createFlags ); 7045 VULKAN_HPP_HASH_COMBINE( seed, micromapCreateInfoEXT.buffer ); 7046 VULKAN_HPP_HASH_COMBINE( seed, micromapCreateInfoEXT.offset ); 7047 VULKAN_HPP_HASH_COMBINE( seed, micromapCreateInfoEXT.size ); 7048 VULKAN_HPP_HASH_COMBINE( seed, micromapCreateInfoEXT.type ); 7049 VULKAN_HPP_HASH_COMBINE( seed, micromapCreateInfoEXT.deviceAddress ); 7050 return seed; 7051 } 7052 }; 7053 7054 template <> 7055 struct hash<VULKAN_HPP_NAMESPACE::MicromapTriangleEXT> 7056 { operator ()std::hash7057 std::size_t operator()( VULKAN_HPP_NAMESPACE::MicromapTriangleEXT const & micromapTriangleEXT ) const VULKAN_HPP_NOEXCEPT 7058 { 7059 std::size_t seed = 0; 7060 VULKAN_HPP_HASH_COMBINE( seed, micromapTriangleEXT.dataOffset ); 7061 VULKAN_HPP_HASH_COMBINE( seed, micromapTriangleEXT.subdivisionLevel ); 7062 VULKAN_HPP_HASH_COMBINE( seed, micromapTriangleEXT.format ); 7063 return seed; 7064 } 7065 }; 7066 7067 template <> 7068 struct hash<VULKAN_HPP_NAMESPACE::MicromapVersionInfoEXT> 7069 { operator ()std::hash7070 std::size_t operator()( VULKAN_HPP_NAMESPACE::MicromapVersionInfoEXT const & micromapVersionInfoEXT ) const VULKAN_HPP_NOEXCEPT 7071 { 7072 std::size_t seed = 0; 7073 VULKAN_HPP_HASH_COMBINE( seed, micromapVersionInfoEXT.sType ); 7074 VULKAN_HPP_HASH_COMBINE( seed, micromapVersionInfoEXT.pNext ); 7075 VULKAN_HPP_HASH_COMBINE( seed, micromapVersionInfoEXT.pVersionData ); 7076 return seed; 7077 } 7078 }; 7079 7080 template <> 7081 struct hash<VULKAN_HPP_NAMESPACE::MultiDrawIndexedInfoEXT> 7082 { operator ()std::hash7083 std::size_t operator()( VULKAN_HPP_NAMESPACE::MultiDrawIndexedInfoEXT const & multiDrawIndexedInfoEXT ) const VULKAN_HPP_NOEXCEPT 7084 { 7085 std::size_t seed = 0; 7086 VULKAN_HPP_HASH_COMBINE( seed, multiDrawIndexedInfoEXT.firstIndex ); 7087 VULKAN_HPP_HASH_COMBINE( seed, multiDrawIndexedInfoEXT.indexCount ); 7088 VULKAN_HPP_HASH_COMBINE( seed, multiDrawIndexedInfoEXT.vertexOffset ); 7089 return seed; 7090 } 7091 }; 7092 7093 template <> 7094 struct hash<VULKAN_HPP_NAMESPACE::MultiDrawInfoEXT> 7095 { operator ()std::hash7096 std::size_t operator()( VULKAN_HPP_NAMESPACE::MultiDrawInfoEXT const & multiDrawInfoEXT ) const VULKAN_HPP_NOEXCEPT 7097 { 7098 std::size_t seed = 0; 7099 VULKAN_HPP_HASH_COMBINE( seed, multiDrawInfoEXT.firstVertex ); 7100 VULKAN_HPP_HASH_COMBINE( seed, multiDrawInfoEXT.vertexCount ); 7101 return seed; 7102 } 7103 }; 7104 7105 template <> 7106 struct hash<VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT> 7107 { operator ()std::hash7108 std::size_t operator()( VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT const & multisamplePropertiesEXT ) const VULKAN_HPP_NOEXCEPT 7109 { 7110 std::size_t seed = 0; 7111 VULKAN_HPP_HASH_COMBINE( seed, multisamplePropertiesEXT.sType ); 7112 VULKAN_HPP_HASH_COMBINE( seed, multisamplePropertiesEXT.pNext ); 7113 VULKAN_HPP_HASH_COMBINE( seed, multisamplePropertiesEXT.maxSampleLocationGridSize ); 7114 return seed; 7115 } 7116 }; 7117 7118 template <> 7119 struct hash<VULKAN_HPP_NAMESPACE::MultisampledRenderToSingleSampledInfoEXT> 7120 { 7121 std::size_t operator ()std::hash7122 operator()( VULKAN_HPP_NAMESPACE::MultisampledRenderToSingleSampledInfoEXT const & multisampledRenderToSingleSampledInfoEXT ) const VULKAN_HPP_NOEXCEPT 7123 { 7124 std::size_t seed = 0; 7125 VULKAN_HPP_HASH_COMBINE( seed, multisampledRenderToSingleSampledInfoEXT.sType ); 7126 VULKAN_HPP_HASH_COMBINE( seed, multisampledRenderToSingleSampledInfoEXT.pNext ); 7127 VULKAN_HPP_HASH_COMBINE( seed, multisampledRenderToSingleSampledInfoEXT.multisampledRenderToSingleSampledEnable ); 7128 VULKAN_HPP_HASH_COMBINE( seed, multisampledRenderToSingleSampledInfoEXT.rasterizationSamples ); 7129 return seed; 7130 } 7131 }; 7132 7133 template <> 7134 struct hash<VULKAN_HPP_NAMESPACE::MultiviewPerViewAttributesInfoNVX> 7135 { operator ()std::hash7136 std::size_t operator()( VULKAN_HPP_NAMESPACE::MultiviewPerViewAttributesInfoNVX const & multiviewPerViewAttributesInfoNVX ) const VULKAN_HPP_NOEXCEPT 7137 { 7138 std::size_t seed = 0; 7139 VULKAN_HPP_HASH_COMBINE( seed, multiviewPerViewAttributesInfoNVX.sType ); 7140 VULKAN_HPP_HASH_COMBINE( seed, multiviewPerViewAttributesInfoNVX.pNext ); 7141 VULKAN_HPP_HASH_COMBINE( seed, multiviewPerViewAttributesInfoNVX.perViewAttributes ); 7142 VULKAN_HPP_HASH_COMBINE( seed, multiviewPerViewAttributesInfoNVX.perViewAttributesPositionXOnly ); 7143 return seed; 7144 } 7145 }; 7146 7147 template <> 7148 struct hash<VULKAN_HPP_NAMESPACE::MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM> 7149 { 7150 std::size_t operator ()std::hash7151 operator()( VULKAN_HPP_NAMESPACE::MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM const & multiviewPerViewRenderAreasRenderPassBeginInfoQCOM ) const 7152 VULKAN_HPP_NOEXCEPT 7153 { 7154 std::size_t seed = 0; 7155 VULKAN_HPP_HASH_COMBINE( seed, multiviewPerViewRenderAreasRenderPassBeginInfoQCOM.sType ); 7156 VULKAN_HPP_HASH_COMBINE( seed, multiviewPerViewRenderAreasRenderPassBeginInfoQCOM.pNext ); 7157 VULKAN_HPP_HASH_COMBINE( seed, multiviewPerViewRenderAreasRenderPassBeginInfoQCOM.perViewRenderAreaCount ); 7158 VULKAN_HPP_HASH_COMBINE( seed, multiviewPerViewRenderAreasRenderPassBeginInfoQCOM.pPerViewRenderAreas ); 7159 return seed; 7160 } 7161 }; 7162 7163 template <> 7164 struct hash<VULKAN_HPP_NAMESPACE::MutableDescriptorTypeListEXT> 7165 { operator ()std::hash7166 std::size_t operator()( VULKAN_HPP_NAMESPACE::MutableDescriptorTypeListEXT const & mutableDescriptorTypeListEXT ) const VULKAN_HPP_NOEXCEPT 7167 { 7168 std::size_t seed = 0; 7169 VULKAN_HPP_HASH_COMBINE( seed, mutableDescriptorTypeListEXT.descriptorTypeCount ); 7170 VULKAN_HPP_HASH_COMBINE( seed, mutableDescriptorTypeListEXT.pDescriptorTypes ); 7171 return seed; 7172 } 7173 }; 7174 7175 template <> 7176 struct hash<VULKAN_HPP_NAMESPACE::MutableDescriptorTypeCreateInfoEXT> 7177 { operator ()std::hash7178 std::size_t operator()( VULKAN_HPP_NAMESPACE::MutableDescriptorTypeCreateInfoEXT const & mutableDescriptorTypeCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 7179 { 7180 std::size_t seed = 0; 7181 VULKAN_HPP_HASH_COMBINE( seed, mutableDescriptorTypeCreateInfoEXT.sType ); 7182 VULKAN_HPP_HASH_COMBINE( seed, mutableDescriptorTypeCreateInfoEXT.pNext ); 7183 VULKAN_HPP_HASH_COMBINE( seed, mutableDescriptorTypeCreateInfoEXT.mutableDescriptorTypeListCount ); 7184 VULKAN_HPP_HASH_COMBINE( seed, mutableDescriptorTypeCreateInfoEXT.pMutableDescriptorTypeLists ); 7185 return seed; 7186 } 7187 }; 7188 7189 template <> 7190 struct hash<VULKAN_HPP_NAMESPACE::OpaqueCaptureDescriptorDataCreateInfoEXT> 7191 { 7192 std::size_t operator ()std::hash7193 operator()( VULKAN_HPP_NAMESPACE::OpaqueCaptureDescriptorDataCreateInfoEXT const & opaqueCaptureDescriptorDataCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 7194 { 7195 std::size_t seed = 0; 7196 VULKAN_HPP_HASH_COMBINE( seed, opaqueCaptureDescriptorDataCreateInfoEXT.sType ); 7197 VULKAN_HPP_HASH_COMBINE( seed, opaqueCaptureDescriptorDataCreateInfoEXT.pNext ); 7198 VULKAN_HPP_HASH_COMBINE( seed, opaqueCaptureDescriptorDataCreateInfoEXT.opaqueCaptureDescriptorData ); 7199 return seed; 7200 } 7201 }; 7202 7203 template <> 7204 struct hash<VULKAN_HPP_NAMESPACE::OpticalFlowExecuteInfoNV> 7205 { operator ()std::hash7206 std::size_t operator()( VULKAN_HPP_NAMESPACE::OpticalFlowExecuteInfoNV const & opticalFlowExecuteInfoNV ) const VULKAN_HPP_NOEXCEPT 7207 { 7208 std::size_t seed = 0; 7209 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowExecuteInfoNV.sType ); 7210 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowExecuteInfoNV.pNext ); 7211 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowExecuteInfoNV.flags ); 7212 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowExecuteInfoNV.regionCount ); 7213 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowExecuteInfoNV.pRegions ); 7214 return seed; 7215 } 7216 }; 7217 7218 template <> 7219 struct hash<VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatInfoNV> 7220 { operator ()std::hash7221 std::size_t operator()( VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatInfoNV const & opticalFlowImageFormatInfoNV ) const VULKAN_HPP_NOEXCEPT 7222 { 7223 std::size_t seed = 0; 7224 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowImageFormatInfoNV.sType ); 7225 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowImageFormatInfoNV.pNext ); 7226 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowImageFormatInfoNV.usage ); 7227 return seed; 7228 } 7229 }; 7230 7231 template <> 7232 struct hash<VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV> 7233 { operator ()std::hash7234 std::size_t operator()( VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV const & opticalFlowImageFormatPropertiesNV ) const VULKAN_HPP_NOEXCEPT 7235 { 7236 std::size_t seed = 0; 7237 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowImageFormatPropertiesNV.sType ); 7238 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowImageFormatPropertiesNV.pNext ); 7239 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowImageFormatPropertiesNV.format ); 7240 return seed; 7241 } 7242 }; 7243 7244 template <> 7245 struct hash<VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreateInfoNV> 7246 { operator ()std::hash7247 std::size_t operator()( VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreateInfoNV const & opticalFlowSessionCreateInfoNV ) const VULKAN_HPP_NOEXCEPT 7248 { 7249 std::size_t seed = 0; 7250 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.sType ); 7251 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.pNext ); 7252 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.width ); 7253 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.height ); 7254 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.imageFormat ); 7255 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.flowVectorFormat ); 7256 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.costFormat ); 7257 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.outputGridSize ); 7258 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.hintGridSize ); 7259 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.performanceLevel ); 7260 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.flags ); 7261 return seed; 7262 } 7263 }; 7264 7265 template <> 7266 struct hash<VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreatePrivateDataInfoNV> 7267 { 7268 std::size_t operator ()std::hash7269 operator()( VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreatePrivateDataInfoNV const & opticalFlowSessionCreatePrivateDataInfoNV ) const VULKAN_HPP_NOEXCEPT 7270 { 7271 std::size_t seed = 0; 7272 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreatePrivateDataInfoNV.sType ); 7273 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreatePrivateDataInfoNV.pNext ); 7274 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreatePrivateDataInfoNV.id ); 7275 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreatePrivateDataInfoNV.size ); 7276 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreatePrivateDataInfoNV.pPrivateData ); 7277 return seed; 7278 } 7279 }; 7280 7281 template <> 7282 struct hash<VULKAN_HPP_NAMESPACE::OutOfBandQueueTypeInfoNV> 7283 { operator ()std::hash7284 std::size_t operator()( VULKAN_HPP_NAMESPACE::OutOfBandQueueTypeInfoNV const & outOfBandQueueTypeInfoNV ) const VULKAN_HPP_NOEXCEPT 7285 { 7286 std::size_t seed = 0; 7287 VULKAN_HPP_HASH_COMBINE( seed, outOfBandQueueTypeInfoNV.sType ); 7288 VULKAN_HPP_HASH_COMBINE( seed, outOfBandQueueTypeInfoNV.pNext ); 7289 VULKAN_HPP_HASH_COMBINE( seed, outOfBandQueueTypeInfoNV.queueType ); 7290 return seed; 7291 } 7292 }; 7293 7294 template <> 7295 struct hash<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE> 7296 { operator ()std::hash7297 std::size_t operator()( VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE const & pastPresentationTimingGOOGLE ) const VULKAN_HPP_NOEXCEPT 7298 { 7299 std::size_t seed = 0; 7300 VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingGOOGLE.presentID ); 7301 VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingGOOGLE.desiredPresentTime ); 7302 VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingGOOGLE.actualPresentTime ); 7303 VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingGOOGLE.earliestPresentTime ); 7304 VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingGOOGLE.presentMargin ); 7305 return seed; 7306 } 7307 }; 7308 7309 template <> 7310 struct hash<VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL> 7311 { 7312 std::size_t operator ()std::hash7313 operator()( VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL const & performanceConfigurationAcquireInfoINTEL ) const VULKAN_HPP_NOEXCEPT 7314 { 7315 std::size_t seed = 0; 7316 VULKAN_HPP_HASH_COMBINE( seed, performanceConfigurationAcquireInfoINTEL.sType ); 7317 VULKAN_HPP_HASH_COMBINE( seed, performanceConfigurationAcquireInfoINTEL.pNext ); 7318 VULKAN_HPP_HASH_COMBINE( seed, performanceConfigurationAcquireInfoINTEL.type ); 7319 return seed; 7320 } 7321 }; 7322 7323 template <> 7324 struct hash<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR> 7325 { operator ()std::hash7326 std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR const & performanceCounterDescriptionKHR ) const VULKAN_HPP_NOEXCEPT 7327 { 7328 std::size_t seed = 0; 7329 VULKAN_HPP_HASH_COMBINE( seed, performanceCounterDescriptionKHR.sType ); 7330 VULKAN_HPP_HASH_COMBINE( seed, performanceCounterDescriptionKHR.pNext ); 7331 VULKAN_HPP_HASH_COMBINE( seed, performanceCounterDescriptionKHR.flags ); 7332 for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) 7333 { 7334 VULKAN_HPP_HASH_COMBINE( seed, performanceCounterDescriptionKHR.name[i] ); 7335 } 7336 for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) 7337 { 7338 VULKAN_HPP_HASH_COMBINE( seed, performanceCounterDescriptionKHR.category[i] ); 7339 } 7340 for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) 7341 { 7342 VULKAN_HPP_HASH_COMBINE( seed, performanceCounterDescriptionKHR.description[i] ); 7343 } 7344 return seed; 7345 } 7346 }; 7347 7348 template <> 7349 struct hash<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR> 7350 { operator ()std::hash7351 std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceCounterKHR const & performanceCounterKHR ) const VULKAN_HPP_NOEXCEPT 7352 { 7353 std::size_t seed = 0; 7354 VULKAN_HPP_HASH_COMBINE( seed, performanceCounterKHR.sType ); 7355 VULKAN_HPP_HASH_COMBINE( seed, performanceCounterKHR.pNext ); 7356 VULKAN_HPP_HASH_COMBINE( seed, performanceCounterKHR.unit ); 7357 VULKAN_HPP_HASH_COMBINE( seed, performanceCounterKHR.scope ); 7358 VULKAN_HPP_HASH_COMBINE( seed, performanceCounterKHR.storage ); 7359 for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) 7360 { 7361 VULKAN_HPP_HASH_COMBINE( seed, performanceCounterKHR.uuid[i] ); 7362 } 7363 return seed; 7364 } 7365 }; 7366 7367 template <> 7368 struct hash<VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL> 7369 { operator ()std::hash7370 std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL const & performanceMarkerInfoINTEL ) const VULKAN_HPP_NOEXCEPT 7371 { 7372 std::size_t seed = 0; 7373 VULKAN_HPP_HASH_COMBINE( seed, performanceMarkerInfoINTEL.sType ); 7374 VULKAN_HPP_HASH_COMBINE( seed, performanceMarkerInfoINTEL.pNext ); 7375 VULKAN_HPP_HASH_COMBINE( seed, performanceMarkerInfoINTEL.marker ); 7376 return seed; 7377 } 7378 }; 7379 7380 template <> 7381 struct hash<VULKAN_HPP_NAMESPACE::PerformanceOverrideInfoINTEL> 7382 { operator ()std::hash7383 std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceOverrideInfoINTEL const & performanceOverrideInfoINTEL ) const VULKAN_HPP_NOEXCEPT 7384 { 7385 std::size_t seed = 0; 7386 VULKAN_HPP_HASH_COMBINE( seed, performanceOverrideInfoINTEL.sType ); 7387 VULKAN_HPP_HASH_COMBINE( seed, performanceOverrideInfoINTEL.pNext ); 7388 VULKAN_HPP_HASH_COMBINE( seed, performanceOverrideInfoINTEL.type ); 7389 VULKAN_HPP_HASH_COMBINE( seed, performanceOverrideInfoINTEL.enable ); 7390 VULKAN_HPP_HASH_COMBINE( seed, performanceOverrideInfoINTEL.parameter ); 7391 return seed; 7392 } 7393 }; 7394 7395 template <> 7396 struct hash<VULKAN_HPP_NAMESPACE::PerformanceQuerySubmitInfoKHR> 7397 { operator ()std::hash7398 std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceQuerySubmitInfoKHR const & performanceQuerySubmitInfoKHR ) const VULKAN_HPP_NOEXCEPT 7399 { 7400 std::size_t seed = 0; 7401 VULKAN_HPP_HASH_COMBINE( seed, performanceQuerySubmitInfoKHR.sType ); 7402 VULKAN_HPP_HASH_COMBINE( seed, performanceQuerySubmitInfoKHR.pNext ); 7403 VULKAN_HPP_HASH_COMBINE( seed, performanceQuerySubmitInfoKHR.counterPassIndex ); 7404 return seed; 7405 } 7406 }; 7407 7408 template <> 7409 struct hash<VULKAN_HPP_NAMESPACE::PerformanceStreamMarkerInfoINTEL> 7410 { operator ()std::hash7411 std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceStreamMarkerInfoINTEL const & performanceStreamMarkerInfoINTEL ) const VULKAN_HPP_NOEXCEPT 7412 { 7413 std::size_t seed = 0; 7414 VULKAN_HPP_HASH_COMBINE( seed, performanceStreamMarkerInfoINTEL.sType ); 7415 VULKAN_HPP_HASH_COMBINE( seed, performanceStreamMarkerInfoINTEL.pNext ); 7416 VULKAN_HPP_HASH_COMBINE( seed, performanceStreamMarkerInfoINTEL.marker ); 7417 return seed; 7418 } 7419 }; 7420 7421 template <> 7422 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevice16BitStorageFeatures> 7423 { operator ()std::hash7424 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevice16BitStorageFeatures const & physicalDevice16BitStorageFeatures ) const VULKAN_HPP_NOEXCEPT 7425 { 7426 std::size_t seed = 0; 7427 VULKAN_HPP_HASH_COMBINE( seed, physicalDevice16BitStorageFeatures.sType ); 7428 VULKAN_HPP_HASH_COMBINE( seed, physicalDevice16BitStorageFeatures.pNext ); 7429 VULKAN_HPP_HASH_COMBINE( seed, physicalDevice16BitStorageFeatures.storageBuffer16BitAccess ); 7430 VULKAN_HPP_HASH_COMBINE( seed, physicalDevice16BitStorageFeatures.uniformAndStorageBuffer16BitAccess ); 7431 VULKAN_HPP_HASH_COMBINE( seed, physicalDevice16BitStorageFeatures.storagePushConstant16 ); 7432 VULKAN_HPP_HASH_COMBINE( seed, physicalDevice16BitStorageFeatures.storageInputOutput16 ); 7433 return seed; 7434 } 7435 }; 7436 7437 template <> 7438 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevice4444FormatsFeaturesEXT> 7439 { operator ()std::hash7440 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevice4444FormatsFeaturesEXT const & physicalDevice4444FormatsFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 7441 { 7442 std::size_t seed = 0; 7443 VULKAN_HPP_HASH_COMBINE( seed, physicalDevice4444FormatsFeaturesEXT.sType ); 7444 VULKAN_HPP_HASH_COMBINE( seed, physicalDevice4444FormatsFeaturesEXT.pNext ); 7445 VULKAN_HPP_HASH_COMBINE( seed, physicalDevice4444FormatsFeaturesEXT.formatA4R4G4B4 ); 7446 VULKAN_HPP_HASH_COMBINE( seed, physicalDevice4444FormatsFeaturesEXT.formatA4B4G4R4 ); 7447 return seed; 7448 } 7449 }; 7450 7451 template <> 7452 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevice8BitStorageFeatures> 7453 { operator ()std::hash7454 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevice8BitStorageFeatures const & physicalDevice8BitStorageFeatures ) const VULKAN_HPP_NOEXCEPT 7455 { 7456 std::size_t seed = 0; 7457 VULKAN_HPP_HASH_COMBINE( seed, physicalDevice8BitStorageFeatures.sType ); 7458 VULKAN_HPP_HASH_COMBINE( seed, physicalDevice8BitStorageFeatures.pNext ); 7459 VULKAN_HPP_HASH_COMBINE( seed, physicalDevice8BitStorageFeatures.storageBuffer8BitAccess ); 7460 VULKAN_HPP_HASH_COMBINE( seed, physicalDevice8BitStorageFeatures.uniformAndStorageBuffer8BitAccess ); 7461 VULKAN_HPP_HASH_COMBINE( seed, physicalDevice8BitStorageFeatures.storagePushConstant8 ); 7462 return seed; 7463 } 7464 }; 7465 7466 template <> 7467 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceASTCDecodeFeaturesEXT> 7468 { operator ()std::hash7469 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceASTCDecodeFeaturesEXT const & physicalDeviceASTCDecodeFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 7470 { 7471 std::size_t seed = 0; 7472 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceASTCDecodeFeaturesEXT.sType ); 7473 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceASTCDecodeFeaturesEXT.pNext ); 7474 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceASTCDecodeFeaturesEXT.decodeModeSharedExponent ); 7475 return seed; 7476 } 7477 }; 7478 7479 template <> 7480 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceAccelerationStructureFeaturesKHR> 7481 { operator ()std::hash7482 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceAccelerationStructureFeaturesKHR const & physicalDeviceAccelerationStructureFeaturesKHR ) const 7483 VULKAN_HPP_NOEXCEPT 7484 { 7485 std::size_t seed = 0; 7486 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructureFeaturesKHR.sType ); 7487 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructureFeaturesKHR.pNext ); 7488 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructureFeaturesKHR.accelerationStructure ); 7489 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructureFeaturesKHR.accelerationStructureCaptureReplay ); 7490 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructureFeaturesKHR.accelerationStructureIndirectBuild ); 7491 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructureFeaturesKHR.accelerationStructureHostCommands ); 7492 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructureFeaturesKHR.descriptorBindingAccelerationStructureUpdateAfterBind ); 7493 return seed; 7494 } 7495 }; 7496 7497 template <> 7498 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceAccelerationStructurePropertiesKHR> 7499 { operator ()std::hash7500 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceAccelerationStructurePropertiesKHR const & physicalDeviceAccelerationStructurePropertiesKHR ) 7501 const VULKAN_HPP_NOEXCEPT 7502 { 7503 std::size_t seed = 0; 7504 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.sType ); 7505 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.pNext ); 7506 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.maxGeometryCount ); 7507 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.maxInstanceCount ); 7508 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.maxPrimitiveCount ); 7509 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.maxPerStageDescriptorAccelerationStructures ); 7510 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.maxPerStageDescriptorUpdateAfterBindAccelerationStructures ); 7511 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.maxDescriptorSetAccelerationStructures ); 7512 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.maxDescriptorSetUpdateAfterBindAccelerationStructures ); 7513 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.minAccelerationStructureScratchOffsetAlignment ); 7514 return seed; 7515 } 7516 }; 7517 7518 template <> 7519 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceAddressBindingReportFeaturesEXT> 7520 { operator ()std::hash7521 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceAddressBindingReportFeaturesEXT const & physicalDeviceAddressBindingReportFeaturesEXT ) const 7522 VULKAN_HPP_NOEXCEPT 7523 { 7524 std::size_t seed = 0; 7525 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAddressBindingReportFeaturesEXT.sType ); 7526 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAddressBindingReportFeaturesEXT.pNext ); 7527 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAddressBindingReportFeaturesEXT.reportAddressBinding ); 7528 return seed; 7529 } 7530 }; 7531 7532 template <> 7533 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceAmigoProfilingFeaturesSEC> 7534 { 7535 std::size_t operator ()std::hash7536 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceAmigoProfilingFeaturesSEC const & physicalDeviceAmigoProfilingFeaturesSEC ) const VULKAN_HPP_NOEXCEPT 7537 { 7538 std::size_t seed = 0; 7539 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAmigoProfilingFeaturesSEC.sType ); 7540 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAmigoProfilingFeaturesSEC.pNext ); 7541 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAmigoProfilingFeaturesSEC.amigoProfiling ); 7542 return seed; 7543 } 7544 }; 7545 7546 template <> 7547 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceAntiLagFeaturesAMD> 7548 { operator ()std::hash7549 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceAntiLagFeaturesAMD const & physicalDeviceAntiLagFeaturesAMD ) const VULKAN_HPP_NOEXCEPT 7550 { 7551 std::size_t seed = 0; 7552 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAntiLagFeaturesAMD.sType ); 7553 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAntiLagFeaturesAMD.pNext ); 7554 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAntiLagFeaturesAMD.antiLag ); 7555 return seed; 7556 } 7557 }; 7558 7559 template <> 7560 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT> 7561 { operator ()std::hash7562 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT const & 7563 physicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 7564 { 7565 std::size_t seed = 0; 7566 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT.sType ); 7567 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT.pNext ); 7568 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT.attachmentFeedbackLoopDynamicState ); 7569 return seed; 7570 } 7571 }; 7572 7573 template <> 7574 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT> 7575 { operator ()std::hash7576 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT const & 7577 physicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 7578 { 7579 std::size_t seed = 0; 7580 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT.sType ); 7581 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT.pNext ); 7582 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT.attachmentFeedbackLoopLayout ); 7583 return seed; 7584 } 7585 }; 7586 7587 template <> 7588 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceBlendOperationAdvancedFeaturesEXT> 7589 { operator ()std::hash7590 std::size_t operator()( 7591 VULKAN_HPP_NAMESPACE::PhysicalDeviceBlendOperationAdvancedFeaturesEXT const & physicalDeviceBlendOperationAdvancedFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 7592 { 7593 std::size_t seed = 0; 7594 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedFeaturesEXT.sType ); 7595 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedFeaturesEXT.pNext ); 7596 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedFeaturesEXT.advancedBlendCoherentOperations ); 7597 return seed; 7598 } 7599 }; 7600 7601 template <> 7602 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceBlendOperationAdvancedPropertiesEXT> 7603 { operator ()std::hash7604 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceBlendOperationAdvancedPropertiesEXT const & physicalDeviceBlendOperationAdvancedPropertiesEXT ) 7605 const VULKAN_HPP_NOEXCEPT 7606 { 7607 std::size_t seed = 0; 7608 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.sType ); 7609 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.pNext ); 7610 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendMaxColorAttachments ); 7611 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendIndependentBlend ); 7612 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendNonPremultipliedSrcColor ); 7613 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendNonPremultipliedDstColor ); 7614 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendCorrelatedOverlap ); 7615 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendAllOperations ); 7616 return seed; 7617 } 7618 }; 7619 7620 template <> 7621 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceBorderColorSwizzleFeaturesEXT> 7622 { operator ()std::hash7623 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceBorderColorSwizzleFeaturesEXT const & physicalDeviceBorderColorSwizzleFeaturesEXT ) const 7624 VULKAN_HPP_NOEXCEPT 7625 { 7626 std::size_t seed = 0; 7627 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBorderColorSwizzleFeaturesEXT.sType ); 7628 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBorderColorSwizzleFeaturesEXT.pNext ); 7629 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBorderColorSwizzleFeaturesEXT.borderColorSwizzle ); 7630 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBorderColorSwizzleFeaturesEXT.borderColorSwizzleFromImage ); 7631 return seed; 7632 } 7633 }; 7634 7635 template <> 7636 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceBufferDeviceAddressFeatures> 7637 { 7638 std::size_t operator ()std::hash7639 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceBufferDeviceAddressFeatures const & physicalDeviceBufferDeviceAddressFeatures ) const VULKAN_HPP_NOEXCEPT 7640 { 7641 std::size_t seed = 0; 7642 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeatures.sType ); 7643 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeatures.pNext ); 7644 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeatures.bufferDeviceAddress ); 7645 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeatures.bufferDeviceAddressCaptureReplay ); 7646 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeatures.bufferDeviceAddressMultiDevice ); 7647 return seed; 7648 } 7649 }; 7650 7651 template <> 7652 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceBufferDeviceAddressFeaturesEXT> 7653 { operator ()std::hash7654 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceBufferDeviceAddressFeaturesEXT const & physicalDeviceBufferDeviceAddressFeaturesEXT ) const 7655 VULKAN_HPP_NOEXCEPT 7656 { 7657 std::size_t seed = 0; 7658 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeaturesEXT.sType ); 7659 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeaturesEXT.pNext ); 7660 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeaturesEXT.bufferDeviceAddress ); 7661 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeaturesEXT.bufferDeviceAddressCaptureReplay ); 7662 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeaturesEXT.bufferDeviceAddressMultiDevice ); 7663 return seed; 7664 } 7665 }; 7666 7667 template <> 7668 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterCullingShaderFeaturesHUAWEI> 7669 { operator ()std::hash7670 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterCullingShaderFeaturesHUAWEI const & physicalDeviceClusterCullingShaderFeaturesHUAWEI ) 7671 const VULKAN_HPP_NOEXCEPT 7672 { 7673 std::size_t seed = 0; 7674 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderFeaturesHUAWEI.sType ); 7675 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderFeaturesHUAWEI.pNext ); 7676 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderFeaturesHUAWEI.clustercullingShader ); 7677 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderFeaturesHUAWEI.multiviewClusterCullingShader ); 7678 return seed; 7679 } 7680 }; 7681 7682 template <> 7683 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterCullingShaderPropertiesHUAWEI> 7684 { 7685 std::size_t operator ()std::hash7686 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterCullingShaderPropertiesHUAWEI const & physicalDeviceClusterCullingShaderPropertiesHUAWEI ) const 7687 VULKAN_HPP_NOEXCEPT 7688 { 7689 std::size_t seed = 0; 7690 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderPropertiesHUAWEI.sType ); 7691 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderPropertiesHUAWEI.pNext ); 7692 for ( size_t i = 0; i < 3; ++i ) 7693 { 7694 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderPropertiesHUAWEI.maxWorkGroupCount[i] ); 7695 } 7696 for ( size_t i = 0; i < 3; ++i ) 7697 { 7698 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderPropertiesHUAWEI.maxWorkGroupSize[i] ); 7699 } 7700 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderPropertiesHUAWEI.maxOutputClusterCount ); 7701 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderPropertiesHUAWEI.indirectBufferOffsetAlignment ); 7702 return seed; 7703 } 7704 }; 7705 7706 template <> 7707 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI> 7708 { 7709 std::size_t operator ()std::hash7710 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI const & physicalDeviceClusterCullingShaderVrsFeaturesHUAWEI ) const 7711 VULKAN_HPP_NOEXCEPT 7712 { 7713 std::size_t seed = 0; 7714 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderVrsFeaturesHUAWEI.sType ); 7715 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderVrsFeaturesHUAWEI.pNext ); 7716 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderVrsFeaturesHUAWEI.clusterShadingRate ); 7717 return seed; 7718 } 7719 }; 7720 7721 template <> 7722 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCoherentMemoryFeaturesAMD> 7723 { 7724 std::size_t operator ()std::hash7725 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCoherentMemoryFeaturesAMD const & physicalDeviceCoherentMemoryFeaturesAMD ) const VULKAN_HPP_NOEXCEPT 7726 { 7727 std::size_t seed = 0; 7728 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCoherentMemoryFeaturesAMD.sType ); 7729 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCoherentMemoryFeaturesAMD.pNext ); 7730 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCoherentMemoryFeaturesAMD.deviceCoherentMemory ); 7731 return seed; 7732 } 7733 }; 7734 7735 template <> 7736 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceColorWriteEnableFeaturesEXT> 7737 { 7738 std::size_t operator ()std::hash7739 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceColorWriteEnableFeaturesEXT const & physicalDeviceColorWriteEnableFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 7740 { 7741 std::size_t seed = 0; 7742 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceColorWriteEnableFeaturesEXT.sType ); 7743 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceColorWriteEnableFeaturesEXT.pNext ); 7744 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceColorWriteEnableFeaturesEXT.colorWriteEnable ); 7745 return seed; 7746 } 7747 }; 7748 7749 template <> 7750 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCommandBufferInheritanceFeaturesNV> 7751 { operator ()std::hash7752 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCommandBufferInheritanceFeaturesNV const & physicalDeviceCommandBufferInheritanceFeaturesNV ) 7753 const VULKAN_HPP_NOEXCEPT 7754 { 7755 std::size_t seed = 0; 7756 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCommandBufferInheritanceFeaturesNV.sType ); 7757 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCommandBufferInheritanceFeaturesNV.pNext ); 7758 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCommandBufferInheritanceFeaturesNV.commandBufferInheritance ); 7759 return seed; 7760 } 7761 }; 7762 7763 template <> 7764 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceComputeShaderDerivativesFeaturesNV> 7765 { operator ()std::hash7766 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceComputeShaderDerivativesFeaturesNV const & physicalDeviceComputeShaderDerivativesFeaturesNV ) 7767 const VULKAN_HPP_NOEXCEPT 7768 { 7769 std::size_t seed = 0; 7770 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceComputeShaderDerivativesFeaturesNV.sType ); 7771 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceComputeShaderDerivativesFeaturesNV.pNext ); 7772 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceComputeShaderDerivativesFeaturesNV.computeDerivativeGroupQuads ); 7773 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceComputeShaderDerivativesFeaturesNV.computeDerivativeGroupLinear ); 7774 return seed; 7775 } 7776 }; 7777 7778 template <> 7779 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceConditionalRenderingFeaturesEXT> 7780 { operator ()std::hash7781 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceConditionalRenderingFeaturesEXT const & physicalDeviceConditionalRenderingFeaturesEXT ) const 7782 VULKAN_HPP_NOEXCEPT 7783 { 7784 std::size_t seed = 0; 7785 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConditionalRenderingFeaturesEXT.sType ); 7786 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConditionalRenderingFeaturesEXT.pNext ); 7787 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConditionalRenderingFeaturesEXT.conditionalRendering ); 7788 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConditionalRenderingFeaturesEXT.inheritedConditionalRendering ); 7789 return seed; 7790 } 7791 }; 7792 7793 template <> 7794 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceConservativeRasterizationPropertiesEXT> 7795 { operator ()std::hash7796 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceConservativeRasterizationPropertiesEXT const & 7797 physicalDeviceConservativeRasterizationPropertiesEXT ) const VULKAN_HPP_NOEXCEPT 7798 { 7799 std::size_t seed = 0; 7800 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.sType ); 7801 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.pNext ); 7802 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.primitiveOverestimationSize ); 7803 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.maxExtraPrimitiveOverestimationSize ); 7804 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.extraPrimitiveOverestimationSizeGranularity ); 7805 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.primitiveUnderestimation ); 7806 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.conservativePointAndLineRasterization ); 7807 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.degenerateTrianglesRasterized ); 7808 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.degenerateLinesRasterized ); 7809 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.fullyCoveredFragmentShaderInputVariable ); 7810 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.conservativeRasterizationPostDepthCoverage ); 7811 return seed; 7812 } 7813 }; 7814 7815 template <> 7816 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixFeaturesKHR> 7817 { operator ()std::hash7818 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixFeaturesKHR const & physicalDeviceCooperativeMatrixFeaturesKHR ) const 7819 VULKAN_HPP_NOEXCEPT 7820 { 7821 std::size_t seed = 0; 7822 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixFeaturesKHR.sType ); 7823 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixFeaturesKHR.pNext ); 7824 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixFeaturesKHR.cooperativeMatrix ); 7825 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixFeaturesKHR.cooperativeMatrixRobustBufferAccess ); 7826 return seed; 7827 } 7828 }; 7829 7830 template <> 7831 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixFeaturesNV> 7832 { 7833 std::size_t operator ()std::hash7834 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixFeaturesNV const & physicalDeviceCooperativeMatrixFeaturesNV ) const VULKAN_HPP_NOEXCEPT 7835 { 7836 std::size_t seed = 0; 7837 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixFeaturesNV.sType ); 7838 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixFeaturesNV.pNext ); 7839 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixFeaturesNV.cooperativeMatrix ); 7840 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixFeaturesNV.cooperativeMatrixRobustBufferAccess ); 7841 return seed; 7842 } 7843 }; 7844 7845 template <> 7846 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixPropertiesKHR> 7847 { operator ()std::hash7848 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixPropertiesKHR const & physicalDeviceCooperativeMatrixPropertiesKHR ) const 7849 VULKAN_HPP_NOEXCEPT 7850 { 7851 std::size_t seed = 0; 7852 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixPropertiesKHR.sType ); 7853 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixPropertiesKHR.pNext ); 7854 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixPropertiesKHR.cooperativeMatrixSupportedStages ); 7855 return seed; 7856 } 7857 }; 7858 7859 template <> 7860 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixPropertiesNV> 7861 { operator ()std::hash7862 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixPropertiesNV const & physicalDeviceCooperativeMatrixPropertiesNV ) const 7863 VULKAN_HPP_NOEXCEPT 7864 { 7865 std::size_t seed = 0; 7866 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixPropertiesNV.sType ); 7867 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixPropertiesNV.pNext ); 7868 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixPropertiesNV.cooperativeMatrixSupportedStages ); 7869 return seed; 7870 } 7871 }; 7872 7873 template <> 7874 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectFeaturesNV> 7875 { operator ()std::hash7876 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectFeaturesNV const & physicalDeviceCopyMemoryIndirectFeaturesNV ) const 7877 VULKAN_HPP_NOEXCEPT 7878 { 7879 std::size_t seed = 0; 7880 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCopyMemoryIndirectFeaturesNV.sType ); 7881 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCopyMemoryIndirectFeaturesNV.pNext ); 7882 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCopyMemoryIndirectFeaturesNV.indirectCopy ); 7883 return seed; 7884 } 7885 }; 7886 7887 template <> 7888 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectPropertiesNV> 7889 { operator ()std::hash7890 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectPropertiesNV const & physicalDeviceCopyMemoryIndirectPropertiesNV ) const 7891 VULKAN_HPP_NOEXCEPT 7892 { 7893 std::size_t seed = 0; 7894 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCopyMemoryIndirectPropertiesNV.sType ); 7895 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCopyMemoryIndirectPropertiesNV.pNext ); 7896 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCopyMemoryIndirectPropertiesNV.supportedQueues ); 7897 return seed; 7898 } 7899 }; 7900 7901 template <> 7902 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCornerSampledImageFeaturesNV> 7903 { operator ()std::hash7904 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCornerSampledImageFeaturesNV const & physicalDeviceCornerSampledImageFeaturesNV ) const 7905 VULKAN_HPP_NOEXCEPT 7906 { 7907 std::size_t seed = 0; 7908 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCornerSampledImageFeaturesNV.sType ); 7909 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCornerSampledImageFeaturesNV.pNext ); 7910 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCornerSampledImageFeaturesNV.cornerSampledImage ); 7911 return seed; 7912 } 7913 }; 7914 7915 template <> 7916 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCoverageReductionModeFeaturesNV> 7917 { operator ()std::hash7918 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCoverageReductionModeFeaturesNV const & physicalDeviceCoverageReductionModeFeaturesNV ) const 7919 VULKAN_HPP_NOEXCEPT 7920 { 7921 std::size_t seed = 0; 7922 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCoverageReductionModeFeaturesNV.sType ); 7923 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCoverageReductionModeFeaturesNV.pNext ); 7924 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCoverageReductionModeFeaturesNV.coverageReductionMode ); 7925 return seed; 7926 } 7927 }; 7928 7929 template <> 7930 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCubicClampFeaturesQCOM> 7931 { operator ()std::hash7932 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCubicClampFeaturesQCOM const & physicalDeviceCubicClampFeaturesQCOM ) const VULKAN_HPP_NOEXCEPT 7933 { 7934 std::size_t seed = 0; 7935 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCubicClampFeaturesQCOM.sType ); 7936 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCubicClampFeaturesQCOM.pNext ); 7937 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCubicClampFeaturesQCOM.cubicRangeClamp ); 7938 return seed; 7939 } 7940 }; 7941 7942 template <> 7943 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCubicWeightsFeaturesQCOM> 7944 { 7945 std::size_t operator ()std::hash7946 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCubicWeightsFeaturesQCOM const & physicalDeviceCubicWeightsFeaturesQCOM ) const VULKAN_HPP_NOEXCEPT 7947 { 7948 std::size_t seed = 0; 7949 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCubicWeightsFeaturesQCOM.sType ); 7950 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCubicWeightsFeaturesQCOM.pNext ); 7951 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCubicWeightsFeaturesQCOM.selectableCubicWeights ); 7952 return seed; 7953 } 7954 }; 7955 7956 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 7957 template <> 7958 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCudaKernelLaunchFeaturesNV> 7959 { 7960 std::size_t operator ()std::hash7961 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCudaKernelLaunchFeaturesNV const & physicalDeviceCudaKernelLaunchFeaturesNV ) const VULKAN_HPP_NOEXCEPT 7962 { 7963 std::size_t seed = 0; 7964 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCudaKernelLaunchFeaturesNV.sType ); 7965 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCudaKernelLaunchFeaturesNV.pNext ); 7966 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCudaKernelLaunchFeaturesNV.cudaKernelLaunchFeatures ); 7967 return seed; 7968 } 7969 }; 7970 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 7971 7972 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 7973 template <> 7974 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCudaKernelLaunchPropertiesNV> 7975 { operator ()std::hash7976 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCudaKernelLaunchPropertiesNV const & physicalDeviceCudaKernelLaunchPropertiesNV ) const 7977 VULKAN_HPP_NOEXCEPT 7978 { 7979 std::size_t seed = 0; 7980 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCudaKernelLaunchPropertiesNV.sType ); 7981 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCudaKernelLaunchPropertiesNV.pNext ); 7982 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCudaKernelLaunchPropertiesNV.computeCapabilityMinor ); 7983 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCudaKernelLaunchPropertiesNV.computeCapabilityMajor ); 7984 return seed; 7985 } 7986 }; 7987 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 7988 7989 template <> 7990 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomBorderColorFeaturesEXT> 7991 { operator ()std::hash7992 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomBorderColorFeaturesEXT const & physicalDeviceCustomBorderColorFeaturesEXT ) const 7993 VULKAN_HPP_NOEXCEPT 7994 { 7995 std::size_t seed = 0; 7996 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCustomBorderColorFeaturesEXT.sType ); 7997 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCustomBorderColorFeaturesEXT.pNext ); 7998 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCustomBorderColorFeaturesEXT.customBorderColors ); 7999 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCustomBorderColorFeaturesEXT.customBorderColorWithoutFormat ); 8000 return seed; 8001 } 8002 }; 8003 8004 template <> 8005 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomBorderColorPropertiesEXT> 8006 { operator ()std::hash8007 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomBorderColorPropertiesEXT const & physicalDeviceCustomBorderColorPropertiesEXT ) const 8008 VULKAN_HPP_NOEXCEPT 8009 { 8010 std::size_t seed = 0; 8011 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCustomBorderColorPropertiesEXT.sType ); 8012 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCustomBorderColorPropertiesEXT.pNext ); 8013 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCustomBorderColorPropertiesEXT.maxCustomBorderColorSamplers ); 8014 return seed; 8015 } 8016 }; 8017 8018 template <> 8019 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV> 8020 { operator ()std::hash8021 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const & 8022 physicalDeviceDedicatedAllocationImageAliasingFeaturesNV ) const VULKAN_HPP_NOEXCEPT 8023 { 8024 std::size_t seed = 0; 8025 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDedicatedAllocationImageAliasingFeaturesNV.sType ); 8026 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDedicatedAllocationImageAliasingFeaturesNV.pNext ); 8027 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDedicatedAllocationImageAliasingFeaturesNV.dedicatedAllocationImageAliasing ); 8028 return seed; 8029 } 8030 }; 8031 8032 template <> 8033 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthBiasControlFeaturesEXT> 8034 { 8035 std::size_t operator ()std::hash8036 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthBiasControlFeaturesEXT const & physicalDeviceDepthBiasControlFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 8037 { 8038 std::size_t seed = 0; 8039 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthBiasControlFeaturesEXT.sType ); 8040 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthBiasControlFeaturesEXT.pNext ); 8041 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthBiasControlFeaturesEXT.depthBiasControl ); 8042 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthBiasControlFeaturesEXT.leastRepresentableValueForceUnormRepresentation ); 8043 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthBiasControlFeaturesEXT.floatRepresentation ); 8044 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthBiasControlFeaturesEXT.depthBiasExact ); 8045 return seed; 8046 } 8047 }; 8048 8049 template <> 8050 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClampZeroOneFeaturesEXT> 8051 { operator ()std::hash8052 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClampZeroOneFeaturesEXT const & physicalDeviceDepthClampZeroOneFeaturesEXT ) const 8053 VULKAN_HPP_NOEXCEPT 8054 { 8055 std::size_t seed = 0; 8056 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClampZeroOneFeaturesEXT.sType ); 8057 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClampZeroOneFeaturesEXT.pNext ); 8058 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClampZeroOneFeaturesEXT.depthClampZeroOne ); 8059 return seed; 8060 } 8061 }; 8062 8063 template <> 8064 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClipControlFeaturesEXT> 8065 { 8066 std::size_t operator ()std::hash8067 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClipControlFeaturesEXT const & physicalDeviceDepthClipControlFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 8068 { 8069 std::size_t seed = 0; 8070 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClipControlFeaturesEXT.sType ); 8071 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClipControlFeaturesEXT.pNext ); 8072 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClipControlFeaturesEXT.depthClipControl ); 8073 return seed; 8074 } 8075 }; 8076 8077 template <> 8078 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClipEnableFeaturesEXT> 8079 { 8080 std::size_t operator ()std::hash8081 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClipEnableFeaturesEXT const & physicalDeviceDepthClipEnableFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 8082 { 8083 std::size_t seed = 0; 8084 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClipEnableFeaturesEXT.sType ); 8085 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClipEnableFeaturesEXT.pNext ); 8086 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClipEnableFeaturesEXT.depthClipEnable ); 8087 return seed; 8088 } 8089 }; 8090 8091 template <> 8092 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthStencilResolveProperties> 8093 { operator ()std::hash8094 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthStencilResolveProperties const & physicalDeviceDepthStencilResolveProperties ) const 8095 VULKAN_HPP_NOEXCEPT 8096 { 8097 std::size_t seed = 0; 8098 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthStencilResolveProperties.sType ); 8099 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthStencilResolveProperties.pNext ); 8100 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthStencilResolveProperties.supportedDepthResolveModes ); 8101 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthStencilResolveProperties.supportedStencilResolveModes ); 8102 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthStencilResolveProperties.independentResolveNone ); 8103 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthStencilResolveProperties.independentResolve ); 8104 return seed; 8105 } 8106 }; 8107 8108 template <> 8109 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT> 8110 { operator ()std::hash8111 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT const & 8112 physicalDeviceDescriptorBufferDensityMapPropertiesEXT ) const VULKAN_HPP_NOEXCEPT 8113 { 8114 std::size_t seed = 0; 8115 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferDensityMapPropertiesEXT.sType ); 8116 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferDensityMapPropertiesEXT.pNext ); 8117 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferDensityMapPropertiesEXT.combinedImageSamplerDensityMapDescriptorSize ); 8118 return seed; 8119 } 8120 }; 8121 8122 template <> 8123 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferFeaturesEXT> 8124 { 8125 std::size_t operator ()std::hash8126 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferFeaturesEXT const & physicalDeviceDescriptorBufferFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 8127 { 8128 std::size_t seed = 0; 8129 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferFeaturesEXT.sType ); 8130 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferFeaturesEXT.pNext ); 8131 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferFeaturesEXT.descriptorBuffer ); 8132 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferFeaturesEXT.descriptorBufferCaptureReplay ); 8133 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferFeaturesEXT.descriptorBufferImageLayoutIgnored ); 8134 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferFeaturesEXT.descriptorBufferPushDescriptors ); 8135 return seed; 8136 } 8137 }; 8138 8139 template <> 8140 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferPropertiesEXT> 8141 { operator ()std::hash8142 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferPropertiesEXT const & physicalDeviceDescriptorBufferPropertiesEXT ) const 8143 VULKAN_HPP_NOEXCEPT 8144 { 8145 std::size_t seed = 0; 8146 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.sType ); 8147 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.pNext ); 8148 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.combinedImageSamplerDescriptorSingleArray ); 8149 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.bufferlessPushDescriptors ); 8150 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.allowSamplerImageViewPostSubmitCreation ); 8151 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.descriptorBufferOffsetAlignment ); 8152 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.maxDescriptorBufferBindings ); 8153 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.maxResourceDescriptorBufferBindings ); 8154 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.maxSamplerDescriptorBufferBindings ); 8155 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.maxEmbeddedImmutableSamplerBindings ); 8156 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.maxEmbeddedImmutableSamplers ); 8157 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.bufferCaptureReplayDescriptorDataSize ); 8158 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.imageCaptureReplayDescriptorDataSize ); 8159 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.imageViewCaptureReplayDescriptorDataSize ); 8160 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.samplerCaptureReplayDescriptorDataSize ); 8161 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.accelerationStructureCaptureReplayDescriptorDataSize ); 8162 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.samplerDescriptorSize ); 8163 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.combinedImageSamplerDescriptorSize ); 8164 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.sampledImageDescriptorSize ); 8165 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.storageImageDescriptorSize ); 8166 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.uniformTexelBufferDescriptorSize ); 8167 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.robustUniformTexelBufferDescriptorSize ); 8168 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.storageTexelBufferDescriptorSize ); 8169 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.robustStorageTexelBufferDescriptorSize ); 8170 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.uniformBufferDescriptorSize ); 8171 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.robustUniformBufferDescriptorSize ); 8172 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.storageBufferDescriptorSize ); 8173 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.robustStorageBufferDescriptorSize ); 8174 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.inputAttachmentDescriptorSize ); 8175 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.accelerationStructureDescriptorSize ); 8176 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.maxSamplerDescriptorBufferRange ); 8177 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.maxResourceDescriptorBufferRange ); 8178 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.samplerDescriptorBufferAddressSpaceSize ); 8179 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.resourceDescriptorBufferAddressSpaceSize ); 8180 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.descriptorBufferAddressSpaceSize ); 8181 return seed; 8182 } 8183 }; 8184 8185 template <> 8186 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorIndexingFeatures> 8187 { 8188 std::size_t operator ()std::hash8189 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorIndexingFeatures const & physicalDeviceDescriptorIndexingFeatures ) const VULKAN_HPP_NOEXCEPT 8190 { 8191 std::size_t seed = 0; 8192 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.sType ); 8193 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.pNext ); 8194 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderInputAttachmentArrayDynamicIndexing ); 8195 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderUniformTexelBufferArrayDynamicIndexing ); 8196 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderStorageTexelBufferArrayDynamicIndexing ); 8197 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderUniformBufferArrayNonUniformIndexing ); 8198 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderSampledImageArrayNonUniformIndexing ); 8199 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderStorageBufferArrayNonUniformIndexing ); 8200 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderStorageImageArrayNonUniformIndexing ); 8201 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderInputAttachmentArrayNonUniformIndexing ); 8202 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderUniformTexelBufferArrayNonUniformIndexing ); 8203 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderStorageTexelBufferArrayNonUniformIndexing ); 8204 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingUniformBufferUpdateAfterBind ); 8205 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingSampledImageUpdateAfterBind ); 8206 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingStorageImageUpdateAfterBind ); 8207 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingStorageBufferUpdateAfterBind ); 8208 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingUniformTexelBufferUpdateAfterBind ); 8209 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingStorageTexelBufferUpdateAfterBind ); 8210 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingUpdateUnusedWhilePending ); 8211 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingPartiallyBound ); 8212 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingVariableDescriptorCount ); 8213 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.runtimeDescriptorArray ); 8214 return seed; 8215 } 8216 }; 8217 8218 template <> 8219 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorIndexingProperties> 8220 { operator ()std::hash8221 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorIndexingProperties const & physicalDeviceDescriptorIndexingProperties ) const 8222 VULKAN_HPP_NOEXCEPT 8223 { 8224 std::size_t seed = 0; 8225 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.sType ); 8226 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.pNext ); 8227 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxUpdateAfterBindDescriptorsInAllPools ); 8228 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.shaderUniformBufferArrayNonUniformIndexingNative ); 8229 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.shaderSampledImageArrayNonUniformIndexingNative ); 8230 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.shaderStorageBufferArrayNonUniformIndexingNative ); 8231 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.shaderStorageImageArrayNonUniformIndexingNative ); 8232 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.shaderInputAttachmentArrayNonUniformIndexingNative ); 8233 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.robustBufferAccessUpdateAfterBind ); 8234 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.quadDivergentImplicitLod ); 8235 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindSamplers ); 8236 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindUniformBuffers ); 8237 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindStorageBuffers ); 8238 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindSampledImages ); 8239 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindStorageImages ); 8240 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindInputAttachments ); 8241 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxPerStageUpdateAfterBindResources ); 8242 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindSamplers ); 8243 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindUniformBuffers ); 8244 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic ); 8245 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindStorageBuffers ); 8246 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic ); 8247 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindSampledImages ); 8248 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindStorageImages ); 8249 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindInputAttachments ); 8250 return seed; 8251 } 8252 }; 8253 8254 template <> 8255 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorPoolOverallocationFeaturesNV> 8256 { operator ()std::hash8257 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorPoolOverallocationFeaturesNV const & 8258 physicalDeviceDescriptorPoolOverallocationFeaturesNV ) const VULKAN_HPP_NOEXCEPT 8259 { 8260 std::size_t seed = 0; 8261 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorPoolOverallocationFeaturesNV.sType ); 8262 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorPoolOverallocationFeaturesNV.pNext ); 8263 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorPoolOverallocationFeaturesNV.descriptorPoolOverallocation ); 8264 return seed; 8265 } 8266 }; 8267 8268 template <> 8269 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE> 8270 { 8271 std::size_t operator ()std::hash8272 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE const & physicalDeviceDescriptorSetHostMappingFeaturesVALVE ) const 8273 VULKAN_HPP_NOEXCEPT 8274 { 8275 std::size_t seed = 0; 8276 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorSetHostMappingFeaturesVALVE.sType ); 8277 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorSetHostMappingFeaturesVALVE.pNext ); 8278 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorSetHostMappingFeaturesVALVE.descriptorSetHostMapping ); 8279 return seed; 8280 } 8281 }; 8282 8283 template <> 8284 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV> 8285 { operator ()std::hash8286 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV const & 8287 physicalDeviceDeviceGeneratedCommandsComputeFeaturesNV ) const VULKAN_HPP_NOEXCEPT 8288 { 8289 std::size_t seed = 0; 8290 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsComputeFeaturesNV.sType ); 8291 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsComputeFeaturesNV.pNext ); 8292 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsComputeFeaturesNV.deviceGeneratedCompute ); 8293 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsComputeFeaturesNV.deviceGeneratedComputePipelines ); 8294 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsComputeFeaturesNV.deviceGeneratedComputeCaptureReplay ); 8295 return seed; 8296 } 8297 }; 8298 8299 template <> 8300 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsFeaturesNV> 8301 { operator ()std::hash8302 std::size_t operator()( 8303 VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsFeaturesNV const & physicalDeviceDeviceGeneratedCommandsFeaturesNV ) const VULKAN_HPP_NOEXCEPT 8304 { 8305 std::size_t seed = 0; 8306 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsFeaturesNV.sType ); 8307 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsFeaturesNV.pNext ); 8308 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsFeaturesNV.deviceGeneratedCommands ); 8309 return seed; 8310 } 8311 }; 8312 8313 template <> 8314 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsPropertiesNV> 8315 { operator ()std::hash8316 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsPropertiesNV const & physicalDeviceDeviceGeneratedCommandsPropertiesNV ) 8317 const VULKAN_HPP_NOEXCEPT 8318 { 8319 std::size_t seed = 0; 8320 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.sType ); 8321 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.pNext ); 8322 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxGraphicsShaderGroupCount ); 8323 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxIndirectSequenceCount ); 8324 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxIndirectCommandsTokenCount ); 8325 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxIndirectCommandsStreamCount ); 8326 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxIndirectCommandsTokenOffset ); 8327 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxIndirectCommandsStreamStride ); 8328 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.minSequencesCountBufferOffsetAlignment ); 8329 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.minSequencesIndexBufferOffsetAlignment ); 8330 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.minIndirectCommandsBufferOffsetAlignment ); 8331 return seed; 8332 } 8333 }; 8334 8335 template <> 8336 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceMemoryReportFeaturesEXT> 8337 { operator ()std::hash8338 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceMemoryReportFeaturesEXT const & physicalDeviceDeviceMemoryReportFeaturesEXT ) const 8339 VULKAN_HPP_NOEXCEPT 8340 { 8341 std::size_t seed = 0; 8342 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceMemoryReportFeaturesEXT.sType ); 8343 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceMemoryReportFeaturesEXT.pNext ); 8344 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceMemoryReportFeaturesEXT.deviceMemoryReport ); 8345 return seed; 8346 } 8347 }; 8348 8349 template <> 8350 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDiagnosticsConfigFeaturesNV> 8351 { 8352 std::size_t operator ()std::hash8353 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDiagnosticsConfigFeaturesNV const & physicalDeviceDiagnosticsConfigFeaturesNV ) const VULKAN_HPP_NOEXCEPT 8354 { 8355 std::size_t seed = 0; 8356 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDiagnosticsConfigFeaturesNV.sType ); 8357 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDiagnosticsConfigFeaturesNV.pNext ); 8358 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDiagnosticsConfigFeaturesNV.diagnosticsConfig ); 8359 return seed; 8360 } 8361 }; 8362 8363 template <> 8364 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDiscardRectanglePropertiesEXT> 8365 { operator ()std::hash8366 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDiscardRectanglePropertiesEXT const & physicalDeviceDiscardRectanglePropertiesEXT ) const 8367 VULKAN_HPP_NOEXCEPT 8368 { 8369 std::size_t seed = 0; 8370 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDiscardRectanglePropertiesEXT.sType ); 8371 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDiscardRectanglePropertiesEXT.pNext ); 8372 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDiscardRectanglePropertiesEXT.maxDiscardRectangles ); 8373 return seed; 8374 } 8375 }; 8376 8377 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 8378 template <> 8379 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDisplacementMicromapFeaturesNV> 8380 { operator ()std::hash8381 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDisplacementMicromapFeaturesNV const & physicalDeviceDisplacementMicromapFeaturesNV ) const 8382 VULKAN_HPP_NOEXCEPT 8383 { 8384 std::size_t seed = 0; 8385 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDisplacementMicromapFeaturesNV.sType ); 8386 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDisplacementMicromapFeaturesNV.pNext ); 8387 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDisplacementMicromapFeaturesNV.displacementMicromap ); 8388 return seed; 8389 } 8390 }; 8391 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 8392 8393 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 8394 template <> 8395 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDisplacementMicromapPropertiesNV> 8396 { operator ()std::hash8397 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDisplacementMicromapPropertiesNV const & physicalDeviceDisplacementMicromapPropertiesNV ) const 8398 VULKAN_HPP_NOEXCEPT 8399 { 8400 std::size_t seed = 0; 8401 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDisplacementMicromapPropertiesNV.sType ); 8402 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDisplacementMicromapPropertiesNV.pNext ); 8403 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDisplacementMicromapPropertiesNV.maxDisplacementMicromapSubdivisionLevel ); 8404 return seed; 8405 } 8406 }; 8407 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 8408 8409 template <> 8410 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDriverProperties> 8411 { operator ()std::hash8412 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDriverProperties const & physicalDeviceDriverProperties ) const VULKAN_HPP_NOEXCEPT 8413 { 8414 std::size_t seed = 0; 8415 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDriverProperties.sType ); 8416 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDriverProperties.pNext ); 8417 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDriverProperties.driverID ); 8418 for ( size_t i = 0; i < VK_MAX_DRIVER_NAME_SIZE; ++i ) 8419 { 8420 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDriverProperties.driverName[i] ); 8421 } 8422 for ( size_t i = 0; i < VK_MAX_DRIVER_INFO_SIZE; ++i ) 8423 { 8424 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDriverProperties.driverInfo[i] ); 8425 } 8426 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDriverProperties.conformanceVersion ); 8427 return seed; 8428 } 8429 }; 8430 8431 template <> 8432 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDrmPropertiesEXT> 8433 { operator ()std::hash8434 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDrmPropertiesEXT const & physicalDeviceDrmPropertiesEXT ) const VULKAN_HPP_NOEXCEPT 8435 { 8436 std::size_t seed = 0; 8437 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDrmPropertiesEXT.sType ); 8438 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDrmPropertiesEXT.pNext ); 8439 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDrmPropertiesEXT.hasPrimary ); 8440 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDrmPropertiesEXT.hasRender ); 8441 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDrmPropertiesEXT.primaryMajor ); 8442 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDrmPropertiesEXT.primaryMinor ); 8443 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDrmPropertiesEXT.renderMajor ); 8444 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDrmPropertiesEXT.renderMinor ); 8445 return seed; 8446 } 8447 }; 8448 8449 template <> 8450 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingFeatures> 8451 { 8452 std::size_t operator ()std::hash8453 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingFeatures const & physicalDeviceDynamicRenderingFeatures ) const VULKAN_HPP_NOEXCEPT 8454 { 8455 std::size_t seed = 0; 8456 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDynamicRenderingFeatures.sType ); 8457 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDynamicRenderingFeatures.pNext ); 8458 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDynamicRenderingFeatures.dynamicRendering ); 8459 return seed; 8460 } 8461 }; 8462 8463 template <> 8464 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingLocalReadFeatures> 8465 { operator ()std::hash8466 std::size_t operator()( 8467 VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingLocalReadFeatures const & physicalDeviceDynamicRenderingLocalReadFeatures ) const VULKAN_HPP_NOEXCEPT 8468 { 8469 std::size_t seed = 0; 8470 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDynamicRenderingLocalReadFeatures.sType ); 8471 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDynamicRenderingLocalReadFeatures.pNext ); 8472 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDynamicRenderingLocalReadFeatures.dynamicRenderingLocalRead ); 8473 return seed; 8474 } 8475 }; 8476 8477 template <> 8478 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT> 8479 { operator ()std::hash8480 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT const & 8481 physicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 8482 { 8483 std::size_t seed = 0; 8484 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT.sType ); 8485 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT.pNext ); 8486 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT.dynamicRenderingUnusedAttachments ); 8487 return seed; 8488 } 8489 }; 8490 8491 template <> 8492 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExclusiveScissorFeaturesNV> 8493 { 8494 std::size_t operator ()std::hash8495 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExclusiveScissorFeaturesNV const & physicalDeviceExclusiveScissorFeaturesNV ) const VULKAN_HPP_NOEXCEPT 8496 { 8497 std::size_t seed = 0; 8498 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExclusiveScissorFeaturesNV.sType ); 8499 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExclusiveScissorFeaturesNV.pNext ); 8500 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExclusiveScissorFeaturesNV.exclusiveScissor ); 8501 return seed; 8502 } 8503 }; 8504 8505 template <> 8506 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState2FeaturesEXT> 8507 { operator ()std::hash8508 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState2FeaturesEXT const & physicalDeviceExtendedDynamicState2FeaturesEXT ) const 8509 VULKAN_HPP_NOEXCEPT 8510 { 8511 std::size_t seed = 0; 8512 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState2FeaturesEXT.sType ); 8513 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState2FeaturesEXT.pNext ); 8514 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState2FeaturesEXT.extendedDynamicState2 ); 8515 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState2FeaturesEXT.extendedDynamicState2LogicOp ); 8516 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState2FeaturesEXT.extendedDynamicState2PatchControlPoints ); 8517 return seed; 8518 } 8519 }; 8520 8521 template <> 8522 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState3FeaturesEXT> 8523 { operator ()std::hash8524 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState3FeaturesEXT const & physicalDeviceExtendedDynamicState3FeaturesEXT ) const 8525 VULKAN_HPP_NOEXCEPT 8526 { 8527 std::size_t seed = 0; 8528 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.sType ); 8529 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.pNext ); 8530 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3TessellationDomainOrigin ); 8531 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3DepthClampEnable ); 8532 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3PolygonMode ); 8533 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3RasterizationSamples ); 8534 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3SampleMask ); 8535 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3AlphaToCoverageEnable ); 8536 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3AlphaToOneEnable ); 8537 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3LogicOpEnable ); 8538 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ColorBlendEnable ); 8539 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ColorBlendEquation ); 8540 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ColorWriteMask ); 8541 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3RasterizationStream ); 8542 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ConservativeRasterizationMode ); 8543 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ExtraPrimitiveOverestimationSize ); 8544 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3DepthClipEnable ); 8545 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3SampleLocationsEnable ); 8546 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ColorBlendAdvanced ); 8547 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ProvokingVertexMode ); 8548 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3LineRasterizationMode ); 8549 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3LineStippleEnable ); 8550 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3DepthClipNegativeOneToOne ); 8551 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ViewportWScalingEnable ); 8552 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ViewportSwizzle ); 8553 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3CoverageToColorEnable ); 8554 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3CoverageToColorLocation ); 8555 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3CoverageModulationMode ); 8556 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3CoverageModulationTableEnable ); 8557 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3CoverageModulationTable ); 8558 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3CoverageReductionMode ); 8559 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3RepresentativeFragmentTestEnable ); 8560 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ShadingRateImageEnable ); 8561 return seed; 8562 } 8563 }; 8564 8565 template <> 8566 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState3PropertiesEXT> 8567 { operator ()std::hash8568 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState3PropertiesEXT const & physicalDeviceExtendedDynamicState3PropertiesEXT ) 8569 const VULKAN_HPP_NOEXCEPT 8570 { 8571 std::size_t seed = 0; 8572 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3PropertiesEXT.sType ); 8573 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3PropertiesEXT.pNext ); 8574 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3PropertiesEXT.dynamicPrimitiveTopologyUnrestricted ); 8575 return seed; 8576 } 8577 }; 8578 8579 template <> 8580 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicStateFeaturesEXT> 8581 { operator ()std::hash8582 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicStateFeaturesEXT const & physicalDeviceExtendedDynamicStateFeaturesEXT ) const 8583 VULKAN_HPP_NOEXCEPT 8584 { 8585 std::size_t seed = 0; 8586 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicStateFeaturesEXT.sType ); 8587 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicStateFeaturesEXT.pNext ); 8588 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicStateFeaturesEXT.extendedDynamicState ); 8589 return seed; 8590 } 8591 }; 8592 8593 template <> 8594 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV> 8595 { 8596 std::size_t operator ()std::hash8597 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV const & physicalDeviceExtendedSparseAddressSpaceFeaturesNV ) const 8598 VULKAN_HPP_NOEXCEPT 8599 { 8600 std::size_t seed = 0; 8601 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedSparseAddressSpaceFeaturesNV.sType ); 8602 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedSparseAddressSpaceFeaturesNV.pNext ); 8603 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedSparseAddressSpaceFeaturesNV.extendedSparseAddressSpace ); 8604 return seed; 8605 } 8606 }; 8607 8608 template <> 8609 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedSparseAddressSpacePropertiesNV> 8610 { operator ()std::hash8611 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedSparseAddressSpacePropertiesNV const & 8612 physicalDeviceExtendedSparseAddressSpacePropertiesNV ) const VULKAN_HPP_NOEXCEPT 8613 { 8614 std::size_t seed = 0; 8615 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedSparseAddressSpacePropertiesNV.sType ); 8616 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedSparseAddressSpacePropertiesNV.pNext ); 8617 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedSparseAddressSpacePropertiesNV.extendedSparseAddressSpaceSize ); 8618 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedSparseAddressSpacePropertiesNV.extendedSparseImageUsageFlags ); 8619 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedSparseAddressSpacePropertiesNV.extendedSparseBufferUsageFlags ); 8620 return seed; 8621 } 8622 }; 8623 8624 template <> 8625 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo> 8626 { operator ()std::hash8627 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo const & physicalDeviceExternalBufferInfo ) const VULKAN_HPP_NOEXCEPT 8628 { 8629 std::size_t seed = 0; 8630 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalBufferInfo.sType ); 8631 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalBufferInfo.pNext ); 8632 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalBufferInfo.flags ); 8633 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalBufferInfo.usage ); 8634 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalBufferInfo.handleType ); 8635 return seed; 8636 } 8637 }; 8638 8639 template <> 8640 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo> 8641 { operator ()std::hash8642 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo const & physicalDeviceExternalFenceInfo ) const VULKAN_HPP_NOEXCEPT 8643 { 8644 std::size_t seed = 0; 8645 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFenceInfo.sType ); 8646 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFenceInfo.pNext ); 8647 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFenceInfo.handleType ); 8648 return seed; 8649 } 8650 }; 8651 8652 # if defined( VK_USE_PLATFORM_ANDROID_KHR ) 8653 template <> 8654 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFormatResolveFeaturesANDROID> 8655 { 8656 std::size_t operator ()std::hash8657 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFormatResolveFeaturesANDROID const & physicalDeviceExternalFormatResolveFeaturesANDROID ) const 8658 VULKAN_HPP_NOEXCEPT 8659 { 8660 std::size_t seed = 0; 8661 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFormatResolveFeaturesANDROID.sType ); 8662 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFormatResolveFeaturesANDROID.pNext ); 8663 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFormatResolveFeaturesANDROID.externalFormatResolve ); 8664 return seed; 8665 } 8666 }; 8667 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ 8668 8669 # if defined( VK_USE_PLATFORM_ANDROID_KHR ) 8670 template <> 8671 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFormatResolvePropertiesANDROID> 8672 { operator ()std::hash8673 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFormatResolvePropertiesANDROID const & 8674 physicalDeviceExternalFormatResolvePropertiesANDROID ) const VULKAN_HPP_NOEXCEPT 8675 { 8676 std::size_t seed = 0; 8677 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFormatResolvePropertiesANDROID.sType ); 8678 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFormatResolvePropertiesANDROID.pNext ); 8679 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFormatResolvePropertiesANDROID.nullColorAttachmentWithExternalFormatResolve ); 8680 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFormatResolvePropertiesANDROID.externalFormatResolveChromaOffsetX ); 8681 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFormatResolvePropertiesANDROID.externalFormatResolveChromaOffsetY ); 8682 return seed; 8683 } 8684 }; 8685 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ 8686 8687 template <> 8688 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalImageFormatInfo> 8689 { 8690 std::size_t operator ()std::hash8691 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalImageFormatInfo const & physicalDeviceExternalImageFormatInfo ) const VULKAN_HPP_NOEXCEPT 8692 { 8693 std::size_t seed = 0; 8694 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalImageFormatInfo.sType ); 8695 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalImageFormatInfo.pNext ); 8696 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalImageFormatInfo.handleType ); 8697 return seed; 8698 } 8699 }; 8700 8701 template <> 8702 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryHostPropertiesEXT> 8703 { operator ()std::hash8704 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryHostPropertiesEXT const & physicalDeviceExternalMemoryHostPropertiesEXT ) const 8705 VULKAN_HPP_NOEXCEPT 8706 { 8707 std::size_t seed = 0; 8708 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalMemoryHostPropertiesEXT.sType ); 8709 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalMemoryHostPropertiesEXT.pNext ); 8710 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalMemoryHostPropertiesEXT.minImportedHostPointerAlignment ); 8711 return seed; 8712 } 8713 }; 8714 8715 template <> 8716 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryRDMAFeaturesNV> 8717 { operator ()std::hash8718 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryRDMAFeaturesNV const & physicalDeviceExternalMemoryRDMAFeaturesNV ) const 8719 VULKAN_HPP_NOEXCEPT 8720 { 8721 std::size_t seed = 0; 8722 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalMemoryRDMAFeaturesNV.sType ); 8723 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalMemoryRDMAFeaturesNV.pNext ); 8724 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalMemoryRDMAFeaturesNV.externalMemoryRDMA ); 8725 return seed; 8726 } 8727 }; 8728 8729 # if defined( VK_USE_PLATFORM_SCREEN_QNX ) 8730 template <> 8731 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX> 8732 { 8733 std::size_t operator ()std::hash8734 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX const & physicalDeviceExternalMemoryScreenBufferFeaturesQNX ) const 8735 VULKAN_HPP_NOEXCEPT 8736 { 8737 std::size_t seed = 0; 8738 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalMemoryScreenBufferFeaturesQNX.sType ); 8739 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalMemoryScreenBufferFeaturesQNX.pNext ); 8740 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalMemoryScreenBufferFeaturesQNX.screenBufferImport ); 8741 return seed; 8742 } 8743 }; 8744 # endif /*VK_USE_PLATFORM_SCREEN_QNX*/ 8745 8746 template <> 8747 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo> 8748 { operator ()std::hash8749 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo const & physicalDeviceExternalSemaphoreInfo ) const VULKAN_HPP_NOEXCEPT 8750 { 8751 std::size_t seed = 0; 8752 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalSemaphoreInfo.sType ); 8753 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalSemaphoreInfo.pNext ); 8754 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalSemaphoreInfo.handleType ); 8755 return seed; 8756 } 8757 }; 8758 8759 template <> 8760 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFaultFeaturesEXT> 8761 { operator ()std::hash8762 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFaultFeaturesEXT const & physicalDeviceFaultFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 8763 { 8764 std::size_t seed = 0; 8765 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFaultFeaturesEXT.sType ); 8766 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFaultFeaturesEXT.pNext ); 8767 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFaultFeaturesEXT.deviceFault ); 8768 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFaultFeaturesEXT.deviceFaultVendorBinary ); 8769 return seed; 8770 } 8771 }; 8772 8773 template <> 8774 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2> 8775 { operator ()std::hash8776 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 const & physicalDeviceFeatures2 ) const VULKAN_HPP_NOEXCEPT 8777 { 8778 std::size_t seed = 0; 8779 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures2.sType ); 8780 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures2.pNext ); 8781 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures2.features ); 8782 return seed; 8783 } 8784 }; 8785 8786 template <> 8787 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFloatControlsProperties> 8788 { 8789 std::size_t operator ()std::hash8790 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFloatControlsProperties const & physicalDeviceFloatControlsProperties ) const VULKAN_HPP_NOEXCEPT 8791 { 8792 std::size_t seed = 0; 8793 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.sType ); 8794 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.pNext ); 8795 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.denormBehaviorIndependence ); 8796 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.roundingModeIndependence ); 8797 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderSignedZeroInfNanPreserveFloat16 ); 8798 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderSignedZeroInfNanPreserveFloat32 ); 8799 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderSignedZeroInfNanPreserveFloat64 ); 8800 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderDenormPreserveFloat16 ); 8801 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderDenormPreserveFloat32 ); 8802 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderDenormPreserveFloat64 ); 8803 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderDenormFlushToZeroFloat16 ); 8804 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderDenormFlushToZeroFloat32 ); 8805 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderDenormFlushToZeroFloat64 ); 8806 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTEFloat16 ); 8807 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTEFloat32 ); 8808 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTEFloat64 ); 8809 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTZFloat16 ); 8810 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTZFloat32 ); 8811 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTZFloat64 ); 8812 return seed; 8813 } 8814 }; 8815 8816 template <> 8817 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMap2FeaturesEXT> 8818 { operator ()std::hash8819 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMap2FeaturesEXT const & physicalDeviceFragmentDensityMap2FeaturesEXT ) const 8820 VULKAN_HPP_NOEXCEPT 8821 { 8822 std::size_t seed = 0; 8823 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMap2FeaturesEXT.sType ); 8824 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMap2FeaturesEXT.pNext ); 8825 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMap2FeaturesEXT.fragmentDensityMapDeferred ); 8826 return seed; 8827 } 8828 }; 8829 8830 template <> 8831 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMap2PropertiesEXT> 8832 { operator ()std::hash8833 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMap2PropertiesEXT const & physicalDeviceFragmentDensityMap2PropertiesEXT ) const 8834 VULKAN_HPP_NOEXCEPT 8835 { 8836 std::size_t seed = 0; 8837 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMap2PropertiesEXT.sType ); 8838 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMap2PropertiesEXT.pNext ); 8839 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMap2PropertiesEXT.subsampledLoads ); 8840 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMap2PropertiesEXT.subsampledCoarseReconstructionEarlyAccess ); 8841 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMap2PropertiesEXT.maxSubsampledArrayLayers ); 8842 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMap2PropertiesEXT.maxDescriptorSetSubsampledSamplers ); 8843 return seed; 8844 } 8845 }; 8846 8847 template <> 8848 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapFeaturesEXT> 8849 { operator ()std::hash8850 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapFeaturesEXT const & physicalDeviceFragmentDensityMapFeaturesEXT ) const 8851 VULKAN_HPP_NOEXCEPT 8852 { 8853 std::size_t seed = 0; 8854 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapFeaturesEXT.sType ); 8855 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapFeaturesEXT.pNext ); 8856 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapFeaturesEXT.fragmentDensityMap ); 8857 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapFeaturesEXT.fragmentDensityMapDynamic ); 8858 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapFeaturesEXT.fragmentDensityMapNonSubsampledImages ); 8859 return seed; 8860 } 8861 }; 8862 8863 template <> 8864 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM> 8865 { 8866 std::size_t operator ()std::hash8867 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM const & physicalDeviceFragmentDensityMapOffsetFeaturesQCOM ) const 8868 VULKAN_HPP_NOEXCEPT 8869 { 8870 std::size_t seed = 0; 8871 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetFeaturesQCOM.sType ); 8872 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetFeaturesQCOM.pNext ); 8873 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetFeaturesQCOM.fragmentDensityMapOffset ); 8874 return seed; 8875 } 8876 }; 8877 8878 template <> 8879 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM> 8880 { operator ()std::hash8881 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM const & 8882 physicalDeviceFragmentDensityMapOffsetPropertiesQCOM ) const VULKAN_HPP_NOEXCEPT 8883 { 8884 std::size_t seed = 0; 8885 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetPropertiesQCOM.sType ); 8886 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetPropertiesQCOM.pNext ); 8887 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetPropertiesQCOM.fragmentDensityOffsetGranularity ); 8888 return seed; 8889 } 8890 }; 8891 8892 template <> 8893 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapPropertiesEXT> 8894 { operator ()std::hash8895 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapPropertiesEXT const & physicalDeviceFragmentDensityMapPropertiesEXT ) const 8896 VULKAN_HPP_NOEXCEPT 8897 { 8898 std::size_t seed = 0; 8899 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapPropertiesEXT.sType ); 8900 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapPropertiesEXT.pNext ); 8901 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapPropertiesEXT.minFragmentDensityTexelSize ); 8902 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapPropertiesEXT.maxFragmentDensityTexelSize ); 8903 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapPropertiesEXT.fragmentDensityInvocations ); 8904 return seed; 8905 } 8906 }; 8907 8908 template <> 8909 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderBarycentricFeaturesKHR> 8910 { 8911 std::size_t operator ()std::hash8912 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderBarycentricFeaturesKHR const & physicalDeviceFragmentShaderBarycentricFeaturesKHR ) const 8913 VULKAN_HPP_NOEXCEPT 8914 { 8915 std::size_t seed = 0; 8916 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderBarycentricFeaturesKHR.sType ); 8917 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderBarycentricFeaturesKHR.pNext ); 8918 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderBarycentricFeaturesKHR.fragmentShaderBarycentric ); 8919 return seed; 8920 } 8921 }; 8922 8923 template <> 8924 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderBarycentricPropertiesKHR> 8925 { operator ()std::hash8926 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderBarycentricPropertiesKHR const & 8927 physicalDeviceFragmentShaderBarycentricPropertiesKHR ) const VULKAN_HPP_NOEXCEPT 8928 { 8929 std::size_t seed = 0; 8930 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderBarycentricPropertiesKHR.sType ); 8931 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderBarycentricPropertiesKHR.pNext ); 8932 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderBarycentricPropertiesKHR.triStripVertexOrderIndependentOfProvokingVertex ); 8933 return seed; 8934 } 8935 }; 8936 8937 template <> 8938 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderInterlockFeaturesEXT> 8939 { operator ()std::hash8940 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderInterlockFeaturesEXT const & physicalDeviceFragmentShaderInterlockFeaturesEXT ) 8941 const VULKAN_HPP_NOEXCEPT 8942 { 8943 std::size_t seed = 0; 8944 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderInterlockFeaturesEXT.sType ); 8945 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderInterlockFeaturesEXT.pNext ); 8946 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderInterlockFeaturesEXT.fragmentShaderSampleInterlock ); 8947 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderInterlockFeaturesEXT.fragmentShaderPixelInterlock ); 8948 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderInterlockFeaturesEXT.fragmentShaderShadingRateInterlock ); 8949 return seed; 8950 } 8951 }; 8952 8953 template <> 8954 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateEnumsFeaturesNV> 8955 { operator ()std::hash8956 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateEnumsFeaturesNV const & physicalDeviceFragmentShadingRateEnumsFeaturesNV ) 8957 const VULKAN_HPP_NOEXCEPT 8958 { 8959 std::size_t seed = 0; 8960 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateEnumsFeaturesNV.sType ); 8961 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateEnumsFeaturesNV.pNext ); 8962 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateEnumsFeaturesNV.fragmentShadingRateEnums ); 8963 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateEnumsFeaturesNV.supersampleFragmentShadingRates ); 8964 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateEnumsFeaturesNV.noInvocationFragmentShadingRates ); 8965 return seed; 8966 } 8967 }; 8968 8969 template <> 8970 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateEnumsPropertiesNV> 8971 { 8972 std::size_t operator ()std::hash8973 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateEnumsPropertiesNV const & physicalDeviceFragmentShadingRateEnumsPropertiesNV ) const 8974 VULKAN_HPP_NOEXCEPT 8975 { 8976 std::size_t seed = 0; 8977 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateEnumsPropertiesNV.sType ); 8978 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateEnumsPropertiesNV.pNext ); 8979 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateEnumsPropertiesNV.maxFragmentShadingRateInvocationCount ); 8980 return seed; 8981 } 8982 }; 8983 8984 template <> 8985 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateFeaturesKHR> 8986 { operator ()std::hash8987 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateFeaturesKHR const & physicalDeviceFragmentShadingRateFeaturesKHR ) const 8988 VULKAN_HPP_NOEXCEPT 8989 { 8990 std::size_t seed = 0; 8991 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateFeaturesKHR.sType ); 8992 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateFeaturesKHR.pNext ); 8993 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateFeaturesKHR.pipelineFragmentShadingRate ); 8994 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateFeaturesKHR.primitiveFragmentShadingRate ); 8995 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateFeaturesKHR.attachmentFragmentShadingRate ); 8996 return seed; 8997 } 8998 }; 8999 9000 template <> 9001 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR> 9002 { operator ()std::hash9003 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR const & physicalDeviceFragmentShadingRateKHR ) const VULKAN_HPP_NOEXCEPT 9004 { 9005 std::size_t seed = 0; 9006 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateKHR.sType ); 9007 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateKHR.pNext ); 9008 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateKHR.sampleCounts ); 9009 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateKHR.fragmentSize ); 9010 return seed; 9011 } 9012 }; 9013 9014 template <> 9015 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRatePropertiesKHR> 9016 { operator ()std::hash9017 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRatePropertiesKHR const & physicalDeviceFragmentShadingRatePropertiesKHR ) const 9018 VULKAN_HPP_NOEXCEPT 9019 { 9020 std::size_t seed = 0; 9021 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.sType ); 9022 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.pNext ); 9023 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.minFragmentShadingRateAttachmentTexelSize ); 9024 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentShadingRateAttachmentTexelSize ); 9025 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentShadingRateAttachmentTexelSizeAspectRatio ); 9026 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.primitiveFragmentShadingRateWithMultipleViewports ); 9027 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.layeredShadingRateAttachments ); 9028 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateNonTrivialCombinerOps ); 9029 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentSize ); 9030 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentSizeAspectRatio ); 9031 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentShadingRateCoverageSamples ); 9032 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentShadingRateRasterizationSamples ); 9033 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithShaderDepthStencilWrites ); 9034 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithSampleMask ); 9035 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithShaderSampleMask ); 9036 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithConservativeRasterization ); 9037 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithFragmentShaderInterlock ); 9038 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithCustomSampleLocations ); 9039 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateStrictMultiplyCombiner ); 9040 return seed; 9041 } 9042 }; 9043 9044 template <> 9045 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFrameBoundaryFeaturesEXT> 9046 { 9047 std::size_t operator ()std::hash9048 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFrameBoundaryFeaturesEXT const & physicalDeviceFrameBoundaryFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 9049 { 9050 std::size_t seed = 0; 9051 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFrameBoundaryFeaturesEXT.sType ); 9052 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFrameBoundaryFeaturesEXT.pNext ); 9053 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFrameBoundaryFeaturesEXT.frameBoundary ); 9054 return seed; 9055 } 9056 }; 9057 9058 template <> 9059 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceGlobalPriorityQueryFeatures> 9060 { 9061 std::size_t operator ()std::hash9062 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceGlobalPriorityQueryFeatures const & physicalDeviceGlobalPriorityQueryFeatures ) const VULKAN_HPP_NOEXCEPT 9063 { 9064 std::size_t seed = 0; 9065 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGlobalPriorityQueryFeatures.sType ); 9066 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGlobalPriorityQueryFeatures.pNext ); 9067 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGlobalPriorityQueryFeatures.globalPriorityQuery ); 9068 return seed; 9069 } 9070 }; 9071 9072 template <> 9073 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT> 9074 { operator ()std::hash9075 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT const & physicalDeviceGraphicsPipelineLibraryFeaturesEXT ) 9076 const VULKAN_HPP_NOEXCEPT 9077 { 9078 std::size_t seed = 0; 9079 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGraphicsPipelineLibraryFeaturesEXT.sType ); 9080 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGraphicsPipelineLibraryFeaturesEXT.pNext ); 9081 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGraphicsPipelineLibraryFeaturesEXT.graphicsPipelineLibrary ); 9082 return seed; 9083 } 9084 }; 9085 9086 template <> 9087 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT> 9088 { 9089 std::size_t operator ()std::hash9090 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT const & physicalDeviceGraphicsPipelineLibraryPropertiesEXT ) const 9091 VULKAN_HPP_NOEXCEPT 9092 { 9093 std::size_t seed = 0; 9094 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGraphicsPipelineLibraryPropertiesEXT.sType ); 9095 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGraphicsPipelineLibraryPropertiesEXT.pNext ); 9096 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGraphicsPipelineLibraryPropertiesEXT.graphicsPipelineLibraryFastLinking ); 9097 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGraphicsPipelineLibraryPropertiesEXT.graphicsPipelineLibraryIndependentInterpolationDecoration ); 9098 return seed; 9099 } 9100 }; 9101 9102 template <> 9103 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties> 9104 { operator ()std::hash9105 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties const & physicalDeviceGroupProperties ) const VULKAN_HPP_NOEXCEPT 9106 { 9107 std::size_t seed = 0; 9108 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGroupProperties.sType ); 9109 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGroupProperties.pNext ); 9110 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGroupProperties.physicalDeviceCount ); 9111 for ( size_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; ++i ) 9112 { 9113 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGroupProperties.physicalDevices[i] ); 9114 } 9115 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGroupProperties.subsetAllocation ); 9116 return seed; 9117 } 9118 }; 9119 9120 template <> 9121 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceHostImageCopyFeatures> 9122 { operator ()std::hash9123 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceHostImageCopyFeatures const & physicalDeviceHostImageCopyFeatures ) const VULKAN_HPP_NOEXCEPT 9124 { 9125 std::size_t seed = 0; 9126 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyFeatures.sType ); 9127 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyFeatures.pNext ); 9128 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyFeatures.hostImageCopy ); 9129 return seed; 9130 } 9131 }; 9132 9133 template <> 9134 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceHostImageCopyProperties> 9135 { 9136 std::size_t operator ()std::hash9137 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceHostImageCopyProperties const & physicalDeviceHostImageCopyProperties ) const VULKAN_HPP_NOEXCEPT 9138 { 9139 std::size_t seed = 0; 9140 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyProperties.sType ); 9141 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyProperties.pNext ); 9142 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyProperties.copySrcLayoutCount ); 9143 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyProperties.pCopySrcLayouts ); 9144 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyProperties.copyDstLayoutCount ); 9145 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyProperties.pCopyDstLayouts ); 9146 for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) 9147 { 9148 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyProperties.optimalTilingLayoutUUID[i] ); 9149 } 9150 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyProperties.identicalMemoryTypeRequirements ); 9151 return seed; 9152 } 9153 }; 9154 9155 template <> 9156 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceHostQueryResetFeatures> 9157 { operator ()std::hash9158 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceHostQueryResetFeatures const & physicalDeviceHostQueryResetFeatures ) const VULKAN_HPP_NOEXCEPT 9159 { 9160 std::size_t seed = 0; 9161 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostQueryResetFeatures.sType ); 9162 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostQueryResetFeatures.pNext ); 9163 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostQueryResetFeatures.hostQueryReset ); 9164 return seed; 9165 } 9166 }; 9167 9168 template <> 9169 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceIDProperties> 9170 { operator ()std::hash9171 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceIDProperties const & physicalDeviceIDProperties ) const VULKAN_HPP_NOEXCEPT 9172 { 9173 std::size_t seed = 0; 9174 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIDProperties.sType ); 9175 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIDProperties.pNext ); 9176 for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) 9177 { 9178 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIDProperties.deviceUUID[i] ); 9179 } 9180 for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) 9181 { 9182 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIDProperties.driverUUID[i] ); 9183 } 9184 for ( size_t i = 0; i < VK_LUID_SIZE; ++i ) 9185 { 9186 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIDProperties.deviceLUID[i] ); 9187 } 9188 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIDProperties.deviceNodeMask ); 9189 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIDProperties.deviceLUIDValid ); 9190 return seed; 9191 } 9192 }; 9193 9194 template <> 9195 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImage2DViewOf3DFeaturesEXT> 9196 { 9197 std::size_t operator ()std::hash9198 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImage2DViewOf3DFeaturesEXT const & physicalDeviceImage2DViewOf3DFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 9199 { 9200 std::size_t seed = 0; 9201 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImage2DViewOf3DFeaturesEXT.sType ); 9202 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImage2DViewOf3DFeaturesEXT.pNext ); 9203 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImage2DViewOf3DFeaturesEXT.image2DViewOf3D ); 9204 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImage2DViewOf3DFeaturesEXT.sampler2DViewOf3D ); 9205 return seed; 9206 } 9207 }; 9208 9209 template <> 9210 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageAlignmentControlFeaturesMESA> 9211 { operator ()std::hash9212 std::size_t operator()( 9213 VULKAN_HPP_NAMESPACE::PhysicalDeviceImageAlignmentControlFeaturesMESA const & physicalDeviceImageAlignmentControlFeaturesMESA ) const VULKAN_HPP_NOEXCEPT 9214 { 9215 std::size_t seed = 0; 9216 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageAlignmentControlFeaturesMESA.sType ); 9217 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageAlignmentControlFeaturesMESA.pNext ); 9218 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageAlignmentControlFeaturesMESA.imageAlignmentControl ); 9219 return seed; 9220 } 9221 }; 9222 9223 template <> 9224 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageAlignmentControlPropertiesMESA> 9225 { operator ()std::hash9226 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageAlignmentControlPropertiesMESA const & physicalDeviceImageAlignmentControlPropertiesMESA ) 9227 const VULKAN_HPP_NOEXCEPT 9228 { 9229 std::size_t seed = 0; 9230 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageAlignmentControlPropertiesMESA.sType ); 9231 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageAlignmentControlPropertiesMESA.pNext ); 9232 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageAlignmentControlPropertiesMESA.supportedImageAlignmentMask ); 9233 return seed; 9234 } 9235 }; 9236 9237 template <> 9238 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageCompressionControlFeaturesEXT> 9239 { operator ()std::hash9240 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageCompressionControlFeaturesEXT const & physicalDeviceImageCompressionControlFeaturesEXT ) 9241 const VULKAN_HPP_NOEXCEPT 9242 { 9243 std::size_t seed = 0; 9244 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageCompressionControlFeaturesEXT.sType ); 9245 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageCompressionControlFeaturesEXT.pNext ); 9246 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageCompressionControlFeaturesEXT.imageCompressionControl ); 9247 return seed; 9248 } 9249 }; 9250 9251 template <> 9252 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT> 9253 { operator ()std::hash9254 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT const & 9255 physicalDeviceImageCompressionControlSwapchainFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 9256 { 9257 std::size_t seed = 0; 9258 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageCompressionControlSwapchainFeaturesEXT.sType ); 9259 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageCompressionControlSwapchainFeaturesEXT.pNext ); 9260 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageCompressionControlSwapchainFeaturesEXT.imageCompressionControlSwapchain ); 9261 return seed; 9262 } 9263 }; 9264 9265 template <> 9266 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageDrmFormatModifierInfoEXT> 9267 { operator ()std::hash9268 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageDrmFormatModifierInfoEXT const & physicalDeviceImageDrmFormatModifierInfoEXT ) const 9269 VULKAN_HPP_NOEXCEPT 9270 { 9271 std::size_t seed = 0; 9272 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageDrmFormatModifierInfoEXT.sType ); 9273 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageDrmFormatModifierInfoEXT.pNext ); 9274 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageDrmFormatModifierInfoEXT.drmFormatModifier ); 9275 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageDrmFormatModifierInfoEXT.sharingMode ); 9276 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageDrmFormatModifierInfoEXT.queueFamilyIndexCount ); 9277 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageDrmFormatModifierInfoEXT.pQueueFamilyIndices ); 9278 return seed; 9279 } 9280 }; 9281 9282 template <> 9283 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2> 9284 { operator ()std::hash9285 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 const & physicalDeviceImageFormatInfo2 ) const VULKAN_HPP_NOEXCEPT 9286 { 9287 std::size_t seed = 0; 9288 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageFormatInfo2.sType ); 9289 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageFormatInfo2.pNext ); 9290 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageFormatInfo2.format ); 9291 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageFormatInfo2.type ); 9292 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageFormatInfo2.tiling ); 9293 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageFormatInfo2.usage ); 9294 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageFormatInfo2.flags ); 9295 return seed; 9296 } 9297 }; 9298 9299 template <> 9300 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessing2FeaturesQCOM> 9301 { operator ()std::hash9302 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessing2FeaturesQCOM const & physicalDeviceImageProcessing2FeaturesQCOM ) const 9303 VULKAN_HPP_NOEXCEPT 9304 { 9305 std::size_t seed = 0; 9306 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessing2FeaturesQCOM.sType ); 9307 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessing2FeaturesQCOM.pNext ); 9308 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessing2FeaturesQCOM.textureBlockMatch2 ); 9309 return seed; 9310 } 9311 }; 9312 9313 template <> 9314 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessing2PropertiesQCOM> 9315 { operator ()std::hash9316 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessing2PropertiesQCOM const & physicalDeviceImageProcessing2PropertiesQCOM ) const 9317 VULKAN_HPP_NOEXCEPT 9318 { 9319 std::size_t seed = 0; 9320 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessing2PropertiesQCOM.sType ); 9321 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessing2PropertiesQCOM.pNext ); 9322 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessing2PropertiesQCOM.maxBlockMatchWindow ); 9323 return seed; 9324 } 9325 }; 9326 9327 template <> 9328 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessingFeaturesQCOM> 9329 { 9330 std::size_t operator ()std::hash9331 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessingFeaturesQCOM const & physicalDeviceImageProcessingFeaturesQCOM ) const VULKAN_HPP_NOEXCEPT 9332 { 9333 std::size_t seed = 0; 9334 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingFeaturesQCOM.sType ); 9335 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingFeaturesQCOM.pNext ); 9336 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingFeaturesQCOM.textureSampleWeighted ); 9337 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingFeaturesQCOM.textureBoxFilter ); 9338 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingFeaturesQCOM.textureBlockMatch ); 9339 return seed; 9340 } 9341 }; 9342 9343 template <> 9344 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessingPropertiesQCOM> 9345 { operator ()std::hash9346 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessingPropertiesQCOM const & physicalDeviceImageProcessingPropertiesQCOM ) const 9347 VULKAN_HPP_NOEXCEPT 9348 { 9349 std::size_t seed = 0; 9350 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingPropertiesQCOM.sType ); 9351 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingPropertiesQCOM.pNext ); 9352 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingPropertiesQCOM.maxWeightFilterPhases ); 9353 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingPropertiesQCOM.maxWeightFilterDimension ); 9354 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingPropertiesQCOM.maxBlockMatchRegion ); 9355 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingPropertiesQCOM.maxBoxFilterBlockSize ); 9356 return seed; 9357 } 9358 }; 9359 9360 template <> 9361 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageRobustnessFeatures> 9362 { 9363 std::size_t operator ()std::hash9364 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageRobustnessFeatures const & physicalDeviceImageRobustnessFeatures ) const VULKAN_HPP_NOEXCEPT 9365 { 9366 std::size_t seed = 0; 9367 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageRobustnessFeatures.sType ); 9368 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageRobustnessFeatures.pNext ); 9369 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageRobustnessFeatures.robustImageAccess ); 9370 return seed; 9371 } 9372 }; 9373 9374 template <> 9375 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageSlicedViewOf3DFeaturesEXT> 9376 { operator ()std::hash9377 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageSlicedViewOf3DFeaturesEXT const & physicalDeviceImageSlicedViewOf3DFeaturesEXT ) const 9378 VULKAN_HPP_NOEXCEPT 9379 { 9380 std::size_t seed = 0; 9381 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageSlicedViewOf3DFeaturesEXT.sType ); 9382 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageSlicedViewOf3DFeaturesEXT.pNext ); 9383 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageSlicedViewOf3DFeaturesEXT.imageSlicedViewOf3D ); 9384 return seed; 9385 } 9386 }; 9387 9388 template <> 9389 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageViewImageFormatInfoEXT> 9390 { 9391 std::size_t operator ()std::hash9392 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageViewImageFormatInfoEXT const & physicalDeviceImageViewImageFormatInfoEXT ) const VULKAN_HPP_NOEXCEPT 9393 { 9394 std::size_t seed = 0; 9395 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageViewImageFormatInfoEXT.sType ); 9396 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageViewImageFormatInfoEXT.pNext ); 9397 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageViewImageFormatInfoEXT.imageViewType ); 9398 return seed; 9399 } 9400 }; 9401 9402 template <> 9403 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageViewMinLodFeaturesEXT> 9404 { 9405 std::size_t operator ()std::hash9406 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageViewMinLodFeaturesEXT const & physicalDeviceImageViewMinLodFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 9407 { 9408 std::size_t seed = 0; 9409 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageViewMinLodFeaturesEXT.sType ); 9410 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageViewMinLodFeaturesEXT.pNext ); 9411 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageViewMinLodFeaturesEXT.minLod ); 9412 return seed; 9413 } 9414 }; 9415 9416 template <> 9417 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImagelessFramebufferFeatures> 9418 { operator ()std::hash9419 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImagelessFramebufferFeatures const & physicalDeviceImagelessFramebufferFeatures ) const 9420 VULKAN_HPP_NOEXCEPT 9421 { 9422 std::size_t seed = 0; 9423 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImagelessFramebufferFeatures.sType ); 9424 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImagelessFramebufferFeatures.pNext ); 9425 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImagelessFramebufferFeatures.imagelessFramebuffer ); 9426 return seed; 9427 } 9428 }; 9429 9430 template <> 9431 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceIndexTypeUint8Features> 9432 { operator ()std::hash9433 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceIndexTypeUint8Features const & physicalDeviceIndexTypeUint8Features ) const VULKAN_HPP_NOEXCEPT 9434 { 9435 std::size_t seed = 0; 9436 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIndexTypeUint8Features.sType ); 9437 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIndexTypeUint8Features.pNext ); 9438 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIndexTypeUint8Features.indexTypeUint8 ); 9439 return seed; 9440 } 9441 }; 9442 9443 template <> 9444 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceInheritedViewportScissorFeaturesNV> 9445 { operator ()std::hash9446 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceInheritedViewportScissorFeaturesNV const & physicalDeviceInheritedViewportScissorFeaturesNV ) 9447 const VULKAN_HPP_NOEXCEPT 9448 { 9449 std::size_t seed = 0; 9450 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInheritedViewportScissorFeaturesNV.sType ); 9451 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInheritedViewportScissorFeaturesNV.pNext ); 9452 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInheritedViewportScissorFeaturesNV.inheritedViewportScissor2D ); 9453 return seed; 9454 } 9455 }; 9456 9457 template <> 9458 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceInlineUniformBlockFeatures> 9459 { 9460 std::size_t operator ()std::hash9461 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceInlineUniformBlockFeatures const & physicalDeviceInlineUniformBlockFeatures ) const VULKAN_HPP_NOEXCEPT 9462 { 9463 std::size_t seed = 0; 9464 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockFeatures.sType ); 9465 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockFeatures.pNext ); 9466 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockFeatures.inlineUniformBlock ); 9467 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockFeatures.descriptorBindingInlineUniformBlockUpdateAfterBind ); 9468 return seed; 9469 } 9470 }; 9471 9472 template <> 9473 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceInlineUniformBlockProperties> 9474 { operator ()std::hash9475 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceInlineUniformBlockProperties const & physicalDeviceInlineUniformBlockProperties ) const 9476 VULKAN_HPP_NOEXCEPT 9477 { 9478 std::size_t seed = 0; 9479 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockProperties.sType ); 9480 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockProperties.pNext ); 9481 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockProperties.maxInlineUniformBlockSize ); 9482 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockProperties.maxPerStageDescriptorInlineUniformBlocks ); 9483 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockProperties.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks ); 9484 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockProperties.maxDescriptorSetInlineUniformBlocks ); 9485 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockProperties.maxDescriptorSetUpdateAfterBindInlineUniformBlocks ); 9486 return seed; 9487 } 9488 }; 9489 9490 template <> 9491 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceInvocationMaskFeaturesHUAWEI> 9492 { operator ()std::hash9493 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceInvocationMaskFeaturesHUAWEI const & physicalDeviceInvocationMaskFeaturesHUAWEI ) const 9494 VULKAN_HPP_NOEXCEPT 9495 { 9496 std::size_t seed = 0; 9497 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInvocationMaskFeaturesHUAWEI.sType ); 9498 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInvocationMaskFeaturesHUAWEI.pNext ); 9499 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInvocationMaskFeaturesHUAWEI.invocationMask ); 9500 return seed; 9501 } 9502 }; 9503 9504 template <> 9505 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredApiPropertiesKHR> 9506 { 9507 std::size_t operator ()std::hash9508 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredApiPropertiesKHR const & physicalDeviceLayeredApiPropertiesKHR ) const VULKAN_HPP_NOEXCEPT 9509 { 9510 std::size_t seed = 0; 9511 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredApiPropertiesKHR.sType ); 9512 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredApiPropertiesKHR.pNext ); 9513 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredApiPropertiesKHR.vendorID ); 9514 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredApiPropertiesKHR.deviceID ); 9515 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredApiPropertiesKHR.layeredAPI ); 9516 for ( size_t i = 0; i < VK_MAX_PHYSICAL_DEVICE_NAME_SIZE; ++i ) 9517 { 9518 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredApiPropertiesKHR.deviceName[i] ); 9519 } 9520 return seed; 9521 } 9522 }; 9523 9524 template <> 9525 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredApiPropertiesListKHR> 9526 { 9527 std::size_t operator ()std::hash9528 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredApiPropertiesListKHR const & physicalDeviceLayeredApiPropertiesListKHR ) const VULKAN_HPP_NOEXCEPT 9529 { 9530 std::size_t seed = 0; 9531 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredApiPropertiesListKHR.sType ); 9532 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredApiPropertiesListKHR.pNext ); 9533 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredApiPropertiesListKHR.layeredApiCount ); 9534 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredApiPropertiesListKHR.pLayeredApis ); 9535 return seed; 9536 } 9537 }; 9538 9539 template <> 9540 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLimits> 9541 { operator ()std::hash9542 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLimits const & physicalDeviceLimits ) const VULKAN_HPP_NOEXCEPT 9543 { 9544 std::size_t seed = 0; 9545 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxImageDimension1D ); 9546 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxImageDimension2D ); 9547 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxImageDimension3D ); 9548 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxImageDimensionCube ); 9549 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxImageArrayLayers ); 9550 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTexelBufferElements ); 9551 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxUniformBufferRange ); 9552 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxStorageBufferRange ); 9553 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxPushConstantsSize ); 9554 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxMemoryAllocationCount ); 9555 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxSamplerAllocationCount ); 9556 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.bufferImageGranularity ); 9557 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.sparseAddressSpaceSize ); 9558 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxBoundDescriptorSets ); 9559 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxPerStageDescriptorSamplers ); 9560 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxPerStageDescriptorUniformBuffers ); 9561 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxPerStageDescriptorStorageBuffers ); 9562 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxPerStageDescriptorSampledImages ); 9563 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxPerStageDescriptorStorageImages ); 9564 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxPerStageDescriptorInputAttachments ); 9565 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxPerStageResources ); 9566 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDescriptorSetSamplers ); 9567 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDescriptorSetUniformBuffers ); 9568 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDescriptorSetUniformBuffersDynamic ); 9569 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDescriptorSetStorageBuffers ); 9570 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDescriptorSetStorageBuffersDynamic ); 9571 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDescriptorSetSampledImages ); 9572 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDescriptorSetStorageImages ); 9573 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDescriptorSetInputAttachments ); 9574 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxVertexInputAttributes ); 9575 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxVertexInputBindings ); 9576 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxVertexInputAttributeOffset ); 9577 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxVertexInputBindingStride ); 9578 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxVertexOutputComponents ); 9579 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTessellationGenerationLevel ); 9580 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTessellationPatchSize ); 9581 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTessellationControlPerVertexInputComponents ); 9582 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTessellationControlPerVertexOutputComponents ); 9583 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTessellationControlPerPatchOutputComponents ); 9584 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTessellationControlTotalOutputComponents ); 9585 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTessellationEvaluationInputComponents ); 9586 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTessellationEvaluationOutputComponents ); 9587 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxGeometryShaderInvocations ); 9588 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxGeometryInputComponents ); 9589 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxGeometryOutputComponents ); 9590 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxGeometryOutputVertices ); 9591 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxGeometryTotalOutputComponents ); 9592 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxFragmentInputComponents ); 9593 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxFragmentOutputAttachments ); 9594 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxFragmentDualSrcAttachments ); 9595 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxFragmentCombinedOutputResources ); 9596 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxComputeSharedMemorySize ); 9597 for ( size_t i = 0; i < 3; ++i ) 9598 { 9599 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxComputeWorkGroupCount[i] ); 9600 } 9601 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxComputeWorkGroupInvocations ); 9602 for ( size_t i = 0; i < 3; ++i ) 9603 { 9604 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxComputeWorkGroupSize[i] ); 9605 } 9606 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.subPixelPrecisionBits ); 9607 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.subTexelPrecisionBits ); 9608 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.mipmapPrecisionBits ); 9609 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDrawIndexedIndexValue ); 9610 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDrawIndirectCount ); 9611 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxSamplerLodBias ); 9612 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxSamplerAnisotropy ); 9613 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxViewports ); 9614 for ( size_t i = 0; i < 2; ++i ) 9615 { 9616 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxViewportDimensions[i] ); 9617 } 9618 for ( size_t i = 0; i < 2; ++i ) 9619 { 9620 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.viewportBoundsRange[i] ); 9621 } 9622 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.viewportSubPixelBits ); 9623 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.minMemoryMapAlignment ); 9624 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.minTexelBufferOffsetAlignment ); 9625 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.minUniformBufferOffsetAlignment ); 9626 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.minStorageBufferOffsetAlignment ); 9627 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.minTexelOffset ); 9628 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTexelOffset ); 9629 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.minTexelGatherOffset ); 9630 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTexelGatherOffset ); 9631 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.minInterpolationOffset ); 9632 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxInterpolationOffset ); 9633 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.subPixelInterpolationOffsetBits ); 9634 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxFramebufferWidth ); 9635 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxFramebufferHeight ); 9636 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxFramebufferLayers ); 9637 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.framebufferColorSampleCounts ); 9638 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.framebufferDepthSampleCounts ); 9639 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.framebufferStencilSampleCounts ); 9640 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.framebufferNoAttachmentsSampleCounts ); 9641 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxColorAttachments ); 9642 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.sampledImageColorSampleCounts ); 9643 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.sampledImageIntegerSampleCounts ); 9644 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.sampledImageDepthSampleCounts ); 9645 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.sampledImageStencilSampleCounts ); 9646 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.storageImageSampleCounts ); 9647 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxSampleMaskWords ); 9648 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.timestampComputeAndGraphics ); 9649 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.timestampPeriod ); 9650 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxClipDistances ); 9651 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxCullDistances ); 9652 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxCombinedClipAndCullDistances ); 9653 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.discreteQueuePriorities ); 9654 for ( size_t i = 0; i < 2; ++i ) 9655 { 9656 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.pointSizeRange[i] ); 9657 } 9658 for ( size_t i = 0; i < 2; ++i ) 9659 { 9660 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.lineWidthRange[i] ); 9661 } 9662 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.pointSizeGranularity ); 9663 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.lineWidthGranularity ); 9664 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.strictLines ); 9665 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.standardSampleLocations ); 9666 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.optimalBufferCopyOffsetAlignment ); 9667 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.optimalBufferCopyRowPitchAlignment ); 9668 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.nonCoherentAtomSize ); 9669 return seed; 9670 } 9671 }; 9672 9673 template <> 9674 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseProperties> 9675 { operator ()std::hash9676 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseProperties const & physicalDeviceSparseProperties ) const VULKAN_HPP_NOEXCEPT 9677 { 9678 std::size_t seed = 0; 9679 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseProperties.residencyStandard2DBlockShape ); 9680 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseProperties.residencyStandard2DMultisampleBlockShape ); 9681 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseProperties.residencyStandard3DBlockShape ); 9682 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseProperties.residencyAlignedMipSize ); 9683 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseProperties.residencyNonResidentStrict ); 9684 return seed; 9685 } 9686 }; 9687 9688 template <> 9689 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties> 9690 { operator ()std::hash9691 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties const & physicalDeviceProperties ) const VULKAN_HPP_NOEXCEPT 9692 { 9693 std::size_t seed = 0; 9694 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.apiVersion ); 9695 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.driverVersion ); 9696 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.vendorID ); 9697 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.deviceID ); 9698 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.deviceType ); 9699 for ( size_t i = 0; i < VK_MAX_PHYSICAL_DEVICE_NAME_SIZE; ++i ) 9700 { 9701 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.deviceName[i] ); 9702 } 9703 for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) 9704 { 9705 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.pipelineCacheUUID[i] ); 9706 } 9707 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.limits ); 9708 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.sparseProperties ); 9709 return seed; 9710 } 9711 }; 9712 9713 template <> 9714 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2> 9715 { operator ()std::hash9716 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 const & physicalDeviceProperties2 ) const VULKAN_HPP_NOEXCEPT 9717 { 9718 std::size_t seed = 0; 9719 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties2.sType ); 9720 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties2.pNext ); 9721 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties2.properties ); 9722 return seed; 9723 } 9724 }; 9725 9726 template <> 9727 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredApiVulkanPropertiesKHR> 9728 { operator ()std::hash9729 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredApiVulkanPropertiesKHR const & physicalDeviceLayeredApiVulkanPropertiesKHR ) const 9730 VULKAN_HPP_NOEXCEPT 9731 { 9732 std::size_t seed = 0; 9733 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredApiVulkanPropertiesKHR.sType ); 9734 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredApiVulkanPropertiesKHR.pNext ); 9735 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredApiVulkanPropertiesKHR.properties ); 9736 return seed; 9737 } 9738 }; 9739 9740 template <> 9741 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredDriverPropertiesMSFT> 9742 { 9743 std::size_t operator ()std::hash9744 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredDriverPropertiesMSFT const & physicalDeviceLayeredDriverPropertiesMSFT ) const VULKAN_HPP_NOEXCEPT 9745 { 9746 std::size_t seed = 0; 9747 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredDriverPropertiesMSFT.sType ); 9748 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredDriverPropertiesMSFT.pNext ); 9749 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredDriverPropertiesMSFT.underlyingAPI ); 9750 return seed; 9751 } 9752 }; 9753 9754 template <> 9755 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLegacyDitheringFeaturesEXT> 9756 { 9757 std::size_t operator ()std::hash9758 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLegacyDitheringFeaturesEXT const & physicalDeviceLegacyDitheringFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 9759 { 9760 std::size_t seed = 0; 9761 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyDitheringFeaturesEXT.sType ); 9762 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyDitheringFeaturesEXT.pNext ); 9763 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyDitheringFeaturesEXT.legacyDithering ); 9764 return seed; 9765 } 9766 }; 9767 9768 template <> 9769 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLegacyVertexAttributesFeaturesEXT> 9770 { operator ()std::hash9771 std::size_t operator()( 9772 VULKAN_HPP_NAMESPACE::PhysicalDeviceLegacyVertexAttributesFeaturesEXT const & physicalDeviceLegacyVertexAttributesFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 9773 { 9774 std::size_t seed = 0; 9775 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyVertexAttributesFeaturesEXT.sType ); 9776 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyVertexAttributesFeaturesEXT.pNext ); 9777 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyVertexAttributesFeaturesEXT.legacyVertexAttributes ); 9778 return seed; 9779 } 9780 }; 9781 9782 template <> 9783 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLegacyVertexAttributesPropertiesEXT> 9784 { operator ()std::hash9785 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLegacyVertexAttributesPropertiesEXT const & physicalDeviceLegacyVertexAttributesPropertiesEXT ) 9786 const VULKAN_HPP_NOEXCEPT 9787 { 9788 std::size_t seed = 0; 9789 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyVertexAttributesPropertiesEXT.sType ); 9790 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyVertexAttributesPropertiesEXT.pNext ); 9791 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyVertexAttributesPropertiesEXT.nativeUnalignedPerformance ); 9792 return seed; 9793 } 9794 }; 9795 9796 template <> 9797 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationFeatures> 9798 { 9799 std::size_t operator ()std::hash9800 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationFeatures const & physicalDeviceLineRasterizationFeatures ) const VULKAN_HPP_NOEXCEPT 9801 { 9802 std::size_t seed = 0; 9803 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeatures.sType ); 9804 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeatures.pNext ); 9805 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeatures.rectangularLines ); 9806 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeatures.bresenhamLines ); 9807 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeatures.smoothLines ); 9808 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeatures.stippledRectangularLines ); 9809 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeatures.stippledBresenhamLines ); 9810 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeatures.stippledSmoothLines ); 9811 return seed; 9812 } 9813 }; 9814 9815 template <> 9816 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationProperties> 9817 { 9818 std::size_t operator ()std::hash9819 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationProperties const & physicalDeviceLineRasterizationProperties ) const VULKAN_HPP_NOEXCEPT 9820 { 9821 std::size_t seed = 0; 9822 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationProperties.sType ); 9823 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationProperties.pNext ); 9824 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationProperties.lineSubPixelPrecisionBits ); 9825 return seed; 9826 } 9827 }; 9828 9829 template <> 9830 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLinearColorAttachmentFeaturesNV> 9831 { operator ()std::hash9832 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLinearColorAttachmentFeaturesNV const & physicalDeviceLinearColorAttachmentFeaturesNV ) const 9833 VULKAN_HPP_NOEXCEPT 9834 { 9835 std::size_t seed = 0; 9836 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLinearColorAttachmentFeaturesNV.sType ); 9837 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLinearColorAttachmentFeaturesNV.pNext ); 9838 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLinearColorAttachmentFeaturesNV.linearColorAttachment ); 9839 return seed; 9840 } 9841 }; 9842 9843 template <> 9844 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance3Properties> 9845 { operator ()std::hash9846 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance3Properties const & physicalDeviceMaintenance3Properties ) const VULKAN_HPP_NOEXCEPT 9847 { 9848 std::size_t seed = 0; 9849 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance3Properties.sType ); 9850 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance3Properties.pNext ); 9851 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance3Properties.maxPerSetDescriptors ); 9852 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance3Properties.maxMemoryAllocationSize ); 9853 return seed; 9854 } 9855 }; 9856 9857 template <> 9858 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance4Features> 9859 { operator ()std::hash9860 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance4Features const & physicalDeviceMaintenance4Features ) const VULKAN_HPP_NOEXCEPT 9861 { 9862 std::size_t seed = 0; 9863 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance4Features.sType ); 9864 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance4Features.pNext ); 9865 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance4Features.maintenance4 ); 9866 return seed; 9867 } 9868 }; 9869 9870 template <> 9871 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance4Properties> 9872 { operator ()std::hash9873 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance4Properties const & physicalDeviceMaintenance4Properties ) const VULKAN_HPP_NOEXCEPT 9874 { 9875 std::size_t seed = 0; 9876 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance4Properties.sType ); 9877 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance4Properties.pNext ); 9878 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance4Properties.maxBufferSize ); 9879 return seed; 9880 } 9881 }; 9882 9883 template <> 9884 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance5Features> 9885 { operator ()std::hash9886 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance5Features const & physicalDeviceMaintenance5Features ) const VULKAN_HPP_NOEXCEPT 9887 { 9888 std::size_t seed = 0; 9889 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5Features.sType ); 9890 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5Features.pNext ); 9891 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5Features.maintenance5 ); 9892 return seed; 9893 } 9894 }; 9895 9896 template <> 9897 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance5Properties> 9898 { operator ()std::hash9899 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance5Properties const & physicalDeviceMaintenance5Properties ) const VULKAN_HPP_NOEXCEPT 9900 { 9901 std::size_t seed = 0; 9902 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5Properties.sType ); 9903 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5Properties.pNext ); 9904 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5Properties.earlyFragmentMultisampleCoverageAfterSampleCounting ); 9905 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5Properties.earlyFragmentSampleMaskTestBeforeSampleCounting ); 9906 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5Properties.depthStencilSwizzleOneSupport ); 9907 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5Properties.polygonModePointSize ); 9908 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5Properties.nonStrictSinglePixelWideLinesUseParallelogram ); 9909 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5Properties.nonStrictWideLinesUseParallelogram ); 9910 return seed; 9911 } 9912 }; 9913 9914 template <> 9915 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance6Features> 9916 { operator ()std::hash9917 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance6Features const & physicalDeviceMaintenance6Features ) const VULKAN_HPP_NOEXCEPT 9918 { 9919 std::size_t seed = 0; 9920 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance6Features.sType ); 9921 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance6Features.pNext ); 9922 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance6Features.maintenance6 ); 9923 return seed; 9924 } 9925 }; 9926 9927 template <> 9928 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance6Properties> 9929 { operator ()std::hash9930 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance6Properties const & physicalDeviceMaintenance6Properties ) const VULKAN_HPP_NOEXCEPT 9931 { 9932 std::size_t seed = 0; 9933 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance6Properties.sType ); 9934 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance6Properties.pNext ); 9935 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance6Properties.blockTexelViewCompatibleMultipleLayers ); 9936 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance6Properties.maxCombinedImageSamplerDescriptorCount ); 9937 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance6Properties.fragmentShadingRateClampCombinerInputs ); 9938 return seed; 9939 } 9940 }; 9941 9942 template <> 9943 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance7FeaturesKHR> 9944 { 9945 std::size_t operator ()std::hash9946 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance7FeaturesKHR const & physicalDeviceMaintenance7FeaturesKHR ) const VULKAN_HPP_NOEXCEPT 9947 { 9948 std::size_t seed = 0; 9949 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance7FeaturesKHR.sType ); 9950 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance7FeaturesKHR.pNext ); 9951 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance7FeaturesKHR.maintenance7 ); 9952 return seed; 9953 } 9954 }; 9955 9956 template <> 9957 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance7PropertiesKHR> 9958 { 9959 std::size_t operator ()std::hash9960 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance7PropertiesKHR const & physicalDeviceMaintenance7PropertiesKHR ) const VULKAN_HPP_NOEXCEPT 9961 { 9962 std::size_t seed = 0; 9963 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance7PropertiesKHR.sType ); 9964 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance7PropertiesKHR.pNext ); 9965 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance7PropertiesKHR.robustFragmentShadingRateAttachmentAccess ); 9966 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance7PropertiesKHR.separateDepthStencilAttachmentAccess ); 9967 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance7PropertiesKHR.maxDescriptorSetTotalUniformBuffersDynamic ); 9968 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance7PropertiesKHR.maxDescriptorSetTotalStorageBuffersDynamic ); 9969 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance7PropertiesKHR.maxDescriptorSetTotalBuffersDynamic ); 9970 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance7PropertiesKHR.maxDescriptorSetUpdateAfterBindTotalUniformBuffersDynamic ); 9971 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance7PropertiesKHR.maxDescriptorSetUpdateAfterBindTotalStorageBuffersDynamic ); 9972 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance7PropertiesKHR.maxDescriptorSetUpdateAfterBindTotalBuffersDynamic ); 9973 return seed; 9974 } 9975 }; 9976 9977 template <> 9978 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMapMemoryPlacedFeaturesEXT> 9979 { 9980 std::size_t operator ()std::hash9981 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMapMemoryPlacedFeaturesEXT const & physicalDeviceMapMemoryPlacedFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 9982 { 9983 std::size_t seed = 0; 9984 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMapMemoryPlacedFeaturesEXT.sType ); 9985 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMapMemoryPlacedFeaturesEXT.pNext ); 9986 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMapMemoryPlacedFeaturesEXT.memoryMapPlaced ); 9987 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMapMemoryPlacedFeaturesEXT.memoryMapRangePlaced ); 9988 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMapMemoryPlacedFeaturesEXT.memoryUnmapReserve ); 9989 return seed; 9990 } 9991 }; 9992 9993 template <> 9994 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMapMemoryPlacedPropertiesEXT> 9995 { operator ()std::hash9996 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMapMemoryPlacedPropertiesEXT const & physicalDeviceMapMemoryPlacedPropertiesEXT ) const 9997 VULKAN_HPP_NOEXCEPT 9998 { 9999 std::size_t seed = 0; 10000 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMapMemoryPlacedPropertiesEXT.sType ); 10001 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMapMemoryPlacedPropertiesEXT.pNext ); 10002 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMapMemoryPlacedPropertiesEXT.minPlacedMemoryMapAlignment ); 10003 return seed; 10004 } 10005 }; 10006 10007 template <> 10008 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryBudgetPropertiesEXT> 10009 { 10010 std::size_t operator ()std::hash10011 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryBudgetPropertiesEXT const & physicalDeviceMemoryBudgetPropertiesEXT ) const VULKAN_HPP_NOEXCEPT 10012 { 10013 std::size_t seed = 0; 10014 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryBudgetPropertiesEXT.sType ); 10015 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryBudgetPropertiesEXT.pNext ); 10016 for ( size_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i ) 10017 { 10018 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryBudgetPropertiesEXT.heapBudget[i] ); 10019 } 10020 for ( size_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i ) 10021 { 10022 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryBudgetPropertiesEXT.heapUsage[i] ); 10023 } 10024 return seed; 10025 } 10026 }; 10027 10028 template <> 10029 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryDecompressionFeaturesNV> 10030 { operator ()std::hash10031 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryDecompressionFeaturesNV const & physicalDeviceMemoryDecompressionFeaturesNV ) const 10032 VULKAN_HPP_NOEXCEPT 10033 { 10034 std::size_t seed = 0; 10035 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionFeaturesNV.sType ); 10036 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionFeaturesNV.pNext ); 10037 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionFeaturesNV.memoryDecompression ); 10038 return seed; 10039 } 10040 }; 10041 10042 template <> 10043 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryDecompressionPropertiesNV> 10044 { operator ()std::hash10045 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryDecompressionPropertiesNV const & physicalDeviceMemoryDecompressionPropertiesNV ) const 10046 VULKAN_HPP_NOEXCEPT 10047 { 10048 std::size_t seed = 0; 10049 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionPropertiesNV.sType ); 10050 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionPropertiesNV.pNext ); 10051 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionPropertiesNV.decompressionMethods ); 10052 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionPropertiesNV.maxDecompressionIndirectCount ); 10053 return seed; 10054 } 10055 }; 10056 10057 template <> 10058 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryPriorityFeaturesEXT> 10059 { 10060 std::size_t operator ()std::hash10061 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryPriorityFeaturesEXT const & physicalDeviceMemoryPriorityFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 10062 { 10063 std::size_t seed = 0; 10064 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryPriorityFeaturesEXT.sType ); 10065 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryPriorityFeaturesEXT.pNext ); 10066 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryPriorityFeaturesEXT.memoryPriority ); 10067 return seed; 10068 } 10069 }; 10070 10071 template <> 10072 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties> 10073 { operator ()std::hash10074 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties const & physicalDeviceMemoryProperties ) const VULKAN_HPP_NOEXCEPT 10075 { 10076 std::size_t seed = 0; 10077 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryProperties.memoryTypeCount ); 10078 for ( size_t i = 0; i < VK_MAX_MEMORY_TYPES; ++i ) 10079 { 10080 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryProperties.memoryTypes[i] ); 10081 } 10082 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryProperties.memoryHeapCount ); 10083 for ( size_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i ) 10084 { 10085 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryProperties.memoryHeaps[i] ); 10086 } 10087 return seed; 10088 } 10089 }; 10090 10091 template <> 10092 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2> 10093 { operator ()std::hash10094 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 const & physicalDeviceMemoryProperties2 ) const VULKAN_HPP_NOEXCEPT 10095 { 10096 std::size_t seed = 0; 10097 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryProperties2.sType ); 10098 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryProperties2.pNext ); 10099 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryProperties2.memoryProperties ); 10100 return seed; 10101 } 10102 }; 10103 10104 template <> 10105 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderFeaturesEXT> 10106 { operator ()std::hash10107 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderFeaturesEXT const & physicalDeviceMeshShaderFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 10108 { 10109 std::size_t seed = 0; 10110 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesEXT.sType ); 10111 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesEXT.pNext ); 10112 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesEXT.taskShader ); 10113 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesEXT.meshShader ); 10114 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesEXT.multiviewMeshShader ); 10115 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesEXT.primitiveFragmentShadingRateMeshShader ); 10116 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesEXT.meshShaderQueries ); 10117 return seed; 10118 } 10119 }; 10120 10121 template <> 10122 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderFeaturesNV> 10123 { operator ()std::hash10124 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderFeaturesNV const & physicalDeviceMeshShaderFeaturesNV ) const VULKAN_HPP_NOEXCEPT 10125 { 10126 std::size_t seed = 0; 10127 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesNV.sType ); 10128 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesNV.pNext ); 10129 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesNV.taskShader ); 10130 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesNV.meshShader ); 10131 return seed; 10132 } 10133 }; 10134 10135 template <> 10136 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderPropertiesEXT> 10137 { 10138 std::size_t operator ()std::hash10139 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderPropertiesEXT const & physicalDeviceMeshShaderPropertiesEXT ) const VULKAN_HPP_NOEXCEPT 10140 { 10141 std::size_t seed = 0; 10142 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.sType ); 10143 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.pNext ); 10144 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxTaskWorkGroupTotalCount ); 10145 for ( size_t i = 0; i < 3; ++i ) 10146 { 10147 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxTaskWorkGroupCount[i] ); 10148 } 10149 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxTaskWorkGroupInvocations ); 10150 for ( size_t i = 0; i < 3; ++i ) 10151 { 10152 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxTaskWorkGroupSize[i] ); 10153 } 10154 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxTaskPayloadSize ); 10155 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxTaskSharedMemorySize ); 10156 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxTaskPayloadAndSharedMemorySize ); 10157 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshWorkGroupTotalCount ); 10158 for ( size_t i = 0; i < 3; ++i ) 10159 { 10160 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshWorkGroupCount[i] ); 10161 } 10162 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshWorkGroupInvocations ); 10163 for ( size_t i = 0; i < 3; ++i ) 10164 { 10165 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshWorkGroupSize[i] ); 10166 } 10167 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshSharedMemorySize ); 10168 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshPayloadAndSharedMemorySize ); 10169 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshOutputMemorySize ); 10170 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshPayloadAndOutputMemorySize ); 10171 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshOutputComponents ); 10172 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshOutputVertices ); 10173 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshOutputPrimitives ); 10174 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshOutputLayers ); 10175 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshMultiviewViewCount ); 10176 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.meshOutputPerVertexGranularity ); 10177 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.meshOutputPerPrimitiveGranularity ); 10178 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxPreferredTaskWorkGroupInvocations ); 10179 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxPreferredMeshWorkGroupInvocations ); 10180 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.prefersLocalInvocationVertexOutput ); 10181 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.prefersLocalInvocationPrimitiveOutput ); 10182 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.prefersCompactVertexOutput ); 10183 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.prefersCompactPrimitiveOutput ); 10184 return seed; 10185 } 10186 }; 10187 10188 template <> 10189 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderPropertiesNV> 10190 { operator ()std::hash10191 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderPropertiesNV const & physicalDeviceMeshShaderPropertiesNV ) const VULKAN_HPP_NOEXCEPT 10192 { 10193 std::size_t seed = 0; 10194 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.sType ); 10195 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.pNext ); 10196 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxDrawMeshTasksCount ); 10197 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxTaskWorkGroupInvocations ); 10198 for ( size_t i = 0; i < 3; ++i ) 10199 { 10200 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxTaskWorkGroupSize[i] ); 10201 } 10202 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxTaskTotalMemorySize ); 10203 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxTaskOutputCount ); 10204 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxMeshWorkGroupInvocations ); 10205 for ( size_t i = 0; i < 3; ++i ) 10206 { 10207 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxMeshWorkGroupSize[i] ); 10208 } 10209 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxMeshTotalMemorySize ); 10210 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxMeshOutputVertices ); 10211 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxMeshOutputPrimitives ); 10212 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxMeshMultiviewViewCount ); 10213 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.meshOutputPerVertexGranularity ); 10214 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.meshOutputPerPrimitiveGranularity ); 10215 return seed; 10216 } 10217 }; 10218 10219 template <> 10220 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiDrawFeaturesEXT> 10221 { operator ()std::hash10222 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiDrawFeaturesEXT const & physicalDeviceMultiDrawFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 10223 { 10224 std::size_t seed = 0; 10225 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiDrawFeaturesEXT.sType ); 10226 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiDrawFeaturesEXT.pNext ); 10227 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiDrawFeaturesEXT.multiDraw ); 10228 return seed; 10229 } 10230 }; 10231 10232 template <> 10233 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiDrawPropertiesEXT> 10234 { operator ()std::hash10235 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiDrawPropertiesEXT const & physicalDeviceMultiDrawPropertiesEXT ) const VULKAN_HPP_NOEXCEPT 10236 { 10237 std::size_t seed = 0; 10238 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiDrawPropertiesEXT.sType ); 10239 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiDrawPropertiesEXT.pNext ); 10240 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiDrawPropertiesEXT.maxMultiDrawCount ); 10241 return seed; 10242 } 10243 }; 10244 10245 template <> 10246 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT> 10247 { operator ()std::hash10248 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT const & 10249 physicalDeviceMultisampledRenderToSingleSampledFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 10250 { 10251 std::size_t seed = 0; 10252 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultisampledRenderToSingleSampledFeaturesEXT.sType ); 10253 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultisampledRenderToSingleSampledFeaturesEXT.pNext ); 10254 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultisampledRenderToSingleSampledFeaturesEXT.multisampledRenderToSingleSampled ); 10255 return seed; 10256 } 10257 }; 10258 10259 template <> 10260 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewFeatures> 10261 { operator ()std::hash10262 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewFeatures const & physicalDeviceMultiviewFeatures ) const VULKAN_HPP_NOEXCEPT 10263 { 10264 std::size_t seed = 0; 10265 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewFeatures.sType ); 10266 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewFeatures.pNext ); 10267 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewFeatures.multiview ); 10268 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewFeatures.multiviewGeometryShader ); 10269 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewFeatures.multiviewTessellationShader ); 10270 return seed; 10271 } 10272 }; 10273 10274 template <> 10275 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX> 10276 { operator ()std::hash10277 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const & 10278 physicalDeviceMultiviewPerViewAttributesPropertiesNVX ) const VULKAN_HPP_NOEXCEPT 10279 { 10280 std::size_t seed = 0; 10281 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewAttributesPropertiesNVX.sType ); 10282 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewAttributesPropertiesNVX.pNext ); 10283 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewAttributesPropertiesNVX.perViewPositionAllComponents ); 10284 return seed; 10285 } 10286 }; 10287 10288 template <> 10289 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM> 10290 { operator ()std::hash10291 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM const & 10292 physicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM ) const VULKAN_HPP_NOEXCEPT 10293 { 10294 std::size_t seed = 0; 10295 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM.sType ); 10296 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM.pNext ); 10297 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM.multiviewPerViewRenderAreas ); 10298 return seed; 10299 } 10300 }; 10301 10302 template <> 10303 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM> 10304 { 10305 std::size_t operator ()std::hash10306 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM const & physicalDeviceMultiviewPerViewViewportsFeaturesQCOM ) const 10307 VULKAN_HPP_NOEXCEPT 10308 { 10309 std::size_t seed = 0; 10310 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewViewportsFeaturesQCOM.sType ); 10311 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewViewportsFeaturesQCOM.pNext ); 10312 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewViewportsFeaturesQCOM.multiviewPerViewViewports ); 10313 return seed; 10314 } 10315 }; 10316 10317 template <> 10318 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewProperties> 10319 { operator ()std::hash10320 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewProperties const & physicalDeviceMultiviewProperties ) const VULKAN_HPP_NOEXCEPT 10321 { 10322 std::size_t seed = 0; 10323 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewProperties.sType ); 10324 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewProperties.pNext ); 10325 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewProperties.maxMultiviewViewCount ); 10326 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewProperties.maxMultiviewInstanceIndex ); 10327 return seed; 10328 } 10329 }; 10330 10331 template <> 10332 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMutableDescriptorTypeFeaturesEXT> 10333 { operator ()std::hash10334 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMutableDescriptorTypeFeaturesEXT const & physicalDeviceMutableDescriptorTypeFeaturesEXT ) const 10335 VULKAN_HPP_NOEXCEPT 10336 { 10337 std::size_t seed = 0; 10338 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMutableDescriptorTypeFeaturesEXT.sType ); 10339 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMutableDescriptorTypeFeaturesEXT.pNext ); 10340 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMutableDescriptorTypeFeaturesEXT.mutableDescriptorType ); 10341 return seed; 10342 } 10343 }; 10344 10345 template <> 10346 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceNestedCommandBufferFeaturesEXT> 10347 { operator ()std::hash10348 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceNestedCommandBufferFeaturesEXT const & physicalDeviceNestedCommandBufferFeaturesEXT ) const 10349 VULKAN_HPP_NOEXCEPT 10350 { 10351 std::size_t seed = 0; 10352 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNestedCommandBufferFeaturesEXT.sType ); 10353 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNestedCommandBufferFeaturesEXT.pNext ); 10354 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNestedCommandBufferFeaturesEXT.nestedCommandBuffer ); 10355 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNestedCommandBufferFeaturesEXT.nestedCommandBufferRendering ); 10356 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNestedCommandBufferFeaturesEXT.nestedCommandBufferSimultaneousUse ); 10357 return seed; 10358 } 10359 }; 10360 10361 template <> 10362 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceNestedCommandBufferPropertiesEXT> 10363 { operator ()std::hash10364 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceNestedCommandBufferPropertiesEXT const & physicalDeviceNestedCommandBufferPropertiesEXT ) const 10365 VULKAN_HPP_NOEXCEPT 10366 { 10367 std::size_t seed = 0; 10368 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNestedCommandBufferPropertiesEXT.sType ); 10369 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNestedCommandBufferPropertiesEXT.pNext ); 10370 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNestedCommandBufferPropertiesEXT.maxCommandBufferNestingLevel ); 10371 return seed; 10372 } 10373 }; 10374 10375 template <> 10376 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceNonSeamlessCubeMapFeaturesEXT> 10377 { operator ()std::hash10378 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceNonSeamlessCubeMapFeaturesEXT const & physicalDeviceNonSeamlessCubeMapFeaturesEXT ) const 10379 VULKAN_HPP_NOEXCEPT 10380 { 10381 std::size_t seed = 0; 10382 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNonSeamlessCubeMapFeaturesEXT.sType ); 10383 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNonSeamlessCubeMapFeaturesEXT.pNext ); 10384 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNonSeamlessCubeMapFeaturesEXT.nonSeamlessCubeMap ); 10385 return seed; 10386 } 10387 }; 10388 10389 template <> 10390 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceOpacityMicromapFeaturesEXT> 10391 { 10392 std::size_t operator ()std::hash10393 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceOpacityMicromapFeaturesEXT const & physicalDeviceOpacityMicromapFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 10394 { 10395 std::size_t seed = 0; 10396 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapFeaturesEXT.sType ); 10397 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapFeaturesEXT.pNext ); 10398 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapFeaturesEXT.micromap ); 10399 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapFeaturesEXT.micromapCaptureReplay ); 10400 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapFeaturesEXT.micromapHostCommands ); 10401 return seed; 10402 } 10403 }; 10404 10405 template <> 10406 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceOpacityMicromapPropertiesEXT> 10407 { operator ()std::hash10408 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceOpacityMicromapPropertiesEXT const & physicalDeviceOpacityMicromapPropertiesEXT ) const 10409 VULKAN_HPP_NOEXCEPT 10410 { 10411 std::size_t seed = 0; 10412 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapPropertiesEXT.sType ); 10413 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapPropertiesEXT.pNext ); 10414 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapPropertiesEXT.maxOpacity2StateSubdivisionLevel ); 10415 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapPropertiesEXT.maxOpacity4StateSubdivisionLevel ); 10416 return seed; 10417 } 10418 }; 10419 10420 template <> 10421 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceOpticalFlowFeaturesNV> 10422 { operator ()std::hash10423 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceOpticalFlowFeaturesNV const & physicalDeviceOpticalFlowFeaturesNV ) const VULKAN_HPP_NOEXCEPT 10424 { 10425 std::size_t seed = 0; 10426 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowFeaturesNV.sType ); 10427 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowFeaturesNV.pNext ); 10428 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowFeaturesNV.opticalFlow ); 10429 return seed; 10430 } 10431 }; 10432 10433 template <> 10434 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceOpticalFlowPropertiesNV> 10435 { 10436 std::size_t operator ()std::hash10437 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceOpticalFlowPropertiesNV const & physicalDeviceOpticalFlowPropertiesNV ) const VULKAN_HPP_NOEXCEPT 10438 { 10439 std::size_t seed = 0; 10440 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.sType ); 10441 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.pNext ); 10442 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.supportedOutputGridSizes ); 10443 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.supportedHintGridSizes ); 10444 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.hintSupported ); 10445 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.costSupported ); 10446 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.bidirectionalFlowSupported ); 10447 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.globalFlowSupported ); 10448 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.minWidth ); 10449 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.minHeight ); 10450 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.maxWidth ); 10451 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.maxHeight ); 10452 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.maxNumRegionsOfInterest ); 10453 return seed; 10454 } 10455 }; 10456 10457 template <> 10458 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePCIBusInfoPropertiesEXT> 10459 { 10460 std::size_t operator ()std::hash10461 operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePCIBusInfoPropertiesEXT const & physicalDevicePCIBusInfoPropertiesEXT ) const VULKAN_HPP_NOEXCEPT 10462 { 10463 std::size_t seed = 0; 10464 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePCIBusInfoPropertiesEXT.sType ); 10465 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePCIBusInfoPropertiesEXT.pNext ); 10466 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePCIBusInfoPropertiesEXT.pciDomain ); 10467 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePCIBusInfoPropertiesEXT.pciBus ); 10468 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePCIBusInfoPropertiesEXT.pciDevice ); 10469 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePCIBusInfoPropertiesEXT.pciFunction ); 10470 return seed; 10471 } 10472 }; 10473 10474 template <> 10475 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT> 10476 { 10477 std::size_t operator ()std::hash10478 operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT const & physicalDevicePageableDeviceLocalMemoryFeaturesEXT ) const 10479 VULKAN_HPP_NOEXCEPT 10480 { 10481 std::size_t seed = 0; 10482 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePageableDeviceLocalMemoryFeaturesEXT.sType ); 10483 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePageableDeviceLocalMemoryFeaturesEXT.pNext ); 10484 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePageableDeviceLocalMemoryFeaturesEXT.pageableDeviceLocalMemory ); 10485 return seed; 10486 } 10487 }; 10488 10489 template <> 10490 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePerStageDescriptorSetFeaturesNV> 10491 { operator ()std::hash10492 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePerStageDescriptorSetFeaturesNV const & physicalDevicePerStageDescriptorSetFeaturesNV ) const 10493 VULKAN_HPP_NOEXCEPT 10494 { 10495 std::size_t seed = 0; 10496 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerStageDescriptorSetFeaturesNV.sType ); 10497 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerStageDescriptorSetFeaturesNV.pNext ); 10498 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerStageDescriptorSetFeaturesNV.perStageDescriptorSet ); 10499 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerStageDescriptorSetFeaturesNV.dynamicPipelineLayout ); 10500 return seed; 10501 } 10502 }; 10503 10504 template <> 10505 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceQueryFeaturesKHR> 10506 { 10507 std::size_t operator ()std::hash10508 operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceQueryFeaturesKHR const & physicalDevicePerformanceQueryFeaturesKHR ) const VULKAN_HPP_NOEXCEPT 10509 { 10510 std::size_t seed = 0; 10511 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceQueryFeaturesKHR.sType ); 10512 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceQueryFeaturesKHR.pNext ); 10513 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceQueryFeaturesKHR.performanceCounterQueryPools ); 10514 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceQueryFeaturesKHR.performanceCounterMultipleQueryPools ); 10515 return seed; 10516 } 10517 }; 10518 10519 template <> 10520 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceQueryPropertiesKHR> 10521 { operator ()std::hash10522 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceQueryPropertiesKHR const & physicalDevicePerformanceQueryPropertiesKHR ) const 10523 VULKAN_HPP_NOEXCEPT 10524 { 10525 std::size_t seed = 0; 10526 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceQueryPropertiesKHR.sType ); 10527 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceQueryPropertiesKHR.pNext ); 10528 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceQueryPropertiesKHR.allowCommandBufferQueryCopies ); 10529 return seed; 10530 } 10531 }; 10532 10533 template <> 10534 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineBinaryFeaturesKHR> 10535 { 10536 std::size_t operator ()std::hash10537 operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineBinaryFeaturesKHR const & physicalDevicePipelineBinaryFeaturesKHR ) const VULKAN_HPP_NOEXCEPT 10538 { 10539 std::size_t seed = 0; 10540 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineBinaryFeaturesKHR.sType ); 10541 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineBinaryFeaturesKHR.pNext ); 10542 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineBinaryFeaturesKHR.pipelineBinaries ); 10543 return seed; 10544 } 10545 }; 10546 10547 template <> 10548 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineBinaryPropertiesKHR> 10549 { 10550 std::size_t operator ()std::hash10551 operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineBinaryPropertiesKHR const & physicalDevicePipelineBinaryPropertiesKHR ) const VULKAN_HPP_NOEXCEPT 10552 { 10553 std::size_t seed = 0; 10554 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineBinaryPropertiesKHR.sType ); 10555 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineBinaryPropertiesKHR.pNext ); 10556 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineBinaryPropertiesKHR.pipelineBinaryInternalCache ); 10557 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineBinaryPropertiesKHR.pipelineBinaryInternalCacheControl ); 10558 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineBinaryPropertiesKHR.pipelineBinaryPrefersInternalCache ); 10559 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineBinaryPropertiesKHR.pipelineBinaryPrecompiledInternalCache ); 10560 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineBinaryPropertiesKHR.pipelineBinaryCompressedData ); 10561 return seed; 10562 } 10563 }; 10564 10565 template <> 10566 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineCreationCacheControlFeatures> 10567 { 10568 std::size_t operator ()std::hash10569 operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineCreationCacheControlFeatures const & physicalDevicePipelineCreationCacheControlFeatures ) const 10570 VULKAN_HPP_NOEXCEPT 10571 { 10572 std::size_t seed = 0; 10573 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineCreationCacheControlFeatures.sType ); 10574 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineCreationCacheControlFeatures.pNext ); 10575 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineCreationCacheControlFeatures.pipelineCreationCacheControl ); 10576 return seed; 10577 } 10578 }; 10579 10580 template <> 10581 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR> 10582 { operator ()std::hash10583 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR const & 10584 physicalDevicePipelineExecutablePropertiesFeaturesKHR ) const VULKAN_HPP_NOEXCEPT 10585 { 10586 std::size_t seed = 0; 10587 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineExecutablePropertiesFeaturesKHR.sType ); 10588 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineExecutablePropertiesFeaturesKHR.pNext ); 10589 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineExecutablePropertiesFeaturesKHR.pipelineExecutableInfo ); 10590 return seed; 10591 } 10592 }; 10593 10594 template <> 10595 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT> 10596 { operator ()std::hash10597 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT const & 10598 physicalDevicePipelineLibraryGroupHandlesFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 10599 { 10600 std::size_t seed = 0; 10601 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineLibraryGroupHandlesFeaturesEXT.sType ); 10602 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineLibraryGroupHandlesFeaturesEXT.pNext ); 10603 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineLibraryGroupHandlesFeaturesEXT.pipelineLibraryGroupHandles ); 10604 return seed; 10605 } 10606 }; 10607 10608 template <> 10609 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelinePropertiesFeaturesEXT> 10610 { operator ()std::hash10611 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelinePropertiesFeaturesEXT const & physicalDevicePipelinePropertiesFeaturesEXT ) const 10612 VULKAN_HPP_NOEXCEPT 10613 { 10614 std::size_t seed = 0; 10615 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelinePropertiesFeaturesEXT.sType ); 10616 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelinePropertiesFeaturesEXT.pNext ); 10617 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelinePropertiesFeaturesEXT.pipelinePropertiesIdentifier ); 10618 return seed; 10619 } 10620 }; 10621 10622 template <> 10623 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineProtectedAccessFeatures> 10624 { operator ()std::hash10625 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineProtectedAccessFeatures const & physicalDevicePipelineProtectedAccessFeatures ) const 10626 VULKAN_HPP_NOEXCEPT 10627 { 10628 std::size_t seed = 0; 10629 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineProtectedAccessFeatures.sType ); 10630 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineProtectedAccessFeatures.pNext ); 10631 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineProtectedAccessFeatures.pipelineProtectedAccess ); 10632 return seed; 10633 } 10634 }; 10635 10636 template <> 10637 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineRobustnessFeatures> 10638 { 10639 std::size_t operator ()std::hash10640 operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineRobustnessFeatures const & physicalDevicePipelineRobustnessFeatures ) const VULKAN_HPP_NOEXCEPT 10641 { 10642 std::size_t seed = 0; 10643 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineRobustnessFeatures.sType ); 10644 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineRobustnessFeatures.pNext ); 10645 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineRobustnessFeatures.pipelineRobustness ); 10646 return seed; 10647 } 10648 }; 10649 10650 template <> 10651 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineRobustnessProperties> 10652 { operator ()std::hash10653 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineRobustnessProperties const & physicalDevicePipelineRobustnessProperties ) const 10654 VULKAN_HPP_NOEXCEPT 10655 { 10656 std::size_t seed = 0; 10657 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineRobustnessProperties.sType ); 10658 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineRobustnessProperties.pNext ); 10659 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineRobustnessProperties.defaultRobustnessStorageBuffers ); 10660 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineRobustnessProperties.defaultRobustnessUniformBuffers ); 10661 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineRobustnessProperties.defaultRobustnessVertexInputs ); 10662 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineRobustnessProperties.defaultRobustnessImages ); 10663 return seed; 10664 } 10665 }; 10666 10667 template <> 10668 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePointClippingProperties> 10669 { 10670 std::size_t operator ()std::hash10671 operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePointClippingProperties const & physicalDevicePointClippingProperties ) const VULKAN_HPP_NOEXCEPT 10672 { 10673 std::size_t seed = 0; 10674 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePointClippingProperties.sType ); 10675 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePointClippingProperties.pNext ); 10676 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePointClippingProperties.pointClippingBehavior ); 10677 return seed; 10678 } 10679 }; 10680 10681 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 10682 template <> 10683 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePortabilitySubsetFeaturesKHR> 10684 { operator ()std::hash10685 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePortabilitySubsetFeaturesKHR const & physicalDevicePortabilitySubsetFeaturesKHR ) const 10686 VULKAN_HPP_NOEXCEPT 10687 { 10688 std::size_t seed = 0; 10689 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.sType ); 10690 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.pNext ); 10691 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.constantAlphaColorBlendFactors ); 10692 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.events ); 10693 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.imageViewFormatReinterpretation ); 10694 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.imageViewFormatSwizzle ); 10695 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.imageView2DOn3DImage ); 10696 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.multisampleArrayImage ); 10697 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.mutableComparisonSamplers ); 10698 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.pointPolygons ); 10699 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.samplerMipLodBias ); 10700 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.separateStencilMaskRef ); 10701 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.shaderSampleRateInterpolationFunctions ); 10702 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.tessellationIsolines ); 10703 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.tessellationPointMode ); 10704 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.triangleFans ); 10705 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.vertexAttributeAccessBeyondStride ); 10706 return seed; 10707 } 10708 }; 10709 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 10710 10711 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 10712 template <> 10713 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePortabilitySubsetPropertiesKHR> 10714 { operator ()std::hash10715 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePortabilitySubsetPropertiesKHR const & physicalDevicePortabilitySubsetPropertiesKHR ) const 10716 VULKAN_HPP_NOEXCEPT 10717 { 10718 std::size_t seed = 0; 10719 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetPropertiesKHR.sType ); 10720 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetPropertiesKHR.pNext ); 10721 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetPropertiesKHR.minVertexInputBindingStrideAlignment ); 10722 return seed; 10723 } 10724 }; 10725 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 10726 10727 template <> 10728 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePresentBarrierFeaturesNV> 10729 { 10730 std::size_t operator ()std::hash10731 operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePresentBarrierFeaturesNV const & physicalDevicePresentBarrierFeaturesNV ) const VULKAN_HPP_NOEXCEPT 10732 { 10733 std::size_t seed = 0; 10734 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentBarrierFeaturesNV.sType ); 10735 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentBarrierFeaturesNV.pNext ); 10736 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentBarrierFeaturesNV.presentBarrier ); 10737 return seed; 10738 } 10739 }; 10740 10741 template <> 10742 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePresentIdFeaturesKHR> 10743 { operator ()std::hash10744 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePresentIdFeaturesKHR const & physicalDevicePresentIdFeaturesKHR ) const VULKAN_HPP_NOEXCEPT 10745 { 10746 std::size_t seed = 0; 10747 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentIdFeaturesKHR.sType ); 10748 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentIdFeaturesKHR.pNext ); 10749 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentIdFeaturesKHR.presentId ); 10750 return seed; 10751 } 10752 }; 10753 10754 template <> 10755 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePresentWaitFeaturesKHR> 10756 { operator ()std::hash10757 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePresentWaitFeaturesKHR const & physicalDevicePresentWaitFeaturesKHR ) const VULKAN_HPP_NOEXCEPT 10758 { 10759 std::size_t seed = 0; 10760 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentWaitFeaturesKHR.sType ); 10761 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentWaitFeaturesKHR.pNext ); 10762 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentWaitFeaturesKHR.presentWait ); 10763 return seed; 10764 } 10765 }; 10766 10767 template <> 10768 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT> 10769 { operator ()std::hash10770 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT const & 10771 physicalDevicePrimitiveTopologyListRestartFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 10772 { 10773 std::size_t seed = 0; 10774 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrimitiveTopologyListRestartFeaturesEXT.sType ); 10775 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrimitiveTopologyListRestartFeaturesEXT.pNext ); 10776 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrimitiveTopologyListRestartFeaturesEXT.primitiveTopologyListRestart ); 10777 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrimitiveTopologyListRestartFeaturesEXT.primitiveTopologyPatchListRestart ); 10778 return seed; 10779 } 10780 }; 10781 10782 template <> 10783 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT> 10784 { operator ()std::hash10785 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT const & physicalDevicePrimitivesGeneratedQueryFeaturesEXT ) 10786 const VULKAN_HPP_NOEXCEPT 10787 { 10788 std::size_t seed = 0; 10789 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrimitivesGeneratedQueryFeaturesEXT.sType ); 10790 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrimitivesGeneratedQueryFeaturesEXT.pNext ); 10791 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrimitivesGeneratedQueryFeaturesEXT.primitivesGeneratedQuery ); 10792 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrimitivesGeneratedQueryFeaturesEXT.primitivesGeneratedQueryWithRasterizerDiscard ); 10793 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrimitivesGeneratedQueryFeaturesEXT.primitivesGeneratedQueryWithNonZeroStreams ); 10794 return seed; 10795 } 10796 }; 10797 10798 template <> 10799 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePrivateDataFeatures> 10800 { operator ()std::hash10801 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePrivateDataFeatures const & physicalDevicePrivateDataFeatures ) const VULKAN_HPP_NOEXCEPT 10802 { 10803 std::size_t seed = 0; 10804 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrivateDataFeatures.sType ); 10805 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrivateDataFeatures.pNext ); 10806 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrivateDataFeatures.privateData ); 10807 return seed; 10808 } 10809 }; 10810 10811 template <> 10812 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceProtectedMemoryFeatures> 10813 { 10814 std::size_t operator ()std::hash10815 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProtectedMemoryFeatures const & physicalDeviceProtectedMemoryFeatures ) const VULKAN_HPP_NOEXCEPT 10816 { 10817 std::size_t seed = 0; 10818 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProtectedMemoryFeatures.sType ); 10819 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProtectedMemoryFeatures.pNext ); 10820 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProtectedMemoryFeatures.protectedMemory ); 10821 return seed; 10822 } 10823 }; 10824 10825 template <> 10826 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceProtectedMemoryProperties> 10827 { 10828 std::size_t operator ()std::hash10829 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProtectedMemoryProperties const & physicalDeviceProtectedMemoryProperties ) const VULKAN_HPP_NOEXCEPT 10830 { 10831 std::size_t seed = 0; 10832 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProtectedMemoryProperties.sType ); 10833 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProtectedMemoryProperties.pNext ); 10834 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProtectedMemoryProperties.protectedNoFault ); 10835 return seed; 10836 } 10837 }; 10838 10839 template <> 10840 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceProvokingVertexFeaturesEXT> 10841 { 10842 std::size_t operator ()std::hash10843 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProvokingVertexFeaturesEXT const & physicalDeviceProvokingVertexFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 10844 { 10845 std::size_t seed = 0; 10846 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProvokingVertexFeaturesEXT.sType ); 10847 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProvokingVertexFeaturesEXT.pNext ); 10848 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProvokingVertexFeaturesEXT.provokingVertexLast ); 10849 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProvokingVertexFeaturesEXT.transformFeedbackPreservesProvokingVertex ); 10850 return seed; 10851 } 10852 }; 10853 10854 template <> 10855 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceProvokingVertexPropertiesEXT> 10856 { operator ()std::hash10857 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProvokingVertexPropertiesEXT const & physicalDeviceProvokingVertexPropertiesEXT ) const 10858 VULKAN_HPP_NOEXCEPT 10859 { 10860 std::size_t seed = 0; 10861 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProvokingVertexPropertiesEXT.sType ); 10862 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProvokingVertexPropertiesEXT.pNext ); 10863 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProvokingVertexPropertiesEXT.provokingVertexModePerPipeline ); 10864 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProvokingVertexPropertiesEXT.transformFeedbackPreservesTriangleFanProvokingVertex ); 10865 return seed; 10866 } 10867 }; 10868 10869 template <> 10870 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePushDescriptorProperties> 10871 { 10872 std::size_t operator ()std::hash10873 operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePushDescriptorProperties const & physicalDevicePushDescriptorProperties ) const VULKAN_HPP_NOEXCEPT 10874 { 10875 std::size_t seed = 0; 10876 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePushDescriptorProperties.sType ); 10877 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePushDescriptorProperties.pNext ); 10878 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePushDescriptorProperties.maxPushDescriptors ); 10879 return seed; 10880 } 10881 }; 10882 10883 template <> 10884 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRGBA10X6FormatsFeaturesEXT> 10885 { 10886 std::size_t operator ()std::hash10887 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRGBA10X6FormatsFeaturesEXT const & physicalDeviceRGBA10X6FormatsFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 10888 { 10889 std::size_t seed = 0; 10890 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRGBA10X6FormatsFeaturesEXT.sType ); 10891 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRGBA10X6FormatsFeaturesEXT.pNext ); 10892 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRGBA10X6FormatsFeaturesEXT.formatRgba10x6WithoutYCbCrSampler ); 10893 return seed; 10894 } 10895 }; 10896 10897 template <> 10898 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT> 10899 { operator ()std::hash10900 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT const & 10901 physicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 10902 { 10903 std::size_t seed = 0; 10904 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT.sType ); 10905 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT.pNext ); 10906 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT.rasterizationOrderColorAttachmentAccess ); 10907 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT.rasterizationOrderDepthAttachmentAccess ); 10908 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT.rasterizationOrderStencilAttachmentAccess ); 10909 return seed; 10910 } 10911 }; 10912 10913 template <> 10914 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRawAccessChainsFeaturesNV> 10915 { 10916 std::size_t operator ()std::hash10917 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRawAccessChainsFeaturesNV const & physicalDeviceRawAccessChainsFeaturesNV ) const VULKAN_HPP_NOEXCEPT 10918 { 10919 std::size_t seed = 0; 10920 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRawAccessChainsFeaturesNV.sType ); 10921 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRawAccessChainsFeaturesNV.pNext ); 10922 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRawAccessChainsFeaturesNV.shaderRawAccessChains ); 10923 return seed; 10924 } 10925 }; 10926 10927 template <> 10928 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayQueryFeaturesKHR> 10929 { operator ()std::hash10930 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayQueryFeaturesKHR const & physicalDeviceRayQueryFeaturesKHR ) const VULKAN_HPP_NOEXCEPT 10931 { 10932 std::size_t seed = 0; 10933 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayQueryFeaturesKHR.sType ); 10934 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayQueryFeaturesKHR.pNext ); 10935 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayQueryFeaturesKHR.rayQuery ); 10936 return seed; 10937 } 10938 }; 10939 10940 template <> 10941 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderFeaturesNV> 10942 { 10943 std::size_t operator ()std::hash10944 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderFeaturesNV const & physicalDeviceRayTracingInvocationReorderFeaturesNV ) const 10945 VULKAN_HPP_NOEXCEPT 10946 { 10947 std::size_t seed = 0; 10948 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderFeaturesNV.sType ); 10949 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderFeaturesNV.pNext ); 10950 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderFeaturesNV.rayTracingInvocationReorder ); 10951 return seed; 10952 } 10953 }; 10954 10955 template <> 10956 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderPropertiesNV> 10957 { operator ()std::hash10958 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderPropertiesNV const & 10959 physicalDeviceRayTracingInvocationReorderPropertiesNV ) const VULKAN_HPP_NOEXCEPT 10960 { 10961 std::size_t seed = 0; 10962 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderPropertiesNV.sType ); 10963 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderPropertiesNV.pNext ); 10964 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderPropertiesNV.rayTracingInvocationReorderReorderingHint ); 10965 return seed; 10966 } 10967 }; 10968 10969 template <> 10970 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingMaintenance1FeaturesKHR> 10971 { operator ()std::hash10972 std::size_t operator()( 10973 VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingMaintenance1FeaturesKHR const & physicalDeviceRayTracingMaintenance1FeaturesKHR ) const VULKAN_HPP_NOEXCEPT 10974 { 10975 std::size_t seed = 0; 10976 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingMaintenance1FeaturesKHR.sType ); 10977 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingMaintenance1FeaturesKHR.pNext ); 10978 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingMaintenance1FeaturesKHR.rayTracingMaintenance1 ); 10979 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingMaintenance1FeaturesKHR.rayTracingPipelineTraceRaysIndirect2 ); 10980 return seed; 10981 } 10982 }; 10983 10984 template <> 10985 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingMotionBlurFeaturesNV> 10986 { operator ()std::hash10987 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingMotionBlurFeaturesNV const & physicalDeviceRayTracingMotionBlurFeaturesNV ) const 10988 VULKAN_HPP_NOEXCEPT 10989 { 10990 std::size_t seed = 0; 10991 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingMotionBlurFeaturesNV.sType ); 10992 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingMotionBlurFeaturesNV.pNext ); 10993 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingMotionBlurFeaturesNV.rayTracingMotionBlur ); 10994 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingMotionBlurFeaturesNV.rayTracingMotionBlurPipelineTraceRaysIndirect ); 10995 return seed; 10996 } 10997 }; 10998 10999 template <> 11000 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPipelineFeaturesKHR> 11001 { operator ()std::hash11002 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPipelineFeaturesKHR const & physicalDeviceRayTracingPipelineFeaturesKHR ) const 11003 VULKAN_HPP_NOEXCEPT 11004 { 11005 std::size_t seed = 0; 11006 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelineFeaturesKHR.sType ); 11007 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelineFeaturesKHR.pNext ); 11008 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelineFeaturesKHR.rayTracingPipeline ); 11009 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelineFeaturesKHR.rayTracingPipelineShaderGroupHandleCaptureReplay ); 11010 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelineFeaturesKHR.rayTracingPipelineShaderGroupHandleCaptureReplayMixed ); 11011 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelineFeaturesKHR.rayTracingPipelineTraceRaysIndirect ); 11012 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelineFeaturesKHR.rayTraversalPrimitiveCulling ); 11013 return seed; 11014 } 11015 }; 11016 11017 template <> 11018 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPipelinePropertiesKHR> 11019 { operator ()std::hash11020 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPipelinePropertiesKHR const & physicalDeviceRayTracingPipelinePropertiesKHR ) const 11021 VULKAN_HPP_NOEXCEPT 11022 { 11023 std::size_t seed = 0; 11024 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.sType ); 11025 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.pNext ); 11026 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.shaderGroupHandleSize ); 11027 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.maxRayRecursionDepth ); 11028 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.maxShaderGroupStride ); 11029 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.shaderGroupBaseAlignment ); 11030 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.shaderGroupHandleCaptureReplaySize ); 11031 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.maxRayDispatchInvocationCount ); 11032 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.shaderGroupHandleAlignment ); 11033 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.maxRayHitAttributeSize ); 11034 return seed; 11035 } 11036 }; 11037 11038 template <> 11039 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPositionFetchFeaturesKHR> 11040 { operator ()std::hash11041 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPositionFetchFeaturesKHR const & physicalDeviceRayTracingPositionFetchFeaturesKHR ) 11042 const VULKAN_HPP_NOEXCEPT 11043 { 11044 std::size_t seed = 0; 11045 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPositionFetchFeaturesKHR.sType ); 11046 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPositionFetchFeaturesKHR.pNext ); 11047 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPositionFetchFeaturesKHR.rayTracingPositionFetch ); 11048 return seed; 11049 } 11050 }; 11051 11052 template <> 11053 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPropertiesNV> 11054 { operator ()std::hash11055 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPropertiesNV const & physicalDeviceRayTracingPropertiesNV ) const VULKAN_HPP_NOEXCEPT 11056 { 11057 std::size_t seed = 0; 11058 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.sType ); 11059 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.pNext ); 11060 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.shaderGroupHandleSize ); 11061 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.maxRecursionDepth ); 11062 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.maxShaderGroupStride ); 11063 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.shaderGroupBaseAlignment ); 11064 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.maxGeometryCount ); 11065 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.maxInstanceCount ); 11066 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.maxTriangleCount ); 11067 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.maxDescriptorSetAccelerationStructures ); 11068 return seed; 11069 } 11070 }; 11071 11072 template <> 11073 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingValidationFeaturesNV> 11074 { operator ()std::hash11075 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingValidationFeaturesNV const & physicalDeviceRayTracingValidationFeaturesNV ) const 11076 VULKAN_HPP_NOEXCEPT 11077 { 11078 std::size_t seed = 0; 11079 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingValidationFeaturesNV.sType ); 11080 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingValidationFeaturesNV.pNext ); 11081 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingValidationFeaturesNV.rayTracingValidation ); 11082 return seed; 11083 } 11084 }; 11085 11086 template <> 11087 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRelaxedLineRasterizationFeaturesIMG> 11088 { operator ()std::hash11089 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRelaxedLineRasterizationFeaturesIMG const & physicalDeviceRelaxedLineRasterizationFeaturesIMG ) 11090 const VULKAN_HPP_NOEXCEPT 11091 { 11092 std::size_t seed = 0; 11093 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRelaxedLineRasterizationFeaturesIMG.sType ); 11094 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRelaxedLineRasterizationFeaturesIMG.pNext ); 11095 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRelaxedLineRasterizationFeaturesIMG.relaxedLineRasterization ); 11096 return seed; 11097 } 11098 }; 11099 11100 template <> 11101 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRenderPassStripedFeaturesARM> 11102 { operator ()std::hash11103 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRenderPassStripedFeaturesARM const & physicalDeviceRenderPassStripedFeaturesARM ) const 11104 VULKAN_HPP_NOEXCEPT 11105 { 11106 std::size_t seed = 0; 11107 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRenderPassStripedFeaturesARM.sType ); 11108 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRenderPassStripedFeaturesARM.pNext ); 11109 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRenderPassStripedFeaturesARM.renderPassStriped ); 11110 return seed; 11111 } 11112 }; 11113 11114 template <> 11115 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRenderPassStripedPropertiesARM> 11116 { operator ()std::hash11117 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRenderPassStripedPropertiesARM const & physicalDeviceRenderPassStripedPropertiesARM ) const 11118 VULKAN_HPP_NOEXCEPT 11119 { 11120 std::size_t seed = 0; 11121 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRenderPassStripedPropertiesARM.sType ); 11122 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRenderPassStripedPropertiesARM.pNext ); 11123 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRenderPassStripedPropertiesARM.renderPassStripeGranularity ); 11124 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRenderPassStripedPropertiesARM.maxRenderPassStripes ); 11125 return seed; 11126 } 11127 }; 11128 11129 template <> 11130 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRepresentativeFragmentTestFeaturesNV> 11131 { 11132 std::size_t operator ()std::hash11133 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRepresentativeFragmentTestFeaturesNV const & physicalDeviceRepresentativeFragmentTestFeaturesNV ) const 11134 VULKAN_HPP_NOEXCEPT 11135 { 11136 std::size_t seed = 0; 11137 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRepresentativeFragmentTestFeaturesNV.sType ); 11138 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRepresentativeFragmentTestFeaturesNV.pNext ); 11139 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRepresentativeFragmentTestFeaturesNV.representativeFragmentTest ); 11140 return seed; 11141 } 11142 }; 11143 11144 template <> 11145 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2FeaturesEXT> 11146 { operator ()std::hash11147 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2FeaturesEXT const & physicalDeviceRobustness2FeaturesEXT ) const VULKAN_HPP_NOEXCEPT 11148 { 11149 std::size_t seed = 0; 11150 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2FeaturesEXT.sType ); 11151 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2FeaturesEXT.pNext ); 11152 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2FeaturesEXT.robustBufferAccess2 ); 11153 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2FeaturesEXT.robustImageAccess2 ); 11154 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2FeaturesEXT.nullDescriptor ); 11155 return seed; 11156 } 11157 }; 11158 11159 template <> 11160 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2PropertiesEXT> 11161 { 11162 std::size_t operator ()std::hash11163 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2PropertiesEXT const & physicalDeviceRobustness2PropertiesEXT ) const VULKAN_HPP_NOEXCEPT 11164 { 11165 std::size_t seed = 0; 11166 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2PropertiesEXT.sType ); 11167 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2PropertiesEXT.pNext ); 11168 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2PropertiesEXT.robustStorageBufferAccessSizeAlignment ); 11169 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2PropertiesEXT.robustUniformBufferAccessSizeAlignment ); 11170 return seed; 11171 } 11172 }; 11173 11174 template <> 11175 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSampleLocationsPropertiesEXT> 11176 { operator ()std::hash11177 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSampleLocationsPropertiesEXT const & physicalDeviceSampleLocationsPropertiesEXT ) const 11178 VULKAN_HPP_NOEXCEPT 11179 { 11180 std::size_t seed = 0; 11181 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSampleLocationsPropertiesEXT.sType ); 11182 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSampleLocationsPropertiesEXT.pNext ); 11183 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSampleLocationsPropertiesEXT.sampleLocationSampleCounts ); 11184 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSampleLocationsPropertiesEXT.maxSampleLocationGridSize ); 11185 for ( size_t i = 0; i < 2; ++i ) 11186 { 11187 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSampleLocationsPropertiesEXT.sampleLocationCoordinateRange[i] ); 11188 } 11189 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSampleLocationsPropertiesEXT.sampleLocationSubPixelBits ); 11190 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSampleLocationsPropertiesEXT.variableSampleLocations ); 11191 return seed; 11192 } 11193 }; 11194 11195 template <> 11196 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSamplerFilterMinmaxProperties> 11197 { operator ()std::hash11198 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSamplerFilterMinmaxProperties const & physicalDeviceSamplerFilterMinmaxProperties ) const 11199 VULKAN_HPP_NOEXCEPT 11200 { 11201 std::size_t seed = 0; 11202 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSamplerFilterMinmaxProperties.sType ); 11203 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSamplerFilterMinmaxProperties.pNext ); 11204 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSamplerFilterMinmaxProperties.filterMinmaxSingleComponentFormats ); 11205 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSamplerFilterMinmaxProperties.filterMinmaxImageComponentMapping ); 11206 return seed; 11207 } 11208 }; 11209 11210 template <> 11211 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSamplerYcbcrConversionFeatures> 11212 { operator ()std::hash11213 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSamplerYcbcrConversionFeatures const & physicalDeviceSamplerYcbcrConversionFeatures ) const 11214 VULKAN_HPP_NOEXCEPT 11215 { 11216 std::size_t seed = 0; 11217 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSamplerYcbcrConversionFeatures.sType ); 11218 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSamplerYcbcrConversionFeatures.pNext ); 11219 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSamplerYcbcrConversionFeatures.samplerYcbcrConversion ); 11220 return seed; 11221 } 11222 }; 11223 11224 template <> 11225 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceScalarBlockLayoutFeatures> 11226 { 11227 std::size_t operator ()std::hash11228 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceScalarBlockLayoutFeatures const & physicalDeviceScalarBlockLayoutFeatures ) const VULKAN_HPP_NOEXCEPT 11229 { 11230 std::size_t seed = 0; 11231 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceScalarBlockLayoutFeatures.sType ); 11232 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceScalarBlockLayoutFeatures.pNext ); 11233 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceScalarBlockLayoutFeatures.scalarBlockLayout ); 11234 return seed; 11235 } 11236 }; 11237 11238 template <> 11239 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSchedulingControlsFeaturesARM> 11240 { operator ()std::hash11241 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSchedulingControlsFeaturesARM const & physicalDeviceSchedulingControlsFeaturesARM ) const 11242 VULKAN_HPP_NOEXCEPT 11243 { 11244 std::size_t seed = 0; 11245 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSchedulingControlsFeaturesARM.sType ); 11246 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSchedulingControlsFeaturesARM.pNext ); 11247 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSchedulingControlsFeaturesARM.schedulingControls ); 11248 return seed; 11249 } 11250 }; 11251 11252 template <> 11253 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSchedulingControlsPropertiesARM> 11254 { operator ()std::hash11255 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSchedulingControlsPropertiesARM const & physicalDeviceSchedulingControlsPropertiesARM ) const 11256 VULKAN_HPP_NOEXCEPT 11257 { 11258 std::size_t seed = 0; 11259 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSchedulingControlsPropertiesARM.sType ); 11260 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSchedulingControlsPropertiesARM.pNext ); 11261 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSchedulingControlsPropertiesARM.schedulingControlsFlags ); 11262 return seed; 11263 } 11264 }; 11265 11266 template <> 11267 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSeparateDepthStencilLayoutsFeatures> 11268 { operator ()std::hash11269 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSeparateDepthStencilLayoutsFeatures const & physicalDeviceSeparateDepthStencilLayoutsFeatures ) 11270 const VULKAN_HPP_NOEXCEPT 11271 { 11272 std::size_t seed = 0; 11273 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSeparateDepthStencilLayoutsFeatures.sType ); 11274 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSeparateDepthStencilLayoutsFeatures.pNext ); 11275 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSeparateDepthStencilLayoutsFeatures.separateDepthStencilLayouts ); 11276 return seed; 11277 } 11278 }; 11279 11280 template <> 11281 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV> 11282 { operator ()std::hash11283 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV const & physicalDeviceShaderAtomicFloat16VectorFeaturesNV ) 11284 const VULKAN_HPP_NOEXCEPT 11285 { 11286 std::size_t seed = 0; 11287 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat16VectorFeaturesNV.sType ); 11288 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat16VectorFeaturesNV.pNext ); 11289 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat16VectorFeaturesNV.shaderFloat16VectorAtomics ); 11290 return seed; 11291 } 11292 }; 11293 11294 template <> 11295 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloat2FeaturesEXT> 11296 { operator ()std::hash11297 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloat2FeaturesEXT const & physicalDeviceShaderAtomicFloat2FeaturesEXT ) const 11298 VULKAN_HPP_NOEXCEPT 11299 { 11300 std::size_t seed = 0; 11301 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.sType ); 11302 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.pNext ); 11303 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderBufferFloat16Atomics ); 11304 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderBufferFloat16AtomicAdd ); 11305 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderBufferFloat16AtomicMinMax ); 11306 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderBufferFloat32AtomicMinMax ); 11307 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderBufferFloat64AtomicMinMax ); 11308 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderSharedFloat16Atomics ); 11309 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderSharedFloat16AtomicAdd ); 11310 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderSharedFloat16AtomicMinMax ); 11311 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderSharedFloat32AtomicMinMax ); 11312 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderSharedFloat64AtomicMinMax ); 11313 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderImageFloat32AtomicMinMax ); 11314 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.sparseImageFloat32AtomicMinMax ); 11315 return seed; 11316 } 11317 }; 11318 11319 template <> 11320 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloatFeaturesEXT> 11321 { operator ()std::hash11322 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloatFeaturesEXT const & physicalDeviceShaderAtomicFloatFeaturesEXT ) const 11323 VULKAN_HPP_NOEXCEPT 11324 { 11325 std::size_t seed = 0; 11326 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.sType ); 11327 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.pNext ); 11328 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderBufferFloat32Atomics ); 11329 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderBufferFloat32AtomicAdd ); 11330 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderBufferFloat64Atomics ); 11331 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderBufferFloat64AtomicAdd ); 11332 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderSharedFloat32Atomics ); 11333 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderSharedFloat32AtomicAdd ); 11334 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderSharedFloat64Atomics ); 11335 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderSharedFloat64AtomicAdd ); 11336 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderImageFloat32Atomics ); 11337 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderImageFloat32AtomicAdd ); 11338 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.sparseImageFloat32Atomics ); 11339 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.sparseImageFloat32AtomicAdd ); 11340 return seed; 11341 } 11342 }; 11343 11344 template <> 11345 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicInt64Features> 11346 { 11347 std::size_t operator ()std::hash11348 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicInt64Features const & physicalDeviceShaderAtomicInt64Features ) const VULKAN_HPP_NOEXCEPT 11349 { 11350 std::size_t seed = 0; 11351 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicInt64Features.sType ); 11352 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicInt64Features.pNext ); 11353 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicInt64Features.shaderBufferInt64Atomics ); 11354 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicInt64Features.shaderSharedInt64Atomics ); 11355 return seed; 11356 } 11357 }; 11358 11359 template <> 11360 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderClockFeaturesKHR> 11361 { operator ()std::hash11362 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderClockFeaturesKHR const & physicalDeviceShaderClockFeaturesKHR ) const VULKAN_HPP_NOEXCEPT 11363 { 11364 std::size_t seed = 0; 11365 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderClockFeaturesKHR.sType ); 11366 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderClockFeaturesKHR.pNext ); 11367 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderClockFeaturesKHR.shaderSubgroupClock ); 11368 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderClockFeaturesKHR.shaderDeviceClock ); 11369 return seed; 11370 } 11371 }; 11372 11373 template <> 11374 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCoreBuiltinsFeaturesARM> 11375 { operator ()std::hash11376 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCoreBuiltinsFeaturesARM const & physicalDeviceShaderCoreBuiltinsFeaturesARM ) const 11377 VULKAN_HPP_NOEXCEPT 11378 { 11379 std::size_t seed = 0; 11380 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreBuiltinsFeaturesARM.sType ); 11381 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreBuiltinsFeaturesARM.pNext ); 11382 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreBuiltinsFeaturesARM.shaderCoreBuiltins ); 11383 return seed; 11384 } 11385 }; 11386 11387 template <> 11388 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCoreBuiltinsPropertiesARM> 11389 { operator ()std::hash11390 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCoreBuiltinsPropertiesARM const & physicalDeviceShaderCoreBuiltinsPropertiesARM ) const 11391 VULKAN_HPP_NOEXCEPT 11392 { 11393 std::size_t seed = 0; 11394 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreBuiltinsPropertiesARM.sType ); 11395 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreBuiltinsPropertiesARM.pNext ); 11396 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreBuiltinsPropertiesARM.shaderCoreMask ); 11397 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreBuiltinsPropertiesARM.shaderCoreCount ); 11398 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreBuiltinsPropertiesARM.shaderWarpsPerCore ); 11399 return seed; 11400 } 11401 }; 11402 11403 template <> 11404 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCoreProperties2AMD> 11405 { 11406 std::size_t operator ()std::hash11407 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCoreProperties2AMD const & physicalDeviceShaderCoreProperties2AMD ) const VULKAN_HPP_NOEXCEPT 11408 { 11409 std::size_t seed = 0; 11410 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreProperties2AMD.sType ); 11411 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreProperties2AMD.pNext ); 11412 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreProperties2AMD.shaderCoreFeatures ); 11413 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreProperties2AMD.activeComputeUnitCount ); 11414 return seed; 11415 } 11416 }; 11417 11418 template <> 11419 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCorePropertiesAMD> 11420 { 11421 std::size_t operator ()std::hash11422 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCorePropertiesAMD const & physicalDeviceShaderCorePropertiesAMD ) const VULKAN_HPP_NOEXCEPT 11423 { 11424 std::size_t seed = 0; 11425 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.sType ); 11426 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.pNext ); 11427 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.shaderEngineCount ); 11428 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.shaderArraysPerEngineCount ); 11429 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.computeUnitsPerShaderArray ); 11430 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.simdPerComputeUnit ); 11431 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.wavefrontsPerSimd ); 11432 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.wavefrontSize ); 11433 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.sgprsPerSimd ); 11434 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.minSgprAllocation ); 11435 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.maxSgprAllocation ); 11436 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.sgprAllocationGranularity ); 11437 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.vgprsPerSimd ); 11438 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.minVgprAllocation ); 11439 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.maxVgprAllocation ); 11440 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.vgprAllocationGranularity ); 11441 return seed; 11442 } 11443 }; 11444 11445 template <> 11446 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCorePropertiesARM> 11447 { 11448 std::size_t operator ()std::hash11449 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCorePropertiesARM const & physicalDeviceShaderCorePropertiesARM ) const VULKAN_HPP_NOEXCEPT 11450 { 11451 std::size_t seed = 0; 11452 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesARM.sType ); 11453 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesARM.pNext ); 11454 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesARM.pixelRate ); 11455 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesARM.texelRate ); 11456 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesARM.fmaRate ); 11457 return seed; 11458 } 11459 }; 11460 11461 template <> 11462 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderDemoteToHelperInvocationFeatures> 11463 { operator ()std::hash11464 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderDemoteToHelperInvocationFeatures const & 11465 physicalDeviceShaderDemoteToHelperInvocationFeatures ) const VULKAN_HPP_NOEXCEPT 11466 { 11467 std::size_t seed = 0; 11468 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderDemoteToHelperInvocationFeatures.sType ); 11469 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderDemoteToHelperInvocationFeatures.pNext ); 11470 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderDemoteToHelperInvocationFeatures.shaderDemoteToHelperInvocation ); 11471 return seed; 11472 } 11473 }; 11474 11475 template <> 11476 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderDrawParametersFeatures> 11477 { operator ()std::hash11478 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderDrawParametersFeatures const & physicalDeviceShaderDrawParametersFeatures ) const 11479 VULKAN_HPP_NOEXCEPT 11480 { 11481 std::size_t seed = 0; 11482 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderDrawParametersFeatures.sType ); 11483 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderDrawParametersFeatures.pNext ); 11484 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderDrawParametersFeatures.shaderDrawParameters ); 11485 return seed; 11486 } 11487 }; 11488 11489 template <> 11490 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD> 11491 { operator ()std::hash11492 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD const & 11493 physicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD ) const VULKAN_HPP_NOEXCEPT 11494 { 11495 std::size_t seed = 0; 11496 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD.sType ); 11497 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD.pNext ); 11498 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD.shaderEarlyAndLateFragmentTests ); 11499 return seed; 11500 } 11501 }; 11502 11503 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 11504 template <> 11505 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderEnqueueFeaturesAMDX> 11506 { 11507 std::size_t operator ()std::hash11508 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderEnqueueFeaturesAMDX const & physicalDeviceShaderEnqueueFeaturesAMDX ) const VULKAN_HPP_NOEXCEPT 11509 { 11510 std::size_t seed = 0; 11511 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueueFeaturesAMDX.sType ); 11512 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueueFeaturesAMDX.pNext ); 11513 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueueFeaturesAMDX.shaderEnqueue ); 11514 return seed; 11515 } 11516 }; 11517 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 11518 11519 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 11520 template <> 11521 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderEnqueuePropertiesAMDX> 11522 { 11523 std::size_t operator ()std::hash11524 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderEnqueuePropertiesAMDX const & physicalDeviceShaderEnqueuePropertiesAMDX ) const VULKAN_HPP_NOEXCEPT 11525 { 11526 std::size_t seed = 0; 11527 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueuePropertiesAMDX.sType ); 11528 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueuePropertiesAMDX.pNext ); 11529 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueuePropertiesAMDX.maxExecutionGraphDepth ); 11530 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueuePropertiesAMDX.maxExecutionGraphShaderOutputNodes ); 11531 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueuePropertiesAMDX.maxExecutionGraphShaderPayloadSize ); 11532 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueuePropertiesAMDX.maxExecutionGraphShaderPayloadCount ); 11533 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueuePropertiesAMDX.executionGraphDispatchAddressAlignment ); 11534 return seed; 11535 } 11536 }; 11537 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 11538 11539 template <> 11540 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderExpectAssumeFeatures> 11541 { 11542 std::size_t operator ()std::hash11543 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderExpectAssumeFeatures const & physicalDeviceShaderExpectAssumeFeatures ) const VULKAN_HPP_NOEXCEPT 11544 { 11545 std::size_t seed = 0; 11546 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderExpectAssumeFeatures.sType ); 11547 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderExpectAssumeFeatures.pNext ); 11548 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderExpectAssumeFeatures.shaderExpectAssume ); 11549 return seed; 11550 } 11551 }; 11552 11553 template <> 11554 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFloat16Int8Features> 11555 { 11556 std::size_t operator ()std::hash11557 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFloat16Int8Features const & physicalDeviceShaderFloat16Int8Features ) const VULKAN_HPP_NOEXCEPT 11558 { 11559 std::size_t seed = 0; 11560 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFloat16Int8Features.sType ); 11561 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFloat16Int8Features.pNext ); 11562 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFloat16Int8Features.shaderFloat16 ); 11563 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFloat16Int8Features.shaderInt8 ); 11564 return seed; 11565 } 11566 }; 11567 11568 template <> 11569 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFloatControls2Features> 11570 { operator ()std::hash11571 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFloatControls2Features const & physicalDeviceShaderFloatControls2Features ) const 11572 VULKAN_HPP_NOEXCEPT 11573 { 11574 std::size_t seed = 0; 11575 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFloatControls2Features.sType ); 11576 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFloatControls2Features.pNext ); 11577 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFloatControls2Features.shaderFloatControls2 ); 11578 return seed; 11579 } 11580 }; 11581 11582 template <> 11583 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderImageAtomicInt64FeaturesEXT> 11584 { operator ()std::hash11585 std::size_t operator()( 11586 VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderImageAtomicInt64FeaturesEXT const & physicalDeviceShaderImageAtomicInt64FeaturesEXT ) const VULKAN_HPP_NOEXCEPT 11587 { 11588 std::size_t seed = 0; 11589 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderImageAtomicInt64FeaturesEXT.sType ); 11590 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderImageAtomicInt64FeaturesEXT.pNext ); 11591 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderImageAtomicInt64FeaturesEXT.shaderImageInt64Atomics ); 11592 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderImageAtomicInt64FeaturesEXT.sparseImageInt64Atomics ); 11593 return seed; 11594 } 11595 }; 11596 11597 template <> 11598 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderImageFootprintFeaturesNV> 11599 { operator ()std::hash11600 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderImageFootprintFeaturesNV const & physicalDeviceShaderImageFootprintFeaturesNV ) const 11601 VULKAN_HPP_NOEXCEPT 11602 { 11603 std::size_t seed = 0; 11604 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderImageFootprintFeaturesNV.sType ); 11605 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderImageFootprintFeaturesNV.pNext ); 11606 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderImageFootprintFeaturesNV.imageFootprint ); 11607 return seed; 11608 } 11609 }; 11610 11611 template <> 11612 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerDotProductFeatures> 11613 { operator ()std::hash11614 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerDotProductFeatures const & physicalDeviceShaderIntegerDotProductFeatures ) const 11615 VULKAN_HPP_NOEXCEPT 11616 { 11617 std::size_t seed = 0; 11618 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductFeatures.sType ); 11619 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductFeatures.pNext ); 11620 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductFeatures.shaderIntegerDotProduct ); 11621 return seed; 11622 } 11623 }; 11624 11625 template <> 11626 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerDotProductProperties> 11627 { operator ()std::hash11628 std::size_t operator()( 11629 VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerDotProductProperties const & physicalDeviceShaderIntegerDotProductProperties ) const VULKAN_HPP_NOEXCEPT 11630 { 11631 std::size_t seed = 0; 11632 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.sType ); 11633 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.pNext ); 11634 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct8BitUnsignedAccelerated ); 11635 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct8BitSignedAccelerated ); 11636 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct8BitMixedSignednessAccelerated ); 11637 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct4x8BitPackedUnsignedAccelerated ); 11638 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct4x8BitPackedSignedAccelerated ); 11639 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct4x8BitPackedMixedSignednessAccelerated ); 11640 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct16BitUnsignedAccelerated ); 11641 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct16BitSignedAccelerated ); 11642 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct16BitMixedSignednessAccelerated ); 11643 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct32BitUnsignedAccelerated ); 11644 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct32BitSignedAccelerated ); 11645 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct32BitMixedSignednessAccelerated ); 11646 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct64BitUnsignedAccelerated ); 11647 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct64BitSignedAccelerated ); 11648 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct64BitMixedSignednessAccelerated ); 11649 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating8BitUnsignedAccelerated ); 11650 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating8BitSignedAccelerated ); 11651 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated ); 11652 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated ); 11653 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated ); 11654 VULKAN_HPP_HASH_COMBINE( seed, 11655 physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated ); 11656 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating16BitUnsignedAccelerated ); 11657 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating16BitSignedAccelerated ); 11658 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated ); 11659 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating32BitUnsignedAccelerated ); 11660 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating32BitSignedAccelerated ); 11661 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated ); 11662 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating64BitUnsignedAccelerated ); 11663 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating64BitSignedAccelerated ); 11664 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated ); 11665 return seed; 11666 } 11667 }; 11668 11669 template <> 11670 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL> 11671 { 11672 std::size_t operator ()std::hash11673 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const & physicalDeviceShaderIntegerFunctions2FeaturesINTEL ) const 11674 VULKAN_HPP_NOEXCEPT 11675 { 11676 std::size_t seed = 0; 11677 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerFunctions2FeaturesINTEL.sType ); 11678 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerFunctions2FeaturesINTEL.pNext ); 11679 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerFunctions2FeaturesINTEL.shaderIntegerFunctions2 ); 11680 return seed; 11681 } 11682 }; 11683 11684 template <> 11685 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR> 11686 { 11687 std::size_t operator ()std::hash11688 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR const & physicalDeviceShaderMaximalReconvergenceFeaturesKHR ) const 11689 VULKAN_HPP_NOEXCEPT 11690 { 11691 std::size_t seed = 0; 11692 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderMaximalReconvergenceFeaturesKHR.sType ); 11693 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderMaximalReconvergenceFeaturesKHR.pNext ); 11694 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderMaximalReconvergenceFeaturesKHR.shaderMaximalReconvergence ); 11695 return seed; 11696 } 11697 }; 11698 11699 template <> 11700 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderModuleIdentifierFeaturesEXT> 11701 { operator ()std::hash11702 std::size_t operator()( 11703 VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderModuleIdentifierFeaturesEXT const & physicalDeviceShaderModuleIdentifierFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 11704 { 11705 std::size_t seed = 0; 11706 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderModuleIdentifierFeaturesEXT.sType ); 11707 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderModuleIdentifierFeaturesEXT.pNext ); 11708 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderModuleIdentifierFeaturesEXT.shaderModuleIdentifier ); 11709 return seed; 11710 } 11711 }; 11712 11713 template <> 11714 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderModuleIdentifierPropertiesEXT> 11715 { operator ()std::hash11716 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderModuleIdentifierPropertiesEXT const & physicalDeviceShaderModuleIdentifierPropertiesEXT ) 11717 const VULKAN_HPP_NOEXCEPT 11718 { 11719 std::size_t seed = 0; 11720 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderModuleIdentifierPropertiesEXT.sType ); 11721 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderModuleIdentifierPropertiesEXT.pNext ); 11722 for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) 11723 { 11724 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderModuleIdentifierPropertiesEXT.shaderModuleIdentifierAlgorithmUUID[i] ); 11725 } 11726 return seed; 11727 } 11728 }; 11729 11730 template <> 11731 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderObjectFeaturesEXT> 11732 { 11733 std::size_t operator ()std::hash11734 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderObjectFeaturesEXT const & physicalDeviceShaderObjectFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 11735 { 11736 std::size_t seed = 0; 11737 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderObjectFeaturesEXT.sType ); 11738 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderObjectFeaturesEXT.pNext ); 11739 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderObjectFeaturesEXT.shaderObject ); 11740 return seed; 11741 } 11742 }; 11743 11744 template <> 11745 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderObjectPropertiesEXT> 11746 { 11747 std::size_t operator ()std::hash11748 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderObjectPropertiesEXT const & physicalDeviceShaderObjectPropertiesEXT ) const VULKAN_HPP_NOEXCEPT 11749 { 11750 std::size_t seed = 0; 11751 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderObjectPropertiesEXT.sType ); 11752 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderObjectPropertiesEXT.pNext ); 11753 for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) 11754 { 11755 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderObjectPropertiesEXT.shaderBinaryUUID[i] ); 11756 } 11757 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderObjectPropertiesEXT.shaderBinaryVersion ); 11758 return seed; 11759 } 11760 }; 11761 11762 template <> 11763 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderQuadControlFeaturesKHR> 11764 { operator ()std::hash11765 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderQuadControlFeaturesKHR const & physicalDeviceShaderQuadControlFeaturesKHR ) const 11766 VULKAN_HPP_NOEXCEPT 11767 { 11768 std::size_t seed = 0; 11769 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderQuadControlFeaturesKHR.sType ); 11770 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderQuadControlFeaturesKHR.pNext ); 11771 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderQuadControlFeaturesKHR.shaderQuadControl ); 11772 return seed; 11773 } 11774 }; 11775 11776 template <> 11777 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR> 11778 { operator ()std::hash11779 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR const & 11780 physicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR ) const VULKAN_HPP_NOEXCEPT 11781 { 11782 std::size_t seed = 0; 11783 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR.sType ); 11784 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR.pNext ); 11785 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR.shaderRelaxedExtendedInstruction ); 11786 return seed; 11787 } 11788 }; 11789 11790 template <> 11791 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderReplicatedCompositesFeaturesEXT> 11792 { 11793 std::size_t operator ()std::hash11794 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderReplicatedCompositesFeaturesEXT const & physicalDeviceShaderReplicatedCompositesFeaturesEXT ) const 11795 VULKAN_HPP_NOEXCEPT 11796 { 11797 std::size_t seed = 0; 11798 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderReplicatedCompositesFeaturesEXT.sType ); 11799 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderReplicatedCompositesFeaturesEXT.pNext ); 11800 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderReplicatedCompositesFeaturesEXT.shaderReplicatedComposites ); 11801 return seed; 11802 } 11803 }; 11804 11805 template <> 11806 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSMBuiltinsFeaturesNV> 11807 { 11808 std::size_t operator ()std::hash11809 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSMBuiltinsFeaturesNV const & physicalDeviceShaderSMBuiltinsFeaturesNV ) const VULKAN_HPP_NOEXCEPT 11810 { 11811 std::size_t seed = 0; 11812 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSMBuiltinsFeaturesNV.sType ); 11813 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSMBuiltinsFeaturesNV.pNext ); 11814 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSMBuiltinsFeaturesNV.shaderSMBuiltins ); 11815 return seed; 11816 } 11817 }; 11818 11819 template <> 11820 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSMBuiltinsPropertiesNV> 11821 { operator ()std::hash11822 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSMBuiltinsPropertiesNV const & physicalDeviceShaderSMBuiltinsPropertiesNV ) const 11823 VULKAN_HPP_NOEXCEPT 11824 { 11825 std::size_t seed = 0; 11826 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSMBuiltinsPropertiesNV.sType ); 11827 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSMBuiltinsPropertiesNV.pNext ); 11828 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSMBuiltinsPropertiesNV.shaderSMCount ); 11829 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSMBuiltinsPropertiesNV.shaderWarpsPerSM ); 11830 return seed; 11831 } 11832 }; 11833 11834 template <> 11835 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupExtendedTypesFeatures> 11836 { operator ()std::hash11837 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupExtendedTypesFeatures const & physicalDeviceShaderSubgroupExtendedTypesFeatures ) 11838 const VULKAN_HPP_NOEXCEPT 11839 { 11840 std::size_t seed = 0; 11841 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupExtendedTypesFeatures.sType ); 11842 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupExtendedTypesFeatures.pNext ); 11843 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupExtendedTypesFeatures.shaderSubgroupExtendedTypes ); 11844 return seed; 11845 } 11846 }; 11847 11848 template <> 11849 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupRotateFeatures> 11850 { operator ()std::hash11851 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupRotateFeatures const & physicalDeviceShaderSubgroupRotateFeatures ) const 11852 VULKAN_HPP_NOEXCEPT 11853 { 11854 std::size_t seed = 0; 11855 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupRotateFeatures.sType ); 11856 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupRotateFeatures.pNext ); 11857 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupRotateFeatures.shaderSubgroupRotate ); 11858 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupRotateFeatures.shaderSubgroupRotateClustered ); 11859 return seed; 11860 } 11861 }; 11862 11863 template <> 11864 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR> 11865 { operator ()std::hash11866 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR const & 11867 physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR ) const VULKAN_HPP_NOEXCEPT 11868 { 11869 std::size_t seed = 0; 11870 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR.sType ); 11871 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR.pNext ); 11872 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR.shaderSubgroupUniformControlFlow ); 11873 return seed; 11874 } 11875 }; 11876 11877 template <> 11878 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderTerminateInvocationFeatures> 11879 { operator ()std::hash11880 std::size_t operator()( 11881 VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderTerminateInvocationFeatures const & physicalDeviceShaderTerminateInvocationFeatures ) const VULKAN_HPP_NOEXCEPT 11882 { 11883 std::size_t seed = 0; 11884 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTerminateInvocationFeatures.sType ); 11885 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTerminateInvocationFeatures.pNext ); 11886 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTerminateInvocationFeatures.shaderTerminateInvocation ); 11887 return seed; 11888 } 11889 }; 11890 11891 template <> 11892 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderTileImageFeaturesEXT> 11893 { 11894 std::size_t operator ()std::hash11895 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderTileImageFeaturesEXT const & physicalDeviceShaderTileImageFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 11896 { 11897 std::size_t seed = 0; 11898 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImageFeaturesEXT.sType ); 11899 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImageFeaturesEXT.pNext ); 11900 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImageFeaturesEXT.shaderTileImageColorReadAccess ); 11901 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImageFeaturesEXT.shaderTileImageDepthReadAccess ); 11902 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImageFeaturesEXT.shaderTileImageStencilReadAccess ); 11903 return seed; 11904 } 11905 }; 11906 11907 template <> 11908 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderTileImagePropertiesEXT> 11909 { operator ()std::hash11910 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderTileImagePropertiesEXT const & physicalDeviceShaderTileImagePropertiesEXT ) const 11911 VULKAN_HPP_NOEXCEPT 11912 { 11913 std::size_t seed = 0; 11914 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImagePropertiesEXT.sType ); 11915 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImagePropertiesEXT.pNext ); 11916 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImagePropertiesEXT.shaderTileImageCoherentReadAccelerated ); 11917 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImagePropertiesEXT.shaderTileImageReadSampleFromPixelRateInvocation ); 11918 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImagePropertiesEXT.shaderTileImageReadFromHelperInvocation ); 11919 return seed; 11920 } 11921 }; 11922 11923 template <> 11924 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShadingRateImageFeaturesNV> 11925 { 11926 std::size_t operator ()std::hash11927 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShadingRateImageFeaturesNV const & physicalDeviceShadingRateImageFeaturesNV ) const VULKAN_HPP_NOEXCEPT 11928 { 11929 std::size_t seed = 0; 11930 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShadingRateImageFeaturesNV.sType ); 11931 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShadingRateImageFeaturesNV.pNext ); 11932 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShadingRateImageFeaturesNV.shadingRateImage ); 11933 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShadingRateImageFeaturesNV.shadingRateCoarseSampleOrder ); 11934 return seed; 11935 } 11936 }; 11937 11938 template <> 11939 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShadingRateImagePropertiesNV> 11940 { operator ()std::hash11941 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShadingRateImagePropertiesNV const & physicalDeviceShadingRateImagePropertiesNV ) const 11942 VULKAN_HPP_NOEXCEPT 11943 { 11944 std::size_t seed = 0; 11945 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShadingRateImagePropertiesNV.sType ); 11946 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShadingRateImagePropertiesNV.pNext ); 11947 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShadingRateImagePropertiesNV.shadingRateTexelSize ); 11948 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShadingRateImagePropertiesNV.shadingRatePaletteSize ); 11949 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShadingRateImagePropertiesNV.shadingRateMaxCoarseSamples ); 11950 return seed; 11951 } 11952 }; 11953 11954 template <> 11955 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2> 11956 { operator ()std::hash11957 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 const & physicalDeviceSparseImageFormatInfo2 ) const VULKAN_HPP_NOEXCEPT 11958 { 11959 std::size_t seed = 0; 11960 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseImageFormatInfo2.sType ); 11961 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseImageFormatInfo2.pNext ); 11962 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseImageFormatInfo2.format ); 11963 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseImageFormatInfo2.type ); 11964 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseImageFormatInfo2.samples ); 11965 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseImageFormatInfo2.usage ); 11966 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseImageFormatInfo2.tiling ); 11967 return seed; 11968 } 11969 }; 11970 11971 template <> 11972 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupProperties> 11973 { operator ()std::hash11974 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupProperties const & physicalDeviceSubgroupProperties ) const VULKAN_HPP_NOEXCEPT 11975 { 11976 std::size_t seed = 0; 11977 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupProperties.sType ); 11978 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupProperties.pNext ); 11979 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupProperties.subgroupSize ); 11980 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupProperties.supportedStages ); 11981 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupProperties.supportedOperations ); 11982 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupProperties.quadOperationsInAllStages ); 11983 return seed; 11984 } 11985 }; 11986 11987 template <> 11988 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupSizeControlFeatures> 11989 { 11990 std::size_t operator ()std::hash11991 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupSizeControlFeatures const & physicalDeviceSubgroupSizeControlFeatures ) const VULKAN_HPP_NOEXCEPT 11992 { 11993 std::size_t seed = 0; 11994 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlFeatures.sType ); 11995 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlFeatures.pNext ); 11996 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlFeatures.subgroupSizeControl ); 11997 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlFeatures.computeFullSubgroups ); 11998 return seed; 11999 } 12000 }; 12001 12002 template <> 12003 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupSizeControlProperties> 12004 { operator ()std::hash12005 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupSizeControlProperties const & physicalDeviceSubgroupSizeControlProperties ) const 12006 VULKAN_HPP_NOEXCEPT 12007 { 12008 std::size_t seed = 0; 12009 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlProperties.sType ); 12010 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlProperties.pNext ); 12011 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlProperties.minSubgroupSize ); 12012 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlProperties.maxSubgroupSize ); 12013 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlProperties.maxComputeWorkgroupSubgroups ); 12014 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlProperties.requiredSubgroupSizeStages ); 12015 return seed; 12016 } 12017 }; 12018 12019 template <> 12020 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassMergeFeedbackFeaturesEXT> 12021 { operator ()std::hash12022 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassMergeFeedbackFeaturesEXT const & physicalDeviceSubpassMergeFeedbackFeaturesEXT ) const 12023 VULKAN_HPP_NOEXCEPT 12024 { 12025 std::size_t seed = 0; 12026 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubpassMergeFeedbackFeaturesEXT.sType ); 12027 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubpassMergeFeedbackFeaturesEXT.pNext ); 12028 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubpassMergeFeedbackFeaturesEXT.subpassMergeFeedback ); 12029 return seed; 12030 } 12031 }; 12032 12033 template <> 12034 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassShadingFeaturesHUAWEI> 12035 { operator ()std::hash12036 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassShadingFeaturesHUAWEI const & physicalDeviceSubpassShadingFeaturesHUAWEI ) const 12037 VULKAN_HPP_NOEXCEPT 12038 { 12039 std::size_t seed = 0; 12040 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubpassShadingFeaturesHUAWEI.sType ); 12041 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubpassShadingFeaturesHUAWEI.pNext ); 12042 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubpassShadingFeaturesHUAWEI.subpassShading ); 12043 return seed; 12044 } 12045 }; 12046 12047 template <> 12048 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassShadingPropertiesHUAWEI> 12049 { operator ()std::hash12050 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassShadingPropertiesHUAWEI const & physicalDeviceSubpassShadingPropertiesHUAWEI ) const 12051 VULKAN_HPP_NOEXCEPT 12052 { 12053 std::size_t seed = 0; 12054 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubpassShadingPropertiesHUAWEI.sType ); 12055 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubpassShadingPropertiesHUAWEI.pNext ); 12056 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubpassShadingPropertiesHUAWEI.maxSubpassShadingWorkgroupSizeAspectRatio ); 12057 return seed; 12058 } 12059 }; 12060 12061 template <> 12062 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR> 12063 { operator ()std::hash12064 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR const & physicalDeviceSurfaceInfo2KHR ) const VULKAN_HPP_NOEXCEPT 12065 { 12066 std::size_t seed = 0; 12067 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSurfaceInfo2KHR.sType ); 12068 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSurfaceInfo2KHR.pNext ); 12069 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSurfaceInfo2KHR.surface ); 12070 return seed; 12071 } 12072 }; 12073 12074 template <> 12075 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSwapchainMaintenance1FeaturesEXT> 12076 { operator ()std::hash12077 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSwapchainMaintenance1FeaturesEXT const & physicalDeviceSwapchainMaintenance1FeaturesEXT ) const 12078 VULKAN_HPP_NOEXCEPT 12079 { 12080 std::size_t seed = 0; 12081 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSwapchainMaintenance1FeaturesEXT.sType ); 12082 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSwapchainMaintenance1FeaturesEXT.pNext ); 12083 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSwapchainMaintenance1FeaturesEXT.swapchainMaintenance1 ); 12084 return seed; 12085 } 12086 }; 12087 12088 template <> 12089 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSynchronization2Features> 12090 { 12091 std::size_t operator ()std::hash12092 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSynchronization2Features const & physicalDeviceSynchronization2Features ) const VULKAN_HPP_NOEXCEPT 12093 { 12094 std::size_t seed = 0; 12095 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSynchronization2Features.sType ); 12096 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSynchronization2Features.pNext ); 12097 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSynchronization2Features.synchronization2 ); 12098 return seed; 12099 } 12100 }; 12101 12102 template <> 12103 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTexelBufferAlignmentFeaturesEXT> 12104 { operator ()std::hash12105 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTexelBufferAlignmentFeaturesEXT const & physicalDeviceTexelBufferAlignmentFeaturesEXT ) const 12106 VULKAN_HPP_NOEXCEPT 12107 { 12108 std::size_t seed = 0; 12109 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTexelBufferAlignmentFeaturesEXT.sType ); 12110 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTexelBufferAlignmentFeaturesEXT.pNext ); 12111 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTexelBufferAlignmentFeaturesEXT.texelBufferAlignment ); 12112 return seed; 12113 } 12114 }; 12115 12116 template <> 12117 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTexelBufferAlignmentProperties> 12118 { operator ()std::hash12119 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTexelBufferAlignmentProperties const & physicalDeviceTexelBufferAlignmentProperties ) const 12120 VULKAN_HPP_NOEXCEPT 12121 { 12122 std::size_t seed = 0; 12123 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTexelBufferAlignmentProperties.sType ); 12124 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTexelBufferAlignmentProperties.pNext ); 12125 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTexelBufferAlignmentProperties.storageTexelBufferOffsetAlignmentBytes ); 12126 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTexelBufferAlignmentProperties.storageTexelBufferOffsetSingleTexelAlignment ); 12127 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTexelBufferAlignmentProperties.uniformTexelBufferOffsetAlignmentBytes ); 12128 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTexelBufferAlignmentProperties.uniformTexelBufferOffsetSingleTexelAlignment ); 12129 return seed; 12130 } 12131 }; 12132 12133 template <> 12134 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTextureCompressionASTCHDRFeatures> 12135 { operator ()std::hash12136 std::size_t operator()( 12137 VULKAN_HPP_NAMESPACE::PhysicalDeviceTextureCompressionASTCHDRFeatures const & physicalDeviceTextureCompressionASTCHDRFeatures ) const VULKAN_HPP_NOEXCEPT 12138 { 12139 std::size_t seed = 0; 12140 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTextureCompressionASTCHDRFeatures.sType ); 12141 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTextureCompressionASTCHDRFeatures.pNext ); 12142 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTextureCompressionASTCHDRFeatures.textureCompressionASTC_HDR ); 12143 return seed; 12144 } 12145 }; 12146 12147 template <> 12148 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTilePropertiesFeaturesQCOM> 12149 { 12150 std::size_t operator ()std::hash12151 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTilePropertiesFeaturesQCOM const & physicalDeviceTilePropertiesFeaturesQCOM ) const VULKAN_HPP_NOEXCEPT 12152 { 12153 std::size_t seed = 0; 12154 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTilePropertiesFeaturesQCOM.sType ); 12155 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTilePropertiesFeaturesQCOM.pNext ); 12156 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTilePropertiesFeaturesQCOM.tileProperties ); 12157 return seed; 12158 } 12159 }; 12160 12161 template <> 12162 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTimelineSemaphoreFeatures> 12163 { 12164 std::size_t operator ()std::hash12165 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTimelineSemaphoreFeatures const & physicalDeviceTimelineSemaphoreFeatures ) const VULKAN_HPP_NOEXCEPT 12166 { 12167 std::size_t seed = 0; 12168 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTimelineSemaphoreFeatures.sType ); 12169 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTimelineSemaphoreFeatures.pNext ); 12170 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTimelineSemaphoreFeatures.timelineSemaphore ); 12171 return seed; 12172 } 12173 }; 12174 12175 template <> 12176 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTimelineSemaphoreProperties> 12177 { 12178 std::size_t operator ()std::hash12179 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTimelineSemaphoreProperties const & physicalDeviceTimelineSemaphoreProperties ) const VULKAN_HPP_NOEXCEPT 12180 { 12181 std::size_t seed = 0; 12182 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTimelineSemaphoreProperties.sType ); 12183 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTimelineSemaphoreProperties.pNext ); 12184 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTimelineSemaphoreProperties.maxTimelineSemaphoreValueDifference ); 12185 return seed; 12186 } 12187 }; 12188 12189 template <> 12190 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties> 12191 { operator ()std::hash12192 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties const & physicalDeviceToolProperties ) const VULKAN_HPP_NOEXCEPT 12193 { 12194 std::size_t seed = 0; 12195 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceToolProperties.sType ); 12196 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceToolProperties.pNext ); 12197 for ( size_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i ) 12198 { 12199 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceToolProperties.name[i] ); 12200 } 12201 for ( size_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i ) 12202 { 12203 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceToolProperties.version[i] ); 12204 } 12205 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceToolProperties.purposes ); 12206 for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) 12207 { 12208 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceToolProperties.description[i] ); 12209 } 12210 for ( size_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i ) 12211 { 12212 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceToolProperties.layer[i] ); 12213 } 12214 return seed; 12215 } 12216 }; 12217 12218 template <> 12219 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTransformFeedbackFeaturesEXT> 12220 { operator ()std::hash12221 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTransformFeedbackFeaturesEXT const & physicalDeviceTransformFeedbackFeaturesEXT ) const 12222 VULKAN_HPP_NOEXCEPT 12223 { 12224 std::size_t seed = 0; 12225 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackFeaturesEXT.sType ); 12226 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackFeaturesEXT.pNext ); 12227 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackFeaturesEXT.transformFeedback ); 12228 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackFeaturesEXT.geometryStreams ); 12229 return seed; 12230 } 12231 }; 12232 12233 template <> 12234 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTransformFeedbackPropertiesEXT> 12235 { operator ()std::hash12236 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTransformFeedbackPropertiesEXT const & physicalDeviceTransformFeedbackPropertiesEXT ) const 12237 VULKAN_HPP_NOEXCEPT 12238 { 12239 std::size_t seed = 0; 12240 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.sType ); 12241 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.pNext ); 12242 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackStreams ); 12243 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackBuffers ); 12244 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackBufferSize ); 12245 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackStreamDataSize ); 12246 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackBufferDataSize ); 12247 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackBufferDataStride ); 12248 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.transformFeedbackQueries ); 12249 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.transformFeedbackStreamsLinesTriangles ); 12250 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.transformFeedbackRasterizationStreamSelect ); 12251 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.transformFeedbackDraw ); 12252 return seed; 12253 } 12254 }; 12255 12256 template <> 12257 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceUniformBufferStandardLayoutFeatures> 12258 { operator ()std::hash12259 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceUniformBufferStandardLayoutFeatures const & physicalDeviceUniformBufferStandardLayoutFeatures ) 12260 const VULKAN_HPP_NOEXCEPT 12261 { 12262 std::size_t seed = 0; 12263 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceUniformBufferStandardLayoutFeatures.sType ); 12264 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceUniformBufferStandardLayoutFeatures.pNext ); 12265 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceUniformBufferStandardLayoutFeatures.uniformBufferStandardLayout ); 12266 return seed; 12267 } 12268 }; 12269 12270 template <> 12271 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVariablePointersFeatures> 12272 { 12273 std::size_t operator ()std::hash12274 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVariablePointersFeatures const & physicalDeviceVariablePointersFeatures ) const VULKAN_HPP_NOEXCEPT 12275 { 12276 std::size_t seed = 0; 12277 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVariablePointersFeatures.sType ); 12278 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVariablePointersFeatures.pNext ); 12279 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVariablePointersFeatures.variablePointersStorageBuffer ); 12280 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVariablePointersFeatures.variablePointers ); 12281 return seed; 12282 } 12283 }; 12284 12285 template <> 12286 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorFeatures> 12287 { operator ()std::hash12288 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorFeatures const & physicalDeviceVertexAttributeDivisorFeatures ) const 12289 VULKAN_HPP_NOEXCEPT 12290 { 12291 std::size_t seed = 0; 12292 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorFeatures.sType ); 12293 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorFeatures.pNext ); 12294 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorFeatures.vertexAttributeInstanceRateDivisor ); 12295 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorFeatures.vertexAttributeInstanceRateZeroDivisor ); 12296 return seed; 12297 } 12298 }; 12299 12300 template <> 12301 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorProperties> 12302 { operator ()std::hash12303 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorProperties const & physicalDeviceVertexAttributeDivisorProperties ) const 12304 VULKAN_HPP_NOEXCEPT 12305 { 12306 std::size_t seed = 0; 12307 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorProperties.sType ); 12308 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorProperties.pNext ); 12309 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorProperties.maxVertexAttribDivisor ); 12310 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorProperties.supportsNonZeroFirstInstance ); 12311 return seed; 12312 } 12313 }; 12314 12315 template <> 12316 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorPropertiesEXT> 12317 { operator ()std::hash12318 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorPropertiesEXT const & physicalDeviceVertexAttributeDivisorPropertiesEXT ) 12319 const VULKAN_HPP_NOEXCEPT 12320 { 12321 std::size_t seed = 0; 12322 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorPropertiesEXT.sType ); 12323 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorPropertiesEXT.pNext ); 12324 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorPropertiesEXT.maxVertexAttribDivisor ); 12325 return seed; 12326 } 12327 }; 12328 12329 template <> 12330 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexInputDynamicStateFeaturesEXT> 12331 { operator ()std::hash12332 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexInputDynamicStateFeaturesEXT const & physicalDeviceVertexInputDynamicStateFeaturesEXT ) 12333 const VULKAN_HPP_NOEXCEPT 12334 { 12335 std::size_t seed = 0; 12336 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexInputDynamicStateFeaturesEXT.sType ); 12337 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexInputDynamicStateFeaturesEXT.pNext ); 12338 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexInputDynamicStateFeaturesEXT.vertexInputDynamicState ); 12339 return seed; 12340 } 12341 }; 12342 12343 template <> 12344 struct hash<VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR> 12345 { operator ()std::hash12346 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR const & videoProfileInfoKHR ) const VULKAN_HPP_NOEXCEPT 12347 { 12348 std::size_t seed = 0; 12349 VULKAN_HPP_HASH_COMBINE( seed, videoProfileInfoKHR.sType ); 12350 VULKAN_HPP_HASH_COMBINE( seed, videoProfileInfoKHR.pNext ); 12351 VULKAN_HPP_HASH_COMBINE( seed, videoProfileInfoKHR.videoCodecOperation ); 12352 VULKAN_HPP_HASH_COMBINE( seed, videoProfileInfoKHR.chromaSubsampling ); 12353 VULKAN_HPP_HASH_COMBINE( seed, videoProfileInfoKHR.lumaBitDepth ); 12354 VULKAN_HPP_HASH_COMBINE( seed, videoProfileInfoKHR.chromaBitDepth ); 12355 return seed; 12356 } 12357 }; 12358 12359 template <> 12360 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeQualityLevelInfoKHR> 12361 { operator ()std::hash12362 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeQualityLevelInfoKHR const & physicalDeviceVideoEncodeQualityLevelInfoKHR ) const 12363 VULKAN_HPP_NOEXCEPT 12364 { 12365 std::size_t seed = 0; 12366 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoEncodeQualityLevelInfoKHR.sType ); 12367 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoEncodeQualityLevelInfoKHR.pNext ); 12368 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoEncodeQualityLevelInfoKHR.pVideoProfile ); 12369 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoEncodeQualityLevelInfoKHR.qualityLevel ); 12370 return seed; 12371 } 12372 }; 12373 12374 template <> 12375 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR> 12376 { operator ()std::hash12377 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR const & physicalDeviceVideoFormatInfoKHR ) const VULKAN_HPP_NOEXCEPT 12378 { 12379 std::size_t seed = 0; 12380 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoFormatInfoKHR.sType ); 12381 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoFormatInfoKHR.pNext ); 12382 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoFormatInfoKHR.imageUsage ); 12383 return seed; 12384 } 12385 }; 12386 12387 template <> 12388 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoMaintenance1FeaturesKHR> 12389 { operator ()std::hash12390 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoMaintenance1FeaturesKHR const & physicalDeviceVideoMaintenance1FeaturesKHR ) const 12391 VULKAN_HPP_NOEXCEPT 12392 { 12393 std::size_t seed = 0; 12394 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoMaintenance1FeaturesKHR.sType ); 12395 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoMaintenance1FeaturesKHR.pNext ); 12396 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoMaintenance1FeaturesKHR.videoMaintenance1 ); 12397 return seed; 12398 } 12399 }; 12400 12401 template <> 12402 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan11Features> 12403 { operator ()std::hash12404 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan11Features const & physicalDeviceVulkan11Features ) const VULKAN_HPP_NOEXCEPT 12405 { 12406 std::size_t seed = 0; 12407 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.sType ); 12408 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.pNext ); 12409 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.storageBuffer16BitAccess ); 12410 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.uniformAndStorageBuffer16BitAccess ); 12411 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.storagePushConstant16 ); 12412 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.storageInputOutput16 ); 12413 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.multiview ); 12414 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.multiviewGeometryShader ); 12415 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.multiviewTessellationShader ); 12416 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.variablePointersStorageBuffer ); 12417 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.variablePointers ); 12418 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.protectedMemory ); 12419 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.samplerYcbcrConversion ); 12420 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.shaderDrawParameters ); 12421 return seed; 12422 } 12423 }; 12424 12425 template <> 12426 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan11Properties> 12427 { operator ()std::hash12428 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan11Properties const & physicalDeviceVulkan11Properties ) const VULKAN_HPP_NOEXCEPT 12429 { 12430 std::size_t seed = 0; 12431 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.sType ); 12432 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.pNext ); 12433 for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) 12434 { 12435 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.deviceUUID[i] ); 12436 } 12437 for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) 12438 { 12439 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.driverUUID[i] ); 12440 } 12441 for ( size_t i = 0; i < VK_LUID_SIZE; ++i ) 12442 { 12443 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.deviceLUID[i] ); 12444 } 12445 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.deviceNodeMask ); 12446 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.deviceLUIDValid ); 12447 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.subgroupSize ); 12448 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.subgroupSupportedStages ); 12449 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.subgroupSupportedOperations ); 12450 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.subgroupQuadOperationsInAllStages ); 12451 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.pointClippingBehavior ); 12452 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.maxMultiviewViewCount ); 12453 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.maxMultiviewInstanceIndex ); 12454 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.protectedNoFault ); 12455 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.maxPerSetDescriptors ); 12456 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.maxMemoryAllocationSize ); 12457 return seed; 12458 } 12459 }; 12460 12461 template <> 12462 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan12Features> 12463 { operator ()std::hash12464 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan12Features const & physicalDeviceVulkan12Features ) const VULKAN_HPP_NOEXCEPT 12465 { 12466 std::size_t seed = 0; 12467 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.sType ); 12468 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.pNext ); 12469 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.samplerMirrorClampToEdge ); 12470 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.drawIndirectCount ); 12471 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.storageBuffer8BitAccess ); 12472 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.uniformAndStorageBuffer8BitAccess ); 12473 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.storagePushConstant8 ); 12474 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderBufferInt64Atomics ); 12475 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderSharedInt64Atomics ); 12476 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderFloat16 ); 12477 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderInt8 ); 12478 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorIndexing ); 12479 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderInputAttachmentArrayDynamicIndexing ); 12480 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderUniformTexelBufferArrayDynamicIndexing ); 12481 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderStorageTexelBufferArrayDynamicIndexing ); 12482 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderUniformBufferArrayNonUniformIndexing ); 12483 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderSampledImageArrayNonUniformIndexing ); 12484 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderStorageBufferArrayNonUniformIndexing ); 12485 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderStorageImageArrayNonUniformIndexing ); 12486 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderInputAttachmentArrayNonUniformIndexing ); 12487 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderUniformTexelBufferArrayNonUniformIndexing ); 12488 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderStorageTexelBufferArrayNonUniformIndexing ); 12489 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorBindingUniformBufferUpdateAfterBind ); 12490 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorBindingSampledImageUpdateAfterBind ); 12491 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorBindingStorageImageUpdateAfterBind ); 12492 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorBindingStorageBufferUpdateAfterBind ); 12493 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorBindingUniformTexelBufferUpdateAfterBind ); 12494 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorBindingStorageTexelBufferUpdateAfterBind ); 12495 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorBindingUpdateUnusedWhilePending ); 12496 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorBindingPartiallyBound ); 12497 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorBindingVariableDescriptorCount ); 12498 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.runtimeDescriptorArray ); 12499 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.samplerFilterMinmax ); 12500 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.scalarBlockLayout ); 12501 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.imagelessFramebuffer ); 12502 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.uniformBufferStandardLayout ); 12503 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderSubgroupExtendedTypes ); 12504 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.separateDepthStencilLayouts ); 12505 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.hostQueryReset ); 12506 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.timelineSemaphore ); 12507 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.bufferDeviceAddress ); 12508 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.bufferDeviceAddressCaptureReplay ); 12509 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.bufferDeviceAddressMultiDevice ); 12510 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.vulkanMemoryModel ); 12511 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.vulkanMemoryModelDeviceScope ); 12512 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.vulkanMemoryModelAvailabilityVisibilityChains ); 12513 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderOutputViewportIndex ); 12514 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderOutputLayer ); 12515 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.subgroupBroadcastDynamicId ); 12516 return seed; 12517 } 12518 }; 12519 12520 template <> 12521 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan12Properties> 12522 { operator ()std::hash12523 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan12Properties const & physicalDeviceVulkan12Properties ) const VULKAN_HPP_NOEXCEPT 12524 { 12525 std::size_t seed = 0; 12526 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.sType ); 12527 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.pNext ); 12528 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.driverID ); 12529 for ( size_t i = 0; i < VK_MAX_DRIVER_NAME_SIZE; ++i ) 12530 { 12531 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.driverName[i] ); 12532 } 12533 for ( size_t i = 0; i < VK_MAX_DRIVER_INFO_SIZE; ++i ) 12534 { 12535 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.driverInfo[i] ); 12536 } 12537 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.conformanceVersion ); 12538 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.denormBehaviorIndependence ); 12539 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.roundingModeIndependence ); 12540 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderSignedZeroInfNanPreserveFloat16 ); 12541 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderSignedZeroInfNanPreserveFloat32 ); 12542 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderSignedZeroInfNanPreserveFloat64 ); 12543 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderDenormPreserveFloat16 ); 12544 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderDenormPreserveFloat32 ); 12545 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderDenormPreserveFloat64 ); 12546 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderDenormFlushToZeroFloat16 ); 12547 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderDenormFlushToZeroFloat32 ); 12548 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderDenormFlushToZeroFloat64 ); 12549 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTEFloat16 ); 12550 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTEFloat32 ); 12551 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTEFloat64 ); 12552 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTZFloat16 ); 12553 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTZFloat32 ); 12554 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTZFloat64 ); 12555 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxUpdateAfterBindDescriptorsInAllPools ); 12556 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderUniformBufferArrayNonUniformIndexingNative ); 12557 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderSampledImageArrayNonUniformIndexingNative ); 12558 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderStorageBufferArrayNonUniformIndexingNative ); 12559 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderStorageImageArrayNonUniformIndexingNative ); 12560 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderInputAttachmentArrayNonUniformIndexingNative ); 12561 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.robustBufferAccessUpdateAfterBind ); 12562 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.quadDivergentImplicitLod ); 12563 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindSamplers ); 12564 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindUniformBuffers ); 12565 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindStorageBuffers ); 12566 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindSampledImages ); 12567 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindStorageImages ); 12568 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindInputAttachments ); 12569 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxPerStageUpdateAfterBindResources ); 12570 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindSamplers ); 12571 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindUniformBuffers ); 12572 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic ); 12573 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindStorageBuffers ); 12574 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic ); 12575 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindSampledImages ); 12576 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindStorageImages ); 12577 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindInputAttachments ); 12578 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.supportedDepthResolveModes ); 12579 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.supportedStencilResolveModes ); 12580 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.independentResolveNone ); 12581 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.independentResolve ); 12582 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.filterMinmaxSingleComponentFormats ); 12583 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.filterMinmaxImageComponentMapping ); 12584 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxTimelineSemaphoreValueDifference ); 12585 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.framebufferIntegerColorSampleCounts ); 12586 return seed; 12587 } 12588 }; 12589 12590 template <> 12591 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan13Features> 12592 { operator ()std::hash12593 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan13Features const & physicalDeviceVulkan13Features ) const VULKAN_HPP_NOEXCEPT 12594 { 12595 std::size_t seed = 0; 12596 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.sType ); 12597 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.pNext ); 12598 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.robustImageAccess ); 12599 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.inlineUniformBlock ); 12600 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.descriptorBindingInlineUniformBlockUpdateAfterBind ); 12601 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.pipelineCreationCacheControl ); 12602 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.privateData ); 12603 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.shaderDemoteToHelperInvocation ); 12604 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.shaderTerminateInvocation ); 12605 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.subgroupSizeControl ); 12606 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.computeFullSubgroups ); 12607 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.synchronization2 ); 12608 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.textureCompressionASTC_HDR ); 12609 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.shaderZeroInitializeWorkgroupMemory ); 12610 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.dynamicRendering ); 12611 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.shaderIntegerDotProduct ); 12612 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.maintenance4 ); 12613 return seed; 12614 } 12615 }; 12616 12617 template <> 12618 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan13Properties> 12619 { operator ()std::hash12620 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan13Properties const & physicalDeviceVulkan13Properties ) const VULKAN_HPP_NOEXCEPT 12621 { 12622 std::size_t seed = 0; 12623 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.sType ); 12624 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.pNext ); 12625 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.minSubgroupSize ); 12626 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.maxSubgroupSize ); 12627 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.maxComputeWorkgroupSubgroups ); 12628 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.requiredSubgroupSizeStages ); 12629 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.maxInlineUniformBlockSize ); 12630 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.maxPerStageDescriptorInlineUniformBlocks ); 12631 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks ); 12632 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.maxDescriptorSetInlineUniformBlocks ); 12633 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.maxDescriptorSetUpdateAfterBindInlineUniformBlocks ); 12634 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.maxInlineUniformTotalSize ); 12635 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct8BitUnsignedAccelerated ); 12636 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct8BitSignedAccelerated ); 12637 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct8BitMixedSignednessAccelerated ); 12638 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct4x8BitPackedUnsignedAccelerated ); 12639 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct4x8BitPackedSignedAccelerated ); 12640 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct4x8BitPackedMixedSignednessAccelerated ); 12641 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct16BitUnsignedAccelerated ); 12642 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct16BitSignedAccelerated ); 12643 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct16BitMixedSignednessAccelerated ); 12644 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct32BitUnsignedAccelerated ); 12645 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct32BitSignedAccelerated ); 12646 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct32BitMixedSignednessAccelerated ); 12647 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct64BitUnsignedAccelerated ); 12648 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct64BitSignedAccelerated ); 12649 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct64BitMixedSignednessAccelerated ); 12650 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating8BitUnsignedAccelerated ); 12651 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating8BitSignedAccelerated ); 12652 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated ); 12653 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated ); 12654 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated ); 12655 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated ); 12656 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating16BitUnsignedAccelerated ); 12657 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating16BitSignedAccelerated ); 12658 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated ); 12659 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating32BitUnsignedAccelerated ); 12660 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating32BitSignedAccelerated ); 12661 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated ); 12662 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating64BitUnsignedAccelerated ); 12663 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating64BitSignedAccelerated ); 12664 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated ); 12665 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.storageTexelBufferOffsetAlignmentBytes ); 12666 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.storageTexelBufferOffsetSingleTexelAlignment ); 12667 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.uniformTexelBufferOffsetAlignmentBytes ); 12668 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.uniformTexelBufferOffsetSingleTexelAlignment ); 12669 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.maxBufferSize ); 12670 return seed; 12671 } 12672 }; 12673 12674 template <> 12675 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan14Features> 12676 { operator ()std::hash12677 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan14Features const & physicalDeviceVulkan14Features ) const VULKAN_HPP_NOEXCEPT 12678 { 12679 std::size_t seed = 0; 12680 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.sType ); 12681 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.pNext ); 12682 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.globalPriorityQuery ); 12683 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.shaderSubgroupRotate ); 12684 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.shaderSubgroupRotateClustered ); 12685 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.shaderFloatControls2 ); 12686 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.shaderExpectAssume ); 12687 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.rectangularLines ); 12688 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.bresenhamLines ); 12689 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.smoothLines ); 12690 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.stippledRectangularLines ); 12691 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.stippledBresenhamLines ); 12692 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.stippledSmoothLines ); 12693 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.vertexAttributeInstanceRateDivisor ); 12694 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.vertexAttributeInstanceRateZeroDivisor ); 12695 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.indexTypeUint8 ); 12696 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.dynamicRenderingLocalRead ); 12697 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.maintenance5 ); 12698 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.maintenance6 ); 12699 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.pipelineProtectedAccess ); 12700 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.pipelineRobustness ); 12701 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.hostImageCopy ); 12702 return seed; 12703 } 12704 }; 12705 12706 template <> 12707 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan14Properties> 12708 { operator ()std::hash12709 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan14Properties const & physicalDeviceVulkan14Properties ) const VULKAN_HPP_NOEXCEPT 12710 { 12711 std::size_t seed = 0; 12712 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.sType ); 12713 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.pNext ); 12714 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.lineSubPixelPrecisionBits ); 12715 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.maxVertexAttribDivisor ); 12716 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.supportsNonZeroFirstInstance ); 12717 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.maxPushDescriptors ); 12718 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.dynamicRenderingLocalReadDepthStencilAttachments ); 12719 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.dynamicRenderingLocalReadMultisampledAttachments ); 12720 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.earlyFragmentMultisampleCoverageAfterSampleCounting ); 12721 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.earlyFragmentSampleMaskTestBeforeSampleCounting ); 12722 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.depthStencilSwizzleOneSupport ); 12723 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.polygonModePointSize ); 12724 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.nonStrictSinglePixelWideLinesUseParallelogram ); 12725 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.nonStrictWideLinesUseParallelogram ); 12726 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.blockTexelViewCompatibleMultipleLayers ); 12727 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.maxCombinedImageSamplerDescriptorCount ); 12728 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.fragmentShadingRateClampCombinerInputs ); 12729 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.defaultRobustnessStorageBuffers ); 12730 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.defaultRobustnessUniformBuffers ); 12731 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.defaultRobustnessVertexInputs ); 12732 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.defaultRobustnessImages ); 12733 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.copySrcLayoutCount ); 12734 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.pCopySrcLayouts ); 12735 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.copyDstLayoutCount ); 12736 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.pCopyDstLayouts ); 12737 for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) 12738 { 12739 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.optimalTilingLayoutUUID[i] ); 12740 } 12741 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.identicalMemoryTypeRequirements ); 12742 return seed; 12743 } 12744 }; 12745 12746 template <> 12747 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkanMemoryModelFeatures> 12748 { 12749 std::size_t operator ()std::hash12750 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkanMemoryModelFeatures const & physicalDeviceVulkanMemoryModelFeatures ) const VULKAN_HPP_NOEXCEPT 12751 { 12752 std::size_t seed = 0; 12753 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkanMemoryModelFeatures.sType ); 12754 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkanMemoryModelFeatures.pNext ); 12755 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkanMemoryModelFeatures.vulkanMemoryModel ); 12756 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkanMemoryModelFeatures.vulkanMemoryModelDeviceScope ); 12757 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkanMemoryModelFeatures.vulkanMemoryModelAvailabilityVisibilityChains ); 12758 return seed; 12759 } 12760 }; 12761 12762 template <> 12763 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR> 12764 { operator ()std::hash12765 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR const & 12766 physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR ) const VULKAN_HPP_NOEXCEPT 12767 { 12768 std::size_t seed = 0; 12769 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.sType ); 12770 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.pNext ); 12771 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.workgroupMemoryExplicitLayout ); 12772 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.workgroupMemoryExplicitLayoutScalarBlockLayout ); 12773 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.workgroupMemoryExplicitLayout8BitAccess ); 12774 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.workgroupMemoryExplicitLayout16BitAccess ); 12775 return seed; 12776 } 12777 }; 12778 12779 template <> 12780 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT> 12781 { operator ()std::hash12782 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT const & physicalDeviceYcbcr2Plane444FormatsFeaturesEXT ) const 12783 VULKAN_HPP_NOEXCEPT 12784 { 12785 std::size_t seed = 0; 12786 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceYcbcr2Plane444FormatsFeaturesEXT.sType ); 12787 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceYcbcr2Plane444FormatsFeaturesEXT.pNext ); 12788 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceYcbcr2Plane444FormatsFeaturesEXT.ycbcr2plane444Formats ); 12789 return seed; 12790 } 12791 }; 12792 12793 template <> 12794 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcrDegammaFeaturesQCOM> 12795 { 12796 std::size_t operator ()std::hash12797 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcrDegammaFeaturesQCOM const & physicalDeviceYcbcrDegammaFeaturesQCOM ) const VULKAN_HPP_NOEXCEPT 12798 { 12799 std::size_t seed = 0; 12800 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceYcbcrDegammaFeaturesQCOM.sType ); 12801 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceYcbcrDegammaFeaturesQCOM.pNext ); 12802 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceYcbcrDegammaFeaturesQCOM.ycbcrDegamma ); 12803 return seed; 12804 } 12805 }; 12806 12807 template <> 12808 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcrImageArraysFeaturesEXT> 12809 { 12810 std::size_t operator ()std::hash12811 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcrImageArraysFeaturesEXT const & physicalDeviceYcbcrImageArraysFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 12812 { 12813 std::size_t seed = 0; 12814 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceYcbcrImageArraysFeaturesEXT.sType ); 12815 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceYcbcrImageArraysFeaturesEXT.pNext ); 12816 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceYcbcrImageArraysFeaturesEXT.ycbcrImageArrays ); 12817 return seed; 12818 } 12819 }; 12820 12821 template <> 12822 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures> 12823 { 12824 std::size_t operator ()std::hash12825 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures const & physicalDeviceZeroInitializeWorkgroupMemoryFeatures ) const 12826 VULKAN_HPP_NOEXCEPT 12827 { 12828 std::size_t seed = 0; 12829 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceZeroInitializeWorkgroupMemoryFeatures.sType ); 12830 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceZeroInitializeWorkgroupMemoryFeatures.pNext ); 12831 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceZeroInitializeWorkgroupMemoryFeatures.shaderZeroInitializeWorkgroupMemory ); 12832 return seed; 12833 } 12834 }; 12835 12836 template <> 12837 struct hash<VULKAN_HPP_NAMESPACE::PipelineBinaryKeyKHR> 12838 { operator ()std::hash12839 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineBinaryKeyKHR const & pipelineBinaryKeyKHR ) const VULKAN_HPP_NOEXCEPT 12840 { 12841 std::size_t seed = 0; 12842 VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryKeyKHR.sType ); 12843 VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryKeyKHR.pNext ); 12844 VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryKeyKHR.keySize ); 12845 for ( size_t i = 0; i < VK_MAX_PIPELINE_BINARY_KEY_SIZE_KHR; ++i ) 12846 { 12847 VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryKeyKHR.key[i] ); 12848 } 12849 return seed; 12850 } 12851 }; 12852 12853 template <> 12854 struct hash<VULKAN_HPP_NAMESPACE::PipelineBinaryDataKHR> 12855 { operator ()std::hash12856 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineBinaryDataKHR const & pipelineBinaryDataKHR ) const VULKAN_HPP_NOEXCEPT 12857 { 12858 std::size_t seed = 0; 12859 VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryDataKHR.dataSize ); 12860 VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryDataKHR.pData ); 12861 return seed; 12862 } 12863 }; 12864 12865 template <> 12866 struct hash<VULKAN_HPP_NAMESPACE::PipelineBinaryKeysAndDataKHR> 12867 { operator ()std::hash12868 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineBinaryKeysAndDataKHR const & pipelineBinaryKeysAndDataKHR ) const VULKAN_HPP_NOEXCEPT 12869 { 12870 std::size_t seed = 0; 12871 VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryKeysAndDataKHR.binaryCount ); 12872 VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryKeysAndDataKHR.pPipelineBinaryKeys ); 12873 VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryKeysAndDataKHR.pPipelineBinaryData ); 12874 return seed; 12875 } 12876 }; 12877 12878 template <> 12879 struct hash<VULKAN_HPP_NAMESPACE::PipelineCreateInfoKHR> 12880 { operator ()std::hash12881 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCreateInfoKHR const & pipelineCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 12882 { 12883 std::size_t seed = 0; 12884 VULKAN_HPP_HASH_COMBINE( seed, pipelineCreateInfoKHR.sType ); 12885 VULKAN_HPP_HASH_COMBINE( seed, pipelineCreateInfoKHR.pNext ); 12886 return seed; 12887 } 12888 }; 12889 12890 template <> 12891 struct hash<VULKAN_HPP_NAMESPACE::PipelineBinaryCreateInfoKHR> 12892 { operator ()std::hash12893 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineBinaryCreateInfoKHR const & pipelineBinaryCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 12894 { 12895 std::size_t seed = 0; 12896 VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryCreateInfoKHR.sType ); 12897 VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryCreateInfoKHR.pNext ); 12898 VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryCreateInfoKHR.pKeysAndDataInfo ); 12899 VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryCreateInfoKHR.pipeline ); 12900 VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryCreateInfoKHR.pPipelineCreateInfo ); 12901 return seed; 12902 } 12903 }; 12904 12905 template <> 12906 struct hash<VULKAN_HPP_NAMESPACE::PipelineBinaryDataInfoKHR> 12907 { operator ()std::hash12908 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineBinaryDataInfoKHR const & pipelineBinaryDataInfoKHR ) const VULKAN_HPP_NOEXCEPT 12909 { 12910 std::size_t seed = 0; 12911 VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryDataInfoKHR.sType ); 12912 VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryDataInfoKHR.pNext ); 12913 VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryDataInfoKHR.pipelineBinary ); 12914 return seed; 12915 } 12916 }; 12917 12918 template <> 12919 struct hash<VULKAN_HPP_NAMESPACE::PipelineBinaryHandlesInfoKHR> 12920 { operator ()std::hash12921 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineBinaryHandlesInfoKHR const & pipelineBinaryHandlesInfoKHR ) const VULKAN_HPP_NOEXCEPT 12922 { 12923 std::size_t seed = 0; 12924 VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryHandlesInfoKHR.sType ); 12925 VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryHandlesInfoKHR.pNext ); 12926 VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryHandlesInfoKHR.pipelineBinaryCount ); 12927 VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryHandlesInfoKHR.pPipelineBinaries ); 12928 return seed; 12929 } 12930 }; 12931 12932 template <> 12933 struct hash<VULKAN_HPP_NAMESPACE::PipelineBinaryInfoKHR> 12934 { operator ()std::hash12935 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineBinaryInfoKHR const & pipelineBinaryInfoKHR ) const VULKAN_HPP_NOEXCEPT 12936 { 12937 std::size_t seed = 0; 12938 VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryInfoKHR.sType ); 12939 VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryInfoKHR.pNext ); 12940 VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryInfoKHR.binaryCount ); 12941 VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryInfoKHR.pPipelineBinaries ); 12942 return seed; 12943 } 12944 }; 12945 12946 template <> 12947 struct hash<VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo> 12948 { operator ()std::hash12949 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo const & pipelineCacheCreateInfo ) const VULKAN_HPP_NOEXCEPT 12950 { 12951 std::size_t seed = 0; 12952 VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheCreateInfo.sType ); 12953 VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheCreateInfo.pNext ); 12954 VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheCreateInfo.flags ); 12955 VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheCreateInfo.initialDataSize ); 12956 VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheCreateInfo.pInitialData ); 12957 return seed; 12958 } 12959 }; 12960 12961 template <> 12962 struct hash<VULKAN_HPP_NAMESPACE::PipelineCacheHeaderVersionOne> 12963 { operator ()std::hash12964 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCacheHeaderVersionOne const & pipelineCacheHeaderVersionOne ) const VULKAN_HPP_NOEXCEPT 12965 { 12966 std::size_t seed = 0; 12967 VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheHeaderVersionOne.headerSize ); 12968 VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheHeaderVersionOne.headerVersion ); 12969 VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheHeaderVersionOne.vendorID ); 12970 VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheHeaderVersionOne.deviceID ); 12971 for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) 12972 { 12973 VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheHeaderVersionOne.pipelineCacheUUID[i] ); 12974 } 12975 return seed; 12976 } 12977 }; 12978 12979 template <> 12980 struct hash<VULKAN_HPP_NAMESPACE::PipelineColorBlendAdvancedStateCreateInfoEXT> 12981 { operator ()std::hash12982 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineColorBlendAdvancedStateCreateInfoEXT const & pipelineColorBlendAdvancedStateCreateInfoEXT ) const 12983 VULKAN_HPP_NOEXCEPT 12984 { 12985 std::size_t seed = 0; 12986 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAdvancedStateCreateInfoEXT.sType ); 12987 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAdvancedStateCreateInfoEXT.pNext ); 12988 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAdvancedStateCreateInfoEXT.srcPremultiplied ); 12989 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAdvancedStateCreateInfoEXT.dstPremultiplied ); 12990 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAdvancedStateCreateInfoEXT.blendOverlap ); 12991 return seed; 12992 } 12993 }; 12994 12995 template <> 12996 struct hash<VULKAN_HPP_NAMESPACE::PipelineColorWriteCreateInfoEXT> 12997 { operator ()std::hash12998 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineColorWriteCreateInfoEXT const & pipelineColorWriteCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 12999 { 13000 std::size_t seed = 0; 13001 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorWriteCreateInfoEXT.sType ); 13002 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorWriteCreateInfoEXT.pNext ); 13003 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorWriteCreateInfoEXT.attachmentCount ); 13004 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorWriteCreateInfoEXT.pColorWriteEnables ); 13005 return seed; 13006 } 13007 }; 13008 13009 template <> 13010 struct hash<VULKAN_HPP_NAMESPACE::PipelineCompilerControlCreateInfoAMD> 13011 { operator ()std::hash13012 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCompilerControlCreateInfoAMD const & pipelineCompilerControlCreateInfoAMD ) const VULKAN_HPP_NOEXCEPT 13013 { 13014 std::size_t seed = 0; 13015 VULKAN_HPP_HASH_COMBINE( seed, pipelineCompilerControlCreateInfoAMD.sType ); 13016 VULKAN_HPP_HASH_COMBINE( seed, pipelineCompilerControlCreateInfoAMD.pNext ); 13017 VULKAN_HPP_HASH_COMBINE( seed, pipelineCompilerControlCreateInfoAMD.compilerControlFlags ); 13018 return seed; 13019 } 13020 }; 13021 13022 template <> 13023 struct hash<VULKAN_HPP_NAMESPACE::PipelineCoverageModulationStateCreateInfoNV> 13024 { operator ()std::hash13025 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCoverageModulationStateCreateInfoNV const & pipelineCoverageModulationStateCreateInfoNV ) const 13026 VULKAN_HPP_NOEXCEPT 13027 { 13028 std::size_t seed = 0; 13029 VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageModulationStateCreateInfoNV.sType ); 13030 VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageModulationStateCreateInfoNV.pNext ); 13031 VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageModulationStateCreateInfoNV.flags ); 13032 VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageModulationStateCreateInfoNV.coverageModulationMode ); 13033 VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageModulationStateCreateInfoNV.coverageModulationTableEnable ); 13034 VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageModulationStateCreateInfoNV.coverageModulationTableCount ); 13035 VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageModulationStateCreateInfoNV.pCoverageModulationTable ); 13036 return seed; 13037 } 13038 }; 13039 13040 template <> 13041 struct hash<VULKAN_HPP_NAMESPACE::PipelineCoverageReductionStateCreateInfoNV> 13042 { operator ()std::hash13043 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCoverageReductionStateCreateInfoNV const & pipelineCoverageReductionStateCreateInfoNV ) const 13044 VULKAN_HPP_NOEXCEPT 13045 { 13046 std::size_t seed = 0; 13047 VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageReductionStateCreateInfoNV.sType ); 13048 VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageReductionStateCreateInfoNV.pNext ); 13049 VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageReductionStateCreateInfoNV.flags ); 13050 VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageReductionStateCreateInfoNV.coverageReductionMode ); 13051 return seed; 13052 } 13053 }; 13054 13055 template <> 13056 struct hash<VULKAN_HPP_NAMESPACE::PipelineCoverageToColorStateCreateInfoNV> 13057 { 13058 std::size_t operator ()std::hash13059 operator()( VULKAN_HPP_NAMESPACE::PipelineCoverageToColorStateCreateInfoNV const & pipelineCoverageToColorStateCreateInfoNV ) const VULKAN_HPP_NOEXCEPT 13060 { 13061 std::size_t seed = 0; 13062 VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageToColorStateCreateInfoNV.sType ); 13063 VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageToColorStateCreateInfoNV.pNext ); 13064 VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageToColorStateCreateInfoNV.flags ); 13065 VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageToColorStateCreateInfoNV.coverageToColorEnable ); 13066 VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageToColorStateCreateInfoNV.coverageToColorLocation ); 13067 return seed; 13068 } 13069 }; 13070 13071 template <> 13072 struct hash<VULKAN_HPP_NAMESPACE::PipelineCreateFlags2CreateInfo> 13073 { operator ()std::hash13074 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCreateFlags2CreateInfo const & pipelineCreateFlags2CreateInfo ) const VULKAN_HPP_NOEXCEPT 13075 { 13076 std::size_t seed = 0; 13077 VULKAN_HPP_HASH_COMBINE( seed, pipelineCreateFlags2CreateInfo.sType ); 13078 VULKAN_HPP_HASH_COMBINE( seed, pipelineCreateFlags2CreateInfo.pNext ); 13079 VULKAN_HPP_HASH_COMBINE( seed, pipelineCreateFlags2CreateInfo.flags ); 13080 return seed; 13081 } 13082 }; 13083 13084 template <> 13085 struct hash<VULKAN_HPP_NAMESPACE::PipelineCreationFeedback> 13086 { operator ()std::hash13087 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCreationFeedback const & pipelineCreationFeedback ) const VULKAN_HPP_NOEXCEPT 13088 { 13089 std::size_t seed = 0; 13090 VULKAN_HPP_HASH_COMBINE( seed, pipelineCreationFeedback.flags ); 13091 VULKAN_HPP_HASH_COMBINE( seed, pipelineCreationFeedback.duration ); 13092 return seed; 13093 } 13094 }; 13095 13096 template <> 13097 struct hash<VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackCreateInfo> 13098 { operator ()std::hash13099 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackCreateInfo const & pipelineCreationFeedbackCreateInfo ) const VULKAN_HPP_NOEXCEPT 13100 { 13101 std::size_t seed = 0; 13102 VULKAN_HPP_HASH_COMBINE( seed, pipelineCreationFeedbackCreateInfo.sType ); 13103 VULKAN_HPP_HASH_COMBINE( seed, pipelineCreationFeedbackCreateInfo.pNext ); 13104 VULKAN_HPP_HASH_COMBINE( seed, pipelineCreationFeedbackCreateInfo.pPipelineCreationFeedback ); 13105 VULKAN_HPP_HASH_COMBINE( seed, pipelineCreationFeedbackCreateInfo.pipelineStageCreationFeedbackCount ); 13106 VULKAN_HPP_HASH_COMBINE( seed, pipelineCreationFeedbackCreateInfo.pPipelineStageCreationFeedbacks ); 13107 return seed; 13108 } 13109 }; 13110 13111 template <> 13112 struct hash<VULKAN_HPP_NAMESPACE::PipelineDiscardRectangleStateCreateInfoEXT> 13113 { operator ()std::hash13114 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineDiscardRectangleStateCreateInfoEXT const & pipelineDiscardRectangleStateCreateInfoEXT ) const 13115 VULKAN_HPP_NOEXCEPT 13116 { 13117 std::size_t seed = 0; 13118 VULKAN_HPP_HASH_COMBINE( seed, pipelineDiscardRectangleStateCreateInfoEXT.sType ); 13119 VULKAN_HPP_HASH_COMBINE( seed, pipelineDiscardRectangleStateCreateInfoEXT.pNext ); 13120 VULKAN_HPP_HASH_COMBINE( seed, pipelineDiscardRectangleStateCreateInfoEXT.flags ); 13121 VULKAN_HPP_HASH_COMBINE( seed, pipelineDiscardRectangleStateCreateInfoEXT.discardRectangleMode ); 13122 VULKAN_HPP_HASH_COMBINE( seed, pipelineDiscardRectangleStateCreateInfoEXT.discardRectangleCount ); 13123 VULKAN_HPP_HASH_COMBINE( seed, pipelineDiscardRectangleStateCreateInfoEXT.pDiscardRectangles ); 13124 return seed; 13125 } 13126 }; 13127 13128 template <> 13129 struct hash<VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR> 13130 { operator ()std::hash13131 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR const & pipelineExecutableInfoKHR ) const VULKAN_HPP_NOEXCEPT 13132 { 13133 std::size_t seed = 0; 13134 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInfoKHR.sType ); 13135 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInfoKHR.pNext ); 13136 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInfoKHR.pipeline ); 13137 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInfoKHR.executableIndex ); 13138 return seed; 13139 } 13140 }; 13141 13142 template <> 13143 struct hash<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR> 13144 { operator ()std::hash13145 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR const & pipelineExecutableInternalRepresentationKHR ) const 13146 VULKAN_HPP_NOEXCEPT 13147 { 13148 std::size_t seed = 0; 13149 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInternalRepresentationKHR.sType ); 13150 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInternalRepresentationKHR.pNext ); 13151 for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) 13152 { 13153 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInternalRepresentationKHR.name[i] ); 13154 } 13155 for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) 13156 { 13157 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInternalRepresentationKHR.description[i] ); 13158 } 13159 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInternalRepresentationKHR.isText ); 13160 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInternalRepresentationKHR.dataSize ); 13161 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInternalRepresentationKHR.pData ); 13162 return seed; 13163 } 13164 }; 13165 13166 template <> 13167 struct hash<VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR> 13168 { operator ()std::hash13169 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR const & pipelineExecutablePropertiesKHR ) const VULKAN_HPP_NOEXCEPT 13170 { 13171 std::size_t seed = 0; 13172 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutablePropertiesKHR.sType ); 13173 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutablePropertiesKHR.pNext ); 13174 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutablePropertiesKHR.stages ); 13175 for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) 13176 { 13177 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutablePropertiesKHR.name[i] ); 13178 } 13179 for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) 13180 { 13181 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutablePropertiesKHR.description[i] ); 13182 } 13183 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutablePropertiesKHR.subgroupSize ); 13184 return seed; 13185 } 13186 }; 13187 13188 template <> 13189 struct hash<VULKAN_HPP_NAMESPACE::PipelineFragmentShadingRateEnumStateCreateInfoNV> 13190 { operator ()std::hash13191 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineFragmentShadingRateEnumStateCreateInfoNV const & pipelineFragmentShadingRateEnumStateCreateInfoNV ) 13192 const VULKAN_HPP_NOEXCEPT 13193 { 13194 std::size_t seed = 0; 13195 VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentShadingRateEnumStateCreateInfoNV.sType ); 13196 VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentShadingRateEnumStateCreateInfoNV.pNext ); 13197 VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentShadingRateEnumStateCreateInfoNV.shadingRateType ); 13198 VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentShadingRateEnumStateCreateInfoNV.shadingRate ); 13199 for ( size_t i = 0; i < 2; ++i ) 13200 { 13201 VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentShadingRateEnumStateCreateInfoNV.combinerOps[i] ); 13202 } 13203 return seed; 13204 } 13205 }; 13206 13207 template <> 13208 struct hash<VULKAN_HPP_NAMESPACE::PipelineFragmentShadingRateStateCreateInfoKHR> 13209 { operator ()std::hash13210 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineFragmentShadingRateStateCreateInfoKHR const & pipelineFragmentShadingRateStateCreateInfoKHR ) const 13211 VULKAN_HPP_NOEXCEPT 13212 { 13213 std::size_t seed = 0; 13214 VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentShadingRateStateCreateInfoKHR.sType ); 13215 VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentShadingRateStateCreateInfoKHR.pNext ); 13216 VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentShadingRateStateCreateInfoKHR.fragmentSize ); 13217 for ( size_t i = 0; i < 2; ++i ) 13218 { 13219 VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentShadingRateStateCreateInfoKHR.combinerOps[i] ); 13220 } 13221 return seed; 13222 } 13223 }; 13224 13225 template <> 13226 struct hash<VULKAN_HPP_NAMESPACE::PipelineIndirectDeviceAddressInfoNV> 13227 { operator ()std::hash13228 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineIndirectDeviceAddressInfoNV const & pipelineIndirectDeviceAddressInfoNV ) const VULKAN_HPP_NOEXCEPT 13229 { 13230 std::size_t seed = 0; 13231 VULKAN_HPP_HASH_COMBINE( seed, pipelineIndirectDeviceAddressInfoNV.sType ); 13232 VULKAN_HPP_HASH_COMBINE( seed, pipelineIndirectDeviceAddressInfoNV.pNext ); 13233 VULKAN_HPP_HASH_COMBINE( seed, pipelineIndirectDeviceAddressInfoNV.pipelineBindPoint ); 13234 VULKAN_HPP_HASH_COMBINE( seed, pipelineIndirectDeviceAddressInfoNV.pipeline ); 13235 return seed; 13236 } 13237 }; 13238 13239 template <> 13240 struct hash<VULKAN_HPP_NAMESPACE::PipelineInfoKHR> 13241 { operator ()std::hash13242 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineInfoKHR const & pipelineInfoKHR ) const VULKAN_HPP_NOEXCEPT 13243 { 13244 std::size_t seed = 0; 13245 VULKAN_HPP_HASH_COMBINE( seed, pipelineInfoKHR.sType ); 13246 VULKAN_HPP_HASH_COMBINE( seed, pipelineInfoKHR.pNext ); 13247 VULKAN_HPP_HASH_COMBINE( seed, pipelineInfoKHR.pipeline ); 13248 return seed; 13249 } 13250 }; 13251 13252 template <> 13253 struct hash<VULKAN_HPP_NAMESPACE::PushConstantRange> 13254 { operator ()std::hash13255 std::size_t operator()( VULKAN_HPP_NAMESPACE::PushConstantRange const & pushConstantRange ) const VULKAN_HPP_NOEXCEPT 13256 { 13257 std::size_t seed = 0; 13258 VULKAN_HPP_HASH_COMBINE( seed, pushConstantRange.stageFlags ); 13259 VULKAN_HPP_HASH_COMBINE( seed, pushConstantRange.offset ); 13260 VULKAN_HPP_HASH_COMBINE( seed, pushConstantRange.size ); 13261 return seed; 13262 } 13263 }; 13264 13265 template <> 13266 struct hash<VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo> 13267 { operator ()std::hash13268 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo const & pipelineLayoutCreateInfo ) const VULKAN_HPP_NOEXCEPT 13269 { 13270 std::size_t seed = 0; 13271 VULKAN_HPP_HASH_COMBINE( seed, pipelineLayoutCreateInfo.sType ); 13272 VULKAN_HPP_HASH_COMBINE( seed, pipelineLayoutCreateInfo.pNext ); 13273 VULKAN_HPP_HASH_COMBINE( seed, pipelineLayoutCreateInfo.flags ); 13274 VULKAN_HPP_HASH_COMBINE( seed, pipelineLayoutCreateInfo.setLayoutCount ); 13275 VULKAN_HPP_HASH_COMBINE( seed, pipelineLayoutCreateInfo.pSetLayouts ); 13276 VULKAN_HPP_HASH_COMBINE( seed, pipelineLayoutCreateInfo.pushConstantRangeCount ); 13277 VULKAN_HPP_HASH_COMBINE( seed, pipelineLayoutCreateInfo.pPushConstantRanges ); 13278 return seed; 13279 } 13280 }; 13281 13282 template <> 13283 struct hash<VULKAN_HPP_NAMESPACE::PipelinePropertiesIdentifierEXT> 13284 { operator ()std::hash13285 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelinePropertiesIdentifierEXT const & pipelinePropertiesIdentifierEXT ) const VULKAN_HPP_NOEXCEPT 13286 { 13287 std::size_t seed = 0; 13288 VULKAN_HPP_HASH_COMBINE( seed, pipelinePropertiesIdentifierEXT.sType ); 13289 VULKAN_HPP_HASH_COMBINE( seed, pipelinePropertiesIdentifierEXT.pNext ); 13290 for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) 13291 { 13292 VULKAN_HPP_HASH_COMBINE( seed, pipelinePropertiesIdentifierEXT.pipelineIdentifier[i] ); 13293 } 13294 return seed; 13295 } 13296 }; 13297 13298 template <> 13299 struct hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationConservativeStateCreateInfoEXT> 13300 { 13301 std::size_t operator ()std::hash13302 operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationConservativeStateCreateInfoEXT const & pipelineRasterizationConservativeStateCreateInfoEXT ) const 13303 VULKAN_HPP_NOEXCEPT 13304 { 13305 std::size_t seed = 0; 13306 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationConservativeStateCreateInfoEXT.sType ); 13307 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationConservativeStateCreateInfoEXT.pNext ); 13308 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationConservativeStateCreateInfoEXT.flags ); 13309 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationConservativeStateCreateInfoEXT.conservativeRasterizationMode ); 13310 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationConservativeStateCreateInfoEXT.extraPrimitiveOverestimationSize ); 13311 return seed; 13312 } 13313 }; 13314 13315 template <> 13316 struct hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationDepthClipStateCreateInfoEXT> 13317 { operator ()std::hash13318 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationDepthClipStateCreateInfoEXT const & pipelineRasterizationDepthClipStateCreateInfoEXT ) 13319 const VULKAN_HPP_NOEXCEPT 13320 { 13321 std::size_t seed = 0; 13322 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationDepthClipStateCreateInfoEXT.sType ); 13323 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationDepthClipStateCreateInfoEXT.pNext ); 13324 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationDepthClipStateCreateInfoEXT.flags ); 13325 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationDepthClipStateCreateInfoEXT.depthClipEnable ); 13326 return seed; 13327 } 13328 }; 13329 13330 template <> 13331 struct hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationLineStateCreateInfo> 13332 { 13333 std::size_t operator ()std::hash13334 operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationLineStateCreateInfo const & pipelineRasterizationLineStateCreateInfo ) const VULKAN_HPP_NOEXCEPT 13335 { 13336 std::size_t seed = 0; 13337 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfo.sType ); 13338 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfo.pNext ); 13339 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfo.lineRasterizationMode ); 13340 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfo.stippledLineEnable ); 13341 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfo.lineStippleFactor ); 13342 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfo.lineStipplePattern ); 13343 return seed; 13344 } 13345 }; 13346 13347 template <> 13348 struct hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationProvokingVertexStateCreateInfoEXT> 13349 { operator ()std::hash13350 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationProvokingVertexStateCreateInfoEXT const & 13351 pipelineRasterizationProvokingVertexStateCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 13352 { 13353 std::size_t seed = 0; 13354 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationProvokingVertexStateCreateInfoEXT.sType ); 13355 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationProvokingVertexStateCreateInfoEXT.pNext ); 13356 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationProvokingVertexStateCreateInfoEXT.provokingVertexMode ); 13357 return seed; 13358 } 13359 }; 13360 13361 template <> 13362 struct hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationStateRasterizationOrderAMD> 13363 { operator ()std::hash13364 std::size_t operator()( 13365 VULKAN_HPP_NAMESPACE::PipelineRasterizationStateRasterizationOrderAMD const & pipelineRasterizationStateRasterizationOrderAMD ) const VULKAN_HPP_NOEXCEPT 13366 { 13367 std::size_t seed = 0; 13368 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateRasterizationOrderAMD.sType ); 13369 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateRasterizationOrderAMD.pNext ); 13370 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateRasterizationOrderAMD.rasterizationOrder ); 13371 return seed; 13372 } 13373 }; 13374 13375 template <> 13376 struct hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationStateStreamCreateInfoEXT> 13377 { operator ()std::hash13378 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationStateStreamCreateInfoEXT const & pipelineRasterizationStateStreamCreateInfoEXT ) const 13379 VULKAN_HPP_NOEXCEPT 13380 { 13381 std::size_t seed = 0; 13382 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateStreamCreateInfoEXT.sType ); 13383 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateStreamCreateInfoEXT.pNext ); 13384 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateStreamCreateInfoEXT.flags ); 13385 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateStreamCreateInfoEXT.rasterizationStream ); 13386 return seed; 13387 } 13388 }; 13389 13390 template <> 13391 struct hash<VULKAN_HPP_NAMESPACE::PipelineRenderingCreateInfo> 13392 { operator ()std::hash13393 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRenderingCreateInfo const & pipelineRenderingCreateInfo ) const VULKAN_HPP_NOEXCEPT 13394 { 13395 std::size_t seed = 0; 13396 VULKAN_HPP_HASH_COMBINE( seed, pipelineRenderingCreateInfo.sType ); 13397 VULKAN_HPP_HASH_COMBINE( seed, pipelineRenderingCreateInfo.pNext ); 13398 VULKAN_HPP_HASH_COMBINE( seed, pipelineRenderingCreateInfo.viewMask ); 13399 VULKAN_HPP_HASH_COMBINE( seed, pipelineRenderingCreateInfo.colorAttachmentCount ); 13400 VULKAN_HPP_HASH_COMBINE( seed, pipelineRenderingCreateInfo.pColorAttachmentFormats ); 13401 VULKAN_HPP_HASH_COMBINE( seed, pipelineRenderingCreateInfo.depthAttachmentFormat ); 13402 VULKAN_HPP_HASH_COMBINE( seed, pipelineRenderingCreateInfo.stencilAttachmentFormat ); 13403 return seed; 13404 } 13405 }; 13406 13407 template <> 13408 struct hash<VULKAN_HPP_NAMESPACE::PipelineRepresentativeFragmentTestStateCreateInfoNV> 13409 { 13410 std::size_t operator ()std::hash13411 operator()( VULKAN_HPP_NAMESPACE::PipelineRepresentativeFragmentTestStateCreateInfoNV const & pipelineRepresentativeFragmentTestStateCreateInfoNV ) const 13412 VULKAN_HPP_NOEXCEPT 13413 { 13414 std::size_t seed = 0; 13415 VULKAN_HPP_HASH_COMBINE( seed, pipelineRepresentativeFragmentTestStateCreateInfoNV.sType ); 13416 VULKAN_HPP_HASH_COMBINE( seed, pipelineRepresentativeFragmentTestStateCreateInfoNV.pNext ); 13417 VULKAN_HPP_HASH_COMBINE( seed, pipelineRepresentativeFragmentTestStateCreateInfoNV.representativeFragmentTestEnable ); 13418 return seed; 13419 } 13420 }; 13421 13422 template <> 13423 struct hash<VULKAN_HPP_NAMESPACE::PipelineRobustnessCreateInfo> 13424 { operator ()std::hash13425 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRobustnessCreateInfo const & pipelineRobustnessCreateInfo ) const VULKAN_HPP_NOEXCEPT 13426 { 13427 std::size_t seed = 0; 13428 VULKAN_HPP_HASH_COMBINE( seed, pipelineRobustnessCreateInfo.sType ); 13429 VULKAN_HPP_HASH_COMBINE( seed, pipelineRobustnessCreateInfo.pNext ); 13430 VULKAN_HPP_HASH_COMBINE( seed, pipelineRobustnessCreateInfo.storageBuffers ); 13431 VULKAN_HPP_HASH_COMBINE( seed, pipelineRobustnessCreateInfo.uniformBuffers ); 13432 VULKAN_HPP_HASH_COMBINE( seed, pipelineRobustnessCreateInfo.vertexInputs ); 13433 VULKAN_HPP_HASH_COMBINE( seed, pipelineRobustnessCreateInfo.images ); 13434 return seed; 13435 } 13436 }; 13437 13438 template <> 13439 struct hash<VULKAN_HPP_NAMESPACE::PipelineSampleLocationsStateCreateInfoEXT> 13440 { 13441 std::size_t operator ()std::hash13442 operator()( VULKAN_HPP_NAMESPACE::PipelineSampleLocationsStateCreateInfoEXT const & pipelineSampleLocationsStateCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 13443 { 13444 std::size_t seed = 0; 13445 VULKAN_HPP_HASH_COMBINE( seed, pipelineSampleLocationsStateCreateInfoEXT.sType ); 13446 VULKAN_HPP_HASH_COMBINE( seed, pipelineSampleLocationsStateCreateInfoEXT.pNext ); 13447 VULKAN_HPP_HASH_COMBINE( seed, pipelineSampleLocationsStateCreateInfoEXT.sampleLocationsEnable ); 13448 VULKAN_HPP_HASH_COMBINE( seed, pipelineSampleLocationsStateCreateInfoEXT.sampleLocationsInfo ); 13449 return seed; 13450 } 13451 }; 13452 13453 template <> 13454 struct hash<VULKAN_HPP_NAMESPACE::PipelineShaderStageModuleIdentifierCreateInfoEXT> 13455 { operator ()std::hash13456 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineShaderStageModuleIdentifierCreateInfoEXT const & pipelineShaderStageModuleIdentifierCreateInfoEXT ) 13457 const VULKAN_HPP_NOEXCEPT 13458 { 13459 std::size_t seed = 0; 13460 VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageModuleIdentifierCreateInfoEXT.sType ); 13461 VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageModuleIdentifierCreateInfoEXT.pNext ); 13462 VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageModuleIdentifierCreateInfoEXT.identifierSize ); 13463 VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageModuleIdentifierCreateInfoEXT.pIdentifier ); 13464 return seed; 13465 } 13466 }; 13467 13468 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 13469 template <> 13470 struct hash<VULKAN_HPP_NAMESPACE::PipelineShaderStageNodeCreateInfoAMDX> 13471 { 13472 std::size_t operator ()std::hash13473 operator()( VULKAN_HPP_NAMESPACE::PipelineShaderStageNodeCreateInfoAMDX const & pipelineShaderStageNodeCreateInfoAMDX ) const VULKAN_HPP_NOEXCEPT 13474 { 13475 std::size_t seed = 0; 13476 VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageNodeCreateInfoAMDX.sType ); 13477 VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageNodeCreateInfoAMDX.pNext ); 13478 for ( const char * p = pipelineShaderStageNodeCreateInfoAMDX.pName; *p != '\0'; ++p ) 13479 { 13480 VULKAN_HPP_HASH_COMBINE( seed, *p ); 13481 } 13482 VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageNodeCreateInfoAMDX.index ); 13483 return seed; 13484 } 13485 }; 13486 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 13487 13488 template <> 13489 struct hash<VULKAN_HPP_NAMESPACE::PipelineShaderStageRequiredSubgroupSizeCreateInfo> 13490 { operator ()std::hash13491 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineShaderStageRequiredSubgroupSizeCreateInfo const & pipelineShaderStageRequiredSubgroupSizeCreateInfo ) 13492 const VULKAN_HPP_NOEXCEPT 13493 { 13494 std::size_t seed = 0; 13495 VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageRequiredSubgroupSizeCreateInfo.sType ); 13496 VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageRequiredSubgroupSizeCreateInfo.pNext ); 13497 VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageRequiredSubgroupSizeCreateInfo.requiredSubgroupSize ); 13498 return seed; 13499 } 13500 }; 13501 13502 template <> 13503 struct hash<VULKAN_HPP_NAMESPACE::PipelineTessellationDomainOriginStateCreateInfo> 13504 { operator ()std::hash13505 std::size_t operator()( 13506 VULKAN_HPP_NAMESPACE::PipelineTessellationDomainOriginStateCreateInfo const & pipelineTessellationDomainOriginStateCreateInfo ) const VULKAN_HPP_NOEXCEPT 13507 { 13508 std::size_t seed = 0; 13509 VULKAN_HPP_HASH_COMBINE( seed, pipelineTessellationDomainOriginStateCreateInfo.sType ); 13510 VULKAN_HPP_HASH_COMBINE( seed, pipelineTessellationDomainOriginStateCreateInfo.pNext ); 13511 VULKAN_HPP_HASH_COMBINE( seed, pipelineTessellationDomainOriginStateCreateInfo.domainOrigin ); 13512 return seed; 13513 } 13514 }; 13515 13516 template <> 13517 struct hash<VULKAN_HPP_NAMESPACE::VertexInputBindingDivisorDescription> 13518 { operator ()std::hash13519 std::size_t operator()( VULKAN_HPP_NAMESPACE::VertexInputBindingDivisorDescription const & vertexInputBindingDivisorDescription ) const VULKAN_HPP_NOEXCEPT 13520 { 13521 std::size_t seed = 0; 13522 VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDivisorDescription.binding ); 13523 VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDivisorDescription.divisor ); 13524 return seed; 13525 } 13526 }; 13527 13528 template <> 13529 struct hash<VULKAN_HPP_NAMESPACE::PipelineVertexInputDivisorStateCreateInfo> 13530 { 13531 std::size_t operator ()std::hash13532 operator()( VULKAN_HPP_NAMESPACE::PipelineVertexInputDivisorStateCreateInfo const & pipelineVertexInputDivisorStateCreateInfo ) const VULKAN_HPP_NOEXCEPT 13533 { 13534 std::size_t seed = 0; 13535 VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputDivisorStateCreateInfo.sType ); 13536 VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputDivisorStateCreateInfo.pNext ); 13537 VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputDivisorStateCreateInfo.vertexBindingDivisorCount ); 13538 VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputDivisorStateCreateInfo.pVertexBindingDivisors ); 13539 return seed; 13540 } 13541 }; 13542 13543 template <> 13544 struct hash<VULKAN_HPP_NAMESPACE::PipelineViewportCoarseSampleOrderStateCreateInfoNV> 13545 { 13546 std::size_t operator ()std::hash13547 operator()( VULKAN_HPP_NAMESPACE::PipelineViewportCoarseSampleOrderStateCreateInfoNV const & pipelineViewportCoarseSampleOrderStateCreateInfoNV ) const 13548 VULKAN_HPP_NOEXCEPT 13549 { 13550 std::size_t seed = 0; 13551 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportCoarseSampleOrderStateCreateInfoNV.sType ); 13552 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportCoarseSampleOrderStateCreateInfoNV.pNext ); 13553 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportCoarseSampleOrderStateCreateInfoNV.sampleOrderType ); 13554 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportCoarseSampleOrderStateCreateInfoNV.customSampleOrderCount ); 13555 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportCoarseSampleOrderStateCreateInfoNV.pCustomSampleOrders ); 13556 return seed; 13557 } 13558 }; 13559 13560 template <> 13561 struct hash<VULKAN_HPP_NAMESPACE::PipelineViewportDepthClipControlCreateInfoEXT> 13562 { operator ()std::hash13563 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineViewportDepthClipControlCreateInfoEXT const & pipelineViewportDepthClipControlCreateInfoEXT ) const 13564 VULKAN_HPP_NOEXCEPT 13565 { 13566 std::size_t seed = 0; 13567 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportDepthClipControlCreateInfoEXT.sType ); 13568 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportDepthClipControlCreateInfoEXT.pNext ); 13569 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportDepthClipControlCreateInfoEXT.negativeOneToOne ); 13570 return seed; 13571 } 13572 }; 13573 13574 template <> 13575 struct hash<VULKAN_HPP_NAMESPACE::PipelineViewportExclusiveScissorStateCreateInfoNV> 13576 { operator ()std::hash13577 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineViewportExclusiveScissorStateCreateInfoNV const & pipelineViewportExclusiveScissorStateCreateInfoNV ) 13578 const VULKAN_HPP_NOEXCEPT 13579 { 13580 std::size_t seed = 0; 13581 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportExclusiveScissorStateCreateInfoNV.sType ); 13582 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportExclusiveScissorStateCreateInfoNV.pNext ); 13583 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportExclusiveScissorStateCreateInfoNV.exclusiveScissorCount ); 13584 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportExclusiveScissorStateCreateInfoNV.pExclusiveScissors ); 13585 return seed; 13586 } 13587 }; 13588 13589 template <> 13590 struct hash<VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV> 13591 { operator ()std::hash13592 std::size_t operator()( VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV const & shadingRatePaletteNV ) const VULKAN_HPP_NOEXCEPT 13593 { 13594 std::size_t seed = 0; 13595 VULKAN_HPP_HASH_COMBINE( seed, shadingRatePaletteNV.shadingRatePaletteEntryCount ); 13596 VULKAN_HPP_HASH_COMBINE( seed, shadingRatePaletteNV.pShadingRatePaletteEntries ); 13597 return seed; 13598 } 13599 }; 13600 13601 template <> 13602 struct hash<VULKAN_HPP_NAMESPACE::PipelineViewportShadingRateImageStateCreateInfoNV> 13603 { operator ()std::hash13604 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineViewportShadingRateImageStateCreateInfoNV const & pipelineViewportShadingRateImageStateCreateInfoNV ) 13605 const VULKAN_HPP_NOEXCEPT 13606 { 13607 std::size_t seed = 0; 13608 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportShadingRateImageStateCreateInfoNV.sType ); 13609 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportShadingRateImageStateCreateInfoNV.pNext ); 13610 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportShadingRateImageStateCreateInfoNV.shadingRateImageEnable ); 13611 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportShadingRateImageStateCreateInfoNV.viewportCount ); 13612 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportShadingRateImageStateCreateInfoNV.pShadingRatePalettes ); 13613 return seed; 13614 } 13615 }; 13616 13617 template <> 13618 struct hash<VULKAN_HPP_NAMESPACE::ViewportSwizzleNV> 13619 { operator ()std::hash13620 std::size_t operator()( VULKAN_HPP_NAMESPACE::ViewportSwizzleNV const & viewportSwizzleNV ) const VULKAN_HPP_NOEXCEPT 13621 { 13622 std::size_t seed = 0; 13623 VULKAN_HPP_HASH_COMBINE( seed, viewportSwizzleNV.x ); 13624 VULKAN_HPP_HASH_COMBINE( seed, viewportSwizzleNV.y ); 13625 VULKAN_HPP_HASH_COMBINE( seed, viewportSwizzleNV.z ); 13626 VULKAN_HPP_HASH_COMBINE( seed, viewportSwizzleNV.w ); 13627 return seed; 13628 } 13629 }; 13630 13631 template <> 13632 struct hash<VULKAN_HPP_NAMESPACE::PipelineViewportSwizzleStateCreateInfoNV> 13633 { 13634 std::size_t operator ()std::hash13635 operator()( VULKAN_HPP_NAMESPACE::PipelineViewportSwizzleStateCreateInfoNV const & pipelineViewportSwizzleStateCreateInfoNV ) const VULKAN_HPP_NOEXCEPT 13636 { 13637 std::size_t seed = 0; 13638 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportSwizzleStateCreateInfoNV.sType ); 13639 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportSwizzleStateCreateInfoNV.pNext ); 13640 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportSwizzleStateCreateInfoNV.flags ); 13641 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportSwizzleStateCreateInfoNV.viewportCount ); 13642 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportSwizzleStateCreateInfoNV.pViewportSwizzles ); 13643 return seed; 13644 } 13645 }; 13646 13647 template <> 13648 struct hash<VULKAN_HPP_NAMESPACE::ViewportWScalingNV> 13649 { operator ()std::hash13650 std::size_t operator()( VULKAN_HPP_NAMESPACE::ViewportWScalingNV const & viewportWScalingNV ) const VULKAN_HPP_NOEXCEPT 13651 { 13652 std::size_t seed = 0; 13653 VULKAN_HPP_HASH_COMBINE( seed, viewportWScalingNV.xcoeff ); 13654 VULKAN_HPP_HASH_COMBINE( seed, viewportWScalingNV.ycoeff ); 13655 return seed; 13656 } 13657 }; 13658 13659 template <> 13660 struct hash<VULKAN_HPP_NAMESPACE::PipelineViewportWScalingStateCreateInfoNV> 13661 { 13662 std::size_t operator ()std::hash13663 operator()( VULKAN_HPP_NAMESPACE::PipelineViewportWScalingStateCreateInfoNV const & pipelineViewportWScalingStateCreateInfoNV ) const VULKAN_HPP_NOEXCEPT 13664 { 13665 std::size_t seed = 0; 13666 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportWScalingStateCreateInfoNV.sType ); 13667 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportWScalingStateCreateInfoNV.pNext ); 13668 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportWScalingStateCreateInfoNV.viewportWScalingEnable ); 13669 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportWScalingStateCreateInfoNV.viewportCount ); 13670 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportWScalingStateCreateInfoNV.pViewportWScalings ); 13671 return seed; 13672 } 13673 }; 13674 13675 # if defined( VK_USE_PLATFORM_GGP ) 13676 template <> 13677 struct hash<VULKAN_HPP_NAMESPACE::PresentFrameTokenGGP> 13678 { operator ()std::hash13679 std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentFrameTokenGGP const & presentFrameTokenGGP ) const VULKAN_HPP_NOEXCEPT 13680 { 13681 std::size_t seed = 0; 13682 VULKAN_HPP_HASH_COMBINE( seed, presentFrameTokenGGP.sType ); 13683 VULKAN_HPP_HASH_COMBINE( seed, presentFrameTokenGGP.pNext ); 13684 VULKAN_HPP_HASH_COMBINE( seed, presentFrameTokenGGP.frameToken ); 13685 return seed; 13686 } 13687 }; 13688 # endif /*VK_USE_PLATFORM_GGP*/ 13689 13690 template <> 13691 struct hash<VULKAN_HPP_NAMESPACE::PresentIdKHR> 13692 { operator ()std::hash13693 std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentIdKHR const & presentIdKHR ) const VULKAN_HPP_NOEXCEPT 13694 { 13695 std::size_t seed = 0; 13696 VULKAN_HPP_HASH_COMBINE( seed, presentIdKHR.sType ); 13697 VULKAN_HPP_HASH_COMBINE( seed, presentIdKHR.pNext ); 13698 VULKAN_HPP_HASH_COMBINE( seed, presentIdKHR.swapchainCount ); 13699 VULKAN_HPP_HASH_COMBINE( seed, presentIdKHR.pPresentIds ); 13700 return seed; 13701 } 13702 }; 13703 13704 template <> 13705 struct hash<VULKAN_HPP_NAMESPACE::PresentInfoKHR> 13706 { operator ()std::hash13707 std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentInfoKHR const & presentInfoKHR ) const VULKAN_HPP_NOEXCEPT 13708 { 13709 std::size_t seed = 0; 13710 VULKAN_HPP_HASH_COMBINE( seed, presentInfoKHR.sType ); 13711 VULKAN_HPP_HASH_COMBINE( seed, presentInfoKHR.pNext ); 13712 VULKAN_HPP_HASH_COMBINE( seed, presentInfoKHR.waitSemaphoreCount ); 13713 VULKAN_HPP_HASH_COMBINE( seed, presentInfoKHR.pWaitSemaphores ); 13714 VULKAN_HPP_HASH_COMBINE( seed, presentInfoKHR.swapchainCount ); 13715 VULKAN_HPP_HASH_COMBINE( seed, presentInfoKHR.pSwapchains ); 13716 VULKAN_HPP_HASH_COMBINE( seed, presentInfoKHR.pImageIndices ); 13717 VULKAN_HPP_HASH_COMBINE( seed, presentInfoKHR.pResults ); 13718 return seed; 13719 } 13720 }; 13721 13722 template <> 13723 struct hash<VULKAN_HPP_NAMESPACE::RectLayerKHR> 13724 { operator ()std::hash13725 std::size_t operator()( VULKAN_HPP_NAMESPACE::RectLayerKHR const & rectLayerKHR ) const VULKAN_HPP_NOEXCEPT 13726 { 13727 std::size_t seed = 0; 13728 VULKAN_HPP_HASH_COMBINE( seed, rectLayerKHR.offset ); 13729 VULKAN_HPP_HASH_COMBINE( seed, rectLayerKHR.extent ); 13730 VULKAN_HPP_HASH_COMBINE( seed, rectLayerKHR.layer ); 13731 return seed; 13732 } 13733 }; 13734 13735 template <> 13736 struct hash<VULKAN_HPP_NAMESPACE::PresentRegionKHR> 13737 { operator ()std::hash13738 std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentRegionKHR const & presentRegionKHR ) const VULKAN_HPP_NOEXCEPT 13739 { 13740 std::size_t seed = 0; 13741 VULKAN_HPP_HASH_COMBINE( seed, presentRegionKHR.rectangleCount ); 13742 VULKAN_HPP_HASH_COMBINE( seed, presentRegionKHR.pRectangles ); 13743 return seed; 13744 } 13745 }; 13746 13747 template <> 13748 struct hash<VULKAN_HPP_NAMESPACE::PresentRegionsKHR> 13749 { operator ()std::hash13750 std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentRegionsKHR const & presentRegionsKHR ) const VULKAN_HPP_NOEXCEPT 13751 { 13752 std::size_t seed = 0; 13753 VULKAN_HPP_HASH_COMBINE( seed, presentRegionsKHR.sType ); 13754 VULKAN_HPP_HASH_COMBINE( seed, presentRegionsKHR.pNext ); 13755 VULKAN_HPP_HASH_COMBINE( seed, presentRegionsKHR.swapchainCount ); 13756 VULKAN_HPP_HASH_COMBINE( seed, presentRegionsKHR.pRegions ); 13757 return seed; 13758 } 13759 }; 13760 13761 template <> 13762 struct hash<VULKAN_HPP_NAMESPACE::PresentTimeGOOGLE> 13763 { operator ()std::hash13764 std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentTimeGOOGLE const & presentTimeGOOGLE ) const VULKAN_HPP_NOEXCEPT 13765 { 13766 std::size_t seed = 0; 13767 VULKAN_HPP_HASH_COMBINE( seed, presentTimeGOOGLE.presentID ); 13768 VULKAN_HPP_HASH_COMBINE( seed, presentTimeGOOGLE.desiredPresentTime ); 13769 return seed; 13770 } 13771 }; 13772 13773 template <> 13774 struct hash<VULKAN_HPP_NAMESPACE::PresentTimesInfoGOOGLE> 13775 { operator ()std::hash13776 std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentTimesInfoGOOGLE const & presentTimesInfoGOOGLE ) const VULKAN_HPP_NOEXCEPT 13777 { 13778 std::size_t seed = 0; 13779 VULKAN_HPP_HASH_COMBINE( seed, presentTimesInfoGOOGLE.sType ); 13780 VULKAN_HPP_HASH_COMBINE( seed, presentTimesInfoGOOGLE.pNext ); 13781 VULKAN_HPP_HASH_COMBINE( seed, presentTimesInfoGOOGLE.swapchainCount ); 13782 VULKAN_HPP_HASH_COMBINE( seed, presentTimesInfoGOOGLE.pTimes ); 13783 return seed; 13784 } 13785 }; 13786 13787 template <> 13788 struct hash<VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo> 13789 { operator ()std::hash13790 std::size_t operator()( VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo const & privateDataSlotCreateInfo ) const VULKAN_HPP_NOEXCEPT 13791 { 13792 std::size_t seed = 0; 13793 VULKAN_HPP_HASH_COMBINE( seed, privateDataSlotCreateInfo.sType ); 13794 VULKAN_HPP_HASH_COMBINE( seed, privateDataSlotCreateInfo.pNext ); 13795 VULKAN_HPP_HASH_COMBINE( seed, privateDataSlotCreateInfo.flags ); 13796 return seed; 13797 } 13798 }; 13799 13800 template <> 13801 struct hash<VULKAN_HPP_NAMESPACE::ProtectedSubmitInfo> 13802 { operator ()std::hash13803 std::size_t operator()( VULKAN_HPP_NAMESPACE::ProtectedSubmitInfo const & protectedSubmitInfo ) const VULKAN_HPP_NOEXCEPT 13804 { 13805 std::size_t seed = 0; 13806 VULKAN_HPP_HASH_COMBINE( seed, protectedSubmitInfo.sType ); 13807 VULKAN_HPP_HASH_COMBINE( seed, protectedSubmitInfo.pNext ); 13808 VULKAN_HPP_HASH_COMBINE( seed, protectedSubmitInfo.protectedSubmit ); 13809 return seed; 13810 } 13811 }; 13812 13813 template <> 13814 struct hash<VULKAN_HPP_NAMESPACE::PushConstantsInfo> 13815 { operator ()std::hash13816 std::size_t operator()( VULKAN_HPP_NAMESPACE::PushConstantsInfo const & pushConstantsInfo ) const VULKAN_HPP_NOEXCEPT 13817 { 13818 std::size_t seed = 0; 13819 VULKAN_HPP_HASH_COMBINE( seed, pushConstantsInfo.sType ); 13820 VULKAN_HPP_HASH_COMBINE( seed, pushConstantsInfo.pNext ); 13821 VULKAN_HPP_HASH_COMBINE( seed, pushConstantsInfo.layout ); 13822 VULKAN_HPP_HASH_COMBINE( seed, pushConstantsInfo.stageFlags ); 13823 VULKAN_HPP_HASH_COMBINE( seed, pushConstantsInfo.offset ); 13824 VULKAN_HPP_HASH_COMBINE( seed, pushConstantsInfo.size ); 13825 VULKAN_HPP_HASH_COMBINE( seed, pushConstantsInfo.pValues ); 13826 return seed; 13827 } 13828 }; 13829 13830 template <> 13831 struct hash<VULKAN_HPP_NAMESPACE::WriteDescriptorSet> 13832 { operator ()std::hash13833 std::size_t operator()( VULKAN_HPP_NAMESPACE::WriteDescriptorSet const & writeDescriptorSet ) const VULKAN_HPP_NOEXCEPT 13834 { 13835 std::size_t seed = 0; 13836 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.sType ); 13837 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.pNext ); 13838 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.dstSet ); 13839 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.dstBinding ); 13840 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.dstArrayElement ); 13841 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.descriptorCount ); 13842 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.descriptorType ); 13843 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.pImageInfo ); 13844 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.pBufferInfo ); 13845 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.pTexelBufferView ); 13846 return seed; 13847 } 13848 }; 13849 13850 template <> 13851 struct hash<VULKAN_HPP_NAMESPACE::PushDescriptorSetInfo> 13852 { operator ()std::hash13853 std::size_t operator()( VULKAN_HPP_NAMESPACE::PushDescriptorSetInfo const & pushDescriptorSetInfo ) const VULKAN_HPP_NOEXCEPT 13854 { 13855 std::size_t seed = 0; 13856 VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetInfo.sType ); 13857 VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetInfo.pNext ); 13858 VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetInfo.stageFlags ); 13859 VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetInfo.layout ); 13860 VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetInfo.set ); 13861 VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetInfo.descriptorWriteCount ); 13862 VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetInfo.pDescriptorWrites ); 13863 return seed; 13864 } 13865 }; 13866 13867 template <> 13868 struct hash<VULKAN_HPP_NAMESPACE::PushDescriptorSetWithTemplateInfo> 13869 { operator ()std::hash13870 std::size_t operator()( VULKAN_HPP_NAMESPACE::PushDescriptorSetWithTemplateInfo const & pushDescriptorSetWithTemplateInfo ) const VULKAN_HPP_NOEXCEPT 13871 { 13872 std::size_t seed = 0; 13873 VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetWithTemplateInfo.sType ); 13874 VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetWithTemplateInfo.pNext ); 13875 VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetWithTemplateInfo.descriptorUpdateTemplate ); 13876 VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetWithTemplateInfo.layout ); 13877 VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetWithTemplateInfo.set ); 13878 VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetWithTemplateInfo.pData ); 13879 return seed; 13880 } 13881 }; 13882 13883 template <> 13884 struct hash<VULKAN_HPP_NAMESPACE::QueryLowLatencySupportNV> 13885 { operator ()std::hash13886 std::size_t operator()( VULKAN_HPP_NAMESPACE::QueryLowLatencySupportNV const & queryLowLatencySupportNV ) const VULKAN_HPP_NOEXCEPT 13887 { 13888 std::size_t seed = 0; 13889 VULKAN_HPP_HASH_COMBINE( seed, queryLowLatencySupportNV.sType ); 13890 VULKAN_HPP_HASH_COMBINE( seed, queryLowLatencySupportNV.pNext ); 13891 VULKAN_HPP_HASH_COMBINE( seed, queryLowLatencySupportNV.pQueriedLowLatencyData ); 13892 return seed; 13893 } 13894 }; 13895 13896 template <> 13897 struct hash<VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo> 13898 { operator ()std::hash13899 std::size_t operator()( VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo const & queryPoolCreateInfo ) const VULKAN_HPP_NOEXCEPT 13900 { 13901 std::size_t seed = 0; 13902 VULKAN_HPP_HASH_COMBINE( seed, queryPoolCreateInfo.sType ); 13903 VULKAN_HPP_HASH_COMBINE( seed, queryPoolCreateInfo.pNext ); 13904 VULKAN_HPP_HASH_COMBINE( seed, queryPoolCreateInfo.flags ); 13905 VULKAN_HPP_HASH_COMBINE( seed, queryPoolCreateInfo.queryType ); 13906 VULKAN_HPP_HASH_COMBINE( seed, queryPoolCreateInfo.queryCount ); 13907 VULKAN_HPP_HASH_COMBINE( seed, queryPoolCreateInfo.pipelineStatistics ); 13908 return seed; 13909 } 13910 }; 13911 13912 template <> 13913 struct hash<VULKAN_HPP_NAMESPACE::QueryPoolPerformanceCreateInfoKHR> 13914 { operator ()std::hash13915 std::size_t operator()( VULKAN_HPP_NAMESPACE::QueryPoolPerformanceCreateInfoKHR const & queryPoolPerformanceCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 13916 { 13917 std::size_t seed = 0; 13918 VULKAN_HPP_HASH_COMBINE( seed, queryPoolPerformanceCreateInfoKHR.sType ); 13919 VULKAN_HPP_HASH_COMBINE( seed, queryPoolPerformanceCreateInfoKHR.pNext ); 13920 VULKAN_HPP_HASH_COMBINE( seed, queryPoolPerformanceCreateInfoKHR.queueFamilyIndex ); 13921 VULKAN_HPP_HASH_COMBINE( seed, queryPoolPerformanceCreateInfoKHR.counterIndexCount ); 13922 VULKAN_HPP_HASH_COMBINE( seed, queryPoolPerformanceCreateInfoKHR.pCounterIndices ); 13923 return seed; 13924 } 13925 }; 13926 13927 template <> 13928 struct hash<VULKAN_HPP_NAMESPACE::QueryPoolPerformanceQueryCreateInfoINTEL> 13929 { 13930 std::size_t operator ()std::hash13931 operator()( VULKAN_HPP_NAMESPACE::QueryPoolPerformanceQueryCreateInfoINTEL const & queryPoolPerformanceQueryCreateInfoINTEL ) const VULKAN_HPP_NOEXCEPT 13932 { 13933 std::size_t seed = 0; 13934 VULKAN_HPP_HASH_COMBINE( seed, queryPoolPerformanceQueryCreateInfoINTEL.sType ); 13935 VULKAN_HPP_HASH_COMBINE( seed, queryPoolPerformanceQueryCreateInfoINTEL.pNext ); 13936 VULKAN_HPP_HASH_COMBINE( seed, queryPoolPerformanceQueryCreateInfoINTEL.performanceCountersSampling ); 13937 return seed; 13938 } 13939 }; 13940 13941 template <> 13942 struct hash<VULKAN_HPP_NAMESPACE::QueryPoolVideoEncodeFeedbackCreateInfoKHR> 13943 { 13944 std::size_t operator ()std::hash13945 operator()( VULKAN_HPP_NAMESPACE::QueryPoolVideoEncodeFeedbackCreateInfoKHR const & queryPoolVideoEncodeFeedbackCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 13946 { 13947 std::size_t seed = 0; 13948 VULKAN_HPP_HASH_COMBINE( seed, queryPoolVideoEncodeFeedbackCreateInfoKHR.sType ); 13949 VULKAN_HPP_HASH_COMBINE( seed, queryPoolVideoEncodeFeedbackCreateInfoKHR.pNext ); 13950 VULKAN_HPP_HASH_COMBINE( seed, queryPoolVideoEncodeFeedbackCreateInfoKHR.encodeFeedbackFlags ); 13951 return seed; 13952 } 13953 }; 13954 13955 template <> 13956 struct hash<VULKAN_HPP_NAMESPACE::QueueFamilyCheckpointProperties2NV> 13957 { operator ()std::hash13958 std::size_t operator()( VULKAN_HPP_NAMESPACE::QueueFamilyCheckpointProperties2NV const & queueFamilyCheckpointProperties2NV ) const VULKAN_HPP_NOEXCEPT 13959 { 13960 std::size_t seed = 0; 13961 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyCheckpointProperties2NV.sType ); 13962 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyCheckpointProperties2NV.pNext ); 13963 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyCheckpointProperties2NV.checkpointExecutionStageMask ); 13964 return seed; 13965 } 13966 }; 13967 13968 template <> 13969 struct hash<VULKAN_HPP_NAMESPACE::QueueFamilyCheckpointPropertiesNV> 13970 { operator ()std::hash13971 std::size_t operator()( VULKAN_HPP_NAMESPACE::QueueFamilyCheckpointPropertiesNV const & queueFamilyCheckpointPropertiesNV ) const VULKAN_HPP_NOEXCEPT 13972 { 13973 std::size_t seed = 0; 13974 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyCheckpointPropertiesNV.sType ); 13975 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyCheckpointPropertiesNV.pNext ); 13976 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyCheckpointPropertiesNV.checkpointExecutionStageMask ); 13977 return seed; 13978 } 13979 }; 13980 13981 template <> 13982 struct hash<VULKAN_HPP_NAMESPACE::QueueFamilyGlobalPriorityProperties> 13983 { operator ()std::hash13984 std::size_t operator()( VULKAN_HPP_NAMESPACE::QueueFamilyGlobalPriorityProperties const & queueFamilyGlobalPriorityProperties ) const VULKAN_HPP_NOEXCEPT 13985 { 13986 std::size_t seed = 0; 13987 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyGlobalPriorityProperties.sType ); 13988 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyGlobalPriorityProperties.pNext ); 13989 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyGlobalPriorityProperties.priorityCount ); 13990 for ( size_t i = 0; i < VK_MAX_GLOBAL_PRIORITY_SIZE; ++i ) 13991 { 13992 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyGlobalPriorityProperties.priorities[i] ); 13993 } 13994 return seed; 13995 } 13996 }; 13997 13998 template <> 13999 struct hash<VULKAN_HPP_NAMESPACE::QueueFamilyProperties> 14000 { operator ()std::hash14001 std::size_t operator()( VULKAN_HPP_NAMESPACE::QueueFamilyProperties const & queueFamilyProperties ) const VULKAN_HPP_NOEXCEPT 14002 { 14003 std::size_t seed = 0; 14004 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyProperties.queueFlags ); 14005 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyProperties.queueCount ); 14006 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyProperties.timestampValidBits ); 14007 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyProperties.minImageTransferGranularity ); 14008 return seed; 14009 } 14010 }; 14011 14012 template <> 14013 struct hash<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2> 14014 { operator ()std::hash14015 std::size_t operator()( VULKAN_HPP_NAMESPACE::QueueFamilyProperties2 const & queueFamilyProperties2 ) const VULKAN_HPP_NOEXCEPT 14016 { 14017 std::size_t seed = 0; 14018 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyProperties2.sType ); 14019 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyProperties2.pNext ); 14020 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyProperties2.queueFamilyProperties ); 14021 return seed; 14022 } 14023 }; 14024 14025 template <> 14026 struct hash<VULKAN_HPP_NAMESPACE::QueueFamilyQueryResultStatusPropertiesKHR> 14027 { 14028 std::size_t operator ()std::hash14029 operator()( VULKAN_HPP_NAMESPACE::QueueFamilyQueryResultStatusPropertiesKHR const & queueFamilyQueryResultStatusPropertiesKHR ) const VULKAN_HPP_NOEXCEPT 14030 { 14031 std::size_t seed = 0; 14032 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyQueryResultStatusPropertiesKHR.sType ); 14033 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyQueryResultStatusPropertiesKHR.pNext ); 14034 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyQueryResultStatusPropertiesKHR.queryResultStatusSupport ); 14035 return seed; 14036 } 14037 }; 14038 14039 template <> 14040 struct hash<VULKAN_HPP_NAMESPACE::QueueFamilyVideoPropertiesKHR> 14041 { operator ()std::hash14042 std::size_t operator()( VULKAN_HPP_NAMESPACE::QueueFamilyVideoPropertiesKHR const & queueFamilyVideoPropertiesKHR ) const VULKAN_HPP_NOEXCEPT 14043 { 14044 std::size_t seed = 0; 14045 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyVideoPropertiesKHR.sType ); 14046 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyVideoPropertiesKHR.pNext ); 14047 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyVideoPropertiesKHR.videoCodecOperations ); 14048 return seed; 14049 } 14050 }; 14051 14052 template <> 14053 struct hash<VULKAN_HPP_NAMESPACE::RayTracingShaderGroupCreateInfoKHR> 14054 { operator ()std::hash14055 std::size_t operator()( VULKAN_HPP_NAMESPACE::RayTracingShaderGroupCreateInfoKHR const & rayTracingShaderGroupCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 14056 { 14057 std::size_t seed = 0; 14058 VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoKHR.sType ); 14059 VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoKHR.pNext ); 14060 VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoKHR.type ); 14061 VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoKHR.generalShader ); 14062 VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoKHR.closestHitShader ); 14063 VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoKHR.anyHitShader ); 14064 VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoKHR.intersectionShader ); 14065 VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoKHR.pShaderGroupCaptureReplayHandle ); 14066 return seed; 14067 } 14068 }; 14069 14070 template <> 14071 struct hash<VULKAN_HPP_NAMESPACE::RayTracingPipelineInterfaceCreateInfoKHR> 14072 { 14073 std::size_t operator ()std::hash14074 operator()( VULKAN_HPP_NAMESPACE::RayTracingPipelineInterfaceCreateInfoKHR const & rayTracingPipelineInterfaceCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 14075 { 14076 std::size_t seed = 0; 14077 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineInterfaceCreateInfoKHR.sType ); 14078 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineInterfaceCreateInfoKHR.pNext ); 14079 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineInterfaceCreateInfoKHR.maxPipelineRayPayloadSize ); 14080 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineInterfaceCreateInfoKHR.maxPipelineRayHitAttributeSize ); 14081 return seed; 14082 } 14083 }; 14084 14085 template <> 14086 struct hash<VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> 14087 { operator ()std::hash14088 std::size_t operator()( VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR const & rayTracingPipelineCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 14089 { 14090 std::size_t seed = 0; 14091 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.sType ); 14092 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.pNext ); 14093 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.flags ); 14094 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.stageCount ); 14095 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.pStages ); 14096 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.groupCount ); 14097 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.pGroups ); 14098 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.maxPipelineRayRecursionDepth ); 14099 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.pLibraryInfo ); 14100 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.pLibraryInterface ); 14101 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.pDynamicState ); 14102 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.layout ); 14103 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.basePipelineHandle ); 14104 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.basePipelineIndex ); 14105 return seed; 14106 } 14107 }; 14108 14109 template <> 14110 struct hash<VULKAN_HPP_NAMESPACE::RayTracingShaderGroupCreateInfoNV> 14111 { operator ()std::hash14112 std::size_t operator()( VULKAN_HPP_NAMESPACE::RayTracingShaderGroupCreateInfoNV const & rayTracingShaderGroupCreateInfoNV ) const VULKAN_HPP_NOEXCEPT 14113 { 14114 std::size_t seed = 0; 14115 VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoNV.sType ); 14116 VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoNV.pNext ); 14117 VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoNV.type ); 14118 VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoNV.generalShader ); 14119 VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoNV.closestHitShader ); 14120 VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoNV.anyHitShader ); 14121 VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoNV.intersectionShader ); 14122 return seed; 14123 } 14124 }; 14125 14126 template <> 14127 struct hash<VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> 14128 { operator ()std::hash14129 std::size_t operator()( VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV const & rayTracingPipelineCreateInfoNV ) const VULKAN_HPP_NOEXCEPT 14130 { 14131 std::size_t seed = 0; 14132 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.sType ); 14133 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.pNext ); 14134 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.flags ); 14135 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.stageCount ); 14136 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.pStages ); 14137 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.groupCount ); 14138 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.pGroups ); 14139 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.maxRecursionDepth ); 14140 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.layout ); 14141 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.basePipelineHandle ); 14142 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.basePipelineIndex ); 14143 return seed; 14144 } 14145 }; 14146 14147 template <> 14148 struct hash<VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE> 14149 { operator ()std::hash14150 std::size_t operator()( VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE const & refreshCycleDurationGOOGLE ) const VULKAN_HPP_NOEXCEPT 14151 { 14152 std::size_t seed = 0; 14153 VULKAN_HPP_HASH_COMBINE( seed, refreshCycleDurationGOOGLE.refreshDuration ); 14154 return seed; 14155 } 14156 }; 14157 14158 template <> 14159 struct hash<VULKAN_HPP_NAMESPACE::ReleaseCapturedPipelineDataInfoKHR> 14160 { operator ()std::hash14161 std::size_t operator()( VULKAN_HPP_NAMESPACE::ReleaseCapturedPipelineDataInfoKHR const & releaseCapturedPipelineDataInfoKHR ) const VULKAN_HPP_NOEXCEPT 14162 { 14163 std::size_t seed = 0; 14164 VULKAN_HPP_HASH_COMBINE( seed, releaseCapturedPipelineDataInfoKHR.sType ); 14165 VULKAN_HPP_HASH_COMBINE( seed, releaseCapturedPipelineDataInfoKHR.pNext ); 14166 VULKAN_HPP_HASH_COMBINE( seed, releaseCapturedPipelineDataInfoKHR.pipeline ); 14167 return seed; 14168 } 14169 }; 14170 14171 template <> 14172 struct hash<VULKAN_HPP_NAMESPACE::ReleaseSwapchainImagesInfoEXT> 14173 { operator ()std::hash14174 std::size_t operator()( VULKAN_HPP_NAMESPACE::ReleaseSwapchainImagesInfoEXT const & releaseSwapchainImagesInfoEXT ) const VULKAN_HPP_NOEXCEPT 14175 { 14176 std::size_t seed = 0; 14177 VULKAN_HPP_HASH_COMBINE( seed, releaseSwapchainImagesInfoEXT.sType ); 14178 VULKAN_HPP_HASH_COMBINE( seed, releaseSwapchainImagesInfoEXT.pNext ); 14179 VULKAN_HPP_HASH_COMBINE( seed, releaseSwapchainImagesInfoEXT.swapchain ); 14180 VULKAN_HPP_HASH_COMBINE( seed, releaseSwapchainImagesInfoEXT.imageIndexCount ); 14181 VULKAN_HPP_HASH_COMBINE( seed, releaseSwapchainImagesInfoEXT.pImageIndices ); 14182 return seed; 14183 } 14184 }; 14185 14186 template <> 14187 struct hash<VULKAN_HPP_NAMESPACE::RenderPassAttachmentBeginInfo> 14188 { operator ()std::hash14189 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassAttachmentBeginInfo const & renderPassAttachmentBeginInfo ) const VULKAN_HPP_NOEXCEPT 14190 { 14191 std::size_t seed = 0; 14192 VULKAN_HPP_HASH_COMBINE( seed, renderPassAttachmentBeginInfo.sType ); 14193 VULKAN_HPP_HASH_COMBINE( seed, renderPassAttachmentBeginInfo.pNext ); 14194 VULKAN_HPP_HASH_COMBINE( seed, renderPassAttachmentBeginInfo.attachmentCount ); 14195 VULKAN_HPP_HASH_COMBINE( seed, renderPassAttachmentBeginInfo.pAttachments ); 14196 return seed; 14197 } 14198 }; 14199 14200 template <> 14201 struct hash<VULKAN_HPP_NAMESPACE::RenderPassBeginInfo> 14202 { operator ()std::hash14203 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassBeginInfo const & renderPassBeginInfo ) const VULKAN_HPP_NOEXCEPT 14204 { 14205 std::size_t seed = 0; 14206 VULKAN_HPP_HASH_COMBINE( seed, renderPassBeginInfo.sType ); 14207 VULKAN_HPP_HASH_COMBINE( seed, renderPassBeginInfo.pNext ); 14208 VULKAN_HPP_HASH_COMBINE( seed, renderPassBeginInfo.renderPass ); 14209 VULKAN_HPP_HASH_COMBINE( seed, renderPassBeginInfo.framebuffer ); 14210 VULKAN_HPP_HASH_COMBINE( seed, renderPassBeginInfo.renderArea ); 14211 VULKAN_HPP_HASH_COMBINE( seed, renderPassBeginInfo.clearValueCount ); 14212 VULKAN_HPP_HASH_COMBINE( seed, renderPassBeginInfo.pClearValues ); 14213 return seed; 14214 } 14215 }; 14216 14217 template <> 14218 struct hash<VULKAN_HPP_NAMESPACE::SubpassDescription> 14219 { operator ()std::hash14220 std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassDescription const & subpassDescription ) const VULKAN_HPP_NOEXCEPT 14221 { 14222 std::size_t seed = 0; 14223 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.flags ); 14224 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.pipelineBindPoint ); 14225 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.inputAttachmentCount ); 14226 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.pInputAttachments ); 14227 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.colorAttachmentCount ); 14228 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.pColorAttachments ); 14229 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.pResolveAttachments ); 14230 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.pDepthStencilAttachment ); 14231 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.preserveAttachmentCount ); 14232 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.pPreserveAttachments ); 14233 return seed; 14234 } 14235 }; 14236 14237 template <> 14238 struct hash<VULKAN_HPP_NAMESPACE::SubpassDependency> 14239 { operator ()std::hash14240 std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassDependency const & subpassDependency ) const VULKAN_HPP_NOEXCEPT 14241 { 14242 std::size_t seed = 0; 14243 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency.srcSubpass ); 14244 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency.dstSubpass ); 14245 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency.srcStageMask ); 14246 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency.dstStageMask ); 14247 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency.srcAccessMask ); 14248 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency.dstAccessMask ); 14249 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency.dependencyFlags ); 14250 return seed; 14251 } 14252 }; 14253 14254 template <> 14255 struct hash<VULKAN_HPP_NAMESPACE::RenderPassCreateInfo> 14256 { operator ()std::hash14257 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassCreateInfo const & renderPassCreateInfo ) const VULKAN_HPP_NOEXCEPT 14258 { 14259 std::size_t seed = 0; 14260 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo.sType ); 14261 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo.pNext ); 14262 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo.flags ); 14263 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo.attachmentCount ); 14264 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo.pAttachments ); 14265 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo.subpassCount ); 14266 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo.pSubpasses ); 14267 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo.dependencyCount ); 14268 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo.pDependencies ); 14269 return seed; 14270 } 14271 }; 14272 14273 template <> 14274 struct hash<VULKAN_HPP_NAMESPACE::SubpassDescription2> 14275 { operator ()std::hash14276 std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassDescription2 const & subpassDescription2 ) const VULKAN_HPP_NOEXCEPT 14277 { 14278 std::size_t seed = 0; 14279 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.sType ); 14280 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.pNext ); 14281 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.flags ); 14282 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.pipelineBindPoint ); 14283 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.viewMask ); 14284 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.inputAttachmentCount ); 14285 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.pInputAttachments ); 14286 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.colorAttachmentCount ); 14287 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.pColorAttachments ); 14288 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.pResolveAttachments ); 14289 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.pDepthStencilAttachment ); 14290 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.preserveAttachmentCount ); 14291 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.pPreserveAttachments ); 14292 return seed; 14293 } 14294 }; 14295 14296 template <> 14297 struct hash<VULKAN_HPP_NAMESPACE::SubpassDependency2> 14298 { operator ()std::hash14299 std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassDependency2 const & subpassDependency2 ) const VULKAN_HPP_NOEXCEPT 14300 { 14301 std::size_t seed = 0; 14302 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.sType ); 14303 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.pNext ); 14304 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.srcSubpass ); 14305 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.dstSubpass ); 14306 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.srcStageMask ); 14307 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.dstStageMask ); 14308 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.srcAccessMask ); 14309 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.dstAccessMask ); 14310 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.dependencyFlags ); 14311 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.viewOffset ); 14312 return seed; 14313 } 14314 }; 14315 14316 template <> 14317 struct hash<VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2> 14318 { operator ()std::hash14319 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 const & renderPassCreateInfo2 ) const VULKAN_HPP_NOEXCEPT 14320 { 14321 std::size_t seed = 0; 14322 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.sType ); 14323 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.pNext ); 14324 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.flags ); 14325 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.attachmentCount ); 14326 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.pAttachments ); 14327 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.subpassCount ); 14328 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.pSubpasses ); 14329 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.dependencyCount ); 14330 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.pDependencies ); 14331 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.correlatedViewMaskCount ); 14332 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.pCorrelatedViewMasks ); 14333 return seed; 14334 } 14335 }; 14336 14337 template <> 14338 struct hash<VULKAN_HPP_NAMESPACE::RenderPassCreationControlEXT> 14339 { operator ()std::hash14340 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassCreationControlEXT const & renderPassCreationControlEXT ) const VULKAN_HPP_NOEXCEPT 14341 { 14342 std::size_t seed = 0; 14343 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreationControlEXT.sType ); 14344 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreationControlEXT.pNext ); 14345 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreationControlEXT.disallowMerging ); 14346 return seed; 14347 } 14348 }; 14349 14350 template <> 14351 struct hash<VULKAN_HPP_NAMESPACE::RenderPassCreationFeedbackInfoEXT> 14352 { operator ()std::hash14353 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassCreationFeedbackInfoEXT const & renderPassCreationFeedbackInfoEXT ) const VULKAN_HPP_NOEXCEPT 14354 { 14355 std::size_t seed = 0; 14356 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreationFeedbackInfoEXT.postMergeSubpassCount ); 14357 return seed; 14358 } 14359 }; 14360 14361 template <> 14362 struct hash<VULKAN_HPP_NAMESPACE::RenderPassCreationFeedbackCreateInfoEXT> 14363 { 14364 std::size_t operator ()std::hash14365 operator()( VULKAN_HPP_NAMESPACE::RenderPassCreationFeedbackCreateInfoEXT const & renderPassCreationFeedbackCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 14366 { 14367 std::size_t seed = 0; 14368 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreationFeedbackCreateInfoEXT.sType ); 14369 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreationFeedbackCreateInfoEXT.pNext ); 14370 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreationFeedbackCreateInfoEXT.pRenderPassFeedback ); 14371 return seed; 14372 } 14373 }; 14374 14375 template <> 14376 struct hash<VULKAN_HPP_NAMESPACE::RenderPassFragmentDensityMapCreateInfoEXT> 14377 { 14378 std::size_t operator ()std::hash14379 operator()( VULKAN_HPP_NAMESPACE::RenderPassFragmentDensityMapCreateInfoEXT const & renderPassFragmentDensityMapCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 14380 { 14381 std::size_t seed = 0; 14382 VULKAN_HPP_HASH_COMBINE( seed, renderPassFragmentDensityMapCreateInfoEXT.sType ); 14383 VULKAN_HPP_HASH_COMBINE( seed, renderPassFragmentDensityMapCreateInfoEXT.pNext ); 14384 VULKAN_HPP_HASH_COMBINE( seed, renderPassFragmentDensityMapCreateInfoEXT.fragmentDensityMapAttachment ); 14385 return seed; 14386 } 14387 }; 14388 14389 template <> 14390 struct hash<VULKAN_HPP_NAMESPACE::RenderPassInputAttachmentAspectCreateInfo> 14391 { 14392 std::size_t operator ()std::hash14393 operator()( VULKAN_HPP_NAMESPACE::RenderPassInputAttachmentAspectCreateInfo const & renderPassInputAttachmentAspectCreateInfo ) const VULKAN_HPP_NOEXCEPT 14394 { 14395 std::size_t seed = 0; 14396 VULKAN_HPP_HASH_COMBINE( seed, renderPassInputAttachmentAspectCreateInfo.sType ); 14397 VULKAN_HPP_HASH_COMBINE( seed, renderPassInputAttachmentAspectCreateInfo.pNext ); 14398 VULKAN_HPP_HASH_COMBINE( seed, renderPassInputAttachmentAspectCreateInfo.aspectReferenceCount ); 14399 VULKAN_HPP_HASH_COMBINE( seed, renderPassInputAttachmentAspectCreateInfo.pAspectReferences ); 14400 return seed; 14401 } 14402 }; 14403 14404 template <> 14405 struct hash<VULKAN_HPP_NAMESPACE::RenderPassMultiviewCreateInfo> 14406 { operator ()std::hash14407 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassMultiviewCreateInfo const & renderPassMultiviewCreateInfo ) const VULKAN_HPP_NOEXCEPT 14408 { 14409 std::size_t seed = 0; 14410 VULKAN_HPP_HASH_COMBINE( seed, renderPassMultiviewCreateInfo.sType ); 14411 VULKAN_HPP_HASH_COMBINE( seed, renderPassMultiviewCreateInfo.pNext ); 14412 VULKAN_HPP_HASH_COMBINE( seed, renderPassMultiviewCreateInfo.subpassCount ); 14413 VULKAN_HPP_HASH_COMBINE( seed, renderPassMultiviewCreateInfo.pViewMasks ); 14414 VULKAN_HPP_HASH_COMBINE( seed, renderPassMultiviewCreateInfo.dependencyCount ); 14415 VULKAN_HPP_HASH_COMBINE( seed, renderPassMultiviewCreateInfo.pViewOffsets ); 14416 VULKAN_HPP_HASH_COMBINE( seed, renderPassMultiviewCreateInfo.correlationMaskCount ); 14417 VULKAN_HPP_HASH_COMBINE( seed, renderPassMultiviewCreateInfo.pCorrelationMasks ); 14418 return seed; 14419 } 14420 }; 14421 14422 template <> 14423 struct hash<VULKAN_HPP_NAMESPACE::SubpassSampleLocationsEXT> 14424 { operator ()std::hash14425 std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassSampleLocationsEXT const & subpassSampleLocationsEXT ) const VULKAN_HPP_NOEXCEPT 14426 { 14427 std::size_t seed = 0; 14428 VULKAN_HPP_HASH_COMBINE( seed, subpassSampleLocationsEXT.subpassIndex ); 14429 VULKAN_HPP_HASH_COMBINE( seed, subpassSampleLocationsEXT.sampleLocationsInfo ); 14430 return seed; 14431 } 14432 }; 14433 14434 template <> 14435 struct hash<VULKAN_HPP_NAMESPACE::RenderPassSampleLocationsBeginInfoEXT> 14436 { 14437 std::size_t operator ()std::hash14438 operator()( VULKAN_HPP_NAMESPACE::RenderPassSampleLocationsBeginInfoEXT const & renderPassSampleLocationsBeginInfoEXT ) const VULKAN_HPP_NOEXCEPT 14439 { 14440 std::size_t seed = 0; 14441 VULKAN_HPP_HASH_COMBINE( seed, renderPassSampleLocationsBeginInfoEXT.sType ); 14442 VULKAN_HPP_HASH_COMBINE( seed, renderPassSampleLocationsBeginInfoEXT.pNext ); 14443 VULKAN_HPP_HASH_COMBINE( seed, renderPassSampleLocationsBeginInfoEXT.attachmentInitialSampleLocationsCount ); 14444 VULKAN_HPP_HASH_COMBINE( seed, renderPassSampleLocationsBeginInfoEXT.pAttachmentInitialSampleLocations ); 14445 VULKAN_HPP_HASH_COMBINE( seed, renderPassSampleLocationsBeginInfoEXT.postSubpassSampleLocationsCount ); 14446 VULKAN_HPP_HASH_COMBINE( seed, renderPassSampleLocationsBeginInfoEXT.pPostSubpassSampleLocations ); 14447 return seed; 14448 } 14449 }; 14450 14451 template <> 14452 struct hash<VULKAN_HPP_NAMESPACE::RenderPassStripeInfoARM> 14453 { operator ()std::hash14454 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassStripeInfoARM const & renderPassStripeInfoARM ) const VULKAN_HPP_NOEXCEPT 14455 { 14456 std::size_t seed = 0; 14457 VULKAN_HPP_HASH_COMBINE( seed, renderPassStripeInfoARM.sType ); 14458 VULKAN_HPP_HASH_COMBINE( seed, renderPassStripeInfoARM.pNext ); 14459 VULKAN_HPP_HASH_COMBINE( seed, renderPassStripeInfoARM.stripeArea ); 14460 return seed; 14461 } 14462 }; 14463 14464 template <> 14465 struct hash<VULKAN_HPP_NAMESPACE::RenderPassStripeBeginInfoARM> 14466 { operator ()std::hash14467 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassStripeBeginInfoARM const & renderPassStripeBeginInfoARM ) const VULKAN_HPP_NOEXCEPT 14468 { 14469 std::size_t seed = 0; 14470 VULKAN_HPP_HASH_COMBINE( seed, renderPassStripeBeginInfoARM.sType ); 14471 VULKAN_HPP_HASH_COMBINE( seed, renderPassStripeBeginInfoARM.pNext ); 14472 VULKAN_HPP_HASH_COMBINE( seed, renderPassStripeBeginInfoARM.stripeInfoCount ); 14473 VULKAN_HPP_HASH_COMBINE( seed, renderPassStripeBeginInfoARM.pStripeInfos ); 14474 return seed; 14475 } 14476 }; 14477 14478 template <> 14479 struct hash<VULKAN_HPP_NAMESPACE::SemaphoreSubmitInfo> 14480 { operator ()std::hash14481 std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreSubmitInfo const & semaphoreSubmitInfo ) const VULKAN_HPP_NOEXCEPT 14482 { 14483 std::size_t seed = 0; 14484 VULKAN_HPP_HASH_COMBINE( seed, semaphoreSubmitInfo.sType ); 14485 VULKAN_HPP_HASH_COMBINE( seed, semaphoreSubmitInfo.pNext ); 14486 VULKAN_HPP_HASH_COMBINE( seed, semaphoreSubmitInfo.semaphore ); 14487 VULKAN_HPP_HASH_COMBINE( seed, semaphoreSubmitInfo.value ); 14488 VULKAN_HPP_HASH_COMBINE( seed, semaphoreSubmitInfo.stageMask ); 14489 VULKAN_HPP_HASH_COMBINE( seed, semaphoreSubmitInfo.deviceIndex ); 14490 return seed; 14491 } 14492 }; 14493 14494 template <> 14495 struct hash<VULKAN_HPP_NAMESPACE::RenderPassStripeSubmitInfoARM> 14496 { operator ()std::hash14497 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassStripeSubmitInfoARM const & renderPassStripeSubmitInfoARM ) const VULKAN_HPP_NOEXCEPT 14498 { 14499 std::size_t seed = 0; 14500 VULKAN_HPP_HASH_COMBINE( seed, renderPassStripeSubmitInfoARM.sType ); 14501 VULKAN_HPP_HASH_COMBINE( seed, renderPassStripeSubmitInfoARM.pNext ); 14502 VULKAN_HPP_HASH_COMBINE( seed, renderPassStripeSubmitInfoARM.stripeSemaphoreInfoCount ); 14503 VULKAN_HPP_HASH_COMBINE( seed, renderPassStripeSubmitInfoARM.pStripeSemaphoreInfos ); 14504 return seed; 14505 } 14506 }; 14507 14508 template <> 14509 struct hash<VULKAN_HPP_NAMESPACE::RenderPassSubpassFeedbackInfoEXT> 14510 { operator ()std::hash14511 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassSubpassFeedbackInfoEXT const & renderPassSubpassFeedbackInfoEXT ) const VULKAN_HPP_NOEXCEPT 14512 { 14513 std::size_t seed = 0; 14514 VULKAN_HPP_HASH_COMBINE( seed, renderPassSubpassFeedbackInfoEXT.subpassMergeStatus ); 14515 for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) 14516 { 14517 VULKAN_HPP_HASH_COMBINE( seed, renderPassSubpassFeedbackInfoEXT.description[i] ); 14518 } 14519 VULKAN_HPP_HASH_COMBINE( seed, renderPassSubpassFeedbackInfoEXT.postMergeIndex ); 14520 return seed; 14521 } 14522 }; 14523 14524 template <> 14525 struct hash<VULKAN_HPP_NAMESPACE::RenderPassSubpassFeedbackCreateInfoEXT> 14526 { 14527 std::size_t operator ()std::hash14528 operator()( VULKAN_HPP_NAMESPACE::RenderPassSubpassFeedbackCreateInfoEXT const & renderPassSubpassFeedbackCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 14529 { 14530 std::size_t seed = 0; 14531 VULKAN_HPP_HASH_COMBINE( seed, renderPassSubpassFeedbackCreateInfoEXT.sType ); 14532 VULKAN_HPP_HASH_COMBINE( seed, renderPassSubpassFeedbackCreateInfoEXT.pNext ); 14533 VULKAN_HPP_HASH_COMBINE( seed, renderPassSubpassFeedbackCreateInfoEXT.pSubpassFeedback ); 14534 return seed; 14535 } 14536 }; 14537 14538 template <> 14539 struct hash<VULKAN_HPP_NAMESPACE::RenderPassTransformBeginInfoQCOM> 14540 { operator ()std::hash14541 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassTransformBeginInfoQCOM const & renderPassTransformBeginInfoQCOM ) const VULKAN_HPP_NOEXCEPT 14542 { 14543 std::size_t seed = 0; 14544 VULKAN_HPP_HASH_COMBINE( seed, renderPassTransformBeginInfoQCOM.sType ); 14545 VULKAN_HPP_HASH_COMBINE( seed, renderPassTransformBeginInfoQCOM.pNext ); 14546 VULKAN_HPP_HASH_COMBINE( seed, renderPassTransformBeginInfoQCOM.transform ); 14547 return seed; 14548 } 14549 }; 14550 14551 template <> 14552 struct hash<VULKAN_HPP_NAMESPACE::RenderingAreaInfo> 14553 { operator ()std::hash14554 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderingAreaInfo const & renderingAreaInfo ) const VULKAN_HPP_NOEXCEPT 14555 { 14556 std::size_t seed = 0; 14557 VULKAN_HPP_HASH_COMBINE( seed, renderingAreaInfo.sType ); 14558 VULKAN_HPP_HASH_COMBINE( seed, renderingAreaInfo.pNext ); 14559 VULKAN_HPP_HASH_COMBINE( seed, renderingAreaInfo.viewMask ); 14560 VULKAN_HPP_HASH_COMBINE( seed, renderingAreaInfo.colorAttachmentCount ); 14561 VULKAN_HPP_HASH_COMBINE( seed, renderingAreaInfo.pColorAttachmentFormats ); 14562 VULKAN_HPP_HASH_COMBINE( seed, renderingAreaInfo.depthAttachmentFormat ); 14563 VULKAN_HPP_HASH_COMBINE( seed, renderingAreaInfo.stencilAttachmentFormat ); 14564 return seed; 14565 } 14566 }; 14567 14568 template <> 14569 struct hash<VULKAN_HPP_NAMESPACE::RenderingAttachmentLocationInfo> 14570 { operator ()std::hash14571 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderingAttachmentLocationInfo const & renderingAttachmentLocationInfo ) const VULKAN_HPP_NOEXCEPT 14572 { 14573 std::size_t seed = 0; 14574 VULKAN_HPP_HASH_COMBINE( seed, renderingAttachmentLocationInfo.sType ); 14575 VULKAN_HPP_HASH_COMBINE( seed, renderingAttachmentLocationInfo.pNext ); 14576 VULKAN_HPP_HASH_COMBINE( seed, renderingAttachmentLocationInfo.colorAttachmentCount ); 14577 VULKAN_HPP_HASH_COMBINE( seed, renderingAttachmentLocationInfo.pColorAttachmentLocations ); 14578 return seed; 14579 } 14580 }; 14581 14582 template <> 14583 struct hash<VULKAN_HPP_NAMESPACE::RenderingFragmentDensityMapAttachmentInfoEXT> 14584 { operator ()std::hash14585 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderingFragmentDensityMapAttachmentInfoEXT const & renderingFragmentDensityMapAttachmentInfoEXT ) const 14586 VULKAN_HPP_NOEXCEPT 14587 { 14588 std::size_t seed = 0; 14589 VULKAN_HPP_HASH_COMBINE( seed, renderingFragmentDensityMapAttachmentInfoEXT.sType ); 14590 VULKAN_HPP_HASH_COMBINE( seed, renderingFragmentDensityMapAttachmentInfoEXT.pNext ); 14591 VULKAN_HPP_HASH_COMBINE( seed, renderingFragmentDensityMapAttachmentInfoEXT.imageView ); 14592 VULKAN_HPP_HASH_COMBINE( seed, renderingFragmentDensityMapAttachmentInfoEXT.imageLayout ); 14593 return seed; 14594 } 14595 }; 14596 14597 template <> 14598 struct hash<VULKAN_HPP_NAMESPACE::RenderingFragmentShadingRateAttachmentInfoKHR> 14599 { operator ()std::hash14600 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderingFragmentShadingRateAttachmentInfoKHR const & renderingFragmentShadingRateAttachmentInfoKHR ) const 14601 VULKAN_HPP_NOEXCEPT 14602 { 14603 std::size_t seed = 0; 14604 VULKAN_HPP_HASH_COMBINE( seed, renderingFragmentShadingRateAttachmentInfoKHR.sType ); 14605 VULKAN_HPP_HASH_COMBINE( seed, renderingFragmentShadingRateAttachmentInfoKHR.pNext ); 14606 VULKAN_HPP_HASH_COMBINE( seed, renderingFragmentShadingRateAttachmentInfoKHR.imageView ); 14607 VULKAN_HPP_HASH_COMBINE( seed, renderingFragmentShadingRateAttachmentInfoKHR.imageLayout ); 14608 VULKAN_HPP_HASH_COMBINE( seed, renderingFragmentShadingRateAttachmentInfoKHR.shadingRateAttachmentTexelSize ); 14609 return seed; 14610 } 14611 }; 14612 14613 template <> 14614 struct hash<VULKAN_HPP_NAMESPACE::RenderingInfo> 14615 { operator ()std::hash14616 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderingInfo const & renderingInfo ) const VULKAN_HPP_NOEXCEPT 14617 { 14618 std::size_t seed = 0; 14619 VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.sType ); 14620 VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.pNext ); 14621 VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.flags ); 14622 VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.renderArea ); 14623 VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.layerCount ); 14624 VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.viewMask ); 14625 VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.colorAttachmentCount ); 14626 VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.pColorAttachments ); 14627 VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.pDepthAttachment ); 14628 VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.pStencilAttachment ); 14629 return seed; 14630 } 14631 }; 14632 14633 template <> 14634 struct hash<VULKAN_HPP_NAMESPACE::RenderingInputAttachmentIndexInfo> 14635 { operator ()std::hash14636 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderingInputAttachmentIndexInfo const & renderingInputAttachmentIndexInfo ) const VULKAN_HPP_NOEXCEPT 14637 { 14638 std::size_t seed = 0; 14639 VULKAN_HPP_HASH_COMBINE( seed, renderingInputAttachmentIndexInfo.sType ); 14640 VULKAN_HPP_HASH_COMBINE( seed, renderingInputAttachmentIndexInfo.pNext ); 14641 VULKAN_HPP_HASH_COMBINE( seed, renderingInputAttachmentIndexInfo.colorAttachmentCount ); 14642 VULKAN_HPP_HASH_COMBINE( seed, renderingInputAttachmentIndexInfo.pColorAttachmentInputIndices ); 14643 VULKAN_HPP_HASH_COMBINE( seed, renderingInputAttachmentIndexInfo.pDepthInputAttachmentIndex ); 14644 VULKAN_HPP_HASH_COMBINE( seed, renderingInputAttachmentIndexInfo.pStencilInputAttachmentIndex ); 14645 return seed; 14646 } 14647 }; 14648 14649 template <> 14650 struct hash<VULKAN_HPP_NAMESPACE::ResolveImageInfo2> 14651 { operator ()std::hash14652 std::size_t operator()( VULKAN_HPP_NAMESPACE::ResolveImageInfo2 const & resolveImageInfo2 ) const VULKAN_HPP_NOEXCEPT 14653 { 14654 std::size_t seed = 0; 14655 VULKAN_HPP_HASH_COMBINE( seed, resolveImageInfo2.sType ); 14656 VULKAN_HPP_HASH_COMBINE( seed, resolveImageInfo2.pNext ); 14657 VULKAN_HPP_HASH_COMBINE( seed, resolveImageInfo2.srcImage ); 14658 VULKAN_HPP_HASH_COMBINE( seed, resolveImageInfo2.srcImageLayout ); 14659 VULKAN_HPP_HASH_COMBINE( seed, resolveImageInfo2.dstImage ); 14660 VULKAN_HPP_HASH_COMBINE( seed, resolveImageInfo2.dstImageLayout ); 14661 VULKAN_HPP_HASH_COMBINE( seed, resolveImageInfo2.regionCount ); 14662 VULKAN_HPP_HASH_COMBINE( seed, resolveImageInfo2.pRegions ); 14663 return seed; 14664 } 14665 }; 14666 14667 template <> 14668 struct hash<VULKAN_HPP_NAMESPACE::SamplerBlockMatchWindowCreateInfoQCOM> 14669 { 14670 std::size_t operator ()std::hash14671 operator()( VULKAN_HPP_NAMESPACE::SamplerBlockMatchWindowCreateInfoQCOM const & samplerBlockMatchWindowCreateInfoQCOM ) const VULKAN_HPP_NOEXCEPT 14672 { 14673 std::size_t seed = 0; 14674 VULKAN_HPP_HASH_COMBINE( seed, samplerBlockMatchWindowCreateInfoQCOM.sType ); 14675 VULKAN_HPP_HASH_COMBINE( seed, samplerBlockMatchWindowCreateInfoQCOM.pNext ); 14676 VULKAN_HPP_HASH_COMBINE( seed, samplerBlockMatchWindowCreateInfoQCOM.windowExtent ); 14677 VULKAN_HPP_HASH_COMBINE( seed, samplerBlockMatchWindowCreateInfoQCOM.windowCompareMode ); 14678 return seed; 14679 } 14680 }; 14681 14682 template <> 14683 struct hash<VULKAN_HPP_NAMESPACE::SamplerBorderColorComponentMappingCreateInfoEXT> 14684 { operator ()std::hash14685 std::size_t operator()( 14686 VULKAN_HPP_NAMESPACE::SamplerBorderColorComponentMappingCreateInfoEXT const & samplerBorderColorComponentMappingCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 14687 { 14688 std::size_t seed = 0; 14689 VULKAN_HPP_HASH_COMBINE( seed, samplerBorderColorComponentMappingCreateInfoEXT.sType ); 14690 VULKAN_HPP_HASH_COMBINE( seed, samplerBorderColorComponentMappingCreateInfoEXT.pNext ); 14691 VULKAN_HPP_HASH_COMBINE( seed, samplerBorderColorComponentMappingCreateInfoEXT.components ); 14692 VULKAN_HPP_HASH_COMBINE( seed, samplerBorderColorComponentMappingCreateInfoEXT.srgb ); 14693 return seed; 14694 } 14695 }; 14696 14697 template <> 14698 struct hash<VULKAN_HPP_NAMESPACE::SamplerCaptureDescriptorDataInfoEXT> 14699 { operator ()std::hash14700 std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerCaptureDescriptorDataInfoEXT const & samplerCaptureDescriptorDataInfoEXT ) const VULKAN_HPP_NOEXCEPT 14701 { 14702 std::size_t seed = 0; 14703 VULKAN_HPP_HASH_COMBINE( seed, samplerCaptureDescriptorDataInfoEXT.sType ); 14704 VULKAN_HPP_HASH_COMBINE( seed, samplerCaptureDescriptorDataInfoEXT.pNext ); 14705 VULKAN_HPP_HASH_COMBINE( seed, samplerCaptureDescriptorDataInfoEXT.sampler ); 14706 return seed; 14707 } 14708 }; 14709 14710 template <> 14711 struct hash<VULKAN_HPP_NAMESPACE::SamplerCreateInfo> 14712 { operator ()std::hash14713 std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerCreateInfo const & samplerCreateInfo ) const VULKAN_HPP_NOEXCEPT 14714 { 14715 std::size_t seed = 0; 14716 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.sType ); 14717 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.pNext ); 14718 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.flags ); 14719 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.magFilter ); 14720 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.minFilter ); 14721 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.mipmapMode ); 14722 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.addressModeU ); 14723 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.addressModeV ); 14724 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.addressModeW ); 14725 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.mipLodBias ); 14726 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.anisotropyEnable ); 14727 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.maxAnisotropy ); 14728 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.compareEnable ); 14729 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.compareOp ); 14730 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.minLod ); 14731 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.maxLod ); 14732 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.borderColor ); 14733 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.unnormalizedCoordinates ); 14734 return seed; 14735 } 14736 }; 14737 14738 template <> 14739 struct hash<VULKAN_HPP_NAMESPACE::SamplerCubicWeightsCreateInfoQCOM> 14740 { operator ()std::hash14741 std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerCubicWeightsCreateInfoQCOM const & samplerCubicWeightsCreateInfoQCOM ) const VULKAN_HPP_NOEXCEPT 14742 { 14743 std::size_t seed = 0; 14744 VULKAN_HPP_HASH_COMBINE( seed, samplerCubicWeightsCreateInfoQCOM.sType ); 14745 VULKAN_HPP_HASH_COMBINE( seed, samplerCubicWeightsCreateInfoQCOM.pNext ); 14746 VULKAN_HPP_HASH_COMBINE( seed, samplerCubicWeightsCreateInfoQCOM.cubicWeights ); 14747 return seed; 14748 } 14749 }; 14750 14751 template <> 14752 struct hash<VULKAN_HPP_NAMESPACE::SamplerReductionModeCreateInfo> 14753 { operator ()std::hash14754 std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerReductionModeCreateInfo const & samplerReductionModeCreateInfo ) const VULKAN_HPP_NOEXCEPT 14755 { 14756 std::size_t seed = 0; 14757 VULKAN_HPP_HASH_COMBINE( seed, samplerReductionModeCreateInfo.sType ); 14758 VULKAN_HPP_HASH_COMBINE( seed, samplerReductionModeCreateInfo.pNext ); 14759 VULKAN_HPP_HASH_COMBINE( seed, samplerReductionModeCreateInfo.reductionMode ); 14760 return seed; 14761 } 14762 }; 14763 14764 template <> 14765 struct hash<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo> 14766 { operator ()std::hash14767 std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo const & samplerYcbcrConversionCreateInfo ) const VULKAN_HPP_NOEXCEPT 14768 { 14769 std::size_t seed = 0; 14770 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.sType ); 14771 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.pNext ); 14772 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.format ); 14773 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.ycbcrModel ); 14774 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.ycbcrRange ); 14775 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.components ); 14776 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.xChromaOffset ); 14777 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.yChromaOffset ); 14778 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.chromaFilter ); 14779 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.forceExplicitReconstruction ); 14780 return seed; 14781 } 14782 }; 14783 14784 template <> 14785 struct hash<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionImageFormatProperties> 14786 { operator ()std::hash14787 std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionImageFormatProperties const & samplerYcbcrConversionImageFormatProperties ) const 14788 VULKAN_HPP_NOEXCEPT 14789 { 14790 std::size_t seed = 0; 14791 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionImageFormatProperties.sType ); 14792 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionImageFormatProperties.pNext ); 14793 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionImageFormatProperties.combinedImageSamplerDescriptorCount ); 14794 return seed; 14795 } 14796 }; 14797 14798 template <> 14799 struct hash<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionInfo> 14800 { operator ()std::hash14801 std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionInfo const & samplerYcbcrConversionInfo ) const VULKAN_HPP_NOEXCEPT 14802 { 14803 std::size_t seed = 0; 14804 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionInfo.sType ); 14805 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionInfo.pNext ); 14806 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionInfo.conversion ); 14807 return seed; 14808 } 14809 }; 14810 14811 template <> 14812 struct hash<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM> 14813 { operator ()std::hash14814 std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM const & samplerYcbcrConversionYcbcrDegammaCreateInfoQCOM ) 14815 const VULKAN_HPP_NOEXCEPT 14816 { 14817 std::size_t seed = 0; 14818 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionYcbcrDegammaCreateInfoQCOM.sType ); 14819 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionYcbcrDegammaCreateInfoQCOM.pNext ); 14820 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionYcbcrDegammaCreateInfoQCOM.enableYDegamma ); 14821 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionYcbcrDegammaCreateInfoQCOM.enableCbCrDegamma ); 14822 return seed; 14823 } 14824 }; 14825 14826 # if defined( VK_USE_PLATFORM_SCREEN_QNX ) 14827 template <> 14828 struct hash<VULKAN_HPP_NAMESPACE::ScreenBufferFormatPropertiesQNX> 14829 { operator ()std::hash14830 std::size_t operator()( VULKAN_HPP_NAMESPACE::ScreenBufferFormatPropertiesQNX const & screenBufferFormatPropertiesQNX ) const VULKAN_HPP_NOEXCEPT 14831 { 14832 std::size_t seed = 0; 14833 VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.sType ); 14834 VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.pNext ); 14835 VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.format ); 14836 VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.externalFormat ); 14837 VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.screenUsage ); 14838 VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.formatFeatures ); 14839 VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.samplerYcbcrConversionComponents ); 14840 VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.suggestedYcbcrModel ); 14841 VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.suggestedYcbcrRange ); 14842 VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.suggestedXChromaOffset ); 14843 VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.suggestedYChromaOffset ); 14844 return seed; 14845 } 14846 }; 14847 # endif /*VK_USE_PLATFORM_SCREEN_QNX*/ 14848 14849 # if defined( VK_USE_PLATFORM_SCREEN_QNX ) 14850 template <> 14851 struct hash<VULKAN_HPP_NAMESPACE::ScreenBufferPropertiesQNX> 14852 { operator ()std::hash14853 std::size_t operator()( VULKAN_HPP_NAMESPACE::ScreenBufferPropertiesQNX const & screenBufferPropertiesQNX ) const VULKAN_HPP_NOEXCEPT 14854 { 14855 std::size_t seed = 0; 14856 VULKAN_HPP_HASH_COMBINE( seed, screenBufferPropertiesQNX.sType ); 14857 VULKAN_HPP_HASH_COMBINE( seed, screenBufferPropertiesQNX.pNext ); 14858 VULKAN_HPP_HASH_COMBINE( seed, screenBufferPropertiesQNX.allocationSize ); 14859 VULKAN_HPP_HASH_COMBINE( seed, screenBufferPropertiesQNX.memoryTypeBits ); 14860 return seed; 14861 } 14862 }; 14863 # endif /*VK_USE_PLATFORM_SCREEN_QNX*/ 14864 14865 # if defined( VK_USE_PLATFORM_SCREEN_QNX ) 14866 template <> 14867 struct hash<VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX> 14868 { operator ()std::hash14869 std::size_t operator()( VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX const & screenSurfaceCreateInfoQNX ) const VULKAN_HPP_NOEXCEPT 14870 { 14871 std::size_t seed = 0; 14872 VULKAN_HPP_HASH_COMBINE( seed, screenSurfaceCreateInfoQNX.sType ); 14873 VULKAN_HPP_HASH_COMBINE( seed, screenSurfaceCreateInfoQNX.pNext ); 14874 VULKAN_HPP_HASH_COMBINE( seed, screenSurfaceCreateInfoQNX.flags ); 14875 VULKAN_HPP_HASH_COMBINE( seed, screenSurfaceCreateInfoQNX.context ); 14876 VULKAN_HPP_HASH_COMBINE( seed, screenSurfaceCreateInfoQNX.window ); 14877 return seed; 14878 } 14879 }; 14880 # endif /*VK_USE_PLATFORM_SCREEN_QNX*/ 14881 14882 template <> 14883 struct hash<VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo> 14884 { operator ()std::hash14885 std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo const & semaphoreCreateInfo ) const VULKAN_HPP_NOEXCEPT 14886 { 14887 std::size_t seed = 0; 14888 VULKAN_HPP_HASH_COMBINE( seed, semaphoreCreateInfo.sType ); 14889 VULKAN_HPP_HASH_COMBINE( seed, semaphoreCreateInfo.pNext ); 14890 VULKAN_HPP_HASH_COMBINE( seed, semaphoreCreateInfo.flags ); 14891 return seed; 14892 } 14893 }; 14894 14895 template <> 14896 struct hash<VULKAN_HPP_NAMESPACE::SemaphoreGetFdInfoKHR> 14897 { operator ()std::hash14898 std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreGetFdInfoKHR const & semaphoreGetFdInfoKHR ) const VULKAN_HPP_NOEXCEPT 14899 { 14900 std::size_t seed = 0; 14901 VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetFdInfoKHR.sType ); 14902 VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetFdInfoKHR.pNext ); 14903 VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetFdInfoKHR.semaphore ); 14904 VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetFdInfoKHR.handleType ); 14905 return seed; 14906 } 14907 }; 14908 14909 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 14910 template <> 14911 struct hash<VULKAN_HPP_NAMESPACE::SemaphoreGetWin32HandleInfoKHR> 14912 { operator ()std::hash14913 std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreGetWin32HandleInfoKHR const & semaphoreGetWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT 14914 { 14915 std::size_t seed = 0; 14916 VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetWin32HandleInfoKHR.sType ); 14917 VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetWin32HandleInfoKHR.pNext ); 14918 VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetWin32HandleInfoKHR.semaphore ); 14919 VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetWin32HandleInfoKHR.handleType ); 14920 return seed; 14921 } 14922 }; 14923 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 14924 14925 # if defined( VK_USE_PLATFORM_FUCHSIA ) 14926 template <> 14927 struct hash<VULKAN_HPP_NAMESPACE::SemaphoreGetZirconHandleInfoFUCHSIA> 14928 { operator ()std::hash14929 std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreGetZirconHandleInfoFUCHSIA const & semaphoreGetZirconHandleInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT 14930 { 14931 std::size_t seed = 0; 14932 VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetZirconHandleInfoFUCHSIA.sType ); 14933 VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetZirconHandleInfoFUCHSIA.pNext ); 14934 VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetZirconHandleInfoFUCHSIA.semaphore ); 14935 VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetZirconHandleInfoFUCHSIA.handleType ); 14936 return seed; 14937 } 14938 }; 14939 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 14940 14941 template <> 14942 struct hash<VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo> 14943 { operator ()std::hash14944 std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo const & semaphoreSignalInfo ) const VULKAN_HPP_NOEXCEPT 14945 { 14946 std::size_t seed = 0; 14947 VULKAN_HPP_HASH_COMBINE( seed, semaphoreSignalInfo.sType ); 14948 VULKAN_HPP_HASH_COMBINE( seed, semaphoreSignalInfo.pNext ); 14949 VULKAN_HPP_HASH_COMBINE( seed, semaphoreSignalInfo.semaphore ); 14950 VULKAN_HPP_HASH_COMBINE( seed, semaphoreSignalInfo.value ); 14951 return seed; 14952 } 14953 }; 14954 14955 template <> 14956 struct hash<VULKAN_HPP_NAMESPACE::SemaphoreTypeCreateInfo> 14957 { operator ()std::hash14958 std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreTypeCreateInfo const & semaphoreTypeCreateInfo ) const VULKAN_HPP_NOEXCEPT 14959 { 14960 std::size_t seed = 0; 14961 VULKAN_HPP_HASH_COMBINE( seed, semaphoreTypeCreateInfo.sType ); 14962 VULKAN_HPP_HASH_COMBINE( seed, semaphoreTypeCreateInfo.pNext ); 14963 VULKAN_HPP_HASH_COMBINE( seed, semaphoreTypeCreateInfo.semaphoreType ); 14964 VULKAN_HPP_HASH_COMBINE( seed, semaphoreTypeCreateInfo.initialValue ); 14965 return seed; 14966 } 14967 }; 14968 14969 template <> 14970 struct hash<VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo> 14971 { operator ()std::hash14972 std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo const & semaphoreWaitInfo ) const VULKAN_HPP_NOEXCEPT 14973 { 14974 std::size_t seed = 0; 14975 VULKAN_HPP_HASH_COMBINE( seed, semaphoreWaitInfo.sType ); 14976 VULKAN_HPP_HASH_COMBINE( seed, semaphoreWaitInfo.pNext ); 14977 VULKAN_HPP_HASH_COMBINE( seed, semaphoreWaitInfo.flags ); 14978 VULKAN_HPP_HASH_COMBINE( seed, semaphoreWaitInfo.semaphoreCount ); 14979 VULKAN_HPP_HASH_COMBINE( seed, semaphoreWaitInfo.pSemaphores ); 14980 VULKAN_HPP_HASH_COMBINE( seed, semaphoreWaitInfo.pValues ); 14981 return seed; 14982 } 14983 }; 14984 14985 template <> 14986 struct hash<VULKAN_HPP_NAMESPACE::SetDescriptorBufferOffsetsInfoEXT> 14987 { operator ()std::hash14988 std::size_t operator()( VULKAN_HPP_NAMESPACE::SetDescriptorBufferOffsetsInfoEXT const & setDescriptorBufferOffsetsInfoEXT ) const VULKAN_HPP_NOEXCEPT 14989 { 14990 std::size_t seed = 0; 14991 VULKAN_HPP_HASH_COMBINE( seed, setDescriptorBufferOffsetsInfoEXT.sType ); 14992 VULKAN_HPP_HASH_COMBINE( seed, setDescriptorBufferOffsetsInfoEXT.pNext ); 14993 VULKAN_HPP_HASH_COMBINE( seed, setDescriptorBufferOffsetsInfoEXT.stageFlags ); 14994 VULKAN_HPP_HASH_COMBINE( seed, setDescriptorBufferOffsetsInfoEXT.layout ); 14995 VULKAN_HPP_HASH_COMBINE( seed, setDescriptorBufferOffsetsInfoEXT.firstSet ); 14996 VULKAN_HPP_HASH_COMBINE( seed, setDescriptorBufferOffsetsInfoEXT.setCount ); 14997 VULKAN_HPP_HASH_COMBINE( seed, setDescriptorBufferOffsetsInfoEXT.pBufferIndices ); 14998 VULKAN_HPP_HASH_COMBINE( seed, setDescriptorBufferOffsetsInfoEXT.pOffsets ); 14999 return seed; 15000 } 15001 }; 15002 15003 template <> 15004 struct hash<VULKAN_HPP_NAMESPACE::SetLatencyMarkerInfoNV> 15005 { operator ()std::hash15006 std::size_t operator()( VULKAN_HPP_NAMESPACE::SetLatencyMarkerInfoNV const & setLatencyMarkerInfoNV ) const VULKAN_HPP_NOEXCEPT 15007 { 15008 std::size_t seed = 0; 15009 VULKAN_HPP_HASH_COMBINE( seed, setLatencyMarkerInfoNV.sType ); 15010 VULKAN_HPP_HASH_COMBINE( seed, setLatencyMarkerInfoNV.pNext ); 15011 VULKAN_HPP_HASH_COMBINE( seed, setLatencyMarkerInfoNV.presentID ); 15012 VULKAN_HPP_HASH_COMBINE( seed, setLatencyMarkerInfoNV.marker ); 15013 return seed; 15014 } 15015 }; 15016 15017 template <> 15018 struct hash<VULKAN_HPP_NAMESPACE::SetStateFlagsIndirectCommandNV> 15019 { operator ()std::hash15020 std::size_t operator()( VULKAN_HPP_NAMESPACE::SetStateFlagsIndirectCommandNV const & setStateFlagsIndirectCommandNV ) const VULKAN_HPP_NOEXCEPT 15021 { 15022 std::size_t seed = 0; 15023 VULKAN_HPP_HASH_COMBINE( seed, setStateFlagsIndirectCommandNV.data ); 15024 return seed; 15025 } 15026 }; 15027 15028 template <> 15029 struct hash<VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT> 15030 { operator ()std::hash15031 std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT const & shaderCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 15032 { 15033 std::size_t seed = 0; 15034 VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.sType ); 15035 VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.pNext ); 15036 VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.flags ); 15037 VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.stage ); 15038 VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.nextStage ); 15039 VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.codeType ); 15040 VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.codeSize ); 15041 VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.pCode ); 15042 for ( const char * p = shaderCreateInfoEXT.pName; *p != '\0'; ++p ) 15043 { 15044 VULKAN_HPP_HASH_COMBINE( seed, *p ); 15045 } 15046 VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.setLayoutCount ); 15047 VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.pSetLayouts ); 15048 VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.pushConstantRangeCount ); 15049 VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.pPushConstantRanges ); 15050 VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.pSpecializationInfo ); 15051 return seed; 15052 } 15053 }; 15054 15055 template <> 15056 struct hash<VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo> 15057 { operator ()std::hash15058 std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo const & shaderModuleCreateInfo ) const VULKAN_HPP_NOEXCEPT 15059 { 15060 std::size_t seed = 0; 15061 VULKAN_HPP_HASH_COMBINE( seed, shaderModuleCreateInfo.sType ); 15062 VULKAN_HPP_HASH_COMBINE( seed, shaderModuleCreateInfo.pNext ); 15063 VULKAN_HPP_HASH_COMBINE( seed, shaderModuleCreateInfo.flags ); 15064 VULKAN_HPP_HASH_COMBINE( seed, shaderModuleCreateInfo.codeSize ); 15065 VULKAN_HPP_HASH_COMBINE( seed, shaderModuleCreateInfo.pCode ); 15066 return seed; 15067 } 15068 }; 15069 15070 template <> 15071 struct hash<VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT> 15072 { operator ()std::hash15073 std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT const & shaderModuleIdentifierEXT ) const VULKAN_HPP_NOEXCEPT 15074 { 15075 std::size_t seed = 0; 15076 VULKAN_HPP_HASH_COMBINE( seed, shaderModuleIdentifierEXT.sType ); 15077 VULKAN_HPP_HASH_COMBINE( seed, shaderModuleIdentifierEXT.pNext ); 15078 VULKAN_HPP_HASH_COMBINE( seed, shaderModuleIdentifierEXT.identifierSize ); 15079 for ( size_t i = 0; i < VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT; ++i ) 15080 { 15081 VULKAN_HPP_HASH_COMBINE( seed, shaderModuleIdentifierEXT.identifier[i] ); 15082 } 15083 return seed; 15084 } 15085 }; 15086 15087 template <> 15088 struct hash<VULKAN_HPP_NAMESPACE::ShaderModuleValidationCacheCreateInfoEXT> 15089 { 15090 std::size_t operator ()std::hash15091 operator()( VULKAN_HPP_NAMESPACE::ShaderModuleValidationCacheCreateInfoEXT const & shaderModuleValidationCacheCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 15092 { 15093 std::size_t seed = 0; 15094 VULKAN_HPP_HASH_COMBINE( seed, shaderModuleValidationCacheCreateInfoEXT.sType ); 15095 VULKAN_HPP_HASH_COMBINE( seed, shaderModuleValidationCacheCreateInfoEXT.pNext ); 15096 VULKAN_HPP_HASH_COMBINE( seed, shaderModuleValidationCacheCreateInfoEXT.validationCache ); 15097 return seed; 15098 } 15099 }; 15100 15101 template <> 15102 struct hash<VULKAN_HPP_NAMESPACE::ShaderResourceUsageAMD> 15103 { operator ()std::hash15104 std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderResourceUsageAMD const & shaderResourceUsageAMD ) const VULKAN_HPP_NOEXCEPT 15105 { 15106 std::size_t seed = 0; 15107 VULKAN_HPP_HASH_COMBINE( seed, shaderResourceUsageAMD.numUsedVgprs ); 15108 VULKAN_HPP_HASH_COMBINE( seed, shaderResourceUsageAMD.numUsedSgprs ); 15109 VULKAN_HPP_HASH_COMBINE( seed, shaderResourceUsageAMD.ldsSizePerLocalWorkGroup ); 15110 VULKAN_HPP_HASH_COMBINE( seed, shaderResourceUsageAMD.ldsUsageSizeInBytes ); 15111 VULKAN_HPP_HASH_COMBINE( seed, shaderResourceUsageAMD.scratchMemUsageInBytes ); 15112 return seed; 15113 } 15114 }; 15115 15116 template <> 15117 struct hash<VULKAN_HPP_NAMESPACE::ShaderStatisticsInfoAMD> 15118 { operator ()std::hash15119 std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderStatisticsInfoAMD const & shaderStatisticsInfoAMD ) const VULKAN_HPP_NOEXCEPT 15120 { 15121 std::size_t seed = 0; 15122 VULKAN_HPP_HASH_COMBINE( seed, shaderStatisticsInfoAMD.shaderStageMask ); 15123 VULKAN_HPP_HASH_COMBINE( seed, shaderStatisticsInfoAMD.resourceUsage ); 15124 VULKAN_HPP_HASH_COMBINE( seed, shaderStatisticsInfoAMD.numPhysicalVgprs ); 15125 VULKAN_HPP_HASH_COMBINE( seed, shaderStatisticsInfoAMD.numPhysicalSgprs ); 15126 VULKAN_HPP_HASH_COMBINE( seed, shaderStatisticsInfoAMD.numAvailableVgprs ); 15127 VULKAN_HPP_HASH_COMBINE( seed, shaderStatisticsInfoAMD.numAvailableSgprs ); 15128 for ( size_t i = 0; i < 3; ++i ) 15129 { 15130 VULKAN_HPP_HASH_COMBINE( seed, shaderStatisticsInfoAMD.computeWorkGroupSize[i] ); 15131 } 15132 return seed; 15133 } 15134 }; 15135 15136 template <> 15137 struct hash<VULKAN_HPP_NAMESPACE::SharedPresentSurfaceCapabilitiesKHR> 15138 { operator ()std::hash15139 std::size_t operator()( VULKAN_HPP_NAMESPACE::SharedPresentSurfaceCapabilitiesKHR const & sharedPresentSurfaceCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT 15140 { 15141 std::size_t seed = 0; 15142 VULKAN_HPP_HASH_COMBINE( seed, sharedPresentSurfaceCapabilitiesKHR.sType ); 15143 VULKAN_HPP_HASH_COMBINE( seed, sharedPresentSurfaceCapabilitiesKHR.pNext ); 15144 VULKAN_HPP_HASH_COMBINE( seed, sharedPresentSurfaceCapabilitiesKHR.sharedPresentSupportedUsageFlags ); 15145 return seed; 15146 } 15147 }; 15148 15149 template <> 15150 struct hash<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties> 15151 { operator ()std::hash15152 std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageFormatProperties const & sparseImageFormatProperties ) const VULKAN_HPP_NOEXCEPT 15153 { 15154 std::size_t seed = 0; 15155 VULKAN_HPP_HASH_COMBINE( seed, sparseImageFormatProperties.aspectMask ); 15156 VULKAN_HPP_HASH_COMBINE( seed, sparseImageFormatProperties.imageGranularity ); 15157 VULKAN_HPP_HASH_COMBINE( seed, sparseImageFormatProperties.flags ); 15158 return seed; 15159 } 15160 }; 15161 15162 template <> 15163 struct hash<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2> 15164 { operator ()std::hash15165 std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2 const & sparseImageFormatProperties2 ) const VULKAN_HPP_NOEXCEPT 15166 { 15167 std::size_t seed = 0; 15168 VULKAN_HPP_HASH_COMBINE( seed, sparseImageFormatProperties2.sType ); 15169 VULKAN_HPP_HASH_COMBINE( seed, sparseImageFormatProperties2.pNext ); 15170 VULKAN_HPP_HASH_COMBINE( seed, sparseImageFormatProperties2.properties ); 15171 return seed; 15172 } 15173 }; 15174 15175 template <> 15176 struct hash<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements> 15177 { operator ()std::hash15178 std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements const & sparseImageMemoryRequirements ) const VULKAN_HPP_NOEXCEPT 15179 { 15180 std::size_t seed = 0; 15181 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryRequirements.formatProperties ); 15182 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryRequirements.imageMipTailFirstLod ); 15183 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryRequirements.imageMipTailSize ); 15184 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryRequirements.imageMipTailOffset ); 15185 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryRequirements.imageMipTailStride ); 15186 return seed; 15187 } 15188 }; 15189 15190 template <> 15191 struct hash<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2> 15192 { operator ()std::hash15193 std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 const & sparseImageMemoryRequirements2 ) const VULKAN_HPP_NOEXCEPT 15194 { 15195 std::size_t seed = 0; 15196 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryRequirements2.sType ); 15197 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryRequirements2.pNext ); 15198 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryRequirements2.memoryRequirements ); 15199 return seed; 15200 } 15201 }; 15202 15203 # if defined( VK_USE_PLATFORM_GGP ) 15204 template <> 15205 struct hash<VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP> 15206 { operator ()std::hash15207 std::size_t operator()( VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP const & streamDescriptorSurfaceCreateInfoGGP ) const VULKAN_HPP_NOEXCEPT 15208 { 15209 std::size_t seed = 0; 15210 VULKAN_HPP_HASH_COMBINE( seed, streamDescriptorSurfaceCreateInfoGGP.sType ); 15211 VULKAN_HPP_HASH_COMBINE( seed, streamDescriptorSurfaceCreateInfoGGP.pNext ); 15212 VULKAN_HPP_HASH_COMBINE( seed, streamDescriptorSurfaceCreateInfoGGP.flags ); 15213 VULKAN_HPP_HASH_COMBINE( seed, streamDescriptorSurfaceCreateInfoGGP.streamDescriptor ); 15214 return seed; 15215 } 15216 }; 15217 # endif /*VK_USE_PLATFORM_GGP*/ 15218 15219 template <> 15220 struct hash<VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR> 15221 { operator ()std::hash15222 std::size_t operator()( VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR const & stridedDeviceAddressRegionKHR ) const VULKAN_HPP_NOEXCEPT 15223 { 15224 std::size_t seed = 0; 15225 VULKAN_HPP_HASH_COMBINE( seed, stridedDeviceAddressRegionKHR.deviceAddress ); 15226 VULKAN_HPP_HASH_COMBINE( seed, stridedDeviceAddressRegionKHR.stride ); 15227 VULKAN_HPP_HASH_COMBINE( seed, stridedDeviceAddressRegionKHR.size ); 15228 return seed; 15229 } 15230 }; 15231 15232 template <> 15233 struct hash<VULKAN_HPP_NAMESPACE::SubmitInfo> 15234 { operator ()std::hash15235 std::size_t operator()( VULKAN_HPP_NAMESPACE::SubmitInfo const & submitInfo ) const VULKAN_HPP_NOEXCEPT 15236 { 15237 std::size_t seed = 0; 15238 VULKAN_HPP_HASH_COMBINE( seed, submitInfo.sType ); 15239 VULKAN_HPP_HASH_COMBINE( seed, submitInfo.pNext ); 15240 VULKAN_HPP_HASH_COMBINE( seed, submitInfo.waitSemaphoreCount ); 15241 VULKAN_HPP_HASH_COMBINE( seed, submitInfo.pWaitSemaphores ); 15242 VULKAN_HPP_HASH_COMBINE( seed, submitInfo.pWaitDstStageMask ); 15243 VULKAN_HPP_HASH_COMBINE( seed, submitInfo.commandBufferCount ); 15244 VULKAN_HPP_HASH_COMBINE( seed, submitInfo.pCommandBuffers ); 15245 VULKAN_HPP_HASH_COMBINE( seed, submitInfo.signalSemaphoreCount ); 15246 VULKAN_HPP_HASH_COMBINE( seed, submitInfo.pSignalSemaphores ); 15247 return seed; 15248 } 15249 }; 15250 15251 template <> 15252 struct hash<VULKAN_HPP_NAMESPACE::SubmitInfo2> 15253 { operator ()std::hash15254 std::size_t operator()( VULKAN_HPP_NAMESPACE::SubmitInfo2 const & submitInfo2 ) const VULKAN_HPP_NOEXCEPT 15255 { 15256 std::size_t seed = 0; 15257 VULKAN_HPP_HASH_COMBINE( seed, submitInfo2.sType ); 15258 VULKAN_HPP_HASH_COMBINE( seed, submitInfo2.pNext ); 15259 VULKAN_HPP_HASH_COMBINE( seed, submitInfo2.flags ); 15260 VULKAN_HPP_HASH_COMBINE( seed, submitInfo2.waitSemaphoreInfoCount ); 15261 VULKAN_HPP_HASH_COMBINE( seed, submitInfo2.pWaitSemaphoreInfos ); 15262 VULKAN_HPP_HASH_COMBINE( seed, submitInfo2.commandBufferInfoCount ); 15263 VULKAN_HPP_HASH_COMBINE( seed, submitInfo2.pCommandBufferInfos ); 15264 VULKAN_HPP_HASH_COMBINE( seed, submitInfo2.signalSemaphoreInfoCount ); 15265 VULKAN_HPP_HASH_COMBINE( seed, submitInfo2.pSignalSemaphoreInfos ); 15266 return seed; 15267 } 15268 }; 15269 15270 template <> 15271 struct hash<VULKAN_HPP_NAMESPACE::SubpassBeginInfo> 15272 { operator ()std::hash15273 std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassBeginInfo const & subpassBeginInfo ) const VULKAN_HPP_NOEXCEPT 15274 { 15275 std::size_t seed = 0; 15276 VULKAN_HPP_HASH_COMBINE( seed, subpassBeginInfo.sType ); 15277 VULKAN_HPP_HASH_COMBINE( seed, subpassBeginInfo.pNext ); 15278 VULKAN_HPP_HASH_COMBINE( seed, subpassBeginInfo.contents ); 15279 return seed; 15280 } 15281 }; 15282 15283 template <> 15284 struct hash<VULKAN_HPP_NAMESPACE::SubpassDescriptionDepthStencilResolve> 15285 { 15286 std::size_t operator ()std::hash15287 operator()( VULKAN_HPP_NAMESPACE::SubpassDescriptionDepthStencilResolve const & subpassDescriptionDepthStencilResolve ) const VULKAN_HPP_NOEXCEPT 15288 { 15289 std::size_t seed = 0; 15290 VULKAN_HPP_HASH_COMBINE( seed, subpassDescriptionDepthStencilResolve.sType ); 15291 VULKAN_HPP_HASH_COMBINE( seed, subpassDescriptionDepthStencilResolve.pNext ); 15292 VULKAN_HPP_HASH_COMBINE( seed, subpassDescriptionDepthStencilResolve.depthResolveMode ); 15293 VULKAN_HPP_HASH_COMBINE( seed, subpassDescriptionDepthStencilResolve.stencilResolveMode ); 15294 VULKAN_HPP_HASH_COMBINE( seed, subpassDescriptionDepthStencilResolve.pDepthStencilResolveAttachment ); 15295 return seed; 15296 } 15297 }; 15298 15299 template <> 15300 struct hash<VULKAN_HPP_NAMESPACE::SubpassEndInfo> 15301 { operator ()std::hash15302 std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassEndInfo const & subpassEndInfo ) const VULKAN_HPP_NOEXCEPT 15303 { 15304 std::size_t seed = 0; 15305 VULKAN_HPP_HASH_COMBINE( seed, subpassEndInfo.sType ); 15306 VULKAN_HPP_HASH_COMBINE( seed, subpassEndInfo.pNext ); 15307 return seed; 15308 } 15309 }; 15310 15311 template <> 15312 struct hash<VULKAN_HPP_NAMESPACE::SubpassFragmentDensityMapOffsetEndInfoQCOM> 15313 { operator ()std::hash15314 std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassFragmentDensityMapOffsetEndInfoQCOM const & subpassFragmentDensityMapOffsetEndInfoQCOM ) const 15315 VULKAN_HPP_NOEXCEPT 15316 { 15317 std::size_t seed = 0; 15318 VULKAN_HPP_HASH_COMBINE( seed, subpassFragmentDensityMapOffsetEndInfoQCOM.sType ); 15319 VULKAN_HPP_HASH_COMBINE( seed, subpassFragmentDensityMapOffsetEndInfoQCOM.pNext ); 15320 VULKAN_HPP_HASH_COMBINE( seed, subpassFragmentDensityMapOffsetEndInfoQCOM.fragmentDensityOffsetCount ); 15321 VULKAN_HPP_HASH_COMBINE( seed, subpassFragmentDensityMapOffsetEndInfoQCOM.pFragmentDensityOffsets ); 15322 return seed; 15323 } 15324 }; 15325 15326 template <> 15327 struct hash<VULKAN_HPP_NAMESPACE::SubpassResolvePerformanceQueryEXT> 15328 { operator ()std::hash15329 std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassResolvePerformanceQueryEXT const & subpassResolvePerformanceQueryEXT ) const VULKAN_HPP_NOEXCEPT 15330 { 15331 std::size_t seed = 0; 15332 VULKAN_HPP_HASH_COMBINE( seed, subpassResolvePerformanceQueryEXT.sType ); 15333 VULKAN_HPP_HASH_COMBINE( seed, subpassResolvePerformanceQueryEXT.pNext ); 15334 VULKAN_HPP_HASH_COMBINE( seed, subpassResolvePerformanceQueryEXT.optimal ); 15335 return seed; 15336 } 15337 }; 15338 15339 template <> 15340 struct hash<VULKAN_HPP_NAMESPACE::SubpassShadingPipelineCreateInfoHUAWEI> 15341 { 15342 std::size_t operator ()std::hash15343 operator()( VULKAN_HPP_NAMESPACE::SubpassShadingPipelineCreateInfoHUAWEI const & subpassShadingPipelineCreateInfoHUAWEI ) const VULKAN_HPP_NOEXCEPT 15344 { 15345 std::size_t seed = 0; 15346 VULKAN_HPP_HASH_COMBINE( seed, subpassShadingPipelineCreateInfoHUAWEI.sType ); 15347 VULKAN_HPP_HASH_COMBINE( seed, subpassShadingPipelineCreateInfoHUAWEI.pNext ); 15348 VULKAN_HPP_HASH_COMBINE( seed, subpassShadingPipelineCreateInfoHUAWEI.renderPass ); 15349 VULKAN_HPP_HASH_COMBINE( seed, subpassShadingPipelineCreateInfoHUAWEI.subpass ); 15350 return seed; 15351 } 15352 }; 15353 15354 template <> 15355 struct hash<VULKAN_HPP_NAMESPACE::SubresourceHostMemcpySize> 15356 { operator ()std::hash15357 std::size_t operator()( VULKAN_HPP_NAMESPACE::SubresourceHostMemcpySize const & subresourceHostMemcpySize ) const VULKAN_HPP_NOEXCEPT 15358 { 15359 std::size_t seed = 0; 15360 VULKAN_HPP_HASH_COMBINE( seed, subresourceHostMemcpySize.sType ); 15361 VULKAN_HPP_HASH_COMBINE( seed, subresourceHostMemcpySize.pNext ); 15362 VULKAN_HPP_HASH_COMBINE( seed, subresourceHostMemcpySize.size ); 15363 return seed; 15364 } 15365 }; 15366 15367 template <> 15368 struct hash<VULKAN_HPP_NAMESPACE::SubresourceLayout2> 15369 { operator ()std::hash15370 std::size_t operator()( VULKAN_HPP_NAMESPACE::SubresourceLayout2 const & subresourceLayout2 ) const VULKAN_HPP_NOEXCEPT 15371 { 15372 std::size_t seed = 0; 15373 VULKAN_HPP_HASH_COMBINE( seed, subresourceLayout2.sType ); 15374 VULKAN_HPP_HASH_COMBINE( seed, subresourceLayout2.pNext ); 15375 VULKAN_HPP_HASH_COMBINE( seed, subresourceLayout2.subresourceLayout ); 15376 return seed; 15377 } 15378 }; 15379 15380 template <> 15381 struct hash<VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT> 15382 { operator ()std::hash15383 std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT const & surfaceCapabilities2EXT ) const VULKAN_HPP_NOEXCEPT 15384 { 15385 std::size_t seed = 0; 15386 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.sType ); 15387 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.pNext ); 15388 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.minImageCount ); 15389 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.maxImageCount ); 15390 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.currentExtent ); 15391 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.minImageExtent ); 15392 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.maxImageExtent ); 15393 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.maxImageArrayLayers ); 15394 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.supportedTransforms ); 15395 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.currentTransform ); 15396 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.supportedCompositeAlpha ); 15397 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.supportedUsageFlags ); 15398 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.supportedSurfaceCounters ); 15399 return seed; 15400 } 15401 }; 15402 15403 template <> 15404 struct hash<VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR> 15405 { operator ()std::hash15406 std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR const & surfaceCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT 15407 { 15408 std::size_t seed = 0; 15409 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.minImageCount ); 15410 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.maxImageCount ); 15411 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.currentExtent ); 15412 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.minImageExtent ); 15413 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.maxImageExtent ); 15414 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.maxImageArrayLayers ); 15415 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.supportedTransforms ); 15416 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.currentTransform ); 15417 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.supportedCompositeAlpha ); 15418 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.supportedUsageFlags ); 15419 return seed; 15420 } 15421 }; 15422 15423 template <> 15424 struct hash<VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR> 15425 { operator ()std::hash15426 std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR const & surfaceCapabilities2KHR ) const VULKAN_HPP_NOEXCEPT 15427 { 15428 std::size_t seed = 0; 15429 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2KHR.sType ); 15430 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2KHR.pNext ); 15431 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2KHR.surfaceCapabilities ); 15432 return seed; 15433 } 15434 }; 15435 15436 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 15437 template <> 15438 struct hash<VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesFullScreenExclusiveEXT> 15439 { 15440 std::size_t operator ()std::hash15441 operator()( VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesFullScreenExclusiveEXT const & surfaceCapabilitiesFullScreenExclusiveEXT ) const VULKAN_HPP_NOEXCEPT 15442 { 15443 std::size_t seed = 0; 15444 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesFullScreenExclusiveEXT.sType ); 15445 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesFullScreenExclusiveEXT.pNext ); 15446 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesFullScreenExclusiveEXT.fullScreenExclusiveSupported ); 15447 return seed; 15448 } 15449 }; 15450 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 15451 15452 template <> 15453 struct hash<VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesPresentBarrierNV> 15454 { operator ()std::hash15455 std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesPresentBarrierNV const & surfaceCapabilitiesPresentBarrierNV ) const VULKAN_HPP_NOEXCEPT 15456 { 15457 std::size_t seed = 0; 15458 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesPresentBarrierNV.sType ); 15459 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesPresentBarrierNV.pNext ); 15460 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesPresentBarrierNV.presentBarrierSupported ); 15461 return seed; 15462 } 15463 }; 15464 15465 template <> 15466 struct hash<VULKAN_HPP_NAMESPACE::SurfaceFormatKHR> 15467 { operator ()std::hash15468 std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceFormatKHR const & surfaceFormatKHR ) const VULKAN_HPP_NOEXCEPT 15469 { 15470 std::size_t seed = 0; 15471 VULKAN_HPP_HASH_COMBINE( seed, surfaceFormatKHR.format ); 15472 VULKAN_HPP_HASH_COMBINE( seed, surfaceFormatKHR.colorSpace ); 15473 return seed; 15474 } 15475 }; 15476 15477 template <> 15478 struct hash<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR> 15479 { operator ()std::hash15480 std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR const & surfaceFormat2KHR ) const VULKAN_HPP_NOEXCEPT 15481 { 15482 std::size_t seed = 0; 15483 VULKAN_HPP_HASH_COMBINE( seed, surfaceFormat2KHR.sType ); 15484 VULKAN_HPP_HASH_COMBINE( seed, surfaceFormat2KHR.pNext ); 15485 VULKAN_HPP_HASH_COMBINE( seed, surfaceFormat2KHR.surfaceFormat ); 15486 return seed; 15487 } 15488 }; 15489 15490 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 15491 template <> 15492 struct hash<VULKAN_HPP_NAMESPACE::SurfaceFullScreenExclusiveInfoEXT> 15493 { operator ()std::hash15494 std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceFullScreenExclusiveInfoEXT const & surfaceFullScreenExclusiveInfoEXT ) const VULKAN_HPP_NOEXCEPT 15495 { 15496 std::size_t seed = 0; 15497 VULKAN_HPP_HASH_COMBINE( seed, surfaceFullScreenExclusiveInfoEXT.sType ); 15498 VULKAN_HPP_HASH_COMBINE( seed, surfaceFullScreenExclusiveInfoEXT.pNext ); 15499 VULKAN_HPP_HASH_COMBINE( seed, surfaceFullScreenExclusiveInfoEXT.fullScreenExclusive ); 15500 return seed; 15501 } 15502 }; 15503 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 15504 15505 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 15506 template <> 15507 struct hash<VULKAN_HPP_NAMESPACE::SurfaceFullScreenExclusiveWin32InfoEXT> 15508 { 15509 std::size_t operator ()std::hash15510 operator()( VULKAN_HPP_NAMESPACE::SurfaceFullScreenExclusiveWin32InfoEXT const & surfaceFullScreenExclusiveWin32InfoEXT ) const VULKAN_HPP_NOEXCEPT 15511 { 15512 std::size_t seed = 0; 15513 VULKAN_HPP_HASH_COMBINE( seed, surfaceFullScreenExclusiveWin32InfoEXT.sType ); 15514 VULKAN_HPP_HASH_COMBINE( seed, surfaceFullScreenExclusiveWin32InfoEXT.pNext ); 15515 VULKAN_HPP_HASH_COMBINE( seed, surfaceFullScreenExclusiveWin32InfoEXT.hmonitor ); 15516 return seed; 15517 } 15518 }; 15519 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 15520 15521 template <> 15522 struct hash<VULKAN_HPP_NAMESPACE::SurfacePresentModeCompatibilityEXT> 15523 { operator ()std::hash15524 std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfacePresentModeCompatibilityEXT const & surfacePresentModeCompatibilityEXT ) const VULKAN_HPP_NOEXCEPT 15525 { 15526 std::size_t seed = 0; 15527 VULKAN_HPP_HASH_COMBINE( seed, surfacePresentModeCompatibilityEXT.sType ); 15528 VULKAN_HPP_HASH_COMBINE( seed, surfacePresentModeCompatibilityEXT.pNext ); 15529 VULKAN_HPP_HASH_COMBINE( seed, surfacePresentModeCompatibilityEXT.presentModeCount ); 15530 VULKAN_HPP_HASH_COMBINE( seed, surfacePresentModeCompatibilityEXT.pPresentModes ); 15531 return seed; 15532 } 15533 }; 15534 15535 template <> 15536 struct hash<VULKAN_HPP_NAMESPACE::SurfacePresentModeEXT> 15537 { operator ()std::hash15538 std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfacePresentModeEXT const & surfacePresentModeEXT ) const VULKAN_HPP_NOEXCEPT 15539 { 15540 std::size_t seed = 0; 15541 VULKAN_HPP_HASH_COMBINE( seed, surfacePresentModeEXT.sType ); 15542 VULKAN_HPP_HASH_COMBINE( seed, surfacePresentModeEXT.pNext ); 15543 VULKAN_HPP_HASH_COMBINE( seed, surfacePresentModeEXT.presentMode ); 15544 return seed; 15545 } 15546 }; 15547 15548 template <> 15549 struct hash<VULKAN_HPP_NAMESPACE::SurfacePresentScalingCapabilitiesEXT> 15550 { operator ()std::hash15551 std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfacePresentScalingCapabilitiesEXT const & surfacePresentScalingCapabilitiesEXT ) const VULKAN_HPP_NOEXCEPT 15552 { 15553 std::size_t seed = 0; 15554 VULKAN_HPP_HASH_COMBINE( seed, surfacePresentScalingCapabilitiesEXT.sType ); 15555 VULKAN_HPP_HASH_COMBINE( seed, surfacePresentScalingCapabilitiesEXT.pNext ); 15556 VULKAN_HPP_HASH_COMBINE( seed, surfacePresentScalingCapabilitiesEXT.supportedPresentScaling ); 15557 VULKAN_HPP_HASH_COMBINE( seed, surfacePresentScalingCapabilitiesEXT.supportedPresentGravityX ); 15558 VULKAN_HPP_HASH_COMBINE( seed, surfacePresentScalingCapabilitiesEXT.supportedPresentGravityY ); 15559 VULKAN_HPP_HASH_COMBINE( seed, surfacePresentScalingCapabilitiesEXT.minScaledImageExtent ); 15560 VULKAN_HPP_HASH_COMBINE( seed, surfacePresentScalingCapabilitiesEXT.maxScaledImageExtent ); 15561 return seed; 15562 } 15563 }; 15564 15565 template <> 15566 struct hash<VULKAN_HPP_NAMESPACE::SurfaceProtectedCapabilitiesKHR> 15567 { operator ()std::hash15568 std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceProtectedCapabilitiesKHR const & surfaceProtectedCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT 15569 { 15570 std::size_t seed = 0; 15571 VULKAN_HPP_HASH_COMBINE( seed, surfaceProtectedCapabilitiesKHR.sType ); 15572 VULKAN_HPP_HASH_COMBINE( seed, surfaceProtectedCapabilitiesKHR.pNext ); 15573 VULKAN_HPP_HASH_COMBINE( seed, surfaceProtectedCapabilitiesKHR.supportsProtected ); 15574 return seed; 15575 } 15576 }; 15577 15578 template <> 15579 struct hash<VULKAN_HPP_NAMESPACE::SwapchainCounterCreateInfoEXT> 15580 { operator ()std::hash15581 std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainCounterCreateInfoEXT const & swapchainCounterCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 15582 { 15583 std::size_t seed = 0; 15584 VULKAN_HPP_HASH_COMBINE( seed, swapchainCounterCreateInfoEXT.sType ); 15585 VULKAN_HPP_HASH_COMBINE( seed, swapchainCounterCreateInfoEXT.pNext ); 15586 VULKAN_HPP_HASH_COMBINE( seed, swapchainCounterCreateInfoEXT.surfaceCounters ); 15587 return seed; 15588 } 15589 }; 15590 15591 template <> 15592 struct hash<VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> 15593 { operator ()std::hash15594 std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR const & swapchainCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 15595 { 15596 std::size_t seed = 0; 15597 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.sType ); 15598 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.pNext ); 15599 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.flags ); 15600 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.surface ); 15601 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.minImageCount ); 15602 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.imageFormat ); 15603 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.imageColorSpace ); 15604 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.imageExtent ); 15605 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.imageArrayLayers ); 15606 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.imageUsage ); 15607 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.imageSharingMode ); 15608 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.queueFamilyIndexCount ); 15609 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.pQueueFamilyIndices ); 15610 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.preTransform ); 15611 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.compositeAlpha ); 15612 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.presentMode ); 15613 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.clipped ); 15614 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.oldSwapchain ); 15615 return seed; 15616 } 15617 }; 15618 15619 template <> 15620 struct hash<VULKAN_HPP_NAMESPACE::SwapchainDisplayNativeHdrCreateInfoAMD> 15621 { 15622 std::size_t operator ()std::hash15623 operator()( VULKAN_HPP_NAMESPACE::SwapchainDisplayNativeHdrCreateInfoAMD const & swapchainDisplayNativeHdrCreateInfoAMD ) const VULKAN_HPP_NOEXCEPT 15624 { 15625 std::size_t seed = 0; 15626 VULKAN_HPP_HASH_COMBINE( seed, swapchainDisplayNativeHdrCreateInfoAMD.sType ); 15627 VULKAN_HPP_HASH_COMBINE( seed, swapchainDisplayNativeHdrCreateInfoAMD.pNext ); 15628 VULKAN_HPP_HASH_COMBINE( seed, swapchainDisplayNativeHdrCreateInfoAMD.localDimmingEnable ); 15629 return seed; 15630 } 15631 }; 15632 15633 template <> 15634 struct hash<VULKAN_HPP_NAMESPACE::SwapchainLatencyCreateInfoNV> 15635 { operator ()std::hash15636 std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainLatencyCreateInfoNV const & swapchainLatencyCreateInfoNV ) const VULKAN_HPP_NOEXCEPT 15637 { 15638 std::size_t seed = 0; 15639 VULKAN_HPP_HASH_COMBINE( seed, swapchainLatencyCreateInfoNV.sType ); 15640 VULKAN_HPP_HASH_COMBINE( seed, swapchainLatencyCreateInfoNV.pNext ); 15641 VULKAN_HPP_HASH_COMBINE( seed, swapchainLatencyCreateInfoNV.latencyModeEnable ); 15642 return seed; 15643 } 15644 }; 15645 15646 template <> 15647 struct hash<VULKAN_HPP_NAMESPACE::SwapchainPresentBarrierCreateInfoNV> 15648 { operator ()std::hash15649 std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainPresentBarrierCreateInfoNV const & swapchainPresentBarrierCreateInfoNV ) const VULKAN_HPP_NOEXCEPT 15650 { 15651 std::size_t seed = 0; 15652 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentBarrierCreateInfoNV.sType ); 15653 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentBarrierCreateInfoNV.pNext ); 15654 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentBarrierCreateInfoNV.presentBarrierEnable ); 15655 return seed; 15656 } 15657 }; 15658 15659 template <> 15660 struct hash<VULKAN_HPP_NAMESPACE::SwapchainPresentFenceInfoEXT> 15661 { operator ()std::hash15662 std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainPresentFenceInfoEXT const & swapchainPresentFenceInfoEXT ) const VULKAN_HPP_NOEXCEPT 15663 { 15664 std::size_t seed = 0; 15665 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentFenceInfoEXT.sType ); 15666 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentFenceInfoEXT.pNext ); 15667 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentFenceInfoEXT.swapchainCount ); 15668 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentFenceInfoEXT.pFences ); 15669 return seed; 15670 } 15671 }; 15672 15673 template <> 15674 struct hash<VULKAN_HPP_NAMESPACE::SwapchainPresentModeInfoEXT> 15675 { operator ()std::hash15676 std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainPresentModeInfoEXT const & swapchainPresentModeInfoEXT ) const VULKAN_HPP_NOEXCEPT 15677 { 15678 std::size_t seed = 0; 15679 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentModeInfoEXT.sType ); 15680 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentModeInfoEXT.pNext ); 15681 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentModeInfoEXT.swapchainCount ); 15682 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentModeInfoEXT.pPresentModes ); 15683 return seed; 15684 } 15685 }; 15686 15687 template <> 15688 struct hash<VULKAN_HPP_NAMESPACE::SwapchainPresentModesCreateInfoEXT> 15689 { operator ()std::hash15690 std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainPresentModesCreateInfoEXT const & swapchainPresentModesCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 15691 { 15692 std::size_t seed = 0; 15693 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentModesCreateInfoEXT.sType ); 15694 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentModesCreateInfoEXT.pNext ); 15695 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentModesCreateInfoEXT.presentModeCount ); 15696 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentModesCreateInfoEXT.pPresentModes ); 15697 return seed; 15698 } 15699 }; 15700 15701 template <> 15702 struct hash<VULKAN_HPP_NAMESPACE::SwapchainPresentScalingCreateInfoEXT> 15703 { operator ()std::hash15704 std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainPresentScalingCreateInfoEXT const & swapchainPresentScalingCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 15705 { 15706 std::size_t seed = 0; 15707 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentScalingCreateInfoEXT.sType ); 15708 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentScalingCreateInfoEXT.pNext ); 15709 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentScalingCreateInfoEXT.scalingBehavior ); 15710 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentScalingCreateInfoEXT.presentGravityX ); 15711 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentScalingCreateInfoEXT.presentGravityY ); 15712 return seed; 15713 } 15714 }; 15715 15716 template <> 15717 struct hash<VULKAN_HPP_NAMESPACE::TextureLODGatherFormatPropertiesAMD> 15718 { operator ()std::hash15719 std::size_t operator()( VULKAN_HPP_NAMESPACE::TextureLODGatherFormatPropertiesAMD const & textureLODGatherFormatPropertiesAMD ) const VULKAN_HPP_NOEXCEPT 15720 { 15721 std::size_t seed = 0; 15722 VULKAN_HPP_HASH_COMBINE( seed, textureLODGatherFormatPropertiesAMD.sType ); 15723 VULKAN_HPP_HASH_COMBINE( seed, textureLODGatherFormatPropertiesAMD.pNext ); 15724 VULKAN_HPP_HASH_COMBINE( seed, textureLODGatherFormatPropertiesAMD.supportsTextureGatherLODBiasAMD ); 15725 return seed; 15726 } 15727 }; 15728 15729 template <> 15730 struct hash<VULKAN_HPP_NAMESPACE::TilePropertiesQCOM> 15731 { operator ()std::hash15732 std::size_t operator()( VULKAN_HPP_NAMESPACE::TilePropertiesQCOM const & tilePropertiesQCOM ) const VULKAN_HPP_NOEXCEPT 15733 { 15734 std::size_t seed = 0; 15735 VULKAN_HPP_HASH_COMBINE( seed, tilePropertiesQCOM.sType ); 15736 VULKAN_HPP_HASH_COMBINE( seed, tilePropertiesQCOM.pNext ); 15737 VULKAN_HPP_HASH_COMBINE( seed, tilePropertiesQCOM.tileSize ); 15738 VULKAN_HPP_HASH_COMBINE( seed, tilePropertiesQCOM.apronSize ); 15739 VULKAN_HPP_HASH_COMBINE( seed, tilePropertiesQCOM.origin ); 15740 return seed; 15741 } 15742 }; 15743 15744 template <> 15745 struct hash<VULKAN_HPP_NAMESPACE::TimelineSemaphoreSubmitInfo> 15746 { operator ()std::hash15747 std::size_t operator()( VULKAN_HPP_NAMESPACE::TimelineSemaphoreSubmitInfo const & timelineSemaphoreSubmitInfo ) const VULKAN_HPP_NOEXCEPT 15748 { 15749 std::size_t seed = 0; 15750 VULKAN_HPP_HASH_COMBINE( seed, timelineSemaphoreSubmitInfo.sType ); 15751 VULKAN_HPP_HASH_COMBINE( seed, timelineSemaphoreSubmitInfo.pNext ); 15752 VULKAN_HPP_HASH_COMBINE( seed, timelineSemaphoreSubmitInfo.waitSemaphoreValueCount ); 15753 VULKAN_HPP_HASH_COMBINE( seed, timelineSemaphoreSubmitInfo.pWaitSemaphoreValues ); 15754 VULKAN_HPP_HASH_COMBINE( seed, timelineSemaphoreSubmitInfo.signalSemaphoreValueCount ); 15755 VULKAN_HPP_HASH_COMBINE( seed, timelineSemaphoreSubmitInfo.pSignalSemaphoreValues ); 15756 return seed; 15757 } 15758 }; 15759 15760 template <> 15761 struct hash<VULKAN_HPP_NAMESPACE::TraceRaysIndirectCommand2KHR> 15762 { operator ()std::hash15763 std::size_t operator()( VULKAN_HPP_NAMESPACE::TraceRaysIndirectCommand2KHR const & traceRaysIndirectCommand2KHR ) const VULKAN_HPP_NOEXCEPT 15764 { 15765 std::size_t seed = 0; 15766 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.raygenShaderRecordAddress ); 15767 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.raygenShaderRecordSize ); 15768 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.missShaderBindingTableAddress ); 15769 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.missShaderBindingTableSize ); 15770 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.missShaderBindingTableStride ); 15771 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.hitShaderBindingTableAddress ); 15772 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.hitShaderBindingTableSize ); 15773 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.hitShaderBindingTableStride ); 15774 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.callableShaderBindingTableAddress ); 15775 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.callableShaderBindingTableSize ); 15776 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.callableShaderBindingTableStride ); 15777 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.width ); 15778 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.height ); 15779 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.depth ); 15780 return seed; 15781 } 15782 }; 15783 15784 template <> 15785 struct hash<VULKAN_HPP_NAMESPACE::TraceRaysIndirectCommandKHR> 15786 { operator ()std::hash15787 std::size_t operator()( VULKAN_HPP_NAMESPACE::TraceRaysIndirectCommandKHR const & traceRaysIndirectCommandKHR ) const VULKAN_HPP_NOEXCEPT 15788 { 15789 std::size_t seed = 0; 15790 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommandKHR.width ); 15791 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommandKHR.height ); 15792 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommandKHR.depth ); 15793 return seed; 15794 } 15795 }; 15796 15797 template <> 15798 struct hash<VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT> 15799 { operator ()std::hash15800 std::size_t operator()( VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT const & validationCacheCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 15801 { 15802 std::size_t seed = 0; 15803 VULKAN_HPP_HASH_COMBINE( seed, validationCacheCreateInfoEXT.sType ); 15804 VULKAN_HPP_HASH_COMBINE( seed, validationCacheCreateInfoEXT.pNext ); 15805 VULKAN_HPP_HASH_COMBINE( seed, validationCacheCreateInfoEXT.flags ); 15806 VULKAN_HPP_HASH_COMBINE( seed, validationCacheCreateInfoEXT.initialDataSize ); 15807 VULKAN_HPP_HASH_COMBINE( seed, validationCacheCreateInfoEXT.pInitialData ); 15808 return seed; 15809 } 15810 }; 15811 15812 template <> 15813 struct hash<VULKAN_HPP_NAMESPACE::ValidationFeaturesEXT> 15814 { operator ()std::hash15815 std::size_t operator()( VULKAN_HPP_NAMESPACE::ValidationFeaturesEXT const & validationFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 15816 { 15817 std::size_t seed = 0; 15818 VULKAN_HPP_HASH_COMBINE( seed, validationFeaturesEXT.sType ); 15819 VULKAN_HPP_HASH_COMBINE( seed, validationFeaturesEXT.pNext ); 15820 VULKAN_HPP_HASH_COMBINE( seed, validationFeaturesEXT.enabledValidationFeatureCount ); 15821 VULKAN_HPP_HASH_COMBINE( seed, validationFeaturesEXT.pEnabledValidationFeatures ); 15822 VULKAN_HPP_HASH_COMBINE( seed, validationFeaturesEXT.disabledValidationFeatureCount ); 15823 VULKAN_HPP_HASH_COMBINE( seed, validationFeaturesEXT.pDisabledValidationFeatures ); 15824 return seed; 15825 } 15826 }; 15827 15828 template <> 15829 struct hash<VULKAN_HPP_NAMESPACE::ValidationFlagsEXT> 15830 { operator ()std::hash15831 std::size_t operator()( VULKAN_HPP_NAMESPACE::ValidationFlagsEXT const & validationFlagsEXT ) const VULKAN_HPP_NOEXCEPT 15832 { 15833 std::size_t seed = 0; 15834 VULKAN_HPP_HASH_COMBINE( seed, validationFlagsEXT.sType ); 15835 VULKAN_HPP_HASH_COMBINE( seed, validationFlagsEXT.pNext ); 15836 VULKAN_HPP_HASH_COMBINE( seed, validationFlagsEXT.disabledValidationCheckCount ); 15837 VULKAN_HPP_HASH_COMBINE( seed, validationFlagsEXT.pDisabledValidationChecks ); 15838 return seed; 15839 } 15840 }; 15841 15842 template <> 15843 struct hash<VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT> 15844 { operator ()std::hash15845 std::size_t operator()( VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT const & vertexInputAttributeDescription2EXT ) const VULKAN_HPP_NOEXCEPT 15846 { 15847 std::size_t seed = 0; 15848 VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription2EXT.sType ); 15849 VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription2EXT.pNext ); 15850 VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription2EXT.location ); 15851 VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription2EXT.binding ); 15852 VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription2EXT.format ); 15853 VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription2EXT.offset ); 15854 return seed; 15855 } 15856 }; 15857 15858 template <> 15859 struct hash<VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT> 15860 { operator ()std::hash15861 std::size_t operator()( VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT const & vertexInputBindingDescription2EXT ) const VULKAN_HPP_NOEXCEPT 15862 { 15863 std::size_t seed = 0; 15864 VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDescription2EXT.sType ); 15865 VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDescription2EXT.pNext ); 15866 VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDescription2EXT.binding ); 15867 VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDescription2EXT.stride ); 15868 VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDescription2EXT.inputRate ); 15869 VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDescription2EXT.divisor ); 15870 return seed; 15871 } 15872 }; 15873 15874 # if defined( VK_USE_PLATFORM_VI_NN ) 15875 template <> 15876 struct hash<VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN> 15877 { operator ()std::hash15878 std::size_t operator()( VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN const & viSurfaceCreateInfoNN ) const VULKAN_HPP_NOEXCEPT 15879 { 15880 std::size_t seed = 0; 15881 VULKAN_HPP_HASH_COMBINE( seed, viSurfaceCreateInfoNN.sType ); 15882 VULKAN_HPP_HASH_COMBINE( seed, viSurfaceCreateInfoNN.pNext ); 15883 VULKAN_HPP_HASH_COMBINE( seed, viSurfaceCreateInfoNN.flags ); 15884 VULKAN_HPP_HASH_COMBINE( seed, viSurfaceCreateInfoNN.window ); 15885 return seed; 15886 } 15887 }; 15888 # endif /*VK_USE_PLATFORM_VI_NN*/ 15889 15890 template <> 15891 struct hash<VULKAN_HPP_NAMESPACE::VideoPictureResourceInfoKHR> 15892 { operator ()std::hash15893 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoPictureResourceInfoKHR const & videoPictureResourceInfoKHR ) const VULKAN_HPP_NOEXCEPT 15894 { 15895 std::size_t seed = 0; 15896 VULKAN_HPP_HASH_COMBINE( seed, videoPictureResourceInfoKHR.sType ); 15897 VULKAN_HPP_HASH_COMBINE( seed, videoPictureResourceInfoKHR.pNext ); 15898 VULKAN_HPP_HASH_COMBINE( seed, videoPictureResourceInfoKHR.codedOffset ); 15899 VULKAN_HPP_HASH_COMBINE( seed, videoPictureResourceInfoKHR.codedExtent ); 15900 VULKAN_HPP_HASH_COMBINE( seed, videoPictureResourceInfoKHR.baseArrayLayer ); 15901 VULKAN_HPP_HASH_COMBINE( seed, videoPictureResourceInfoKHR.imageViewBinding ); 15902 return seed; 15903 } 15904 }; 15905 15906 template <> 15907 struct hash<VULKAN_HPP_NAMESPACE::VideoReferenceSlotInfoKHR> 15908 { operator ()std::hash15909 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoReferenceSlotInfoKHR const & videoReferenceSlotInfoKHR ) const VULKAN_HPP_NOEXCEPT 15910 { 15911 std::size_t seed = 0; 15912 VULKAN_HPP_HASH_COMBINE( seed, videoReferenceSlotInfoKHR.sType ); 15913 VULKAN_HPP_HASH_COMBINE( seed, videoReferenceSlotInfoKHR.pNext ); 15914 VULKAN_HPP_HASH_COMBINE( seed, videoReferenceSlotInfoKHR.slotIndex ); 15915 VULKAN_HPP_HASH_COMBINE( seed, videoReferenceSlotInfoKHR.pPictureResource ); 15916 return seed; 15917 } 15918 }; 15919 15920 template <> 15921 struct hash<VULKAN_HPP_NAMESPACE::VideoBeginCodingInfoKHR> 15922 { operator ()std::hash15923 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoBeginCodingInfoKHR const & videoBeginCodingInfoKHR ) const VULKAN_HPP_NOEXCEPT 15924 { 15925 std::size_t seed = 0; 15926 VULKAN_HPP_HASH_COMBINE( seed, videoBeginCodingInfoKHR.sType ); 15927 VULKAN_HPP_HASH_COMBINE( seed, videoBeginCodingInfoKHR.pNext ); 15928 VULKAN_HPP_HASH_COMBINE( seed, videoBeginCodingInfoKHR.flags ); 15929 VULKAN_HPP_HASH_COMBINE( seed, videoBeginCodingInfoKHR.videoSession ); 15930 VULKAN_HPP_HASH_COMBINE( seed, videoBeginCodingInfoKHR.videoSessionParameters ); 15931 VULKAN_HPP_HASH_COMBINE( seed, videoBeginCodingInfoKHR.referenceSlotCount ); 15932 VULKAN_HPP_HASH_COMBINE( seed, videoBeginCodingInfoKHR.pReferenceSlots ); 15933 return seed; 15934 } 15935 }; 15936 15937 template <> 15938 struct hash<VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR> 15939 { operator ()std::hash15940 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR const & videoCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT 15941 { 15942 std::size_t seed = 0; 15943 VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.sType ); 15944 VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.pNext ); 15945 VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.flags ); 15946 VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.minBitstreamBufferOffsetAlignment ); 15947 VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.minBitstreamBufferSizeAlignment ); 15948 VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.pictureAccessGranularity ); 15949 VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.minCodedExtent ); 15950 VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.maxCodedExtent ); 15951 VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.maxDpbSlots ); 15952 VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.maxActiveReferencePictures ); 15953 VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.stdHeaderVersion ); 15954 return seed; 15955 } 15956 }; 15957 15958 template <> 15959 struct hash<VULKAN_HPP_NAMESPACE::VideoCodingControlInfoKHR> 15960 { operator ()std::hash15961 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoCodingControlInfoKHR const & videoCodingControlInfoKHR ) const VULKAN_HPP_NOEXCEPT 15962 { 15963 std::size_t seed = 0; 15964 VULKAN_HPP_HASH_COMBINE( seed, videoCodingControlInfoKHR.sType ); 15965 VULKAN_HPP_HASH_COMBINE( seed, videoCodingControlInfoKHR.pNext ); 15966 VULKAN_HPP_HASH_COMBINE( seed, videoCodingControlInfoKHR.flags ); 15967 return seed; 15968 } 15969 }; 15970 15971 template <> 15972 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeAV1CapabilitiesKHR> 15973 { operator ()std::hash15974 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeAV1CapabilitiesKHR const & videoDecodeAV1CapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT 15975 { 15976 std::size_t seed = 0; 15977 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1CapabilitiesKHR.sType ); 15978 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1CapabilitiesKHR.pNext ); 15979 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1CapabilitiesKHR.maxLevel ); 15980 return seed; 15981 } 15982 }; 15983 15984 template <> 15985 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeAV1DpbSlotInfoKHR> 15986 { operator ()std::hash15987 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeAV1DpbSlotInfoKHR const & videoDecodeAV1DpbSlotInfoKHR ) const VULKAN_HPP_NOEXCEPT 15988 { 15989 std::size_t seed = 0; 15990 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1DpbSlotInfoKHR.sType ); 15991 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1DpbSlotInfoKHR.pNext ); 15992 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1DpbSlotInfoKHR.pStdReferenceInfo ); 15993 return seed; 15994 } 15995 }; 15996 15997 template <> 15998 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeAV1PictureInfoKHR> 15999 { operator ()std::hash16000 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeAV1PictureInfoKHR const & videoDecodeAV1PictureInfoKHR ) const VULKAN_HPP_NOEXCEPT 16001 { 16002 std::size_t seed = 0; 16003 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1PictureInfoKHR.sType ); 16004 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1PictureInfoKHR.pNext ); 16005 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1PictureInfoKHR.pStdPictureInfo ); 16006 for ( size_t i = 0; i < VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR; ++i ) 16007 { 16008 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1PictureInfoKHR.referenceNameSlotIndices[i] ); 16009 } 16010 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1PictureInfoKHR.frameHeaderOffset ); 16011 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1PictureInfoKHR.tileCount ); 16012 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1PictureInfoKHR.pTileOffsets ); 16013 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1PictureInfoKHR.pTileSizes ); 16014 return seed; 16015 } 16016 }; 16017 16018 template <> 16019 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeAV1ProfileInfoKHR> 16020 { operator ()std::hash16021 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeAV1ProfileInfoKHR const & videoDecodeAV1ProfileInfoKHR ) const VULKAN_HPP_NOEXCEPT 16022 { 16023 std::size_t seed = 0; 16024 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1ProfileInfoKHR.sType ); 16025 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1ProfileInfoKHR.pNext ); 16026 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1ProfileInfoKHR.stdProfile ); 16027 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1ProfileInfoKHR.filmGrainSupport ); 16028 return seed; 16029 } 16030 }; 16031 16032 template <> 16033 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeAV1SessionParametersCreateInfoKHR> 16034 { operator ()std::hash16035 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeAV1SessionParametersCreateInfoKHR const & videoDecodeAV1SessionParametersCreateInfoKHR ) const 16036 VULKAN_HPP_NOEXCEPT 16037 { 16038 std::size_t seed = 0; 16039 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1SessionParametersCreateInfoKHR.sType ); 16040 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1SessionParametersCreateInfoKHR.pNext ); 16041 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1SessionParametersCreateInfoKHR.pStdSequenceHeader ); 16042 return seed; 16043 } 16044 }; 16045 16046 template <> 16047 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeCapabilitiesKHR> 16048 { operator ()std::hash16049 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeCapabilitiesKHR const & videoDecodeCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT 16050 { 16051 std::size_t seed = 0; 16052 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeCapabilitiesKHR.sType ); 16053 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeCapabilitiesKHR.pNext ); 16054 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeCapabilitiesKHR.flags ); 16055 return seed; 16056 } 16057 }; 16058 16059 template <> 16060 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH264CapabilitiesKHR> 16061 { operator ()std::hash16062 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264CapabilitiesKHR const & videoDecodeH264CapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT 16063 { 16064 std::size_t seed = 0; 16065 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264CapabilitiesKHR.sType ); 16066 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264CapabilitiesKHR.pNext ); 16067 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264CapabilitiesKHR.maxLevelIdc ); 16068 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264CapabilitiesKHR.fieldOffsetGranularity ); 16069 return seed; 16070 } 16071 }; 16072 16073 template <> 16074 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH264DpbSlotInfoKHR> 16075 { operator ()std::hash16076 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264DpbSlotInfoKHR const & videoDecodeH264DpbSlotInfoKHR ) const VULKAN_HPP_NOEXCEPT 16077 { 16078 std::size_t seed = 0; 16079 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264DpbSlotInfoKHR.sType ); 16080 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264DpbSlotInfoKHR.pNext ); 16081 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264DpbSlotInfoKHR.pStdReferenceInfo ); 16082 return seed; 16083 } 16084 }; 16085 16086 template <> 16087 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH264PictureInfoKHR> 16088 { operator ()std::hash16089 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264PictureInfoKHR const & videoDecodeH264PictureInfoKHR ) const VULKAN_HPP_NOEXCEPT 16090 { 16091 std::size_t seed = 0; 16092 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264PictureInfoKHR.sType ); 16093 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264PictureInfoKHR.pNext ); 16094 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264PictureInfoKHR.pStdPictureInfo ); 16095 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264PictureInfoKHR.sliceCount ); 16096 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264PictureInfoKHR.pSliceOffsets ); 16097 return seed; 16098 } 16099 }; 16100 16101 template <> 16102 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH264ProfileInfoKHR> 16103 { operator ()std::hash16104 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264ProfileInfoKHR const & videoDecodeH264ProfileInfoKHR ) const VULKAN_HPP_NOEXCEPT 16105 { 16106 std::size_t seed = 0; 16107 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264ProfileInfoKHR.sType ); 16108 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264ProfileInfoKHR.pNext ); 16109 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264ProfileInfoKHR.stdProfileIdc ); 16110 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264ProfileInfoKHR.pictureLayout ); 16111 return seed; 16112 } 16113 }; 16114 16115 template <> 16116 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH264SessionParametersAddInfoKHR> 16117 { operator ()std::hash16118 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264SessionParametersAddInfoKHR const & videoDecodeH264SessionParametersAddInfoKHR ) const 16119 VULKAN_HPP_NOEXCEPT 16120 { 16121 std::size_t seed = 0; 16122 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersAddInfoKHR.sType ); 16123 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersAddInfoKHR.pNext ); 16124 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersAddInfoKHR.stdSPSCount ); 16125 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersAddInfoKHR.pStdSPSs ); 16126 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersAddInfoKHR.stdPPSCount ); 16127 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersAddInfoKHR.pStdPPSs ); 16128 return seed; 16129 } 16130 }; 16131 16132 template <> 16133 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH264SessionParametersCreateInfoKHR> 16134 { operator ()std::hash16135 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264SessionParametersCreateInfoKHR const & videoDecodeH264SessionParametersCreateInfoKHR ) const 16136 VULKAN_HPP_NOEXCEPT 16137 { 16138 std::size_t seed = 0; 16139 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersCreateInfoKHR.sType ); 16140 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersCreateInfoKHR.pNext ); 16141 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersCreateInfoKHR.maxStdSPSCount ); 16142 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersCreateInfoKHR.maxStdPPSCount ); 16143 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersCreateInfoKHR.pParametersAddInfo ); 16144 return seed; 16145 } 16146 }; 16147 16148 template <> 16149 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH265CapabilitiesKHR> 16150 { operator ()std::hash16151 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265CapabilitiesKHR const & videoDecodeH265CapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT 16152 { 16153 std::size_t seed = 0; 16154 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265CapabilitiesKHR.sType ); 16155 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265CapabilitiesKHR.pNext ); 16156 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265CapabilitiesKHR.maxLevelIdc ); 16157 return seed; 16158 } 16159 }; 16160 16161 template <> 16162 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH265DpbSlotInfoKHR> 16163 { operator ()std::hash16164 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265DpbSlotInfoKHR const & videoDecodeH265DpbSlotInfoKHR ) const VULKAN_HPP_NOEXCEPT 16165 { 16166 std::size_t seed = 0; 16167 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265DpbSlotInfoKHR.sType ); 16168 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265DpbSlotInfoKHR.pNext ); 16169 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265DpbSlotInfoKHR.pStdReferenceInfo ); 16170 return seed; 16171 } 16172 }; 16173 16174 template <> 16175 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH265PictureInfoKHR> 16176 { operator ()std::hash16177 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265PictureInfoKHR const & videoDecodeH265PictureInfoKHR ) const VULKAN_HPP_NOEXCEPT 16178 { 16179 std::size_t seed = 0; 16180 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265PictureInfoKHR.sType ); 16181 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265PictureInfoKHR.pNext ); 16182 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265PictureInfoKHR.pStdPictureInfo ); 16183 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265PictureInfoKHR.sliceSegmentCount ); 16184 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265PictureInfoKHR.pSliceSegmentOffsets ); 16185 return seed; 16186 } 16187 }; 16188 16189 template <> 16190 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH265ProfileInfoKHR> 16191 { operator ()std::hash16192 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265ProfileInfoKHR const & videoDecodeH265ProfileInfoKHR ) const VULKAN_HPP_NOEXCEPT 16193 { 16194 std::size_t seed = 0; 16195 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265ProfileInfoKHR.sType ); 16196 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265ProfileInfoKHR.pNext ); 16197 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265ProfileInfoKHR.stdProfileIdc ); 16198 return seed; 16199 } 16200 }; 16201 16202 template <> 16203 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH265SessionParametersAddInfoKHR> 16204 { operator ()std::hash16205 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265SessionParametersAddInfoKHR const & videoDecodeH265SessionParametersAddInfoKHR ) const 16206 VULKAN_HPP_NOEXCEPT 16207 { 16208 std::size_t seed = 0; 16209 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersAddInfoKHR.sType ); 16210 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersAddInfoKHR.pNext ); 16211 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersAddInfoKHR.stdVPSCount ); 16212 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersAddInfoKHR.pStdVPSs ); 16213 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersAddInfoKHR.stdSPSCount ); 16214 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersAddInfoKHR.pStdSPSs ); 16215 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersAddInfoKHR.stdPPSCount ); 16216 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersAddInfoKHR.pStdPPSs ); 16217 return seed; 16218 } 16219 }; 16220 16221 template <> 16222 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH265SessionParametersCreateInfoKHR> 16223 { operator ()std::hash16224 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265SessionParametersCreateInfoKHR const & videoDecodeH265SessionParametersCreateInfoKHR ) const 16225 VULKAN_HPP_NOEXCEPT 16226 { 16227 std::size_t seed = 0; 16228 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersCreateInfoKHR.sType ); 16229 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersCreateInfoKHR.pNext ); 16230 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersCreateInfoKHR.maxStdVPSCount ); 16231 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersCreateInfoKHR.maxStdSPSCount ); 16232 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersCreateInfoKHR.maxStdPPSCount ); 16233 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersCreateInfoKHR.pParametersAddInfo ); 16234 return seed; 16235 } 16236 }; 16237 16238 template <> 16239 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR> 16240 { operator ()std::hash16241 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR const & videoDecodeInfoKHR ) const VULKAN_HPP_NOEXCEPT 16242 { 16243 std::size_t seed = 0; 16244 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.sType ); 16245 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.pNext ); 16246 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.flags ); 16247 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.srcBuffer ); 16248 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.srcBufferOffset ); 16249 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.srcBufferRange ); 16250 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.dstPictureResource ); 16251 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.pSetupReferenceSlot ); 16252 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.referenceSlotCount ); 16253 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.pReferenceSlots ); 16254 return seed; 16255 } 16256 }; 16257 16258 template <> 16259 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeUsageInfoKHR> 16260 { operator ()std::hash16261 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeUsageInfoKHR const & videoDecodeUsageInfoKHR ) const VULKAN_HPP_NOEXCEPT 16262 { 16263 std::size_t seed = 0; 16264 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeUsageInfoKHR.sType ); 16265 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeUsageInfoKHR.pNext ); 16266 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeUsageInfoKHR.videoUsageHints ); 16267 return seed; 16268 } 16269 }; 16270 16271 template <> 16272 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeCapabilitiesKHR> 16273 { operator ()std::hash16274 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeCapabilitiesKHR const & videoEncodeCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT 16275 { 16276 std::size_t seed = 0; 16277 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.sType ); 16278 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.pNext ); 16279 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.flags ); 16280 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.rateControlModes ); 16281 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.maxRateControlLayers ); 16282 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.maxBitrate ); 16283 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.maxQualityLevels ); 16284 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.encodeInputPictureGranularity ); 16285 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.supportedEncodeFeedbackFlags ); 16286 return seed; 16287 } 16288 }; 16289 16290 template <> 16291 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilitiesKHR> 16292 { operator ()std::hash16293 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilitiesKHR const & videoEncodeH264CapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT 16294 { 16295 std::size_t seed = 0; 16296 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.sType ); 16297 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.pNext ); 16298 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.flags ); 16299 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.maxLevelIdc ); 16300 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.maxSliceCount ); 16301 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.maxPPictureL0ReferenceCount ); 16302 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.maxBPictureL0ReferenceCount ); 16303 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.maxL1ReferenceCount ); 16304 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.maxTemporalLayerCount ); 16305 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.expectDyadicTemporalLayerPattern ); 16306 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.minQp ); 16307 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.maxQp ); 16308 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.prefersGopRemainingFrames ); 16309 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.requiresGopRemainingFrames ); 16310 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.stdSyntaxFlags ); 16311 return seed; 16312 } 16313 }; 16314 16315 template <> 16316 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoKHR> 16317 { operator ()std::hash16318 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoKHR const & videoEncodeH264DpbSlotInfoKHR ) const VULKAN_HPP_NOEXCEPT 16319 { 16320 std::size_t seed = 0; 16321 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264DpbSlotInfoKHR.sType ); 16322 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264DpbSlotInfoKHR.pNext ); 16323 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264DpbSlotInfoKHR.pStdReferenceInfo ); 16324 return seed; 16325 } 16326 }; 16327 16328 template <> 16329 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264FrameSizeKHR> 16330 { operator ()std::hash16331 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264FrameSizeKHR const & videoEncodeH264FrameSizeKHR ) const VULKAN_HPP_NOEXCEPT 16332 { 16333 std::size_t seed = 0; 16334 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264FrameSizeKHR.frameISize ); 16335 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264FrameSizeKHR.framePSize ); 16336 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264FrameSizeKHR.frameBSize ); 16337 return seed; 16338 } 16339 }; 16340 16341 template <> 16342 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264GopRemainingFrameInfoKHR> 16343 { 16344 std::size_t operator ()std::hash16345 operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264GopRemainingFrameInfoKHR const & videoEncodeH264GopRemainingFrameInfoKHR ) const VULKAN_HPP_NOEXCEPT 16346 { 16347 std::size_t seed = 0; 16348 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264GopRemainingFrameInfoKHR.sType ); 16349 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264GopRemainingFrameInfoKHR.pNext ); 16350 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264GopRemainingFrameInfoKHR.useGopRemainingFrames ); 16351 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264GopRemainingFrameInfoKHR.gopRemainingI ); 16352 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264GopRemainingFrameInfoKHR.gopRemainingP ); 16353 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264GopRemainingFrameInfoKHR.gopRemainingB ); 16354 return seed; 16355 } 16356 }; 16357 16358 template <> 16359 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264NaluSliceInfoKHR> 16360 { operator ()std::hash16361 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264NaluSliceInfoKHR const & videoEncodeH264NaluSliceInfoKHR ) const VULKAN_HPP_NOEXCEPT 16362 { 16363 std::size_t seed = 0; 16364 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264NaluSliceInfoKHR.sType ); 16365 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264NaluSliceInfoKHR.pNext ); 16366 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264NaluSliceInfoKHR.constantQp ); 16367 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264NaluSliceInfoKHR.pStdSliceHeader ); 16368 return seed; 16369 } 16370 }; 16371 16372 template <> 16373 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264PictureInfoKHR> 16374 { operator ()std::hash16375 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264PictureInfoKHR const & videoEncodeH264PictureInfoKHR ) const VULKAN_HPP_NOEXCEPT 16376 { 16377 std::size_t seed = 0; 16378 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264PictureInfoKHR.sType ); 16379 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264PictureInfoKHR.pNext ); 16380 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264PictureInfoKHR.naluSliceEntryCount ); 16381 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264PictureInfoKHR.pNaluSliceEntries ); 16382 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264PictureInfoKHR.pStdPictureInfo ); 16383 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264PictureInfoKHR.generatePrefixNalu ); 16384 return seed; 16385 } 16386 }; 16387 16388 template <> 16389 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264ProfileInfoKHR> 16390 { operator ()std::hash16391 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264ProfileInfoKHR const & videoEncodeH264ProfileInfoKHR ) const VULKAN_HPP_NOEXCEPT 16392 { 16393 std::size_t seed = 0; 16394 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264ProfileInfoKHR.sType ); 16395 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264ProfileInfoKHR.pNext ); 16396 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264ProfileInfoKHR.stdProfileIdc ); 16397 return seed; 16398 } 16399 }; 16400 16401 template <> 16402 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264QpKHR> 16403 { operator ()std::hash16404 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264QpKHR const & videoEncodeH264QpKHR ) const VULKAN_HPP_NOEXCEPT 16405 { 16406 std::size_t seed = 0; 16407 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QpKHR.qpI ); 16408 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QpKHR.qpP ); 16409 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QpKHR.qpB ); 16410 return seed; 16411 } 16412 }; 16413 16414 template <> 16415 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264QualityLevelPropertiesKHR> 16416 { 16417 std::size_t operator ()std::hash16418 operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264QualityLevelPropertiesKHR const & videoEncodeH264QualityLevelPropertiesKHR ) const VULKAN_HPP_NOEXCEPT 16419 { 16420 std::size_t seed = 0; 16421 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesKHR.sType ); 16422 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesKHR.pNext ); 16423 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesKHR.preferredRateControlFlags ); 16424 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesKHR.preferredGopFrameCount ); 16425 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesKHR.preferredIdrPeriod ); 16426 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesKHR.preferredConsecutiveBFrameCount ); 16427 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesKHR.preferredTemporalLayerCount ); 16428 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesKHR.preferredConstantQp ); 16429 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesKHR.preferredMaxL0ReferenceCount ); 16430 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesKHR.preferredMaxL1ReferenceCount ); 16431 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesKHR.preferredStdEntropyCodingModeFlag ); 16432 return seed; 16433 } 16434 }; 16435 16436 template <> 16437 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlInfoKHR> 16438 { operator ()std::hash16439 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlInfoKHR const & videoEncodeH264RateControlInfoKHR ) const VULKAN_HPP_NOEXCEPT 16440 { 16441 std::size_t seed = 0; 16442 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlInfoKHR.sType ); 16443 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlInfoKHR.pNext ); 16444 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlInfoKHR.flags ); 16445 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlInfoKHR.gopFrameCount ); 16446 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlInfoKHR.idrPeriod ); 16447 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlInfoKHR.consecutiveBFrameCount ); 16448 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlInfoKHR.temporalLayerCount ); 16449 return seed; 16450 } 16451 }; 16452 16453 template <> 16454 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlLayerInfoKHR> 16455 { 16456 std::size_t operator ()std::hash16457 operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlLayerInfoKHR const & videoEncodeH264RateControlLayerInfoKHR ) const VULKAN_HPP_NOEXCEPT 16458 { 16459 std::size_t seed = 0; 16460 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoKHR.sType ); 16461 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoKHR.pNext ); 16462 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoKHR.useMinQp ); 16463 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoKHR.minQp ); 16464 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoKHR.useMaxQp ); 16465 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoKHR.maxQp ); 16466 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoKHR.useMaxFrameSize ); 16467 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoKHR.maxFrameSize ); 16468 return seed; 16469 } 16470 }; 16471 16472 template <> 16473 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionCreateInfoKHR> 16474 { operator ()std::hash16475 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionCreateInfoKHR const & videoEncodeH264SessionCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 16476 { 16477 std::size_t seed = 0; 16478 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionCreateInfoKHR.sType ); 16479 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionCreateInfoKHR.pNext ); 16480 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionCreateInfoKHR.useMaxLevelIdc ); 16481 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionCreateInfoKHR.maxLevelIdc ); 16482 return seed; 16483 } 16484 }; 16485 16486 template <> 16487 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersAddInfoKHR> 16488 { operator ()std::hash16489 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersAddInfoKHR const & videoEncodeH264SessionParametersAddInfoKHR ) const 16490 VULKAN_HPP_NOEXCEPT 16491 { 16492 std::size_t seed = 0; 16493 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersAddInfoKHR.sType ); 16494 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersAddInfoKHR.pNext ); 16495 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersAddInfoKHR.stdSPSCount ); 16496 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersAddInfoKHR.pStdSPSs ); 16497 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersAddInfoKHR.stdPPSCount ); 16498 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersAddInfoKHR.pStdPPSs ); 16499 return seed; 16500 } 16501 }; 16502 16503 template <> 16504 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersCreateInfoKHR> 16505 { operator ()std::hash16506 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersCreateInfoKHR const & videoEncodeH264SessionParametersCreateInfoKHR ) const 16507 VULKAN_HPP_NOEXCEPT 16508 { 16509 std::size_t seed = 0; 16510 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersCreateInfoKHR.sType ); 16511 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersCreateInfoKHR.pNext ); 16512 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersCreateInfoKHR.maxStdSPSCount ); 16513 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersCreateInfoKHR.maxStdPPSCount ); 16514 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersCreateInfoKHR.pParametersAddInfo ); 16515 return seed; 16516 } 16517 }; 16518 16519 template <> 16520 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersFeedbackInfoKHR> 16521 { operator ()std::hash16522 std::size_t operator()( 16523 VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersFeedbackInfoKHR const & videoEncodeH264SessionParametersFeedbackInfoKHR ) const VULKAN_HPP_NOEXCEPT 16524 { 16525 std::size_t seed = 0; 16526 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersFeedbackInfoKHR.sType ); 16527 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersFeedbackInfoKHR.pNext ); 16528 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersFeedbackInfoKHR.hasStdSPSOverrides ); 16529 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersFeedbackInfoKHR.hasStdPPSOverrides ); 16530 return seed; 16531 } 16532 }; 16533 16534 template <> 16535 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersGetInfoKHR> 16536 { operator ()std::hash16537 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersGetInfoKHR const & videoEncodeH264SessionParametersGetInfoKHR ) const 16538 VULKAN_HPP_NOEXCEPT 16539 { 16540 std::size_t seed = 0; 16541 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersGetInfoKHR.sType ); 16542 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersGetInfoKHR.pNext ); 16543 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersGetInfoKHR.writeStdSPS ); 16544 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersGetInfoKHR.writeStdPPS ); 16545 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersGetInfoKHR.stdSPSId ); 16546 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersGetInfoKHR.stdPPSId ); 16547 return seed; 16548 } 16549 }; 16550 16551 template <> 16552 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265CapabilitiesKHR> 16553 { operator ()std::hash16554 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265CapabilitiesKHR const & videoEncodeH265CapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT 16555 { 16556 std::size_t seed = 0; 16557 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.sType ); 16558 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.pNext ); 16559 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.flags ); 16560 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.maxLevelIdc ); 16561 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.maxSliceSegmentCount ); 16562 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.maxTiles ); 16563 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.ctbSizes ); 16564 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.transformBlockSizes ); 16565 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.maxPPictureL0ReferenceCount ); 16566 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.maxBPictureL0ReferenceCount ); 16567 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.maxL1ReferenceCount ); 16568 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.maxSubLayerCount ); 16569 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.expectDyadicTemporalSubLayerPattern ); 16570 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.minQp ); 16571 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.maxQp ); 16572 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.prefersGopRemainingFrames ); 16573 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.requiresGopRemainingFrames ); 16574 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.stdSyntaxFlags ); 16575 return seed; 16576 } 16577 }; 16578 16579 template <> 16580 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265DpbSlotInfoKHR> 16581 { operator ()std::hash16582 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265DpbSlotInfoKHR const & videoEncodeH265DpbSlotInfoKHR ) const VULKAN_HPP_NOEXCEPT 16583 { 16584 std::size_t seed = 0; 16585 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265DpbSlotInfoKHR.sType ); 16586 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265DpbSlotInfoKHR.pNext ); 16587 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265DpbSlotInfoKHR.pStdReferenceInfo ); 16588 return seed; 16589 } 16590 }; 16591 16592 template <> 16593 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265FrameSizeKHR> 16594 { operator ()std::hash16595 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265FrameSizeKHR const & videoEncodeH265FrameSizeKHR ) const VULKAN_HPP_NOEXCEPT 16596 { 16597 std::size_t seed = 0; 16598 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265FrameSizeKHR.frameISize ); 16599 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265FrameSizeKHR.framePSize ); 16600 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265FrameSizeKHR.frameBSize ); 16601 return seed; 16602 } 16603 }; 16604 16605 template <> 16606 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265GopRemainingFrameInfoKHR> 16607 { 16608 std::size_t operator ()std::hash16609 operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265GopRemainingFrameInfoKHR const & videoEncodeH265GopRemainingFrameInfoKHR ) const VULKAN_HPP_NOEXCEPT 16610 { 16611 std::size_t seed = 0; 16612 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265GopRemainingFrameInfoKHR.sType ); 16613 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265GopRemainingFrameInfoKHR.pNext ); 16614 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265GopRemainingFrameInfoKHR.useGopRemainingFrames ); 16615 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265GopRemainingFrameInfoKHR.gopRemainingI ); 16616 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265GopRemainingFrameInfoKHR.gopRemainingP ); 16617 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265GopRemainingFrameInfoKHR.gopRemainingB ); 16618 return seed; 16619 } 16620 }; 16621 16622 template <> 16623 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceSegmentInfoKHR> 16624 { 16625 std::size_t operator ()std::hash16626 operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceSegmentInfoKHR const & videoEncodeH265NaluSliceSegmentInfoKHR ) const VULKAN_HPP_NOEXCEPT 16627 { 16628 std::size_t seed = 0; 16629 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265NaluSliceSegmentInfoKHR.sType ); 16630 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265NaluSliceSegmentInfoKHR.pNext ); 16631 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265NaluSliceSegmentInfoKHR.constantQp ); 16632 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265NaluSliceSegmentInfoKHR.pStdSliceSegmentHeader ); 16633 return seed; 16634 } 16635 }; 16636 16637 template <> 16638 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265PictureInfoKHR> 16639 { operator ()std::hash16640 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265PictureInfoKHR const & videoEncodeH265PictureInfoKHR ) const VULKAN_HPP_NOEXCEPT 16641 { 16642 std::size_t seed = 0; 16643 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265PictureInfoKHR.sType ); 16644 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265PictureInfoKHR.pNext ); 16645 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265PictureInfoKHR.naluSliceSegmentEntryCount ); 16646 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265PictureInfoKHR.pNaluSliceSegmentEntries ); 16647 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265PictureInfoKHR.pStdPictureInfo ); 16648 return seed; 16649 } 16650 }; 16651 16652 template <> 16653 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265ProfileInfoKHR> 16654 { operator ()std::hash16655 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265ProfileInfoKHR const & videoEncodeH265ProfileInfoKHR ) const VULKAN_HPP_NOEXCEPT 16656 { 16657 std::size_t seed = 0; 16658 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265ProfileInfoKHR.sType ); 16659 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265ProfileInfoKHR.pNext ); 16660 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265ProfileInfoKHR.stdProfileIdc ); 16661 return seed; 16662 } 16663 }; 16664 16665 template <> 16666 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265QpKHR> 16667 { operator ()std::hash16668 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265QpKHR const & videoEncodeH265QpKHR ) const VULKAN_HPP_NOEXCEPT 16669 { 16670 std::size_t seed = 0; 16671 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QpKHR.qpI ); 16672 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QpKHR.qpP ); 16673 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QpKHR.qpB ); 16674 return seed; 16675 } 16676 }; 16677 16678 template <> 16679 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265QualityLevelPropertiesKHR> 16680 { 16681 std::size_t operator ()std::hash16682 operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265QualityLevelPropertiesKHR const & videoEncodeH265QualityLevelPropertiesKHR ) const VULKAN_HPP_NOEXCEPT 16683 { 16684 std::size_t seed = 0; 16685 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesKHR.sType ); 16686 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesKHR.pNext ); 16687 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesKHR.preferredRateControlFlags ); 16688 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesKHR.preferredGopFrameCount ); 16689 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesKHR.preferredIdrPeriod ); 16690 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesKHR.preferredConsecutiveBFrameCount ); 16691 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesKHR.preferredSubLayerCount ); 16692 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesKHR.preferredConstantQp ); 16693 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesKHR.preferredMaxL0ReferenceCount ); 16694 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesKHR.preferredMaxL1ReferenceCount ); 16695 return seed; 16696 } 16697 }; 16698 16699 template <> 16700 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlInfoKHR> 16701 { operator ()std::hash16702 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlInfoKHR const & videoEncodeH265RateControlInfoKHR ) const VULKAN_HPP_NOEXCEPT 16703 { 16704 std::size_t seed = 0; 16705 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlInfoKHR.sType ); 16706 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlInfoKHR.pNext ); 16707 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlInfoKHR.flags ); 16708 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlInfoKHR.gopFrameCount ); 16709 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlInfoKHR.idrPeriod ); 16710 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlInfoKHR.consecutiveBFrameCount ); 16711 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlInfoKHR.subLayerCount ); 16712 return seed; 16713 } 16714 }; 16715 16716 template <> 16717 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlLayerInfoKHR> 16718 { 16719 std::size_t operator ()std::hash16720 operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlLayerInfoKHR const & videoEncodeH265RateControlLayerInfoKHR ) const VULKAN_HPP_NOEXCEPT 16721 { 16722 std::size_t seed = 0; 16723 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoKHR.sType ); 16724 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoKHR.pNext ); 16725 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoKHR.useMinQp ); 16726 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoKHR.minQp ); 16727 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoKHR.useMaxQp ); 16728 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoKHR.maxQp ); 16729 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoKHR.useMaxFrameSize ); 16730 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoKHR.maxFrameSize ); 16731 return seed; 16732 } 16733 }; 16734 16735 template <> 16736 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionCreateInfoKHR> 16737 { operator ()std::hash16738 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionCreateInfoKHR const & videoEncodeH265SessionCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 16739 { 16740 std::size_t seed = 0; 16741 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionCreateInfoKHR.sType ); 16742 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionCreateInfoKHR.pNext ); 16743 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionCreateInfoKHR.useMaxLevelIdc ); 16744 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionCreateInfoKHR.maxLevelIdc ); 16745 return seed; 16746 } 16747 }; 16748 16749 template <> 16750 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersAddInfoKHR> 16751 { operator ()std::hash16752 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersAddInfoKHR const & videoEncodeH265SessionParametersAddInfoKHR ) const 16753 VULKAN_HPP_NOEXCEPT 16754 { 16755 std::size_t seed = 0; 16756 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersAddInfoKHR.sType ); 16757 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersAddInfoKHR.pNext ); 16758 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersAddInfoKHR.stdVPSCount ); 16759 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersAddInfoKHR.pStdVPSs ); 16760 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersAddInfoKHR.stdSPSCount ); 16761 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersAddInfoKHR.pStdSPSs ); 16762 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersAddInfoKHR.stdPPSCount ); 16763 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersAddInfoKHR.pStdPPSs ); 16764 return seed; 16765 } 16766 }; 16767 16768 template <> 16769 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersCreateInfoKHR> 16770 { operator ()std::hash16771 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersCreateInfoKHR const & videoEncodeH265SessionParametersCreateInfoKHR ) const 16772 VULKAN_HPP_NOEXCEPT 16773 { 16774 std::size_t seed = 0; 16775 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersCreateInfoKHR.sType ); 16776 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersCreateInfoKHR.pNext ); 16777 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersCreateInfoKHR.maxStdVPSCount ); 16778 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersCreateInfoKHR.maxStdSPSCount ); 16779 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersCreateInfoKHR.maxStdPPSCount ); 16780 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersCreateInfoKHR.pParametersAddInfo ); 16781 return seed; 16782 } 16783 }; 16784 16785 template <> 16786 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersFeedbackInfoKHR> 16787 { operator ()std::hash16788 std::size_t operator()( 16789 VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersFeedbackInfoKHR const & videoEncodeH265SessionParametersFeedbackInfoKHR ) const VULKAN_HPP_NOEXCEPT 16790 { 16791 std::size_t seed = 0; 16792 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersFeedbackInfoKHR.sType ); 16793 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersFeedbackInfoKHR.pNext ); 16794 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersFeedbackInfoKHR.hasStdVPSOverrides ); 16795 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersFeedbackInfoKHR.hasStdSPSOverrides ); 16796 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersFeedbackInfoKHR.hasStdPPSOverrides ); 16797 return seed; 16798 } 16799 }; 16800 16801 template <> 16802 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersGetInfoKHR> 16803 { operator ()std::hash16804 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersGetInfoKHR const & videoEncodeH265SessionParametersGetInfoKHR ) const 16805 VULKAN_HPP_NOEXCEPT 16806 { 16807 std::size_t seed = 0; 16808 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersGetInfoKHR.sType ); 16809 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersGetInfoKHR.pNext ); 16810 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersGetInfoKHR.writeStdVPS ); 16811 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersGetInfoKHR.writeStdSPS ); 16812 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersGetInfoKHR.writeStdPPS ); 16813 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersGetInfoKHR.stdVPSId ); 16814 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersGetInfoKHR.stdSPSId ); 16815 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersGetInfoKHR.stdPPSId ); 16816 return seed; 16817 } 16818 }; 16819 16820 template <> 16821 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeInfoKHR> 16822 { operator ()std::hash16823 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeInfoKHR const & videoEncodeInfoKHR ) const VULKAN_HPP_NOEXCEPT 16824 { 16825 std::size_t seed = 0; 16826 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.sType ); 16827 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.pNext ); 16828 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.flags ); 16829 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.dstBuffer ); 16830 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.dstBufferOffset ); 16831 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.dstBufferRange ); 16832 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.srcPictureResource ); 16833 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.pSetupReferenceSlot ); 16834 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.referenceSlotCount ); 16835 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.pReferenceSlots ); 16836 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.precedingExternallyEncodedBytes ); 16837 return seed; 16838 } 16839 }; 16840 16841 template <> 16842 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelInfoKHR> 16843 { operator ()std::hash16844 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelInfoKHR const & videoEncodeQualityLevelInfoKHR ) const VULKAN_HPP_NOEXCEPT 16845 { 16846 std::size_t seed = 0; 16847 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQualityLevelInfoKHR.sType ); 16848 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQualityLevelInfoKHR.pNext ); 16849 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQualityLevelInfoKHR.qualityLevel ); 16850 return seed; 16851 } 16852 }; 16853 16854 template <> 16855 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelPropertiesKHR> 16856 { operator ()std::hash16857 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelPropertiesKHR const & videoEncodeQualityLevelPropertiesKHR ) const VULKAN_HPP_NOEXCEPT 16858 { 16859 std::size_t seed = 0; 16860 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQualityLevelPropertiesKHR.sType ); 16861 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQualityLevelPropertiesKHR.pNext ); 16862 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQualityLevelPropertiesKHR.preferredRateControlMode ); 16863 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQualityLevelPropertiesKHR.preferredRateControlLayerCount ); 16864 return seed; 16865 } 16866 }; 16867 16868 template <> 16869 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeRateControlLayerInfoKHR> 16870 { operator ()std::hash16871 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeRateControlLayerInfoKHR const & videoEncodeRateControlLayerInfoKHR ) const VULKAN_HPP_NOEXCEPT 16872 { 16873 std::size_t seed = 0; 16874 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlLayerInfoKHR.sType ); 16875 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlLayerInfoKHR.pNext ); 16876 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlLayerInfoKHR.averageBitrate ); 16877 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlLayerInfoKHR.maxBitrate ); 16878 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlLayerInfoKHR.frameRateNumerator ); 16879 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlLayerInfoKHR.frameRateDenominator ); 16880 return seed; 16881 } 16882 }; 16883 16884 template <> 16885 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeRateControlInfoKHR> 16886 { operator ()std::hash16887 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeRateControlInfoKHR const & videoEncodeRateControlInfoKHR ) const VULKAN_HPP_NOEXCEPT 16888 { 16889 std::size_t seed = 0; 16890 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlInfoKHR.sType ); 16891 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlInfoKHR.pNext ); 16892 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlInfoKHR.flags ); 16893 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlInfoKHR.rateControlMode ); 16894 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlInfoKHR.layerCount ); 16895 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlInfoKHR.pLayers ); 16896 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlInfoKHR.virtualBufferSizeInMs ); 16897 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlInfoKHR.initialVirtualBufferSizeInMs ); 16898 return seed; 16899 } 16900 }; 16901 16902 template <> 16903 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersFeedbackInfoKHR> 16904 { operator ()std::hash16905 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersFeedbackInfoKHR const & videoEncodeSessionParametersFeedbackInfoKHR ) const 16906 VULKAN_HPP_NOEXCEPT 16907 { 16908 std::size_t seed = 0; 16909 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionParametersFeedbackInfoKHR.sType ); 16910 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionParametersFeedbackInfoKHR.pNext ); 16911 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionParametersFeedbackInfoKHR.hasOverrides ); 16912 return seed; 16913 } 16914 }; 16915 16916 template <> 16917 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR> 16918 { 16919 std::size_t operator ()std::hash16920 operator()( VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR const & videoEncodeSessionParametersGetInfoKHR ) const VULKAN_HPP_NOEXCEPT 16921 { 16922 std::size_t seed = 0; 16923 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionParametersGetInfoKHR.sType ); 16924 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionParametersGetInfoKHR.pNext ); 16925 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionParametersGetInfoKHR.videoSessionParameters ); 16926 return seed; 16927 } 16928 }; 16929 16930 template <> 16931 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeUsageInfoKHR> 16932 { operator ()std::hash16933 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeUsageInfoKHR const & videoEncodeUsageInfoKHR ) const VULKAN_HPP_NOEXCEPT 16934 { 16935 std::size_t seed = 0; 16936 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeUsageInfoKHR.sType ); 16937 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeUsageInfoKHR.pNext ); 16938 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeUsageInfoKHR.videoUsageHints ); 16939 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeUsageInfoKHR.videoContentHints ); 16940 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeUsageInfoKHR.tuningMode ); 16941 return seed; 16942 } 16943 }; 16944 16945 template <> 16946 struct hash<VULKAN_HPP_NAMESPACE::VideoEndCodingInfoKHR> 16947 { operator ()std::hash16948 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEndCodingInfoKHR const & videoEndCodingInfoKHR ) const VULKAN_HPP_NOEXCEPT 16949 { 16950 std::size_t seed = 0; 16951 VULKAN_HPP_HASH_COMBINE( seed, videoEndCodingInfoKHR.sType ); 16952 VULKAN_HPP_HASH_COMBINE( seed, videoEndCodingInfoKHR.pNext ); 16953 VULKAN_HPP_HASH_COMBINE( seed, videoEndCodingInfoKHR.flags ); 16954 return seed; 16955 } 16956 }; 16957 16958 template <> 16959 struct hash<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR> 16960 { operator ()std::hash16961 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR const & videoFormatPropertiesKHR ) const VULKAN_HPP_NOEXCEPT 16962 { 16963 std::size_t seed = 0; 16964 VULKAN_HPP_HASH_COMBINE( seed, videoFormatPropertiesKHR.sType ); 16965 VULKAN_HPP_HASH_COMBINE( seed, videoFormatPropertiesKHR.pNext ); 16966 VULKAN_HPP_HASH_COMBINE( seed, videoFormatPropertiesKHR.format ); 16967 VULKAN_HPP_HASH_COMBINE( seed, videoFormatPropertiesKHR.componentMapping ); 16968 VULKAN_HPP_HASH_COMBINE( seed, videoFormatPropertiesKHR.imageCreateFlags ); 16969 VULKAN_HPP_HASH_COMBINE( seed, videoFormatPropertiesKHR.imageType ); 16970 VULKAN_HPP_HASH_COMBINE( seed, videoFormatPropertiesKHR.imageTiling ); 16971 VULKAN_HPP_HASH_COMBINE( seed, videoFormatPropertiesKHR.imageUsageFlags ); 16972 return seed; 16973 } 16974 }; 16975 16976 template <> 16977 struct hash<VULKAN_HPP_NAMESPACE::VideoInlineQueryInfoKHR> 16978 { operator ()std::hash16979 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoInlineQueryInfoKHR const & videoInlineQueryInfoKHR ) const VULKAN_HPP_NOEXCEPT 16980 { 16981 std::size_t seed = 0; 16982 VULKAN_HPP_HASH_COMBINE( seed, videoInlineQueryInfoKHR.sType ); 16983 VULKAN_HPP_HASH_COMBINE( seed, videoInlineQueryInfoKHR.pNext ); 16984 VULKAN_HPP_HASH_COMBINE( seed, videoInlineQueryInfoKHR.queryPool ); 16985 VULKAN_HPP_HASH_COMBINE( seed, videoInlineQueryInfoKHR.firstQuery ); 16986 VULKAN_HPP_HASH_COMBINE( seed, videoInlineQueryInfoKHR.queryCount ); 16987 return seed; 16988 } 16989 }; 16990 16991 template <> 16992 struct hash<VULKAN_HPP_NAMESPACE::VideoProfileListInfoKHR> 16993 { operator ()std::hash16994 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoProfileListInfoKHR const & videoProfileListInfoKHR ) const VULKAN_HPP_NOEXCEPT 16995 { 16996 std::size_t seed = 0; 16997 VULKAN_HPP_HASH_COMBINE( seed, videoProfileListInfoKHR.sType ); 16998 VULKAN_HPP_HASH_COMBINE( seed, videoProfileListInfoKHR.pNext ); 16999 VULKAN_HPP_HASH_COMBINE( seed, videoProfileListInfoKHR.profileCount ); 17000 VULKAN_HPP_HASH_COMBINE( seed, videoProfileListInfoKHR.pProfiles ); 17001 return seed; 17002 } 17003 }; 17004 17005 template <> 17006 struct hash<VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR> 17007 { operator ()std::hash17008 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR const & videoSessionCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 17009 { 17010 std::size_t seed = 0; 17011 VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.sType ); 17012 VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.pNext ); 17013 VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.queueFamilyIndex ); 17014 VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.flags ); 17015 VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.pVideoProfile ); 17016 VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.pictureFormat ); 17017 VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.maxCodedExtent ); 17018 VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.referencePictureFormat ); 17019 VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.maxDpbSlots ); 17020 VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.maxActiveReferencePictures ); 17021 VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.pStdHeaderVersion ); 17022 return seed; 17023 } 17024 }; 17025 17026 template <> 17027 struct hash<VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR> 17028 { operator ()std::hash17029 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR const & videoSessionMemoryRequirementsKHR ) const VULKAN_HPP_NOEXCEPT 17030 { 17031 std::size_t seed = 0; 17032 VULKAN_HPP_HASH_COMBINE( seed, videoSessionMemoryRequirementsKHR.sType ); 17033 VULKAN_HPP_HASH_COMBINE( seed, videoSessionMemoryRequirementsKHR.pNext ); 17034 VULKAN_HPP_HASH_COMBINE( seed, videoSessionMemoryRequirementsKHR.memoryBindIndex ); 17035 VULKAN_HPP_HASH_COMBINE( seed, videoSessionMemoryRequirementsKHR.memoryRequirements ); 17036 return seed; 17037 } 17038 }; 17039 17040 template <> 17041 struct hash<VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR> 17042 { operator ()std::hash17043 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR const & videoSessionParametersCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 17044 { 17045 std::size_t seed = 0; 17046 VULKAN_HPP_HASH_COMBINE( seed, videoSessionParametersCreateInfoKHR.sType ); 17047 VULKAN_HPP_HASH_COMBINE( seed, videoSessionParametersCreateInfoKHR.pNext ); 17048 VULKAN_HPP_HASH_COMBINE( seed, videoSessionParametersCreateInfoKHR.flags ); 17049 VULKAN_HPP_HASH_COMBINE( seed, videoSessionParametersCreateInfoKHR.videoSessionParametersTemplate ); 17050 VULKAN_HPP_HASH_COMBINE( seed, videoSessionParametersCreateInfoKHR.videoSession ); 17051 return seed; 17052 } 17053 }; 17054 17055 template <> 17056 struct hash<VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR> 17057 { operator ()std::hash17058 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR const & videoSessionParametersUpdateInfoKHR ) const VULKAN_HPP_NOEXCEPT 17059 { 17060 std::size_t seed = 0; 17061 VULKAN_HPP_HASH_COMBINE( seed, videoSessionParametersUpdateInfoKHR.sType ); 17062 VULKAN_HPP_HASH_COMBINE( seed, videoSessionParametersUpdateInfoKHR.pNext ); 17063 VULKAN_HPP_HASH_COMBINE( seed, videoSessionParametersUpdateInfoKHR.updateSequenceCount ); 17064 return seed; 17065 } 17066 }; 17067 17068 # if defined( VK_USE_PLATFORM_WAYLAND_KHR ) 17069 template <> 17070 struct hash<VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR> 17071 { operator ()std::hash17072 std::size_t operator()( VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR const & waylandSurfaceCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 17073 { 17074 std::size_t seed = 0; 17075 VULKAN_HPP_HASH_COMBINE( seed, waylandSurfaceCreateInfoKHR.sType ); 17076 VULKAN_HPP_HASH_COMBINE( seed, waylandSurfaceCreateInfoKHR.pNext ); 17077 VULKAN_HPP_HASH_COMBINE( seed, waylandSurfaceCreateInfoKHR.flags ); 17078 VULKAN_HPP_HASH_COMBINE( seed, waylandSurfaceCreateInfoKHR.display ); 17079 VULKAN_HPP_HASH_COMBINE( seed, waylandSurfaceCreateInfoKHR.surface ); 17080 return seed; 17081 } 17082 }; 17083 # endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ 17084 17085 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 17086 template <> 17087 struct hash<VULKAN_HPP_NAMESPACE::Win32KeyedMutexAcquireReleaseInfoKHR> 17088 { operator ()std::hash17089 std::size_t operator()( VULKAN_HPP_NAMESPACE::Win32KeyedMutexAcquireReleaseInfoKHR const & win32KeyedMutexAcquireReleaseInfoKHR ) const VULKAN_HPP_NOEXCEPT 17090 { 17091 std::size_t seed = 0; 17092 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoKHR.sType ); 17093 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoKHR.pNext ); 17094 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoKHR.acquireCount ); 17095 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoKHR.pAcquireSyncs ); 17096 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoKHR.pAcquireKeys ); 17097 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoKHR.pAcquireTimeouts ); 17098 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoKHR.releaseCount ); 17099 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoKHR.pReleaseSyncs ); 17100 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoKHR.pReleaseKeys ); 17101 return seed; 17102 } 17103 }; 17104 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 17105 17106 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 17107 template <> 17108 struct hash<VULKAN_HPP_NAMESPACE::Win32KeyedMutexAcquireReleaseInfoNV> 17109 { operator ()std::hash17110 std::size_t operator()( VULKAN_HPP_NAMESPACE::Win32KeyedMutexAcquireReleaseInfoNV const & win32KeyedMutexAcquireReleaseInfoNV ) const VULKAN_HPP_NOEXCEPT 17111 { 17112 std::size_t seed = 0; 17113 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoNV.sType ); 17114 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoNV.pNext ); 17115 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoNV.acquireCount ); 17116 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoNV.pAcquireSyncs ); 17117 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoNV.pAcquireKeys ); 17118 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoNV.pAcquireTimeoutMilliseconds ); 17119 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoNV.releaseCount ); 17120 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoNV.pReleaseSyncs ); 17121 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoNV.pReleaseKeys ); 17122 return seed; 17123 } 17124 }; 17125 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 17126 17127 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 17128 template <> 17129 struct hash<VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR> 17130 { operator ()std::hash17131 std::size_t operator()( VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR const & win32SurfaceCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 17132 { 17133 std::size_t seed = 0; 17134 VULKAN_HPP_HASH_COMBINE( seed, win32SurfaceCreateInfoKHR.sType ); 17135 VULKAN_HPP_HASH_COMBINE( seed, win32SurfaceCreateInfoKHR.pNext ); 17136 VULKAN_HPP_HASH_COMBINE( seed, win32SurfaceCreateInfoKHR.flags ); 17137 VULKAN_HPP_HASH_COMBINE( seed, win32SurfaceCreateInfoKHR.hinstance ); 17138 VULKAN_HPP_HASH_COMBINE( seed, win32SurfaceCreateInfoKHR.hwnd ); 17139 return seed; 17140 } 17141 }; 17142 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 17143 17144 template <> 17145 struct hash<VULKAN_HPP_NAMESPACE::WriteDescriptorSetAccelerationStructureKHR> 17146 { operator ()std::hash17147 std::size_t operator()( VULKAN_HPP_NAMESPACE::WriteDescriptorSetAccelerationStructureKHR const & writeDescriptorSetAccelerationStructureKHR ) const 17148 VULKAN_HPP_NOEXCEPT 17149 { 17150 std::size_t seed = 0; 17151 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetAccelerationStructureKHR.sType ); 17152 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetAccelerationStructureKHR.pNext ); 17153 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetAccelerationStructureKHR.accelerationStructureCount ); 17154 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetAccelerationStructureKHR.pAccelerationStructures ); 17155 return seed; 17156 } 17157 }; 17158 17159 template <> 17160 struct hash<VULKAN_HPP_NAMESPACE::WriteDescriptorSetAccelerationStructureNV> 17161 { 17162 std::size_t operator ()std::hash17163 operator()( VULKAN_HPP_NAMESPACE::WriteDescriptorSetAccelerationStructureNV const & writeDescriptorSetAccelerationStructureNV ) const VULKAN_HPP_NOEXCEPT 17164 { 17165 std::size_t seed = 0; 17166 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetAccelerationStructureNV.sType ); 17167 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetAccelerationStructureNV.pNext ); 17168 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetAccelerationStructureNV.accelerationStructureCount ); 17169 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetAccelerationStructureNV.pAccelerationStructures ); 17170 return seed; 17171 } 17172 }; 17173 17174 template <> 17175 struct hash<VULKAN_HPP_NAMESPACE::WriteDescriptorSetInlineUniformBlock> 17176 { operator ()std::hash17177 std::size_t operator()( VULKAN_HPP_NAMESPACE::WriteDescriptorSetInlineUniformBlock const & writeDescriptorSetInlineUniformBlock ) const VULKAN_HPP_NOEXCEPT 17178 { 17179 std::size_t seed = 0; 17180 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetInlineUniformBlock.sType ); 17181 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetInlineUniformBlock.pNext ); 17182 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetInlineUniformBlock.dataSize ); 17183 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetInlineUniformBlock.pData ); 17184 return seed; 17185 } 17186 }; 17187 17188 # if defined( VK_USE_PLATFORM_XCB_KHR ) 17189 template <> 17190 struct hash<VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR> 17191 { operator ()std::hash17192 std::size_t operator()( VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR const & xcbSurfaceCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 17193 { 17194 std::size_t seed = 0; 17195 VULKAN_HPP_HASH_COMBINE( seed, xcbSurfaceCreateInfoKHR.sType ); 17196 VULKAN_HPP_HASH_COMBINE( seed, xcbSurfaceCreateInfoKHR.pNext ); 17197 VULKAN_HPP_HASH_COMBINE( seed, xcbSurfaceCreateInfoKHR.flags ); 17198 VULKAN_HPP_HASH_COMBINE( seed, xcbSurfaceCreateInfoKHR.connection ); 17199 VULKAN_HPP_HASH_COMBINE( seed, xcbSurfaceCreateInfoKHR.window ); 17200 return seed; 17201 } 17202 }; 17203 # endif /*VK_USE_PLATFORM_XCB_KHR*/ 17204 17205 # if defined( VK_USE_PLATFORM_XLIB_KHR ) 17206 template <> 17207 struct hash<VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR> 17208 { operator ()std::hash17209 std::size_t operator()( VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR const & xlibSurfaceCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 17210 { 17211 std::size_t seed = 0; 17212 VULKAN_HPP_HASH_COMBINE( seed, xlibSurfaceCreateInfoKHR.sType ); 17213 VULKAN_HPP_HASH_COMBINE( seed, xlibSurfaceCreateInfoKHR.pNext ); 17214 VULKAN_HPP_HASH_COMBINE( seed, xlibSurfaceCreateInfoKHR.flags ); 17215 VULKAN_HPP_HASH_COMBINE( seed, xlibSurfaceCreateInfoKHR.dpy ); 17216 VULKAN_HPP_HASH_COMBINE( seed, xlibSurfaceCreateInfoKHR.window ); 17217 return seed; 17218 } 17219 }; 17220 # endif /*VK_USE_PLATFORM_XLIB_KHR*/ 17221 17222 #endif // 14 <= VULKAN_HPP_CPP_VERSION 17223 17224 } // namespace std 17225 #endif 17226