1 // Copyright 2015-2024 The Khronos Group Inc. 2 // 3 // SPDX-License-Identifier: Apache-2.0 OR MIT 4 // 5 6 // This header is generated from the Khronos Vulkan XML API Registry. 7 8 #ifndef VULKAN_HASH_HPP 9 #define VULKAN_HASH_HPP 10 11 #include <vulkan/vulkan.hpp> 12 13 namespace std 14 { 15 //======================================= 16 //=== HASH structures for Flags types === 17 //======================================= 18 19 template <typename BitType> 20 struct hash<VULKAN_HPP_NAMESPACE::Flags<BitType>> 21 { operator ()std::hash22 std::size_t operator()( VULKAN_HPP_NAMESPACE::Flags<BitType> const & flags ) const VULKAN_HPP_NOEXCEPT 23 { 24 return std::hash<typename std::underlying_type<BitType>::type>{}( static_cast<typename std::underlying_type<BitType>::type>( flags ) ); 25 } 26 }; 27 28 //=================================== 29 //=== HASH structures for handles === 30 //=================================== 31 32 //=== VK_VERSION_1_0 === 33 34 template <> 35 struct hash<VULKAN_HPP_NAMESPACE::Instance> 36 { operator ()std::hash37 std::size_t operator()( VULKAN_HPP_NAMESPACE::Instance const & instance ) const VULKAN_HPP_NOEXCEPT 38 { 39 return std::hash<VkInstance>{}( static_cast<VkInstance>( instance ) ); 40 } 41 }; 42 43 template <> 44 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevice> 45 { operator ()std::hash46 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevice const & physicalDevice ) const VULKAN_HPP_NOEXCEPT 47 { 48 return std::hash<VkPhysicalDevice>{}( static_cast<VkPhysicalDevice>( physicalDevice ) ); 49 } 50 }; 51 52 template <> 53 struct hash<VULKAN_HPP_NAMESPACE::Device> 54 { operator ()std::hash55 std::size_t operator()( VULKAN_HPP_NAMESPACE::Device const & device ) const VULKAN_HPP_NOEXCEPT 56 { 57 return std::hash<VkDevice>{}( static_cast<VkDevice>( device ) ); 58 } 59 }; 60 61 template <> 62 struct hash<VULKAN_HPP_NAMESPACE::Queue> 63 { operator ()std::hash64 std::size_t operator()( VULKAN_HPP_NAMESPACE::Queue const & queue ) const VULKAN_HPP_NOEXCEPT 65 { 66 return std::hash<VkQueue>{}( static_cast<VkQueue>( queue ) ); 67 } 68 }; 69 70 template <> 71 struct hash<VULKAN_HPP_NAMESPACE::DeviceMemory> 72 { operator ()std::hash73 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceMemory const & deviceMemory ) const VULKAN_HPP_NOEXCEPT 74 { 75 return std::hash<VkDeviceMemory>{}( static_cast<VkDeviceMemory>( deviceMemory ) ); 76 } 77 }; 78 79 template <> 80 struct hash<VULKAN_HPP_NAMESPACE::Fence> 81 { operator ()std::hash82 std::size_t operator()( VULKAN_HPP_NAMESPACE::Fence const & fence ) const VULKAN_HPP_NOEXCEPT 83 { 84 return std::hash<VkFence>{}( static_cast<VkFence>( fence ) ); 85 } 86 }; 87 88 template <> 89 struct hash<VULKAN_HPP_NAMESPACE::Semaphore> 90 { operator ()std::hash91 std::size_t operator()( VULKAN_HPP_NAMESPACE::Semaphore const & semaphore ) const VULKAN_HPP_NOEXCEPT 92 { 93 return std::hash<VkSemaphore>{}( static_cast<VkSemaphore>( semaphore ) ); 94 } 95 }; 96 97 template <> 98 struct hash<VULKAN_HPP_NAMESPACE::Event> 99 { operator ()std::hash100 std::size_t operator()( VULKAN_HPP_NAMESPACE::Event const & event ) const VULKAN_HPP_NOEXCEPT 101 { 102 return std::hash<VkEvent>{}( static_cast<VkEvent>( event ) ); 103 } 104 }; 105 106 template <> 107 struct hash<VULKAN_HPP_NAMESPACE::QueryPool> 108 { operator ()std::hash109 std::size_t operator()( VULKAN_HPP_NAMESPACE::QueryPool const & queryPool ) const VULKAN_HPP_NOEXCEPT 110 { 111 return std::hash<VkQueryPool>{}( static_cast<VkQueryPool>( queryPool ) ); 112 } 113 }; 114 115 template <> 116 struct hash<VULKAN_HPP_NAMESPACE::Buffer> 117 { operator ()std::hash118 std::size_t operator()( VULKAN_HPP_NAMESPACE::Buffer const & buffer ) const VULKAN_HPP_NOEXCEPT 119 { 120 return std::hash<VkBuffer>{}( static_cast<VkBuffer>( buffer ) ); 121 } 122 }; 123 124 template <> 125 struct hash<VULKAN_HPP_NAMESPACE::BufferView> 126 { operator ()std::hash127 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferView const & bufferView ) const VULKAN_HPP_NOEXCEPT 128 { 129 return std::hash<VkBufferView>{}( static_cast<VkBufferView>( bufferView ) ); 130 } 131 }; 132 133 template <> 134 struct hash<VULKAN_HPP_NAMESPACE::Image> 135 { operator ()std::hash136 std::size_t operator()( VULKAN_HPP_NAMESPACE::Image const & image ) const VULKAN_HPP_NOEXCEPT 137 { 138 return std::hash<VkImage>{}( static_cast<VkImage>( image ) ); 139 } 140 }; 141 142 template <> 143 struct hash<VULKAN_HPP_NAMESPACE::ImageView> 144 { operator ()std::hash145 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageView const & imageView ) const VULKAN_HPP_NOEXCEPT 146 { 147 return std::hash<VkImageView>{}( static_cast<VkImageView>( imageView ) ); 148 } 149 }; 150 151 template <> 152 struct hash<VULKAN_HPP_NAMESPACE::ShaderModule> 153 { operator ()std::hash154 std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderModule const & shaderModule ) const VULKAN_HPP_NOEXCEPT 155 { 156 return std::hash<VkShaderModule>{}( static_cast<VkShaderModule>( shaderModule ) ); 157 } 158 }; 159 160 template <> 161 struct hash<VULKAN_HPP_NAMESPACE::PipelineCache> 162 { operator ()std::hash163 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCache const & pipelineCache ) const VULKAN_HPP_NOEXCEPT 164 { 165 return std::hash<VkPipelineCache>{}( static_cast<VkPipelineCache>( pipelineCache ) ); 166 } 167 }; 168 169 template <> 170 struct hash<VULKAN_HPP_NAMESPACE::Pipeline> 171 { operator ()std::hash172 std::size_t operator()( VULKAN_HPP_NAMESPACE::Pipeline const & pipeline ) const VULKAN_HPP_NOEXCEPT 173 { 174 return std::hash<VkPipeline>{}( static_cast<VkPipeline>( pipeline ) ); 175 } 176 }; 177 178 template <> 179 struct hash<VULKAN_HPP_NAMESPACE::PipelineLayout> 180 { operator ()std::hash181 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineLayout const & pipelineLayout ) const VULKAN_HPP_NOEXCEPT 182 { 183 return std::hash<VkPipelineLayout>{}( static_cast<VkPipelineLayout>( pipelineLayout ) ); 184 } 185 }; 186 187 template <> 188 struct hash<VULKAN_HPP_NAMESPACE::Sampler> 189 { operator ()std::hash190 std::size_t operator()( VULKAN_HPP_NAMESPACE::Sampler const & sampler ) const VULKAN_HPP_NOEXCEPT 191 { 192 return std::hash<VkSampler>{}( static_cast<VkSampler>( sampler ) ); 193 } 194 }; 195 196 template <> 197 struct hash<VULKAN_HPP_NAMESPACE::DescriptorPool> 198 { operator ()std::hash199 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorPool const & descriptorPool ) const VULKAN_HPP_NOEXCEPT 200 { 201 return std::hash<VkDescriptorPool>{}( static_cast<VkDescriptorPool>( descriptorPool ) ); 202 } 203 }; 204 205 template <> 206 struct hash<VULKAN_HPP_NAMESPACE::DescriptorSet> 207 { operator ()std::hash208 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSet const & descriptorSet ) const VULKAN_HPP_NOEXCEPT 209 { 210 return std::hash<VkDescriptorSet>{}( static_cast<VkDescriptorSet>( descriptorSet ) ); 211 } 212 }; 213 214 template <> 215 struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetLayout> 216 { operator ()std::hash217 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetLayout const & descriptorSetLayout ) const VULKAN_HPP_NOEXCEPT 218 { 219 return std::hash<VkDescriptorSetLayout>{}( static_cast<VkDescriptorSetLayout>( descriptorSetLayout ) ); 220 } 221 }; 222 223 template <> 224 struct hash<VULKAN_HPP_NAMESPACE::Framebuffer> 225 { operator ()std::hash226 std::size_t operator()( VULKAN_HPP_NAMESPACE::Framebuffer const & framebuffer ) const VULKAN_HPP_NOEXCEPT 227 { 228 return std::hash<VkFramebuffer>{}( static_cast<VkFramebuffer>( framebuffer ) ); 229 } 230 }; 231 232 template <> 233 struct hash<VULKAN_HPP_NAMESPACE::RenderPass> 234 { operator ()std::hash235 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPass const & renderPass ) const VULKAN_HPP_NOEXCEPT 236 { 237 return std::hash<VkRenderPass>{}( static_cast<VkRenderPass>( renderPass ) ); 238 } 239 }; 240 241 template <> 242 struct hash<VULKAN_HPP_NAMESPACE::CommandPool> 243 { operator ()std::hash244 std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandPool const & commandPool ) const VULKAN_HPP_NOEXCEPT 245 { 246 return std::hash<VkCommandPool>{}( static_cast<VkCommandPool>( commandPool ) ); 247 } 248 }; 249 250 template <> 251 struct hash<VULKAN_HPP_NAMESPACE::CommandBuffer> 252 { operator ()std::hash253 std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBuffer const & commandBuffer ) const VULKAN_HPP_NOEXCEPT 254 { 255 return std::hash<VkCommandBuffer>{}( static_cast<VkCommandBuffer>( commandBuffer ) ); 256 } 257 }; 258 259 //=== VK_VERSION_1_1 === 260 261 template <> 262 struct hash<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion> 263 { operator ()std::hash264 std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion const & samplerYcbcrConversion ) const VULKAN_HPP_NOEXCEPT 265 { 266 return std::hash<VkSamplerYcbcrConversion>{}( static_cast<VkSamplerYcbcrConversion>( samplerYcbcrConversion ) ); 267 } 268 }; 269 270 template <> 271 struct hash<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate> 272 { operator ()std::hash273 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate const & descriptorUpdateTemplate ) const VULKAN_HPP_NOEXCEPT 274 { 275 return std::hash<VkDescriptorUpdateTemplate>{}( static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ) ); 276 } 277 }; 278 279 //=== VK_VERSION_1_3 === 280 281 template <> 282 struct hash<VULKAN_HPP_NAMESPACE::PrivateDataSlot> 283 { operator ()std::hash284 std::size_t operator()( VULKAN_HPP_NAMESPACE::PrivateDataSlot const & privateDataSlot ) const VULKAN_HPP_NOEXCEPT 285 { 286 return std::hash<VkPrivateDataSlot>{}( static_cast<VkPrivateDataSlot>( privateDataSlot ) ); 287 } 288 }; 289 290 //=== VK_KHR_surface === 291 292 template <> 293 struct hash<VULKAN_HPP_NAMESPACE::SurfaceKHR> 294 { operator ()std::hash295 std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceKHR const & surfaceKHR ) const VULKAN_HPP_NOEXCEPT 296 { 297 return std::hash<VkSurfaceKHR>{}( static_cast<VkSurfaceKHR>( surfaceKHR ) ); 298 } 299 }; 300 301 //=== VK_KHR_swapchain === 302 303 template <> 304 struct hash<VULKAN_HPP_NAMESPACE::SwapchainKHR> 305 { operator ()std::hash306 std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainKHR const & swapchainKHR ) const VULKAN_HPP_NOEXCEPT 307 { 308 return std::hash<VkSwapchainKHR>{}( static_cast<VkSwapchainKHR>( swapchainKHR ) ); 309 } 310 }; 311 312 //=== VK_KHR_display === 313 314 template <> 315 struct hash<VULKAN_HPP_NAMESPACE::DisplayKHR> 316 { operator ()std::hash317 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayKHR const & displayKHR ) const VULKAN_HPP_NOEXCEPT 318 { 319 return std::hash<VkDisplayKHR>{}( static_cast<VkDisplayKHR>( displayKHR ) ); 320 } 321 }; 322 323 template <> 324 struct hash<VULKAN_HPP_NAMESPACE::DisplayModeKHR> 325 { operator ()std::hash326 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayModeKHR const & displayModeKHR ) const VULKAN_HPP_NOEXCEPT 327 { 328 return std::hash<VkDisplayModeKHR>{}( static_cast<VkDisplayModeKHR>( displayModeKHR ) ); 329 } 330 }; 331 332 //=== VK_EXT_debug_report === 333 334 template <> 335 struct hash<VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT> 336 { operator ()std::hash337 std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT const & debugReportCallbackEXT ) const VULKAN_HPP_NOEXCEPT 338 { 339 return std::hash<VkDebugReportCallbackEXT>{}( static_cast<VkDebugReportCallbackEXT>( debugReportCallbackEXT ) ); 340 } 341 }; 342 343 //=== VK_KHR_video_queue === 344 345 template <> 346 struct hash<VULKAN_HPP_NAMESPACE::VideoSessionKHR> 347 { operator ()std::hash348 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoSessionKHR const & videoSessionKHR ) const VULKAN_HPP_NOEXCEPT 349 { 350 return std::hash<VkVideoSessionKHR>{}( static_cast<VkVideoSessionKHR>( videoSessionKHR ) ); 351 } 352 }; 353 354 template <> 355 struct hash<VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR> 356 { operator ()std::hash357 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR const & videoSessionParametersKHR ) const VULKAN_HPP_NOEXCEPT 358 { 359 return std::hash<VkVideoSessionParametersKHR>{}( static_cast<VkVideoSessionParametersKHR>( videoSessionParametersKHR ) ); 360 } 361 }; 362 363 //=== VK_NVX_binary_import === 364 365 template <> 366 struct hash<VULKAN_HPP_NAMESPACE::CuModuleNVX> 367 { operator ()std::hash368 std::size_t operator()( VULKAN_HPP_NAMESPACE::CuModuleNVX const & cuModuleNVX ) const VULKAN_HPP_NOEXCEPT 369 { 370 return std::hash<VkCuModuleNVX>{}( static_cast<VkCuModuleNVX>( cuModuleNVX ) ); 371 } 372 }; 373 374 template <> 375 struct hash<VULKAN_HPP_NAMESPACE::CuFunctionNVX> 376 { operator ()std::hash377 std::size_t operator()( VULKAN_HPP_NAMESPACE::CuFunctionNVX const & cuFunctionNVX ) const VULKAN_HPP_NOEXCEPT 378 { 379 return std::hash<VkCuFunctionNVX>{}( static_cast<VkCuFunctionNVX>( cuFunctionNVX ) ); 380 } 381 }; 382 383 //=== VK_EXT_debug_utils === 384 385 template <> 386 struct hash<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT> 387 { operator ()std::hash388 std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT const & debugUtilsMessengerEXT ) const VULKAN_HPP_NOEXCEPT 389 { 390 return std::hash<VkDebugUtilsMessengerEXT>{}( static_cast<VkDebugUtilsMessengerEXT>( debugUtilsMessengerEXT ) ); 391 } 392 }; 393 394 //=== VK_KHR_acceleration_structure === 395 396 template <> 397 struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> 398 { operator ()std::hash399 std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR const & accelerationStructureKHR ) const VULKAN_HPP_NOEXCEPT 400 { 401 return std::hash<VkAccelerationStructureKHR>{}( static_cast<VkAccelerationStructureKHR>( accelerationStructureKHR ) ); 402 } 403 }; 404 405 //=== VK_EXT_validation_cache === 406 407 template <> 408 struct hash<VULKAN_HPP_NAMESPACE::ValidationCacheEXT> 409 { operator ()std::hash410 std::size_t operator()( VULKAN_HPP_NAMESPACE::ValidationCacheEXT const & validationCacheEXT ) const VULKAN_HPP_NOEXCEPT 411 { 412 return std::hash<VkValidationCacheEXT>{}( static_cast<VkValidationCacheEXT>( validationCacheEXT ) ); 413 } 414 }; 415 416 //=== VK_NV_ray_tracing === 417 418 template <> 419 struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureNV> 420 { operator ()std::hash421 std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureNV const & accelerationStructureNV ) const VULKAN_HPP_NOEXCEPT 422 { 423 return std::hash<VkAccelerationStructureNV>{}( static_cast<VkAccelerationStructureNV>( accelerationStructureNV ) ); 424 } 425 }; 426 427 //=== VK_INTEL_performance_query === 428 429 template <> 430 struct hash<VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL> 431 { operator ()std::hash432 std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL const & performanceConfigurationINTEL ) const VULKAN_HPP_NOEXCEPT 433 { 434 return std::hash<VkPerformanceConfigurationINTEL>{}( static_cast<VkPerformanceConfigurationINTEL>( performanceConfigurationINTEL ) ); 435 } 436 }; 437 438 //=== VK_KHR_deferred_host_operations === 439 440 template <> 441 struct hash<VULKAN_HPP_NAMESPACE::DeferredOperationKHR> 442 { operator ()std::hash443 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeferredOperationKHR const & deferredOperationKHR ) const VULKAN_HPP_NOEXCEPT 444 { 445 return std::hash<VkDeferredOperationKHR>{}( static_cast<VkDeferredOperationKHR>( deferredOperationKHR ) ); 446 } 447 }; 448 449 //=== VK_NV_device_generated_commands === 450 451 template <> 452 struct hash<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV> 453 { operator ()std::hash454 std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV const & indirectCommandsLayoutNV ) const VULKAN_HPP_NOEXCEPT 455 { 456 return std::hash<VkIndirectCommandsLayoutNV>{}( static_cast<VkIndirectCommandsLayoutNV>( indirectCommandsLayoutNV ) ); 457 } 458 }; 459 460 #if defined( VK_ENABLE_BETA_EXTENSIONS ) 461 //=== VK_NV_cuda_kernel_launch === 462 463 template <> 464 struct hash<VULKAN_HPP_NAMESPACE::CudaModuleNV> 465 { operator ()std::hash466 std::size_t operator()( VULKAN_HPP_NAMESPACE::CudaModuleNV const & cudaModuleNV ) const VULKAN_HPP_NOEXCEPT 467 { 468 return std::hash<VkCudaModuleNV>{}( static_cast<VkCudaModuleNV>( cudaModuleNV ) ); 469 } 470 }; 471 472 template <> 473 struct hash<VULKAN_HPP_NAMESPACE::CudaFunctionNV> 474 { operator ()std::hash475 std::size_t operator()( VULKAN_HPP_NAMESPACE::CudaFunctionNV const & cudaFunctionNV ) const VULKAN_HPP_NOEXCEPT 476 { 477 return std::hash<VkCudaFunctionNV>{}( static_cast<VkCudaFunctionNV>( cudaFunctionNV ) ); 478 } 479 }; 480 #endif /*VK_ENABLE_BETA_EXTENSIONS*/ 481 482 #if defined( VK_USE_PLATFORM_FUCHSIA ) 483 //=== VK_FUCHSIA_buffer_collection === 484 485 template <> 486 struct hash<VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA> 487 { operator ()std::hash488 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA const & bufferCollectionFUCHSIA ) const VULKAN_HPP_NOEXCEPT 489 { 490 return std::hash<VkBufferCollectionFUCHSIA>{}( static_cast<VkBufferCollectionFUCHSIA>( bufferCollectionFUCHSIA ) ); 491 } 492 }; 493 #endif /*VK_USE_PLATFORM_FUCHSIA*/ 494 495 //=== VK_EXT_opacity_micromap === 496 497 template <> 498 struct hash<VULKAN_HPP_NAMESPACE::MicromapEXT> 499 { operator ()std::hash500 std::size_t operator()( VULKAN_HPP_NAMESPACE::MicromapEXT const & micromapEXT ) const VULKAN_HPP_NOEXCEPT 501 { 502 return std::hash<VkMicromapEXT>{}( static_cast<VkMicromapEXT>( micromapEXT ) ); 503 } 504 }; 505 506 //=== VK_NV_optical_flow === 507 508 template <> 509 struct hash<VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV> 510 { operator ()std::hash511 std::size_t operator()( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV const & opticalFlowSessionNV ) const VULKAN_HPP_NOEXCEPT 512 { 513 return std::hash<VkOpticalFlowSessionNV>{}( static_cast<VkOpticalFlowSessionNV>( opticalFlowSessionNV ) ); 514 } 515 }; 516 517 //=== VK_EXT_shader_object === 518 519 template <> 520 struct hash<VULKAN_HPP_NAMESPACE::ShaderEXT> 521 { operator ()std::hash522 std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderEXT const & shaderEXT ) const VULKAN_HPP_NOEXCEPT 523 { 524 return std::hash<VkShaderEXT>{}( static_cast<VkShaderEXT>( shaderEXT ) ); 525 } 526 }; 527 528 #if 14 <= VULKAN_HPP_CPP_VERSION 529 //====================================== 530 //=== HASH structures for structures === 531 //====================================== 532 533 # if !defined( VULKAN_HPP_HASH_COMBINE ) 534 # define VULKAN_HPP_HASH_COMBINE( seed, value ) \ 535 seed ^= std::hash<std::decay<decltype( value )>::type>{}( value ) + 0x9e3779b9 + ( seed << 6 ) + ( seed >> 2 ) 536 # endif 537 538 template <> 539 struct hash<VULKAN_HPP_NAMESPACE::AabbPositionsKHR> 540 { operator ()std::hash541 std::size_t operator()( VULKAN_HPP_NAMESPACE::AabbPositionsKHR const & aabbPositionsKHR ) const VULKAN_HPP_NOEXCEPT 542 { 543 std::size_t seed = 0; 544 VULKAN_HPP_HASH_COMBINE( seed, aabbPositionsKHR.minX ); 545 VULKAN_HPP_HASH_COMBINE( seed, aabbPositionsKHR.minY ); 546 VULKAN_HPP_HASH_COMBINE( seed, aabbPositionsKHR.minZ ); 547 VULKAN_HPP_HASH_COMBINE( seed, aabbPositionsKHR.maxX ); 548 VULKAN_HPP_HASH_COMBINE( seed, aabbPositionsKHR.maxY ); 549 VULKAN_HPP_HASH_COMBINE( seed, aabbPositionsKHR.maxZ ); 550 return seed; 551 } 552 }; 553 554 template <> 555 struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR> 556 { 557 std::size_t operator ()std::hash558 operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR const & accelerationStructureBuildRangeInfoKHR ) const VULKAN_HPP_NOEXCEPT 559 { 560 std::size_t seed = 0; 561 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildRangeInfoKHR.primitiveCount ); 562 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildRangeInfoKHR.primitiveOffset ); 563 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildRangeInfoKHR.firstVertex ); 564 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildRangeInfoKHR.transformOffset ); 565 return seed; 566 } 567 }; 568 569 template <> 570 struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR> 571 { 572 std::size_t operator ()std::hash573 operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR const & accelerationStructureBuildSizesInfoKHR ) const VULKAN_HPP_NOEXCEPT 574 { 575 std::size_t seed = 0; 576 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildSizesInfoKHR.sType ); 577 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildSizesInfoKHR.pNext ); 578 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildSizesInfoKHR.accelerationStructureSize ); 579 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildSizesInfoKHR.updateScratchSize ); 580 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildSizesInfoKHR.buildScratchSize ); 581 return seed; 582 } 583 }; 584 585 template <> 586 struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureCaptureDescriptorDataInfoEXT> 587 { operator ()std::hash588 std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureCaptureDescriptorDataInfoEXT const & accelerationStructureCaptureDescriptorDataInfoEXT ) 589 const VULKAN_HPP_NOEXCEPT 590 { 591 std::size_t seed = 0; 592 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCaptureDescriptorDataInfoEXT.sType ); 593 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCaptureDescriptorDataInfoEXT.pNext ); 594 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCaptureDescriptorDataInfoEXT.accelerationStructure ); 595 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCaptureDescriptorDataInfoEXT.accelerationStructureNV ); 596 return seed; 597 } 598 }; 599 600 template <> 601 struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR> 602 { operator ()std::hash603 std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR const & accelerationStructureCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 604 { 605 std::size_t seed = 0; 606 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoKHR.sType ); 607 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoKHR.pNext ); 608 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoKHR.createFlags ); 609 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoKHR.buffer ); 610 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoKHR.offset ); 611 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoKHR.size ); 612 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoKHR.type ); 613 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoKHR.deviceAddress ); 614 return seed; 615 } 616 }; 617 618 template <> 619 struct hash<VULKAN_HPP_NAMESPACE::GeometryTrianglesNV> 620 { operator ()std::hash621 std::size_t operator()( VULKAN_HPP_NAMESPACE::GeometryTrianglesNV const & geometryTrianglesNV ) const VULKAN_HPP_NOEXCEPT 622 { 623 std::size_t seed = 0; 624 VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.sType ); 625 VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.pNext ); 626 VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.vertexData ); 627 VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.vertexOffset ); 628 VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.vertexCount ); 629 VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.vertexStride ); 630 VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.vertexFormat ); 631 VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.indexData ); 632 VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.indexOffset ); 633 VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.indexCount ); 634 VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.indexType ); 635 VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.transformData ); 636 VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.transformOffset ); 637 return seed; 638 } 639 }; 640 641 template <> 642 struct hash<VULKAN_HPP_NAMESPACE::GeometryAABBNV> 643 { operator ()std::hash644 std::size_t operator()( VULKAN_HPP_NAMESPACE::GeometryAABBNV const & geometryAABBNV ) const VULKAN_HPP_NOEXCEPT 645 { 646 std::size_t seed = 0; 647 VULKAN_HPP_HASH_COMBINE( seed, geometryAABBNV.sType ); 648 VULKAN_HPP_HASH_COMBINE( seed, geometryAABBNV.pNext ); 649 VULKAN_HPP_HASH_COMBINE( seed, geometryAABBNV.aabbData ); 650 VULKAN_HPP_HASH_COMBINE( seed, geometryAABBNV.numAABBs ); 651 VULKAN_HPP_HASH_COMBINE( seed, geometryAABBNV.stride ); 652 VULKAN_HPP_HASH_COMBINE( seed, geometryAABBNV.offset ); 653 return seed; 654 } 655 }; 656 657 template <> 658 struct hash<VULKAN_HPP_NAMESPACE::GeometryDataNV> 659 { operator ()std::hash660 std::size_t operator()( VULKAN_HPP_NAMESPACE::GeometryDataNV const & geometryDataNV ) const VULKAN_HPP_NOEXCEPT 661 { 662 std::size_t seed = 0; 663 VULKAN_HPP_HASH_COMBINE( seed, geometryDataNV.triangles ); 664 VULKAN_HPP_HASH_COMBINE( seed, geometryDataNV.aabbs ); 665 return seed; 666 } 667 }; 668 669 template <> 670 struct hash<VULKAN_HPP_NAMESPACE::GeometryNV> 671 { operator ()std::hash672 std::size_t operator()( VULKAN_HPP_NAMESPACE::GeometryNV const & geometryNV ) const VULKAN_HPP_NOEXCEPT 673 { 674 std::size_t seed = 0; 675 VULKAN_HPP_HASH_COMBINE( seed, geometryNV.sType ); 676 VULKAN_HPP_HASH_COMBINE( seed, geometryNV.pNext ); 677 VULKAN_HPP_HASH_COMBINE( seed, geometryNV.geometryType ); 678 VULKAN_HPP_HASH_COMBINE( seed, geometryNV.geometry ); 679 VULKAN_HPP_HASH_COMBINE( seed, geometryNV.flags ); 680 return seed; 681 } 682 }; 683 684 template <> 685 struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV> 686 { operator ()std::hash687 std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV const & accelerationStructureInfoNV ) const VULKAN_HPP_NOEXCEPT 688 { 689 std::size_t seed = 0; 690 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInfoNV.sType ); 691 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInfoNV.pNext ); 692 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInfoNV.type ); 693 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInfoNV.flags ); 694 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInfoNV.instanceCount ); 695 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInfoNV.geometryCount ); 696 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInfoNV.pGeometries ); 697 return seed; 698 } 699 }; 700 701 template <> 702 struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV> 703 { operator ()std::hash704 std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV const & accelerationStructureCreateInfoNV ) const VULKAN_HPP_NOEXCEPT 705 { 706 std::size_t seed = 0; 707 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoNV.sType ); 708 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoNV.pNext ); 709 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoNV.compactedSize ); 710 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoNV.info ); 711 return seed; 712 } 713 }; 714 715 template <> 716 struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR> 717 { 718 std::size_t operator ()std::hash719 operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR const & accelerationStructureDeviceAddressInfoKHR ) const VULKAN_HPP_NOEXCEPT 720 { 721 std::size_t seed = 0; 722 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureDeviceAddressInfoKHR.sType ); 723 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureDeviceAddressInfoKHR.pNext ); 724 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureDeviceAddressInfoKHR.accelerationStructure ); 725 return seed; 726 } 727 }; 728 729 template <> 730 struct hash<VULKAN_HPP_NAMESPACE::TransformMatrixKHR> 731 { operator ()std::hash732 std::size_t operator()( VULKAN_HPP_NAMESPACE::TransformMatrixKHR const & transformMatrixKHR ) const VULKAN_HPP_NOEXCEPT 733 { 734 std::size_t seed = 0; 735 for ( size_t i = 0; i < 3; ++i ) 736 { 737 for ( size_t j = 0; j < 4; ++j ) 738 { 739 VULKAN_HPP_HASH_COMBINE( seed, transformMatrixKHR.matrix[i][j] ); 740 } 741 } 742 return seed; 743 } 744 }; 745 746 template <> 747 struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureInstanceKHR> 748 { operator ()std::hash749 std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureInstanceKHR const & accelerationStructureInstanceKHR ) const VULKAN_HPP_NOEXCEPT 750 { 751 std::size_t seed = 0; 752 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInstanceKHR.transform ); 753 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInstanceKHR.instanceCustomIndex ); 754 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInstanceKHR.mask ); 755 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInstanceKHR.instanceShaderBindingTableRecordOffset ); 756 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInstanceKHR.flags ); 757 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInstanceKHR.accelerationStructureReference ); 758 return seed; 759 } 760 }; 761 762 template <> 763 struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureMatrixMotionInstanceNV> 764 { operator ()std::hash765 std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureMatrixMotionInstanceNV const & accelerationStructureMatrixMotionInstanceNV ) const 766 VULKAN_HPP_NOEXCEPT 767 { 768 std::size_t seed = 0; 769 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMatrixMotionInstanceNV.transformT0 ); 770 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMatrixMotionInstanceNV.transformT1 ); 771 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMatrixMotionInstanceNV.instanceCustomIndex ); 772 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMatrixMotionInstanceNV.mask ); 773 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMatrixMotionInstanceNV.instanceShaderBindingTableRecordOffset ); 774 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMatrixMotionInstanceNV.flags ); 775 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMatrixMotionInstanceNV.accelerationStructureReference ); 776 return seed; 777 } 778 }; 779 780 template <> 781 struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV> 782 { operator ()std::hash783 std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV const & accelerationStructureMemoryRequirementsInfoNV ) const 784 VULKAN_HPP_NOEXCEPT 785 { 786 std::size_t seed = 0; 787 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMemoryRequirementsInfoNV.sType ); 788 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMemoryRequirementsInfoNV.pNext ); 789 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMemoryRequirementsInfoNV.type ); 790 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMemoryRequirementsInfoNV.accelerationStructure ); 791 return seed; 792 } 793 }; 794 795 template <> 796 struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInfoNV> 797 { operator ()std::hash798 std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInfoNV const & accelerationStructureMotionInfoNV ) const VULKAN_HPP_NOEXCEPT 799 { 800 std::size_t seed = 0; 801 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMotionInfoNV.sType ); 802 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMotionInfoNV.pNext ); 803 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMotionInfoNV.maxInstances ); 804 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMotionInfoNV.flags ); 805 return seed; 806 } 807 }; 808 809 template <> 810 struct hash<VULKAN_HPP_NAMESPACE::SRTDataNV> 811 { operator ()std::hash812 std::size_t operator()( VULKAN_HPP_NAMESPACE::SRTDataNV const & sRTDataNV ) const VULKAN_HPP_NOEXCEPT 813 { 814 std::size_t seed = 0; 815 VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.sx ); 816 VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.a ); 817 VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.b ); 818 VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.pvx ); 819 VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.sy ); 820 VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.c ); 821 VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.pvy ); 822 VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.sz ); 823 VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.pvz ); 824 VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.qx ); 825 VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.qy ); 826 VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.qz ); 827 VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.qw ); 828 VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.tx ); 829 VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.ty ); 830 VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.tz ); 831 return seed; 832 } 833 }; 834 835 template <> 836 struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureSRTMotionInstanceNV> 837 { 838 std::size_t operator ()std::hash839 operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureSRTMotionInstanceNV const & accelerationStructureSRTMotionInstanceNV ) const VULKAN_HPP_NOEXCEPT 840 { 841 std::size_t seed = 0; 842 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureSRTMotionInstanceNV.transformT0 ); 843 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureSRTMotionInstanceNV.transformT1 ); 844 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureSRTMotionInstanceNV.instanceCustomIndex ); 845 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureSRTMotionInstanceNV.mask ); 846 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureSRTMotionInstanceNV.instanceShaderBindingTableRecordOffset ); 847 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureSRTMotionInstanceNV.flags ); 848 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureSRTMotionInstanceNV.accelerationStructureReference ); 849 return seed; 850 } 851 }; 852 853 template <> 854 struct hash<VULKAN_HPP_NAMESPACE::MicromapUsageEXT> 855 { operator ()std::hash856 std::size_t operator()( VULKAN_HPP_NAMESPACE::MicromapUsageEXT const & micromapUsageEXT ) const VULKAN_HPP_NOEXCEPT 857 { 858 std::size_t seed = 0; 859 VULKAN_HPP_HASH_COMBINE( seed, micromapUsageEXT.count ); 860 VULKAN_HPP_HASH_COMBINE( seed, micromapUsageEXT.subdivisionLevel ); 861 VULKAN_HPP_HASH_COMBINE( seed, micromapUsageEXT.format ); 862 return seed; 863 } 864 }; 865 866 template <> 867 struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureVersionInfoKHR> 868 { operator ()std::hash869 std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureVersionInfoKHR const & accelerationStructureVersionInfoKHR ) const VULKAN_HPP_NOEXCEPT 870 { 871 std::size_t seed = 0; 872 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureVersionInfoKHR.sType ); 873 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureVersionInfoKHR.pNext ); 874 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureVersionInfoKHR.pVersionData ); 875 return seed; 876 } 877 }; 878 879 template <> 880 struct hash<VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR> 881 { operator ()std::hash882 std::size_t operator()( VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR const & acquireNextImageInfoKHR ) const VULKAN_HPP_NOEXCEPT 883 { 884 std::size_t seed = 0; 885 VULKAN_HPP_HASH_COMBINE( seed, acquireNextImageInfoKHR.sType ); 886 VULKAN_HPP_HASH_COMBINE( seed, acquireNextImageInfoKHR.pNext ); 887 VULKAN_HPP_HASH_COMBINE( seed, acquireNextImageInfoKHR.swapchain ); 888 VULKAN_HPP_HASH_COMBINE( seed, acquireNextImageInfoKHR.timeout ); 889 VULKAN_HPP_HASH_COMBINE( seed, acquireNextImageInfoKHR.semaphore ); 890 VULKAN_HPP_HASH_COMBINE( seed, acquireNextImageInfoKHR.fence ); 891 VULKAN_HPP_HASH_COMBINE( seed, acquireNextImageInfoKHR.deviceMask ); 892 return seed; 893 } 894 }; 895 896 template <> 897 struct hash<VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR> 898 { operator ()std::hash899 std::size_t operator()( VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR const & acquireProfilingLockInfoKHR ) const VULKAN_HPP_NOEXCEPT 900 { 901 std::size_t seed = 0; 902 VULKAN_HPP_HASH_COMBINE( seed, acquireProfilingLockInfoKHR.sType ); 903 VULKAN_HPP_HASH_COMBINE( seed, acquireProfilingLockInfoKHR.pNext ); 904 VULKAN_HPP_HASH_COMBINE( seed, acquireProfilingLockInfoKHR.flags ); 905 VULKAN_HPP_HASH_COMBINE( seed, acquireProfilingLockInfoKHR.timeout ); 906 return seed; 907 } 908 }; 909 910 template <> 911 struct hash<VULKAN_HPP_NAMESPACE::AllocationCallbacks> 912 { operator ()std::hash913 std::size_t operator()( VULKAN_HPP_NAMESPACE::AllocationCallbacks const & allocationCallbacks ) const VULKAN_HPP_NOEXCEPT 914 { 915 std::size_t seed = 0; 916 VULKAN_HPP_HASH_COMBINE( seed, allocationCallbacks.pUserData ); 917 VULKAN_HPP_HASH_COMBINE( seed, allocationCallbacks.pfnAllocation ); 918 VULKAN_HPP_HASH_COMBINE( seed, allocationCallbacks.pfnReallocation ); 919 VULKAN_HPP_HASH_COMBINE( seed, allocationCallbacks.pfnFree ); 920 VULKAN_HPP_HASH_COMBINE( seed, allocationCallbacks.pfnInternalAllocation ); 921 VULKAN_HPP_HASH_COMBINE( seed, allocationCallbacks.pfnInternalFree ); 922 return seed; 923 } 924 }; 925 926 template <> 927 struct hash<VULKAN_HPP_NAMESPACE::AmigoProfilingSubmitInfoSEC> 928 { operator ()std::hash929 std::size_t operator()( VULKAN_HPP_NAMESPACE::AmigoProfilingSubmitInfoSEC const & amigoProfilingSubmitInfoSEC ) const VULKAN_HPP_NOEXCEPT 930 { 931 std::size_t seed = 0; 932 VULKAN_HPP_HASH_COMBINE( seed, amigoProfilingSubmitInfoSEC.sType ); 933 VULKAN_HPP_HASH_COMBINE( seed, amigoProfilingSubmitInfoSEC.pNext ); 934 VULKAN_HPP_HASH_COMBINE( seed, amigoProfilingSubmitInfoSEC.firstDrawTimestamp ); 935 VULKAN_HPP_HASH_COMBINE( seed, amigoProfilingSubmitInfoSEC.swapBufferTimestamp ); 936 return seed; 937 } 938 }; 939 940 template <> 941 struct hash<VULKAN_HPP_NAMESPACE::ComponentMapping> 942 { operator ()std::hash943 std::size_t operator()( VULKAN_HPP_NAMESPACE::ComponentMapping const & componentMapping ) const VULKAN_HPP_NOEXCEPT 944 { 945 std::size_t seed = 0; 946 VULKAN_HPP_HASH_COMBINE( seed, componentMapping.r ); 947 VULKAN_HPP_HASH_COMBINE( seed, componentMapping.g ); 948 VULKAN_HPP_HASH_COMBINE( seed, componentMapping.b ); 949 VULKAN_HPP_HASH_COMBINE( seed, componentMapping.a ); 950 return seed; 951 } 952 }; 953 954 # if defined( VK_USE_PLATFORM_ANDROID_KHR ) 955 template <> 956 struct hash<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatProperties2ANDROID> 957 { operator ()std::hash958 std::size_t operator()( VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatProperties2ANDROID const & androidHardwareBufferFormatProperties2ANDROID ) const 959 VULKAN_HPP_NOEXCEPT 960 { 961 std::size_t seed = 0; 962 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.sType ); 963 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.pNext ); 964 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.format ); 965 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.externalFormat ); 966 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.formatFeatures ); 967 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.samplerYcbcrConversionComponents ); 968 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.suggestedYcbcrModel ); 969 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.suggestedYcbcrRange ); 970 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.suggestedXChromaOffset ); 971 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.suggestedYChromaOffset ); 972 return seed; 973 } 974 }; 975 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ 976 977 # if defined( VK_USE_PLATFORM_ANDROID_KHR ) 978 template <> 979 struct hash<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatPropertiesANDROID> 980 { operator ()std::hash981 std::size_t operator()( VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatPropertiesANDROID const & androidHardwareBufferFormatPropertiesANDROID ) const 982 VULKAN_HPP_NOEXCEPT 983 { 984 std::size_t seed = 0; 985 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.sType ); 986 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.pNext ); 987 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.format ); 988 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.externalFormat ); 989 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.formatFeatures ); 990 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.samplerYcbcrConversionComponents ); 991 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.suggestedYcbcrModel ); 992 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.suggestedYcbcrRange ); 993 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.suggestedXChromaOffset ); 994 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.suggestedYChromaOffset ); 995 return seed; 996 } 997 }; 998 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ 999 1000 # if defined( VK_USE_PLATFORM_ANDROID_KHR ) 1001 template <> 1002 struct hash<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatResolvePropertiesANDROID> 1003 { 1004 std::size_t operator ()std::hash1005 operator()( VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatResolvePropertiesANDROID const & androidHardwareBufferFormatResolvePropertiesANDROID ) const 1006 VULKAN_HPP_NOEXCEPT 1007 { 1008 std::size_t seed = 0; 1009 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatResolvePropertiesANDROID.sType ); 1010 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatResolvePropertiesANDROID.pNext ); 1011 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatResolvePropertiesANDROID.colorAttachmentFormat ); 1012 return seed; 1013 } 1014 }; 1015 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ 1016 1017 # if defined( VK_USE_PLATFORM_ANDROID_KHR ) 1018 template <> 1019 struct hash<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID> 1020 { 1021 std::size_t operator ()std::hash1022 operator()( VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID const & androidHardwareBufferPropertiesANDROID ) const VULKAN_HPP_NOEXCEPT 1023 { 1024 std::size_t seed = 0; 1025 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferPropertiesANDROID.sType ); 1026 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferPropertiesANDROID.pNext ); 1027 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferPropertiesANDROID.allocationSize ); 1028 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferPropertiesANDROID.memoryTypeBits ); 1029 return seed; 1030 } 1031 }; 1032 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ 1033 1034 # if defined( VK_USE_PLATFORM_ANDROID_KHR ) 1035 template <> 1036 struct hash<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferUsageANDROID> 1037 { operator ()std::hash1038 std::size_t operator()( VULKAN_HPP_NAMESPACE::AndroidHardwareBufferUsageANDROID const & androidHardwareBufferUsageANDROID ) const VULKAN_HPP_NOEXCEPT 1039 { 1040 std::size_t seed = 0; 1041 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferUsageANDROID.sType ); 1042 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferUsageANDROID.pNext ); 1043 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferUsageANDROID.androidHardwareBufferUsage ); 1044 return seed; 1045 } 1046 }; 1047 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ 1048 1049 # if defined( VK_USE_PLATFORM_ANDROID_KHR ) 1050 template <> 1051 struct hash<VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR> 1052 { operator ()std::hash1053 std::size_t operator()( VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR const & androidSurfaceCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 1054 { 1055 std::size_t seed = 0; 1056 VULKAN_HPP_HASH_COMBINE( seed, androidSurfaceCreateInfoKHR.sType ); 1057 VULKAN_HPP_HASH_COMBINE( seed, androidSurfaceCreateInfoKHR.pNext ); 1058 VULKAN_HPP_HASH_COMBINE( seed, androidSurfaceCreateInfoKHR.flags ); 1059 VULKAN_HPP_HASH_COMBINE( seed, androidSurfaceCreateInfoKHR.window ); 1060 return seed; 1061 } 1062 }; 1063 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ 1064 1065 template <> 1066 struct hash<VULKAN_HPP_NAMESPACE::ApplicationInfo> 1067 { operator ()std::hash1068 std::size_t operator()( VULKAN_HPP_NAMESPACE::ApplicationInfo const & applicationInfo ) const VULKAN_HPP_NOEXCEPT 1069 { 1070 std::size_t seed = 0; 1071 VULKAN_HPP_HASH_COMBINE( seed, applicationInfo.sType ); 1072 VULKAN_HPP_HASH_COMBINE( seed, applicationInfo.pNext ); 1073 for ( const char * p = applicationInfo.pApplicationName; *p != '\0'; ++p ) 1074 { 1075 VULKAN_HPP_HASH_COMBINE( seed, *p ); 1076 } 1077 VULKAN_HPP_HASH_COMBINE( seed, applicationInfo.applicationVersion ); 1078 for ( const char * p = applicationInfo.pEngineName; *p != '\0'; ++p ) 1079 { 1080 VULKAN_HPP_HASH_COMBINE( seed, *p ); 1081 } 1082 VULKAN_HPP_HASH_COMBINE( seed, applicationInfo.engineVersion ); 1083 VULKAN_HPP_HASH_COMBINE( seed, applicationInfo.apiVersion ); 1084 return seed; 1085 } 1086 }; 1087 1088 template <> 1089 struct hash<VULKAN_HPP_NAMESPACE::AttachmentDescription> 1090 { operator ()std::hash1091 std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentDescription const & attachmentDescription ) const VULKAN_HPP_NOEXCEPT 1092 { 1093 std::size_t seed = 0; 1094 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.flags ); 1095 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.format ); 1096 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.samples ); 1097 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.loadOp ); 1098 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.storeOp ); 1099 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.stencilLoadOp ); 1100 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.stencilStoreOp ); 1101 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.initialLayout ); 1102 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.finalLayout ); 1103 return seed; 1104 } 1105 }; 1106 1107 template <> 1108 struct hash<VULKAN_HPP_NAMESPACE::AttachmentDescription2> 1109 { operator ()std::hash1110 std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentDescription2 const & attachmentDescription2 ) const VULKAN_HPP_NOEXCEPT 1111 { 1112 std::size_t seed = 0; 1113 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.sType ); 1114 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.pNext ); 1115 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.flags ); 1116 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.format ); 1117 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.samples ); 1118 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.loadOp ); 1119 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.storeOp ); 1120 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.stencilLoadOp ); 1121 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.stencilStoreOp ); 1122 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.initialLayout ); 1123 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.finalLayout ); 1124 return seed; 1125 } 1126 }; 1127 1128 template <> 1129 struct hash<VULKAN_HPP_NAMESPACE::AttachmentDescriptionStencilLayout> 1130 { operator ()std::hash1131 std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentDescriptionStencilLayout const & attachmentDescriptionStencilLayout ) const VULKAN_HPP_NOEXCEPT 1132 { 1133 std::size_t seed = 0; 1134 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescriptionStencilLayout.sType ); 1135 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescriptionStencilLayout.pNext ); 1136 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescriptionStencilLayout.stencilInitialLayout ); 1137 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescriptionStencilLayout.stencilFinalLayout ); 1138 return seed; 1139 } 1140 }; 1141 1142 template <> 1143 struct hash<VULKAN_HPP_NAMESPACE::AttachmentReference> 1144 { operator ()std::hash1145 std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentReference const & attachmentReference ) const VULKAN_HPP_NOEXCEPT 1146 { 1147 std::size_t seed = 0; 1148 VULKAN_HPP_HASH_COMBINE( seed, attachmentReference.attachment ); 1149 VULKAN_HPP_HASH_COMBINE( seed, attachmentReference.layout ); 1150 return seed; 1151 } 1152 }; 1153 1154 template <> 1155 struct hash<VULKAN_HPP_NAMESPACE::AttachmentReference2> 1156 { operator ()std::hash1157 std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentReference2 const & attachmentReference2 ) const VULKAN_HPP_NOEXCEPT 1158 { 1159 std::size_t seed = 0; 1160 VULKAN_HPP_HASH_COMBINE( seed, attachmentReference2.sType ); 1161 VULKAN_HPP_HASH_COMBINE( seed, attachmentReference2.pNext ); 1162 VULKAN_HPP_HASH_COMBINE( seed, attachmentReference2.attachment ); 1163 VULKAN_HPP_HASH_COMBINE( seed, attachmentReference2.layout ); 1164 VULKAN_HPP_HASH_COMBINE( seed, attachmentReference2.aspectMask ); 1165 return seed; 1166 } 1167 }; 1168 1169 template <> 1170 struct hash<VULKAN_HPP_NAMESPACE::AttachmentReferenceStencilLayout> 1171 { operator ()std::hash1172 std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentReferenceStencilLayout const & attachmentReferenceStencilLayout ) const VULKAN_HPP_NOEXCEPT 1173 { 1174 std::size_t seed = 0; 1175 VULKAN_HPP_HASH_COMBINE( seed, attachmentReferenceStencilLayout.sType ); 1176 VULKAN_HPP_HASH_COMBINE( seed, attachmentReferenceStencilLayout.pNext ); 1177 VULKAN_HPP_HASH_COMBINE( seed, attachmentReferenceStencilLayout.stencilLayout ); 1178 return seed; 1179 } 1180 }; 1181 1182 template <> 1183 struct hash<VULKAN_HPP_NAMESPACE::AttachmentSampleCountInfoAMD> 1184 { operator ()std::hash1185 std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentSampleCountInfoAMD const & attachmentSampleCountInfoAMD ) const VULKAN_HPP_NOEXCEPT 1186 { 1187 std::size_t seed = 0; 1188 VULKAN_HPP_HASH_COMBINE( seed, attachmentSampleCountInfoAMD.sType ); 1189 VULKAN_HPP_HASH_COMBINE( seed, attachmentSampleCountInfoAMD.pNext ); 1190 VULKAN_HPP_HASH_COMBINE( seed, attachmentSampleCountInfoAMD.colorAttachmentCount ); 1191 VULKAN_HPP_HASH_COMBINE( seed, attachmentSampleCountInfoAMD.pColorAttachmentSamples ); 1192 VULKAN_HPP_HASH_COMBINE( seed, attachmentSampleCountInfoAMD.depthStencilAttachmentSamples ); 1193 return seed; 1194 } 1195 }; 1196 1197 template <> 1198 struct hash<VULKAN_HPP_NAMESPACE::Extent2D> 1199 { operator ()std::hash1200 std::size_t operator()( VULKAN_HPP_NAMESPACE::Extent2D const & extent2D ) const VULKAN_HPP_NOEXCEPT 1201 { 1202 std::size_t seed = 0; 1203 VULKAN_HPP_HASH_COMBINE( seed, extent2D.width ); 1204 VULKAN_HPP_HASH_COMBINE( seed, extent2D.height ); 1205 return seed; 1206 } 1207 }; 1208 1209 template <> 1210 struct hash<VULKAN_HPP_NAMESPACE::SampleLocationEXT> 1211 { operator ()std::hash1212 std::size_t operator()( VULKAN_HPP_NAMESPACE::SampleLocationEXT const & sampleLocationEXT ) const VULKAN_HPP_NOEXCEPT 1213 { 1214 std::size_t seed = 0; 1215 VULKAN_HPP_HASH_COMBINE( seed, sampleLocationEXT.x ); 1216 VULKAN_HPP_HASH_COMBINE( seed, sampleLocationEXT.y ); 1217 return seed; 1218 } 1219 }; 1220 1221 template <> 1222 struct hash<VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT> 1223 { operator ()std::hash1224 std::size_t operator()( VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT const & sampleLocationsInfoEXT ) const VULKAN_HPP_NOEXCEPT 1225 { 1226 std::size_t seed = 0; 1227 VULKAN_HPP_HASH_COMBINE( seed, sampleLocationsInfoEXT.sType ); 1228 VULKAN_HPP_HASH_COMBINE( seed, sampleLocationsInfoEXT.pNext ); 1229 VULKAN_HPP_HASH_COMBINE( seed, sampleLocationsInfoEXT.sampleLocationsPerPixel ); 1230 VULKAN_HPP_HASH_COMBINE( seed, sampleLocationsInfoEXT.sampleLocationGridSize ); 1231 VULKAN_HPP_HASH_COMBINE( seed, sampleLocationsInfoEXT.sampleLocationsCount ); 1232 VULKAN_HPP_HASH_COMBINE( seed, sampleLocationsInfoEXT.pSampleLocations ); 1233 return seed; 1234 } 1235 }; 1236 1237 template <> 1238 struct hash<VULKAN_HPP_NAMESPACE::AttachmentSampleLocationsEXT> 1239 { operator ()std::hash1240 std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentSampleLocationsEXT const & attachmentSampleLocationsEXT ) const VULKAN_HPP_NOEXCEPT 1241 { 1242 std::size_t seed = 0; 1243 VULKAN_HPP_HASH_COMBINE( seed, attachmentSampleLocationsEXT.attachmentIndex ); 1244 VULKAN_HPP_HASH_COMBINE( seed, attachmentSampleLocationsEXT.sampleLocationsInfo ); 1245 return seed; 1246 } 1247 }; 1248 1249 template <> 1250 struct hash<VULKAN_HPP_NAMESPACE::BaseInStructure> 1251 { operator ()std::hash1252 std::size_t operator()( VULKAN_HPP_NAMESPACE::BaseInStructure const & baseInStructure ) const VULKAN_HPP_NOEXCEPT 1253 { 1254 std::size_t seed = 0; 1255 VULKAN_HPP_HASH_COMBINE( seed, baseInStructure.sType ); 1256 VULKAN_HPP_HASH_COMBINE( seed, baseInStructure.pNext ); 1257 return seed; 1258 } 1259 }; 1260 1261 template <> 1262 struct hash<VULKAN_HPP_NAMESPACE::BaseOutStructure> 1263 { operator ()std::hash1264 std::size_t operator()( VULKAN_HPP_NAMESPACE::BaseOutStructure const & baseOutStructure ) const VULKAN_HPP_NOEXCEPT 1265 { 1266 std::size_t seed = 0; 1267 VULKAN_HPP_HASH_COMBINE( seed, baseOutStructure.sType ); 1268 VULKAN_HPP_HASH_COMBINE( seed, baseOutStructure.pNext ); 1269 return seed; 1270 } 1271 }; 1272 1273 template <> 1274 struct hash<VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV> 1275 { 1276 std::size_t operator ()std::hash1277 operator()( VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV const & bindAccelerationStructureMemoryInfoNV ) const VULKAN_HPP_NOEXCEPT 1278 { 1279 std::size_t seed = 0; 1280 VULKAN_HPP_HASH_COMBINE( seed, bindAccelerationStructureMemoryInfoNV.sType ); 1281 VULKAN_HPP_HASH_COMBINE( seed, bindAccelerationStructureMemoryInfoNV.pNext ); 1282 VULKAN_HPP_HASH_COMBINE( seed, bindAccelerationStructureMemoryInfoNV.accelerationStructure ); 1283 VULKAN_HPP_HASH_COMBINE( seed, bindAccelerationStructureMemoryInfoNV.memory ); 1284 VULKAN_HPP_HASH_COMBINE( seed, bindAccelerationStructureMemoryInfoNV.memoryOffset ); 1285 VULKAN_HPP_HASH_COMBINE( seed, bindAccelerationStructureMemoryInfoNV.deviceIndexCount ); 1286 VULKAN_HPP_HASH_COMBINE( seed, bindAccelerationStructureMemoryInfoNV.pDeviceIndices ); 1287 return seed; 1288 } 1289 }; 1290 1291 template <> 1292 struct hash<VULKAN_HPP_NAMESPACE::BindBufferMemoryDeviceGroupInfo> 1293 { operator ()std::hash1294 std::size_t operator()( VULKAN_HPP_NAMESPACE::BindBufferMemoryDeviceGroupInfo const & bindBufferMemoryDeviceGroupInfo ) const VULKAN_HPP_NOEXCEPT 1295 { 1296 std::size_t seed = 0; 1297 VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryDeviceGroupInfo.sType ); 1298 VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryDeviceGroupInfo.pNext ); 1299 VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryDeviceGroupInfo.deviceIndexCount ); 1300 VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryDeviceGroupInfo.pDeviceIndices ); 1301 return seed; 1302 } 1303 }; 1304 1305 template <> 1306 struct hash<VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo> 1307 { operator ()std::hash1308 std::size_t operator()( VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo const & bindBufferMemoryInfo ) const VULKAN_HPP_NOEXCEPT 1309 { 1310 std::size_t seed = 0; 1311 VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryInfo.sType ); 1312 VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryInfo.pNext ); 1313 VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryInfo.buffer ); 1314 VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryInfo.memory ); 1315 VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryInfo.memoryOffset ); 1316 return seed; 1317 } 1318 }; 1319 1320 template <> 1321 struct hash<VULKAN_HPP_NAMESPACE::BindDescriptorBufferEmbeddedSamplersInfoEXT> 1322 { operator ()std::hash1323 std::size_t operator()( VULKAN_HPP_NAMESPACE::BindDescriptorBufferEmbeddedSamplersInfoEXT const & bindDescriptorBufferEmbeddedSamplersInfoEXT ) const 1324 VULKAN_HPP_NOEXCEPT 1325 { 1326 std::size_t seed = 0; 1327 VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorBufferEmbeddedSamplersInfoEXT.sType ); 1328 VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorBufferEmbeddedSamplersInfoEXT.pNext ); 1329 VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorBufferEmbeddedSamplersInfoEXT.stageFlags ); 1330 VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorBufferEmbeddedSamplersInfoEXT.layout ); 1331 VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorBufferEmbeddedSamplersInfoEXT.set ); 1332 return seed; 1333 } 1334 }; 1335 1336 template <> 1337 struct hash<VULKAN_HPP_NAMESPACE::BindDescriptorSetsInfoKHR> 1338 { operator ()std::hash1339 std::size_t operator()( VULKAN_HPP_NAMESPACE::BindDescriptorSetsInfoKHR const & bindDescriptorSetsInfoKHR ) const VULKAN_HPP_NOEXCEPT 1340 { 1341 std::size_t seed = 0; 1342 VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorSetsInfoKHR.sType ); 1343 VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorSetsInfoKHR.pNext ); 1344 VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorSetsInfoKHR.stageFlags ); 1345 VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorSetsInfoKHR.layout ); 1346 VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorSetsInfoKHR.firstSet ); 1347 VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorSetsInfoKHR.descriptorSetCount ); 1348 VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorSetsInfoKHR.pDescriptorSets ); 1349 VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorSetsInfoKHR.dynamicOffsetCount ); 1350 VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorSetsInfoKHR.pDynamicOffsets ); 1351 return seed; 1352 } 1353 }; 1354 1355 template <> 1356 struct hash<VULKAN_HPP_NAMESPACE::Offset2D> 1357 { operator ()std::hash1358 std::size_t operator()( VULKAN_HPP_NAMESPACE::Offset2D const & offset2D ) const VULKAN_HPP_NOEXCEPT 1359 { 1360 std::size_t seed = 0; 1361 VULKAN_HPP_HASH_COMBINE( seed, offset2D.x ); 1362 VULKAN_HPP_HASH_COMBINE( seed, offset2D.y ); 1363 return seed; 1364 } 1365 }; 1366 1367 template <> 1368 struct hash<VULKAN_HPP_NAMESPACE::Rect2D> 1369 { operator ()std::hash1370 std::size_t operator()( VULKAN_HPP_NAMESPACE::Rect2D const & rect2D ) const VULKAN_HPP_NOEXCEPT 1371 { 1372 std::size_t seed = 0; 1373 VULKAN_HPP_HASH_COMBINE( seed, rect2D.offset ); 1374 VULKAN_HPP_HASH_COMBINE( seed, rect2D.extent ); 1375 return seed; 1376 } 1377 }; 1378 1379 template <> 1380 struct hash<VULKAN_HPP_NAMESPACE::BindImageMemoryDeviceGroupInfo> 1381 { operator ()std::hash1382 std::size_t operator()( VULKAN_HPP_NAMESPACE::BindImageMemoryDeviceGroupInfo const & bindImageMemoryDeviceGroupInfo ) const VULKAN_HPP_NOEXCEPT 1383 { 1384 std::size_t seed = 0; 1385 VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryDeviceGroupInfo.sType ); 1386 VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryDeviceGroupInfo.pNext ); 1387 VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryDeviceGroupInfo.deviceIndexCount ); 1388 VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryDeviceGroupInfo.pDeviceIndices ); 1389 VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryDeviceGroupInfo.splitInstanceBindRegionCount ); 1390 VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryDeviceGroupInfo.pSplitInstanceBindRegions ); 1391 return seed; 1392 } 1393 }; 1394 1395 template <> 1396 struct hash<VULKAN_HPP_NAMESPACE::BindImageMemoryInfo> 1397 { operator ()std::hash1398 std::size_t operator()( VULKAN_HPP_NAMESPACE::BindImageMemoryInfo const & bindImageMemoryInfo ) const VULKAN_HPP_NOEXCEPT 1399 { 1400 std::size_t seed = 0; 1401 VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryInfo.sType ); 1402 VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryInfo.pNext ); 1403 VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryInfo.image ); 1404 VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryInfo.memory ); 1405 VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryInfo.memoryOffset ); 1406 return seed; 1407 } 1408 }; 1409 1410 template <> 1411 struct hash<VULKAN_HPP_NAMESPACE::BindImageMemorySwapchainInfoKHR> 1412 { operator ()std::hash1413 std::size_t operator()( VULKAN_HPP_NAMESPACE::BindImageMemorySwapchainInfoKHR const & bindImageMemorySwapchainInfoKHR ) const VULKAN_HPP_NOEXCEPT 1414 { 1415 std::size_t seed = 0; 1416 VULKAN_HPP_HASH_COMBINE( seed, bindImageMemorySwapchainInfoKHR.sType ); 1417 VULKAN_HPP_HASH_COMBINE( seed, bindImageMemorySwapchainInfoKHR.pNext ); 1418 VULKAN_HPP_HASH_COMBINE( seed, bindImageMemorySwapchainInfoKHR.swapchain ); 1419 VULKAN_HPP_HASH_COMBINE( seed, bindImageMemorySwapchainInfoKHR.imageIndex ); 1420 return seed; 1421 } 1422 }; 1423 1424 template <> 1425 struct hash<VULKAN_HPP_NAMESPACE::BindImagePlaneMemoryInfo> 1426 { operator ()std::hash1427 std::size_t operator()( VULKAN_HPP_NAMESPACE::BindImagePlaneMemoryInfo const & bindImagePlaneMemoryInfo ) const VULKAN_HPP_NOEXCEPT 1428 { 1429 std::size_t seed = 0; 1430 VULKAN_HPP_HASH_COMBINE( seed, bindImagePlaneMemoryInfo.sType ); 1431 VULKAN_HPP_HASH_COMBINE( seed, bindImagePlaneMemoryInfo.pNext ); 1432 VULKAN_HPP_HASH_COMBINE( seed, bindImagePlaneMemoryInfo.planeAspect ); 1433 return seed; 1434 } 1435 }; 1436 1437 template <> 1438 struct hash<VULKAN_HPP_NAMESPACE::BindIndexBufferIndirectCommandNV> 1439 { operator ()std::hash1440 std::size_t operator()( VULKAN_HPP_NAMESPACE::BindIndexBufferIndirectCommandNV const & bindIndexBufferIndirectCommandNV ) const VULKAN_HPP_NOEXCEPT 1441 { 1442 std::size_t seed = 0; 1443 VULKAN_HPP_HASH_COMBINE( seed, bindIndexBufferIndirectCommandNV.bufferAddress ); 1444 VULKAN_HPP_HASH_COMBINE( seed, bindIndexBufferIndirectCommandNV.size ); 1445 VULKAN_HPP_HASH_COMBINE( seed, bindIndexBufferIndirectCommandNV.indexType ); 1446 return seed; 1447 } 1448 }; 1449 1450 template <> 1451 struct hash<VULKAN_HPP_NAMESPACE::BindMemoryStatusKHR> 1452 { operator ()std::hash1453 std::size_t operator()( VULKAN_HPP_NAMESPACE::BindMemoryStatusKHR const & bindMemoryStatusKHR ) const VULKAN_HPP_NOEXCEPT 1454 { 1455 std::size_t seed = 0; 1456 VULKAN_HPP_HASH_COMBINE( seed, bindMemoryStatusKHR.sType ); 1457 VULKAN_HPP_HASH_COMBINE( seed, bindMemoryStatusKHR.pNext ); 1458 VULKAN_HPP_HASH_COMBINE( seed, bindMemoryStatusKHR.pResult ); 1459 return seed; 1460 } 1461 }; 1462 1463 template <> 1464 struct hash<VULKAN_HPP_NAMESPACE::BindPipelineIndirectCommandNV> 1465 { operator ()std::hash1466 std::size_t operator()( VULKAN_HPP_NAMESPACE::BindPipelineIndirectCommandNV const & bindPipelineIndirectCommandNV ) const VULKAN_HPP_NOEXCEPT 1467 { 1468 std::size_t seed = 0; 1469 VULKAN_HPP_HASH_COMBINE( seed, bindPipelineIndirectCommandNV.pipelineAddress ); 1470 return seed; 1471 } 1472 }; 1473 1474 template <> 1475 struct hash<VULKAN_HPP_NAMESPACE::BindShaderGroupIndirectCommandNV> 1476 { operator ()std::hash1477 std::size_t operator()( VULKAN_HPP_NAMESPACE::BindShaderGroupIndirectCommandNV const & bindShaderGroupIndirectCommandNV ) const VULKAN_HPP_NOEXCEPT 1478 { 1479 std::size_t seed = 0; 1480 VULKAN_HPP_HASH_COMBINE( seed, bindShaderGroupIndirectCommandNV.groupIndex ); 1481 return seed; 1482 } 1483 }; 1484 1485 template <> 1486 struct hash<VULKAN_HPP_NAMESPACE::SparseMemoryBind> 1487 { operator ()std::hash1488 std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseMemoryBind const & sparseMemoryBind ) const VULKAN_HPP_NOEXCEPT 1489 { 1490 std::size_t seed = 0; 1491 VULKAN_HPP_HASH_COMBINE( seed, sparseMemoryBind.resourceOffset ); 1492 VULKAN_HPP_HASH_COMBINE( seed, sparseMemoryBind.size ); 1493 VULKAN_HPP_HASH_COMBINE( seed, sparseMemoryBind.memory ); 1494 VULKAN_HPP_HASH_COMBINE( seed, sparseMemoryBind.memoryOffset ); 1495 VULKAN_HPP_HASH_COMBINE( seed, sparseMemoryBind.flags ); 1496 return seed; 1497 } 1498 }; 1499 1500 template <> 1501 struct hash<VULKAN_HPP_NAMESPACE::SparseBufferMemoryBindInfo> 1502 { operator ()std::hash1503 std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseBufferMemoryBindInfo const & sparseBufferMemoryBindInfo ) const VULKAN_HPP_NOEXCEPT 1504 { 1505 std::size_t seed = 0; 1506 VULKAN_HPP_HASH_COMBINE( seed, sparseBufferMemoryBindInfo.buffer ); 1507 VULKAN_HPP_HASH_COMBINE( seed, sparseBufferMemoryBindInfo.bindCount ); 1508 VULKAN_HPP_HASH_COMBINE( seed, sparseBufferMemoryBindInfo.pBinds ); 1509 return seed; 1510 } 1511 }; 1512 1513 template <> 1514 struct hash<VULKAN_HPP_NAMESPACE::SparseImageOpaqueMemoryBindInfo> 1515 { operator ()std::hash1516 std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageOpaqueMemoryBindInfo const & sparseImageOpaqueMemoryBindInfo ) const VULKAN_HPP_NOEXCEPT 1517 { 1518 std::size_t seed = 0; 1519 VULKAN_HPP_HASH_COMBINE( seed, sparseImageOpaqueMemoryBindInfo.image ); 1520 VULKAN_HPP_HASH_COMBINE( seed, sparseImageOpaqueMemoryBindInfo.bindCount ); 1521 VULKAN_HPP_HASH_COMBINE( seed, sparseImageOpaqueMemoryBindInfo.pBinds ); 1522 return seed; 1523 } 1524 }; 1525 1526 template <> 1527 struct hash<VULKAN_HPP_NAMESPACE::ImageSubresource> 1528 { operator ()std::hash1529 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageSubresource const & imageSubresource ) const VULKAN_HPP_NOEXCEPT 1530 { 1531 std::size_t seed = 0; 1532 VULKAN_HPP_HASH_COMBINE( seed, imageSubresource.aspectMask ); 1533 VULKAN_HPP_HASH_COMBINE( seed, imageSubresource.mipLevel ); 1534 VULKAN_HPP_HASH_COMBINE( seed, imageSubresource.arrayLayer ); 1535 return seed; 1536 } 1537 }; 1538 1539 template <> 1540 struct hash<VULKAN_HPP_NAMESPACE::Offset3D> 1541 { operator ()std::hash1542 std::size_t operator()( VULKAN_HPP_NAMESPACE::Offset3D const & offset3D ) const VULKAN_HPP_NOEXCEPT 1543 { 1544 std::size_t seed = 0; 1545 VULKAN_HPP_HASH_COMBINE( seed, offset3D.x ); 1546 VULKAN_HPP_HASH_COMBINE( seed, offset3D.y ); 1547 VULKAN_HPP_HASH_COMBINE( seed, offset3D.z ); 1548 return seed; 1549 } 1550 }; 1551 1552 template <> 1553 struct hash<VULKAN_HPP_NAMESPACE::Extent3D> 1554 { operator ()std::hash1555 std::size_t operator()( VULKAN_HPP_NAMESPACE::Extent3D const & extent3D ) const VULKAN_HPP_NOEXCEPT 1556 { 1557 std::size_t seed = 0; 1558 VULKAN_HPP_HASH_COMBINE( seed, extent3D.width ); 1559 VULKAN_HPP_HASH_COMBINE( seed, extent3D.height ); 1560 VULKAN_HPP_HASH_COMBINE( seed, extent3D.depth ); 1561 return seed; 1562 } 1563 }; 1564 1565 template <> 1566 struct hash<VULKAN_HPP_NAMESPACE::SparseImageMemoryBind> 1567 { operator ()std::hash1568 std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageMemoryBind const & sparseImageMemoryBind ) const VULKAN_HPP_NOEXCEPT 1569 { 1570 std::size_t seed = 0; 1571 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBind.subresource ); 1572 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBind.offset ); 1573 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBind.extent ); 1574 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBind.memory ); 1575 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBind.memoryOffset ); 1576 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBind.flags ); 1577 return seed; 1578 } 1579 }; 1580 1581 template <> 1582 struct hash<VULKAN_HPP_NAMESPACE::SparseImageMemoryBindInfo> 1583 { operator ()std::hash1584 std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageMemoryBindInfo const & sparseImageMemoryBindInfo ) const VULKAN_HPP_NOEXCEPT 1585 { 1586 std::size_t seed = 0; 1587 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBindInfo.image ); 1588 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBindInfo.bindCount ); 1589 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBindInfo.pBinds ); 1590 return seed; 1591 } 1592 }; 1593 1594 template <> 1595 struct hash<VULKAN_HPP_NAMESPACE::BindSparseInfo> 1596 { operator ()std::hash1597 std::size_t operator()( VULKAN_HPP_NAMESPACE::BindSparseInfo const & bindSparseInfo ) const VULKAN_HPP_NOEXCEPT 1598 { 1599 std::size_t seed = 0; 1600 VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.sType ); 1601 VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.pNext ); 1602 VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.waitSemaphoreCount ); 1603 VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.pWaitSemaphores ); 1604 VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.bufferBindCount ); 1605 VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.pBufferBinds ); 1606 VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.imageOpaqueBindCount ); 1607 VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.pImageOpaqueBinds ); 1608 VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.imageBindCount ); 1609 VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.pImageBinds ); 1610 VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.signalSemaphoreCount ); 1611 VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.pSignalSemaphores ); 1612 return seed; 1613 } 1614 }; 1615 1616 template <> 1617 struct hash<VULKAN_HPP_NAMESPACE::BindVertexBufferIndirectCommandNV> 1618 { operator ()std::hash1619 std::size_t operator()( VULKAN_HPP_NAMESPACE::BindVertexBufferIndirectCommandNV const & bindVertexBufferIndirectCommandNV ) const VULKAN_HPP_NOEXCEPT 1620 { 1621 std::size_t seed = 0; 1622 VULKAN_HPP_HASH_COMBINE( seed, bindVertexBufferIndirectCommandNV.bufferAddress ); 1623 VULKAN_HPP_HASH_COMBINE( seed, bindVertexBufferIndirectCommandNV.size ); 1624 VULKAN_HPP_HASH_COMBINE( seed, bindVertexBufferIndirectCommandNV.stride ); 1625 return seed; 1626 } 1627 }; 1628 1629 template <> 1630 struct hash<VULKAN_HPP_NAMESPACE::BindVideoSessionMemoryInfoKHR> 1631 { operator ()std::hash1632 std::size_t operator()( VULKAN_HPP_NAMESPACE::BindVideoSessionMemoryInfoKHR const & bindVideoSessionMemoryInfoKHR ) const VULKAN_HPP_NOEXCEPT 1633 { 1634 std::size_t seed = 0; 1635 VULKAN_HPP_HASH_COMBINE( seed, bindVideoSessionMemoryInfoKHR.sType ); 1636 VULKAN_HPP_HASH_COMBINE( seed, bindVideoSessionMemoryInfoKHR.pNext ); 1637 VULKAN_HPP_HASH_COMBINE( seed, bindVideoSessionMemoryInfoKHR.memoryBindIndex ); 1638 VULKAN_HPP_HASH_COMBINE( seed, bindVideoSessionMemoryInfoKHR.memory ); 1639 VULKAN_HPP_HASH_COMBINE( seed, bindVideoSessionMemoryInfoKHR.memoryOffset ); 1640 VULKAN_HPP_HASH_COMBINE( seed, bindVideoSessionMemoryInfoKHR.memorySize ); 1641 return seed; 1642 } 1643 }; 1644 1645 template <> 1646 struct hash<VULKAN_HPP_NAMESPACE::BlitImageCubicWeightsInfoQCOM> 1647 { operator ()std::hash1648 std::size_t operator()( VULKAN_HPP_NAMESPACE::BlitImageCubicWeightsInfoQCOM const & blitImageCubicWeightsInfoQCOM ) const VULKAN_HPP_NOEXCEPT 1649 { 1650 std::size_t seed = 0; 1651 VULKAN_HPP_HASH_COMBINE( seed, blitImageCubicWeightsInfoQCOM.sType ); 1652 VULKAN_HPP_HASH_COMBINE( seed, blitImageCubicWeightsInfoQCOM.pNext ); 1653 VULKAN_HPP_HASH_COMBINE( seed, blitImageCubicWeightsInfoQCOM.cubicWeights ); 1654 return seed; 1655 } 1656 }; 1657 1658 template <> 1659 struct hash<VULKAN_HPP_NAMESPACE::ImageSubresourceLayers> 1660 { operator ()std::hash1661 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const & imageSubresourceLayers ) const VULKAN_HPP_NOEXCEPT 1662 { 1663 std::size_t seed = 0; 1664 VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceLayers.aspectMask ); 1665 VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceLayers.mipLevel ); 1666 VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceLayers.baseArrayLayer ); 1667 VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceLayers.layerCount ); 1668 return seed; 1669 } 1670 }; 1671 1672 template <> 1673 struct hash<VULKAN_HPP_NAMESPACE::ImageBlit2> 1674 { operator ()std::hash1675 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageBlit2 const & imageBlit2 ) const VULKAN_HPP_NOEXCEPT 1676 { 1677 std::size_t seed = 0; 1678 VULKAN_HPP_HASH_COMBINE( seed, imageBlit2.sType ); 1679 VULKAN_HPP_HASH_COMBINE( seed, imageBlit2.pNext ); 1680 VULKAN_HPP_HASH_COMBINE( seed, imageBlit2.srcSubresource ); 1681 for ( size_t i = 0; i < 2; ++i ) 1682 { 1683 VULKAN_HPP_HASH_COMBINE( seed, imageBlit2.srcOffsets[i] ); 1684 } 1685 VULKAN_HPP_HASH_COMBINE( seed, imageBlit2.dstSubresource ); 1686 for ( size_t i = 0; i < 2; ++i ) 1687 { 1688 VULKAN_HPP_HASH_COMBINE( seed, imageBlit2.dstOffsets[i] ); 1689 } 1690 return seed; 1691 } 1692 }; 1693 1694 template <> 1695 struct hash<VULKAN_HPP_NAMESPACE::BlitImageInfo2> 1696 { operator ()std::hash1697 std::size_t operator()( VULKAN_HPP_NAMESPACE::BlitImageInfo2 const & blitImageInfo2 ) const VULKAN_HPP_NOEXCEPT 1698 { 1699 std::size_t seed = 0; 1700 VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.sType ); 1701 VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.pNext ); 1702 VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.srcImage ); 1703 VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.srcImageLayout ); 1704 VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.dstImage ); 1705 VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.dstImageLayout ); 1706 VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.regionCount ); 1707 VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.pRegions ); 1708 VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.filter ); 1709 return seed; 1710 } 1711 }; 1712 1713 template <> 1714 struct hash<VULKAN_HPP_NAMESPACE::BufferCaptureDescriptorDataInfoEXT> 1715 { operator ()std::hash1716 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCaptureDescriptorDataInfoEXT const & bufferCaptureDescriptorDataInfoEXT ) const VULKAN_HPP_NOEXCEPT 1717 { 1718 std::size_t seed = 0; 1719 VULKAN_HPP_HASH_COMBINE( seed, bufferCaptureDescriptorDataInfoEXT.sType ); 1720 VULKAN_HPP_HASH_COMBINE( seed, bufferCaptureDescriptorDataInfoEXT.pNext ); 1721 VULKAN_HPP_HASH_COMBINE( seed, bufferCaptureDescriptorDataInfoEXT.buffer ); 1722 return seed; 1723 } 1724 }; 1725 1726 # if defined( VK_USE_PLATFORM_FUCHSIA ) 1727 template <> 1728 struct hash<VULKAN_HPP_NAMESPACE::BufferCollectionBufferCreateInfoFUCHSIA> 1729 { 1730 std::size_t operator ()std::hash1731 operator()( VULKAN_HPP_NAMESPACE::BufferCollectionBufferCreateInfoFUCHSIA const & bufferCollectionBufferCreateInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT 1732 { 1733 std::size_t seed = 0; 1734 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionBufferCreateInfoFUCHSIA.sType ); 1735 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionBufferCreateInfoFUCHSIA.pNext ); 1736 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionBufferCreateInfoFUCHSIA.collection ); 1737 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionBufferCreateInfoFUCHSIA.index ); 1738 return seed; 1739 } 1740 }; 1741 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 1742 1743 # if defined( VK_USE_PLATFORM_FUCHSIA ) 1744 template <> 1745 struct hash<VULKAN_HPP_NAMESPACE::BufferCollectionConstraintsInfoFUCHSIA> 1746 { 1747 std::size_t operator ()std::hash1748 operator()( VULKAN_HPP_NAMESPACE::BufferCollectionConstraintsInfoFUCHSIA const & bufferCollectionConstraintsInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT 1749 { 1750 std::size_t seed = 0; 1751 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionConstraintsInfoFUCHSIA.sType ); 1752 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionConstraintsInfoFUCHSIA.pNext ); 1753 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionConstraintsInfoFUCHSIA.minBufferCount ); 1754 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionConstraintsInfoFUCHSIA.maxBufferCount ); 1755 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionConstraintsInfoFUCHSIA.minBufferCountForCamping ); 1756 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionConstraintsInfoFUCHSIA.minBufferCountForDedicatedSlack ); 1757 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionConstraintsInfoFUCHSIA.minBufferCountForSharedSlack ); 1758 return seed; 1759 } 1760 }; 1761 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 1762 1763 # if defined( VK_USE_PLATFORM_FUCHSIA ) 1764 template <> 1765 struct hash<VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA> 1766 { operator ()std::hash1767 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA const & bufferCollectionCreateInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT 1768 { 1769 std::size_t seed = 0; 1770 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionCreateInfoFUCHSIA.sType ); 1771 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionCreateInfoFUCHSIA.pNext ); 1772 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionCreateInfoFUCHSIA.collectionToken ); 1773 return seed; 1774 } 1775 }; 1776 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 1777 1778 # if defined( VK_USE_PLATFORM_FUCHSIA ) 1779 template <> 1780 struct hash<VULKAN_HPP_NAMESPACE::BufferCollectionImageCreateInfoFUCHSIA> 1781 { 1782 std::size_t operator ()std::hash1783 operator()( VULKAN_HPP_NAMESPACE::BufferCollectionImageCreateInfoFUCHSIA const & bufferCollectionImageCreateInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT 1784 { 1785 std::size_t seed = 0; 1786 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionImageCreateInfoFUCHSIA.sType ); 1787 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionImageCreateInfoFUCHSIA.pNext ); 1788 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionImageCreateInfoFUCHSIA.collection ); 1789 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionImageCreateInfoFUCHSIA.index ); 1790 return seed; 1791 } 1792 }; 1793 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 1794 1795 # if defined( VK_USE_PLATFORM_FUCHSIA ) 1796 template <> 1797 struct hash<VULKAN_HPP_NAMESPACE::SysmemColorSpaceFUCHSIA> 1798 { operator ()std::hash1799 std::size_t operator()( VULKAN_HPP_NAMESPACE::SysmemColorSpaceFUCHSIA const & sysmemColorSpaceFUCHSIA ) const VULKAN_HPP_NOEXCEPT 1800 { 1801 std::size_t seed = 0; 1802 VULKAN_HPP_HASH_COMBINE( seed, sysmemColorSpaceFUCHSIA.sType ); 1803 VULKAN_HPP_HASH_COMBINE( seed, sysmemColorSpaceFUCHSIA.pNext ); 1804 VULKAN_HPP_HASH_COMBINE( seed, sysmemColorSpaceFUCHSIA.colorSpace ); 1805 return seed; 1806 } 1807 }; 1808 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 1809 1810 # if defined( VK_USE_PLATFORM_FUCHSIA ) 1811 template <> 1812 struct hash<VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA> 1813 { operator ()std::hash1814 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA const & bufferCollectionPropertiesFUCHSIA ) const VULKAN_HPP_NOEXCEPT 1815 { 1816 std::size_t seed = 0; 1817 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.sType ); 1818 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.pNext ); 1819 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.memoryTypeBits ); 1820 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.bufferCount ); 1821 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.createInfoIndex ); 1822 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.sysmemPixelFormat ); 1823 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.formatFeatures ); 1824 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.sysmemColorSpaceIndex ); 1825 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.samplerYcbcrConversionComponents ); 1826 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.suggestedYcbcrModel ); 1827 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.suggestedYcbcrRange ); 1828 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.suggestedXChromaOffset ); 1829 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.suggestedYChromaOffset ); 1830 return seed; 1831 } 1832 }; 1833 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 1834 1835 template <> 1836 struct hash<VULKAN_HPP_NAMESPACE::BufferCreateInfo> 1837 { operator ()std::hash1838 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCreateInfo const & bufferCreateInfo ) const VULKAN_HPP_NOEXCEPT 1839 { 1840 std::size_t seed = 0; 1841 VULKAN_HPP_HASH_COMBINE( seed, bufferCreateInfo.sType ); 1842 VULKAN_HPP_HASH_COMBINE( seed, bufferCreateInfo.pNext ); 1843 VULKAN_HPP_HASH_COMBINE( seed, bufferCreateInfo.flags ); 1844 VULKAN_HPP_HASH_COMBINE( seed, bufferCreateInfo.size ); 1845 VULKAN_HPP_HASH_COMBINE( seed, bufferCreateInfo.usage ); 1846 VULKAN_HPP_HASH_COMBINE( seed, bufferCreateInfo.sharingMode ); 1847 VULKAN_HPP_HASH_COMBINE( seed, bufferCreateInfo.queueFamilyIndexCount ); 1848 VULKAN_HPP_HASH_COMBINE( seed, bufferCreateInfo.pQueueFamilyIndices ); 1849 return seed; 1850 } 1851 }; 1852 1853 # if defined( VK_USE_PLATFORM_FUCHSIA ) 1854 template <> 1855 struct hash<VULKAN_HPP_NAMESPACE::BufferConstraintsInfoFUCHSIA> 1856 { operator ()std::hash1857 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferConstraintsInfoFUCHSIA const & bufferConstraintsInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT 1858 { 1859 std::size_t seed = 0; 1860 VULKAN_HPP_HASH_COMBINE( seed, bufferConstraintsInfoFUCHSIA.sType ); 1861 VULKAN_HPP_HASH_COMBINE( seed, bufferConstraintsInfoFUCHSIA.pNext ); 1862 VULKAN_HPP_HASH_COMBINE( seed, bufferConstraintsInfoFUCHSIA.createInfo ); 1863 VULKAN_HPP_HASH_COMBINE( seed, bufferConstraintsInfoFUCHSIA.requiredFormatFeatures ); 1864 VULKAN_HPP_HASH_COMBINE( seed, bufferConstraintsInfoFUCHSIA.bufferCollectionConstraints ); 1865 return seed; 1866 } 1867 }; 1868 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 1869 1870 template <> 1871 struct hash<VULKAN_HPP_NAMESPACE::BufferCopy> 1872 { operator ()std::hash1873 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCopy const & bufferCopy ) const VULKAN_HPP_NOEXCEPT 1874 { 1875 std::size_t seed = 0; 1876 VULKAN_HPP_HASH_COMBINE( seed, bufferCopy.srcOffset ); 1877 VULKAN_HPP_HASH_COMBINE( seed, bufferCopy.dstOffset ); 1878 VULKAN_HPP_HASH_COMBINE( seed, bufferCopy.size ); 1879 return seed; 1880 } 1881 }; 1882 1883 template <> 1884 struct hash<VULKAN_HPP_NAMESPACE::BufferCopy2> 1885 { operator ()std::hash1886 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCopy2 const & bufferCopy2 ) const VULKAN_HPP_NOEXCEPT 1887 { 1888 std::size_t seed = 0; 1889 VULKAN_HPP_HASH_COMBINE( seed, bufferCopy2.sType ); 1890 VULKAN_HPP_HASH_COMBINE( seed, bufferCopy2.pNext ); 1891 VULKAN_HPP_HASH_COMBINE( seed, bufferCopy2.srcOffset ); 1892 VULKAN_HPP_HASH_COMBINE( seed, bufferCopy2.dstOffset ); 1893 VULKAN_HPP_HASH_COMBINE( seed, bufferCopy2.size ); 1894 return seed; 1895 } 1896 }; 1897 1898 template <> 1899 struct hash<VULKAN_HPP_NAMESPACE::BufferDeviceAddressCreateInfoEXT> 1900 { operator ()std::hash1901 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferDeviceAddressCreateInfoEXT const & bufferDeviceAddressCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 1902 { 1903 std::size_t seed = 0; 1904 VULKAN_HPP_HASH_COMBINE( seed, bufferDeviceAddressCreateInfoEXT.sType ); 1905 VULKAN_HPP_HASH_COMBINE( seed, bufferDeviceAddressCreateInfoEXT.pNext ); 1906 VULKAN_HPP_HASH_COMBINE( seed, bufferDeviceAddressCreateInfoEXT.deviceAddress ); 1907 return seed; 1908 } 1909 }; 1910 1911 template <> 1912 struct hash<VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo> 1913 { operator ()std::hash1914 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo const & bufferDeviceAddressInfo ) const VULKAN_HPP_NOEXCEPT 1915 { 1916 std::size_t seed = 0; 1917 VULKAN_HPP_HASH_COMBINE( seed, bufferDeviceAddressInfo.sType ); 1918 VULKAN_HPP_HASH_COMBINE( seed, bufferDeviceAddressInfo.pNext ); 1919 VULKAN_HPP_HASH_COMBINE( seed, bufferDeviceAddressInfo.buffer ); 1920 return seed; 1921 } 1922 }; 1923 1924 template <> 1925 struct hash<VULKAN_HPP_NAMESPACE::BufferImageCopy> 1926 { operator ()std::hash1927 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferImageCopy const & bufferImageCopy ) const VULKAN_HPP_NOEXCEPT 1928 { 1929 std::size_t seed = 0; 1930 VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy.bufferOffset ); 1931 VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy.bufferRowLength ); 1932 VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy.bufferImageHeight ); 1933 VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy.imageSubresource ); 1934 VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy.imageOffset ); 1935 VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy.imageExtent ); 1936 return seed; 1937 } 1938 }; 1939 1940 template <> 1941 struct hash<VULKAN_HPP_NAMESPACE::BufferImageCopy2> 1942 { operator ()std::hash1943 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferImageCopy2 const & bufferImageCopy2 ) const VULKAN_HPP_NOEXCEPT 1944 { 1945 std::size_t seed = 0; 1946 VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy2.sType ); 1947 VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy2.pNext ); 1948 VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy2.bufferOffset ); 1949 VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy2.bufferRowLength ); 1950 VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy2.bufferImageHeight ); 1951 VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy2.imageSubresource ); 1952 VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy2.imageOffset ); 1953 VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy2.imageExtent ); 1954 return seed; 1955 } 1956 }; 1957 1958 template <> 1959 struct hash<VULKAN_HPP_NAMESPACE::BufferMemoryBarrier> 1960 { operator ()std::hash1961 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferMemoryBarrier const & bufferMemoryBarrier ) const VULKAN_HPP_NOEXCEPT 1962 { 1963 std::size_t seed = 0; 1964 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.sType ); 1965 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.pNext ); 1966 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.srcAccessMask ); 1967 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.dstAccessMask ); 1968 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.srcQueueFamilyIndex ); 1969 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.dstQueueFamilyIndex ); 1970 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.buffer ); 1971 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.offset ); 1972 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.size ); 1973 return seed; 1974 } 1975 }; 1976 1977 template <> 1978 struct hash<VULKAN_HPP_NAMESPACE::BufferMemoryBarrier2> 1979 { operator ()std::hash1980 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferMemoryBarrier2 const & bufferMemoryBarrier2 ) const VULKAN_HPP_NOEXCEPT 1981 { 1982 std::size_t seed = 0; 1983 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.sType ); 1984 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.pNext ); 1985 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.srcStageMask ); 1986 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.srcAccessMask ); 1987 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.dstStageMask ); 1988 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.dstAccessMask ); 1989 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.srcQueueFamilyIndex ); 1990 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.dstQueueFamilyIndex ); 1991 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.buffer ); 1992 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.offset ); 1993 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.size ); 1994 return seed; 1995 } 1996 }; 1997 1998 template <> 1999 struct hash<VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2> 2000 { operator ()std::hash2001 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 const & bufferMemoryRequirementsInfo2 ) const VULKAN_HPP_NOEXCEPT 2002 { 2003 std::size_t seed = 0; 2004 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryRequirementsInfo2.sType ); 2005 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryRequirementsInfo2.pNext ); 2006 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryRequirementsInfo2.buffer ); 2007 return seed; 2008 } 2009 }; 2010 2011 template <> 2012 struct hash<VULKAN_HPP_NAMESPACE::BufferOpaqueCaptureAddressCreateInfo> 2013 { operator ()std::hash2014 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferOpaqueCaptureAddressCreateInfo const & bufferOpaqueCaptureAddressCreateInfo ) const VULKAN_HPP_NOEXCEPT 2015 { 2016 std::size_t seed = 0; 2017 VULKAN_HPP_HASH_COMBINE( seed, bufferOpaqueCaptureAddressCreateInfo.sType ); 2018 VULKAN_HPP_HASH_COMBINE( seed, bufferOpaqueCaptureAddressCreateInfo.pNext ); 2019 VULKAN_HPP_HASH_COMBINE( seed, bufferOpaqueCaptureAddressCreateInfo.opaqueCaptureAddress ); 2020 return seed; 2021 } 2022 }; 2023 2024 template <> 2025 struct hash<VULKAN_HPP_NAMESPACE::BufferUsageFlags2CreateInfoKHR> 2026 { operator ()std::hash2027 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferUsageFlags2CreateInfoKHR const & bufferUsageFlags2CreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 2028 { 2029 std::size_t seed = 0; 2030 VULKAN_HPP_HASH_COMBINE( seed, bufferUsageFlags2CreateInfoKHR.sType ); 2031 VULKAN_HPP_HASH_COMBINE( seed, bufferUsageFlags2CreateInfoKHR.pNext ); 2032 VULKAN_HPP_HASH_COMBINE( seed, bufferUsageFlags2CreateInfoKHR.usage ); 2033 return seed; 2034 } 2035 }; 2036 2037 template <> 2038 struct hash<VULKAN_HPP_NAMESPACE::BufferViewCreateInfo> 2039 { operator ()std::hash2040 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferViewCreateInfo const & bufferViewCreateInfo ) const VULKAN_HPP_NOEXCEPT 2041 { 2042 std::size_t seed = 0; 2043 VULKAN_HPP_HASH_COMBINE( seed, bufferViewCreateInfo.sType ); 2044 VULKAN_HPP_HASH_COMBINE( seed, bufferViewCreateInfo.pNext ); 2045 VULKAN_HPP_HASH_COMBINE( seed, bufferViewCreateInfo.flags ); 2046 VULKAN_HPP_HASH_COMBINE( seed, bufferViewCreateInfo.buffer ); 2047 VULKAN_HPP_HASH_COMBINE( seed, bufferViewCreateInfo.format ); 2048 VULKAN_HPP_HASH_COMBINE( seed, bufferViewCreateInfo.offset ); 2049 VULKAN_HPP_HASH_COMBINE( seed, bufferViewCreateInfo.range ); 2050 return seed; 2051 } 2052 }; 2053 2054 template <> 2055 struct hash<VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR> 2056 { operator ()std::hash2057 std::size_t operator()( VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR const & calibratedTimestampInfoKHR ) const VULKAN_HPP_NOEXCEPT 2058 { 2059 std::size_t seed = 0; 2060 VULKAN_HPP_HASH_COMBINE( seed, calibratedTimestampInfoKHR.sType ); 2061 VULKAN_HPP_HASH_COMBINE( seed, calibratedTimestampInfoKHR.pNext ); 2062 VULKAN_HPP_HASH_COMBINE( seed, calibratedTimestampInfoKHR.timeDomain ); 2063 return seed; 2064 } 2065 }; 2066 2067 template <> 2068 struct hash<VULKAN_HPP_NAMESPACE::CheckpointData2NV> 2069 { operator ()std::hash2070 std::size_t operator()( VULKAN_HPP_NAMESPACE::CheckpointData2NV const & checkpointData2NV ) const VULKAN_HPP_NOEXCEPT 2071 { 2072 std::size_t seed = 0; 2073 VULKAN_HPP_HASH_COMBINE( seed, checkpointData2NV.sType ); 2074 VULKAN_HPP_HASH_COMBINE( seed, checkpointData2NV.pNext ); 2075 VULKAN_HPP_HASH_COMBINE( seed, checkpointData2NV.stage ); 2076 VULKAN_HPP_HASH_COMBINE( seed, checkpointData2NV.pCheckpointMarker ); 2077 return seed; 2078 } 2079 }; 2080 2081 template <> 2082 struct hash<VULKAN_HPP_NAMESPACE::CheckpointDataNV> 2083 { operator ()std::hash2084 std::size_t operator()( VULKAN_HPP_NAMESPACE::CheckpointDataNV const & checkpointDataNV ) const VULKAN_HPP_NOEXCEPT 2085 { 2086 std::size_t seed = 0; 2087 VULKAN_HPP_HASH_COMBINE( seed, checkpointDataNV.sType ); 2088 VULKAN_HPP_HASH_COMBINE( seed, checkpointDataNV.pNext ); 2089 VULKAN_HPP_HASH_COMBINE( seed, checkpointDataNV.stage ); 2090 VULKAN_HPP_HASH_COMBINE( seed, checkpointDataNV.pCheckpointMarker ); 2091 return seed; 2092 } 2093 }; 2094 2095 template <> 2096 struct hash<VULKAN_HPP_NAMESPACE::ClearDepthStencilValue> 2097 { operator ()std::hash2098 std::size_t operator()( VULKAN_HPP_NAMESPACE::ClearDepthStencilValue const & clearDepthStencilValue ) const VULKAN_HPP_NOEXCEPT 2099 { 2100 std::size_t seed = 0; 2101 VULKAN_HPP_HASH_COMBINE( seed, clearDepthStencilValue.depth ); 2102 VULKAN_HPP_HASH_COMBINE( seed, clearDepthStencilValue.stencil ); 2103 return seed; 2104 } 2105 }; 2106 2107 template <> 2108 struct hash<VULKAN_HPP_NAMESPACE::ClearRect> 2109 { operator ()std::hash2110 std::size_t operator()( VULKAN_HPP_NAMESPACE::ClearRect const & clearRect ) const VULKAN_HPP_NOEXCEPT 2111 { 2112 std::size_t seed = 0; 2113 VULKAN_HPP_HASH_COMBINE( seed, clearRect.rect ); 2114 VULKAN_HPP_HASH_COMBINE( seed, clearRect.baseArrayLayer ); 2115 VULKAN_HPP_HASH_COMBINE( seed, clearRect.layerCount ); 2116 return seed; 2117 } 2118 }; 2119 2120 template <> 2121 struct hash<VULKAN_HPP_NAMESPACE::CoarseSampleLocationNV> 2122 { operator ()std::hash2123 std::size_t operator()( VULKAN_HPP_NAMESPACE::CoarseSampleLocationNV const & coarseSampleLocationNV ) const VULKAN_HPP_NOEXCEPT 2124 { 2125 std::size_t seed = 0; 2126 VULKAN_HPP_HASH_COMBINE( seed, coarseSampleLocationNV.pixelX ); 2127 VULKAN_HPP_HASH_COMBINE( seed, coarseSampleLocationNV.pixelY ); 2128 VULKAN_HPP_HASH_COMBINE( seed, coarseSampleLocationNV.sample ); 2129 return seed; 2130 } 2131 }; 2132 2133 template <> 2134 struct hash<VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV> 2135 { operator ()std::hash2136 std::size_t operator()( VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV const & coarseSampleOrderCustomNV ) const VULKAN_HPP_NOEXCEPT 2137 { 2138 std::size_t seed = 0; 2139 VULKAN_HPP_HASH_COMBINE( seed, coarseSampleOrderCustomNV.shadingRate ); 2140 VULKAN_HPP_HASH_COMBINE( seed, coarseSampleOrderCustomNV.sampleCount ); 2141 VULKAN_HPP_HASH_COMBINE( seed, coarseSampleOrderCustomNV.sampleLocationCount ); 2142 VULKAN_HPP_HASH_COMBINE( seed, coarseSampleOrderCustomNV.pSampleLocations ); 2143 return seed; 2144 } 2145 }; 2146 2147 template <> 2148 struct hash<VULKAN_HPP_NAMESPACE::ColorBlendAdvancedEXT> 2149 { operator ()std::hash2150 std::size_t operator()( VULKAN_HPP_NAMESPACE::ColorBlendAdvancedEXT const & colorBlendAdvancedEXT ) const VULKAN_HPP_NOEXCEPT 2151 { 2152 std::size_t seed = 0; 2153 VULKAN_HPP_HASH_COMBINE( seed, colorBlendAdvancedEXT.advancedBlendOp ); 2154 VULKAN_HPP_HASH_COMBINE( seed, colorBlendAdvancedEXT.srcPremultiplied ); 2155 VULKAN_HPP_HASH_COMBINE( seed, colorBlendAdvancedEXT.dstPremultiplied ); 2156 VULKAN_HPP_HASH_COMBINE( seed, colorBlendAdvancedEXT.blendOverlap ); 2157 VULKAN_HPP_HASH_COMBINE( seed, colorBlendAdvancedEXT.clampResults ); 2158 return seed; 2159 } 2160 }; 2161 2162 template <> 2163 struct hash<VULKAN_HPP_NAMESPACE::ColorBlendEquationEXT> 2164 { operator ()std::hash2165 std::size_t operator()( VULKAN_HPP_NAMESPACE::ColorBlendEquationEXT const & colorBlendEquationEXT ) const VULKAN_HPP_NOEXCEPT 2166 { 2167 std::size_t seed = 0; 2168 VULKAN_HPP_HASH_COMBINE( seed, colorBlendEquationEXT.srcColorBlendFactor ); 2169 VULKAN_HPP_HASH_COMBINE( seed, colorBlendEquationEXT.dstColorBlendFactor ); 2170 VULKAN_HPP_HASH_COMBINE( seed, colorBlendEquationEXT.colorBlendOp ); 2171 VULKAN_HPP_HASH_COMBINE( seed, colorBlendEquationEXT.srcAlphaBlendFactor ); 2172 VULKAN_HPP_HASH_COMBINE( seed, colorBlendEquationEXT.dstAlphaBlendFactor ); 2173 VULKAN_HPP_HASH_COMBINE( seed, colorBlendEquationEXT.alphaBlendOp ); 2174 return seed; 2175 } 2176 }; 2177 2178 template <> 2179 struct hash<VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo> 2180 { operator ()std::hash2181 std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo const & commandBufferAllocateInfo ) const VULKAN_HPP_NOEXCEPT 2182 { 2183 std::size_t seed = 0; 2184 VULKAN_HPP_HASH_COMBINE( seed, commandBufferAllocateInfo.sType ); 2185 VULKAN_HPP_HASH_COMBINE( seed, commandBufferAllocateInfo.pNext ); 2186 VULKAN_HPP_HASH_COMBINE( seed, commandBufferAllocateInfo.commandPool ); 2187 VULKAN_HPP_HASH_COMBINE( seed, commandBufferAllocateInfo.level ); 2188 VULKAN_HPP_HASH_COMBINE( seed, commandBufferAllocateInfo.commandBufferCount ); 2189 return seed; 2190 } 2191 }; 2192 2193 template <> 2194 struct hash<VULKAN_HPP_NAMESPACE::CommandBufferInheritanceInfo> 2195 { operator ()std::hash2196 std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceInfo const & commandBufferInheritanceInfo ) const VULKAN_HPP_NOEXCEPT 2197 { 2198 std::size_t seed = 0; 2199 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceInfo.sType ); 2200 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceInfo.pNext ); 2201 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceInfo.renderPass ); 2202 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceInfo.subpass ); 2203 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceInfo.framebuffer ); 2204 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceInfo.occlusionQueryEnable ); 2205 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceInfo.queryFlags ); 2206 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceInfo.pipelineStatistics ); 2207 return seed; 2208 } 2209 }; 2210 2211 template <> 2212 struct hash<VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo> 2213 { operator ()std::hash2214 std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo const & commandBufferBeginInfo ) const VULKAN_HPP_NOEXCEPT 2215 { 2216 std::size_t seed = 0; 2217 VULKAN_HPP_HASH_COMBINE( seed, commandBufferBeginInfo.sType ); 2218 VULKAN_HPP_HASH_COMBINE( seed, commandBufferBeginInfo.pNext ); 2219 VULKAN_HPP_HASH_COMBINE( seed, commandBufferBeginInfo.flags ); 2220 VULKAN_HPP_HASH_COMBINE( seed, commandBufferBeginInfo.pInheritanceInfo ); 2221 return seed; 2222 } 2223 }; 2224 2225 template <> 2226 struct hash<VULKAN_HPP_NAMESPACE::CommandBufferInheritanceConditionalRenderingInfoEXT> 2227 { 2228 std::size_t operator ()std::hash2229 operator()( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceConditionalRenderingInfoEXT const & commandBufferInheritanceConditionalRenderingInfoEXT ) const 2230 VULKAN_HPP_NOEXCEPT 2231 { 2232 std::size_t seed = 0; 2233 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceConditionalRenderingInfoEXT.sType ); 2234 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceConditionalRenderingInfoEXT.pNext ); 2235 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceConditionalRenderingInfoEXT.conditionalRenderingEnable ); 2236 return seed; 2237 } 2238 }; 2239 2240 template <> 2241 struct hash<VULKAN_HPP_NAMESPACE::CommandBufferInheritanceRenderPassTransformInfoQCOM> 2242 { 2243 std::size_t operator ()std::hash2244 operator()( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceRenderPassTransformInfoQCOM const & commandBufferInheritanceRenderPassTransformInfoQCOM ) const 2245 VULKAN_HPP_NOEXCEPT 2246 { 2247 std::size_t seed = 0; 2248 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderPassTransformInfoQCOM.sType ); 2249 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderPassTransformInfoQCOM.pNext ); 2250 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderPassTransformInfoQCOM.transform ); 2251 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderPassTransformInfoQCOM.renderArea ); 2252 return seed; 2253 } 2254 }; 2255 2256 template <> 2257 struct hash<VULKAN_HPP_NAMESPACE::CommandBufferInheritanceRenderingInfo> 2258 { 2259 std::size_t operator ()std::hash2260 operator()( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceRenderingInfo const & commandBufferInheritanceRenderingInfo ) const VULKAN_HPP_NOEXCEPT 2261 { 2262 std::size_t seed = 0; 2263 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.sType ); 2264 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.pNext ); 2265 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.flags ); 2266 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.viewMask ); 2267 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.colorAttachmentCount ); 2268 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.pColorAttachmentFormats ); 2269 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.depthAttachmentFormat ); 2270 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.stencilAttachmentFormat ); 2271 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.rasterizationSamples ); 2272 return seed; 2273 } 2274 }; 2275 2276 template <> 2277 struct hash<VULKAN_HPP_NAMESPACE::Viewport> 2278 { operator ()std::hash2279 std::size_t operator()( VULKAN_HPP_NAMESPACE::Viewport const & viewport ) const VULKAN_HPP_NOEXCEPT 2280 { 2281 std::size_t seed = 0; 2282 VULKAN_HPP_HASH_COMBINE( seed, viewport.x ); 2283 VULKAN_HPP_HASH_COMBINE( seed, viewport.y ); 2284 VULKAN_HPP_HASH_COMBINE( seed, viewport.width ); 2285 VULKAN_HPP_HASH_COMBINE( seed, viewport.height ); 2286 VULKAN_HPP_HASH_COMBINE( seed, viewport.minDepth ); 2287 VULKAN_HPP_HASH_COMBINE( seed, viewport.maxDepth ); 2288 return seed; 2289 } 2290 }; 2291 2292 template <> 2293 struct hash<VULKAN_HPP_NAMESPACE::CommandBufferInheritanceViewportScissorInfoNV> 2294 { operator ()std::hash2295 std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceViewportScissorInfoNV const & commandBufferInheritanceViewportScissorInfoNV ) const 2296 VULKAN_HPP_NOEXCEPT 2297 { 2298 std::size_t seed = 0; 2299 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceViewportScissorInfoNV.sType ); 2300 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceViewportScissorInfoNV.pNext ); 2301 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceViewportScissorInfoNV.viewportScissor2D ); 2302 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceViewportScissorInfoNV.viewportDepthCount ); 2303 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceViewportScissorInfoNV.pViewportDepths ); 2304 return seed; 2305 } 2306 }; 2307 2308 template <> 2309 struct hash<VULKAN_HPP_NAMESPACE::CommandBufferSubmitInfo> 2310 { operator ()std::hash2311 std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBufferSubmitInfo const & commandBufferSubmitInfo ) const VULKAN_HPP_NOEXCEPT 2312 { 2313 std::size_t seed = 0; 2314 VULKAN_HPP_HASH_COMBINE( seed, commandBufferSubmitInfo.sType ); 2315 VULKAN_HPP_HASH_COMBINE( seed, commandBufferSubmitInfo.pNext ); 2316 VULKAN_HPP_HASH_COMBINE( seed, commandBufferSubmitInfo.commandBuffer ); 2317 VULKAN_HPP_HASH_COMBINE( seed, commandBufferSubmitInfo.deviceMask ); 2318 return seed; 2319 } 2320 }; 2321 2322 template <> 2323 struct hash<VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo> 2324 { operator ()std::hash2325 std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo const & commandPoolCreateInfo ) const VULKAN_HPP_NOEXCEPT 2326 { 2327 std::size_t seed = 0; 2328 VULKAN_HPP_HASH_COMBINE( seed, commandPoolCreateInfo.sType ); 2329 VULKAN_HPP_HASH_COMBINE( seed, commandPoolCreateInfo.pNext ); 2330 VULKAN_HPP_HASH_COMBINE( seed, commandPoolCreateInfo.flags ); 2331 VULKAN_HPP_HASH_COMBINE( seed, commandPoolCreateInfo.queueFamilyIndex ); 2332 return seed; 2333 } 2334 }; 2335 2336 template <> 2337 struct hash<VULKAN_HPP_NAMESPACE::SpecializationMapEntry> 2338 { operator ()std::hash2339 std::size_t operator()( VULKAN_HPP_NAMESPACE::SpecializationMapEntry const & specializationMapEntry ) const VULKAN_HPP_NOEXCEPT 2340 { 2341 std::size_t seed = 0; 2342 VULKAN_HPP_HASH_COMBINE( seed, specializationMapEntry.constantID ); 2343 VULKAN_HPP_HASH_COMBINE( seed, specializationMapEntry.offset ); 2344 VULKAN_HPP_HASH_COMBINE( seed, specializationMapEntry.size ); 2345 return seed; 2346 } 2347 }; 2348 2349 template <> 2350 struct hash<VULKAN_HPP_NAMESPACE::SpecializationInfo> 2351 { operator ()std::hash2352 std::size_t operator()( VULKAN_HPP_NAMESPACE::SpecializationInfo const & specializationInfo ) const VULKAN_HPP_NOEXCEPT 2353 { 2354 std::size_t seed = 0; 2355 VULKAN_HPP_HASH_COMBINE( seed, specializationInfo.mapEntryCount ); 2356 VULKAN_HPP_HASH_COMBINE( seed, specializationInfo.pMapEntries ); 2357 VULKAN_HPP_HASH_COMBINE( seed, specializationInfo.dataSize ); 2358 VULKAN_HPP_HASH_COMBINE( seed, specializationInfo.pData ); 2359 return seed; 2360 } 2361 }; 2362 2363 template <> 2364 struct hash<VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo> 2365 { operator ()std::hash2366 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo const & pipelineShaderStageCreateInfo ) const VULKAN_HPP_NOEXCEPT 2367 { 2368 std::size_t seed = 0; 2369 VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageCreateInfo.sType ); 2370 VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageCreateInfo.pNext ); 2371 VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageCreateInfo.flags ); 2372 VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageCreateInfo.stage ); 2373 VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageCreateInfo.module ); 2374 for ( const char * p = pipelineShaderStageCreateInfo.pName; *p != '\0'; ++p ) 2375 { 2376 VULKAN_HPP_HASH_COMBINE( seed, *p ); 2377 } 2378 VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageCreateInfo.pSpecializationInfo ); 2379 return seed; 2380 } 2381 }; 2382 2383 template <> 2384 struct hash<VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> 2385 { operator ()std::hash2386 std::size_t operator()( VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo const & computePipelineCreateInfo ) const VULKAN_HPP_NOEXCEPT 2387 { 2388 std::size_t seed = 0; 2389 VULKAN_HPP_HASH_COMBINE( seed, computePipelineCreateInfo.sType ); 2390 VULKAN_HPP_HASH_COMBINE( seed, computePipelineCreateInfo.pNext ); 2391 VULKAN_HPP_HASH_COMBINE( seed, computePipelineCreateInfo.flags ); 2392 VULKAN_HPP_HASH_COMBINE( seed, computePipelineCreateInfo.stage ); 2393 VULKAN_HPP_HASH_COMBINE( seed, computePipelineCreateInfo.layout ); 2394 VULKAN_HPP_HASH_COMBINE( seed, computePipelineCreateInfo.basePipelineHandle ); 2395 VULKAN_HPP_HASH_COMBINE( seed, computePipelineCreateInfo.basePipelineIndex ); 2396 return seed; 2397 } 2398 }; 2399 2400 template <> 2401 struct hash<VULKAN_HPP_NAMESPACE::ComputePipelineIndirectBufferInfoNV> 2402 { operator ()std::hash2403 std::size_t operator()( VULKAN_HPP_NAMESPACE::ComputePipelineIndirectBufferInfoNV const & computePipelineIndirectBufferInfoNV ) const VULKAN_HPP_NOEXCEPT 2404 { 2405 std::size_t seed = 0; 2406 VULKAN_HPP_HASH_COMBINE( seed, computePipelineIndirectBufferInfoNV.sType ); 2407 VULKAN_HPP_HASH_COMBINE( seed, computePipelineIndirectBufferInfoNV.pNext ); 2408 VULKAN_HPP_HASH_COMBINE( seed, computePipelineIndirectBufferInfoNV.deviceAddress ); 2409 VULKAN_HPP_HASH_COMBINE( seed, computePipelineIndirectBufferInfoNV.size ); 2410 VULKAN_HPP_HASH_COMBINE( seed, computePipelineIndirectBufferInfoNV.pipelineDeviceAddressCaptureReplay ); 2411 return seed; 2412 } 2413 }; 2414 2415 template <> 2416 struct hash<VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfoEXT> 2417 { operator ()std::hash2418 std::size_t operator()( VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfoEXT const & conditionalRenderingBeginInfoEXT ) const VULKAN_HPP_NOEXCEPT 2419 { 2420 std::size_t seed = 0; 2421 VULKAN_HPP_HASH_COMBINE( seed, conditionalRenderingBeginInfoEXT.sType ); 2422 VULKAN_HPP_HASH_COMBINE( seed, conditionalRenderingBeginInfoEXT.pNext ); 2423 VULKAN_HPP_HASH_COMBINE( seed, conditionalRenderingBeginInfoEXT.buffer ); 2424 VULKAN_HPP_HASH_COMBINE( seed, conditionalRenderingBeginInfoEXT.offset ); 2425 VULKAN_HPP_HASH_COMBINE( seed, conditionalRenderingBeginInfoEXT.flags ); 2426 return seed; 2427 } 2428 }; 2429 2430 template <> 2431 struct hash<VULKAN_HPP_NAMESPACE::ConformanceVersion> 2432 { operator ()std::hash2433 std::size_t operator()( VULKAN_HPP_NAMESPACE::ConformanceVersion const & conformanceVersion ) const VULKAN_HPP_NOEXCEPT 2434 { 2435 std::size_t seed = 0; 2436 VULKAN_HPP_HASH_COMBINE( seed, conformanceVersion.major ); 2437 VULKAN_HPP_HASH_COMBINE( seed, conformanceVersion.minor ); 2438 VULKAN_HPP_HASH_COMBINE( seed, conformanceVersion.subminor ); 2439 VULKAN_HPP_HASH_COMBINE( seed, conformanceVersion.patch ); 2440 return seed; 2441 } 2442 }; 2443 2444 template <> 2445 struct hash<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR> 2446 { operator ()std::hash2447 std::size_t operator()( VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR const & cooperativeMatrixPropertiesKHR ) const VULKAN_HPP_NOEXCEPT 2448 { 2449 std::size_t seed = 0; 2450 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.sType ); 2451 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.pNext ); 2452 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.MSize ); 2453 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.NSize ); 2454 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.KSize ); 2455 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.AType ); 2456 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.BType ); 2457 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.CType ); 2458 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.ResultType ); 2459 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.saturatingAccumulation ); 2460 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.scope ); 2461 return seed; 2462 } 2463 }; 2464 2465 template <> 2466 struct hash<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV> 2467 { operator ()std::hash2468 std::size_t operator()( VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV const & cooperativeMatrixPropertiesNV ) const VULKAN_HPP_NOEXCEPT 2469 { 2470 std::size_t seed = 0; 2471 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.sType ); 2472 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.pNext ); 2473 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.MSize ); 2474 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.NSize ); 2475 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.KSize ); 2476 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.AType ); 2477 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.BType ); 2478 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.CType ); 2479 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.DType ); 2480 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.scope ); 2481 return seed; 2482 } 2483 }; 2484 2485 template <> 2486 struct hash<VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR> 2487 { operator ()std::hash2488 std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR const & copyAccelerationStructureInfoKHR ) const VULKAN_HPP_NOEXCEPT 2489 { 2490 std::size_t seed = 0; 2491 VULKAN_HPP_HASH_COMBINE( seed, copyAccelerationStructureInfoKHR.sType ); 2492 VULKAN_HPP_HASH_COMBINE( seed, copyAccelerationStructureInfoKHR.pNext ); 2493 VULKAN_HPP_HASH_COMBINE( seed, copyAccelerationStructureInfoKHR.src ); 2494 VULKAN_HPP_HASH_COMBINE( seed, copyAccelerationStructureInfoKHR.dst ); 2495 VULKAN_HPP_HASH_COMBINE( seed, copyAccelerationStructureInfoKHR.mode ); 2496 return seed; 2497 } 2498 }; 2499 2500 template <> 2501 struct hash<VULKAN_HPP_NAMESPACE::CopyBufferInfo2> 2502 { operator ()std::hash2503 std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyBufferInfo2 const & copyBufferInfo2 ) const VULKAN_HPP_NOEXCEPT 2504 { 2505 std::size_t seed = 0; 2506 VULKAN_HPP_HASH_COMBINE( seed, copyBufferInfo2.sType ); 2507 VULKAN_HPP_HASH_COMBINE( seed, copyBufferInfo2.pNext ); 2508 VULKAN_HPP_HASH_COMBINE( seed, copyBufferInfo2.srcBuffer ); 2509 VULKAN_HPP_HASH_COMBINE( seed, copyBufferInfo2.dstBuffer ); 2510 VULKAN_HPP_HASH_COMBINE( seed, copyBufferInfo2.regionCount ); 2511 VULKAN_HPP_HASH_COMBINE( seed, copyBufferInfo2.pRegions ); 2512 return seed; 2513 } 2514 }; 2515 2516 template <> 2517 struct hash<VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2> 2518 { operator ()std::hash2519 std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 const & copyBufferToImageInfo2 ) const VULKAN_HPP_NOEXCEPT 2520 { 2521 std::size_t seed = 0; 2522 VULKAN_HPP_HASH_COMBINE( seed, copyBufferToImageInfo2.sType ); 2523 VULKAN_HPP_HASH_COMBINE( seed, copyBufferToImageInfo2.pNext ); 2524 VULKAN_HPP_HASH_COMBINE( seed, copyBufferToImageInfo2.srcBuffer ); 2525 VULKAN_HPP_HASH_COMBINE( seed, copyBufferToImageInfo2.dstImage ); 2526 VULKAN_HPP_HASH_COMBINE( seed, copyBufferToImageInfo2.dstImageLayout ); 2527 VULKAN_HPP_HASH_COMBINE( seed, copyBufferToImageInfo2.regionCount ); 2528 VULKAN_HPP_HASH_COMBINE( seed, copyBufferToImageInfo2.pRegions ); 2529 return seed; 2530 } 2531 }; 2532 2533 template <> 2534 struct hash<VULKAN_HPP_NAMESPACE::CopyCommandTransformInfoQCOM> 2535 { operator ()std::hash2536 std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyCommandTransformInfoQCOM const & copyCommandTransformInfoQCOM ) const VULKAN_HPP_NOEXCEPT 2537 { 2538 std::size_t seed = 0; 2539 VULKAN_HPP_HASH_COMBINE( seed, copyCommandTransformInfoQCOM.sType ); 2540 VULKAN_HPP_HASH_COMBINE( seed, copyCommandTransformInfoQCOM.pNext ); 2541 VULKAN_HPP_HASH_COMBINE( seed, copyCommandTransformInfoQCOM.transform ); 2542 return seed; 2543 } 2544 }; 2545 2546 template <> 2547 struct hash<VULKAN_HPP_NAMESPACE::CopyDescriptorSet> 2548 { operator ()std::hash2549 std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyDescriptorSet const & copyDescriptorSet ) const VULKAN_HPP_NOEXCEPT 2550 { 2551 std::size_t seed = 0; 2552 VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.sType ); 2553 VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.pNext ); 2554 VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.srcSet ); 2555 VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.srcBinding ); 2556 VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.srcArrayElement ); 2557 VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.dstSet ); 2558 VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.dstBinding ); 2559 VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.dstArrayElement ); 2560 VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.descriptorCount ); 2561 return seed; 2562 } 2563 }; 2564 2565 template <> 2566 struct hash<VULKAN_HPP_NAMESPACE::ImageCopy2> 2567 { operator ()std::hash2568 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageCopy2 const & imageCopy2 ) const VULKAN_HPP_NOEXCEPT 2569 { 2570 std::size_t seed = 0; 2571 VULKAN_HPP_HASH_COMBINE( seed, imageCopy2.sType ); 2572 VULKAN_HPP_HASH_COMBINE( seed, imageCopy2.pNext ); 2573 VULKAN_HPP_HASH_COMBINE( seed, imageCopy2.srcSubresource ); 2574 VULKAN_HPP_HASH_COMBINE( seed, imageCopy2.srcOffset ); 2575 VULKAN_HPP_HASH_COMBINE( seed, imageCopy2.dstSubresource ); 2576 VULKAN_HPP_HASH_COMBINE( seed, imageCopy2.dstOffset ); 2577 VULKAN_HPP_HASH_COMBINE( seed, imageCopy2.extent ); 2578 return seed; 2579 } 2580 }; 2581 2582 template <> 2583 struct hash<VULKAN_HPP_NAMESPACE::CopyImageInfo2> 2584 { operator ()std::hash2585 std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyImageInfo2 const & copyImageInfo2 ) const VULKAN_HPP_NOEXCEPT 2586 { 2587 std::size_t seed = 0; 2588 VULKAN_HPP_HASH_COMBINE( seed, copyImageInfo2.sType ); 2589 VULKAN_HPP_HASH_COMBINE( seed, copyImageInfo2.pNext ); 2590 VULKAN_HPP_HASH_COMBINE( seed, copyImageInfo2.srcImage ); 2591 VULKAN_HPP_HASH_COMBINE( seed, copyImageInfo2.srcImageLayout ); 2592 VULKAN_HPP_HASH_COMBINE( seed, copyImageInfo2.dstImage ); 2593 VULKAN_HPP_HASH_COMBINE( seed, copyImageInfo2.dstImageLayout ); 2594 VULKAN_HPP_HASH_COMBINE( seed, copyImageInfo2.regionCount ); 2595 VULKAN_HPP_HASH_COMBINE( seed, copyImageInfo2.pRegions ); 2596 return seed; 2597 } 2598 }; 2599 2600 template <> 2601 struct hash<VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2> 2602 { operator ()std::hash2603 std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 const & copyImageToBufferInfo2 ) const VULKAN_HPP_NOEXCEPT 2604 { 2605 std::size_t seed = 0; 2606 VULKAN_HPP_HASH_COMBINE( seed, copyImageToBufferInfo2.sType ); 2607 VULKAN_HPP_HASH_COMBINE( seed, copyImageToBufferInfo2.pNext ); 2608 VULKAN_HPP_HASH_COMBINE( seed, copyImageToBufferInfo2.srcImage ); 2609 VULKAN_HPP_HASH_COMBINE( seed, copyImageToBufferInfo2.srcImageLayout ); 2610 VULKAN_HPP_HASH_COMBINE( seed, copyImageToBufferInfo2.dstBuffer ); 2611 VULKAN_HPP_HASH_COMBINE( seed, copyImageToBufferInfo2.regionCount ); 2612 VULKAN_HPP_HASH_COMBINE( seed, copyImageToBufferInfo2.pRegions ); 2613 return seed; 2614 } 2615 }; 2616 2617 template <> 2618 struct hash<VULKAN_HPP_NAMESPACE::CopyImageToImageInfoEXT> 2619 { operator ()std::hash2620 std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyImageToImageInfoEXT const & copyImageToImageInfoEXT ) const VULKAN_HPP_NOEXCEPT 2621 { 2622 std::size_t seed = 0; 2623 VULKAN_HPP_HASH_COMBINE( seed, copyImageToImageInfoEXT.sType ); 2624 VULKAN_HPP_HASH_COMBINE( seed, copyImageToImageInfoEXT.pNext ); 2625 VULKAN_HPP_HASH_COMBINE( seed, copyImageToImageInfoEXT.flags ); 2626 VULKAN_HPP_HASH_COMBINE( seed, copyImageToImageInfoEXT.srcImage ); 2627 VULKAN_HPP_HASH_COMBINE( seed, copyImageToImageInfoEXT.srcImageLayout ); 2628 VULKAN_HPP_HASH_COMBINE( seed, copyImageToImageInfoEXT.dstImage ); 2629 VULKAN_HPP_HASH_COMBINE( seed, copyImageToImageInfoEXT.dstImageLayout ); 2630 VULKAN_HPP_HASH_COMBINE( seed, copyImageToImageInfoEXT.regionCount ); 2631 VULKAN_HPP_HASH_COMBINE( seed, copyImageToImageInfoEXT.pRegions ); 2632 return seed; 2633 } 2634 }; 2635 2636 template <> 2637 struct hash<VULKAN_HPP_NAMESPACE::ImageToMemoryCopyEXT> 2638 { operator ()std::hash2639 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageToMemoryCopyEXT const & imageToMemoryCopyEXT ) const VULKAN_HPP_NOEXCEPT 2640 { 2641 std::size_t seed = 0; 2642 VULKAN_HPP_HASH_COMBINE( seed, imageToMemoryCopyEXT.sType ); 2643 VULKAN_HPP_HASH_COMBINE( seed, imageToMemoryCopyEXT.pNext ); 2644 VULKAN_HPP_HASH_COMBINE( seed, imageToMemoryCopyEXT.pHostPointer ); 2645 VULKAN_HPP_HASH_COMBINE( seed, imageToMemoryCopyEXT.memoryRowLength ); 2646 VULKAN_HPP_HASH_COMBINE( seed, imageToMemoryCopyEXT.memoryImageHeight ); 2647 VULKAN_HPP_HASH_COMBINE( seed, imageToMemoryCopyEXT.imageSubresource ); 2648 VULKAN_HPP_HASH_COMBINE( seed, imageToMemoryCopyEXT.imageOffset ); 2649 VULKAN_HPP_HASH_COMBINE( seed, imageToMemoryCopyEXT.imageExtent ); 2650 return seed; 2651 } 2652 }; 2653 2654 template <> 2655 struct hash<VULKAN_HPP_NAMESPACE::CopyImageToMemoryInfoEXT> 2656 { operator ()std::hash2657 std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyImageToMemoryInfoEXT const & copyImageToMemoryInfoEXT ) const VULKAN_HPP_NOEXCEPT 2658 { 2659 std::size_t seed = 0; 2660 VULKAN_HPP_HASH_COMBINE( seed, copyImageToMemoryInfoEXT.sType ); 2661 VULKAN_HPP_HASH_COMBINE( seed, copyImageToMemoryInfoEXT.pNext ); 2662 VULKAN_HPP_HASH_COMBINE( seed, copyImageToMemoryInfoEXT.flags ); 2663 VULKAN_HPP_HASH_COMBINE( seed, copyImageToMemoryInfoEXT.srcImage ); 2664 VULKAN_HPP_HASH_COMBINE( seed, copyImageToMemoryInfoEXT.srcImageLayout ); 2665 VULKAN_HPP_HASH_COMBINE( seed, copyImageToMemoryInfoEXT.regionCount ); 2666 VULKAN_HPP_HASH_COMBINE( seed, copyImageToMemoryInfoEXT.pRegions ); 2667 return seed; 2668 } 2669 }; 2670 2671 template <> 2672 struct hash<VULKAN_HPP_NAMESPACE::CopyMemoryIndirectCommandNV> 2673 { operator ()std::hash2674 std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyMemoryIndirectCommandNV const & copyMemoryIndirectCommandNV ) const VULKAN_HPP_NOEXCEPT 2675 { 2676 std::size_t seed = 0; 2677 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryIndirectCommandNV.srcAddress ); 2678 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryIndirectCommandNV.dstAddress ); 2679 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryIndirectCommandNV.size ); 2680 return seed; 2681 } 2682 }; 2683 2684 template <> 2685 struct hash<VULKAN_HPP_NAMESPACE::CopyMemoryToImageIndirectCommandNV> 2686 { operator ()std::hash2687 std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyMemoryToImageIndirectCommandNV const & copyMemoryToImageIndirectCommandNV ) const VULKAN_HPP_NOEXCEPT 2688 { 2689 std::size_t seed = 0; 2690 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectCommandNV.srcAddress ); 2691 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectCommandNV.bufferRowLength ); 2692 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectCommandNV.bufferImageHeight ); 2693 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectCommandNV.imageSubresource ); 2694 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectCommandNV.imageOffset ); 2695 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectCommandNV.imageExtent ); 2696 return seed; 2697 } 2698 }; 2699 2700 template <> 2701 struct hash<VULKAN_HPP_NAMESPACE::MemoryToImageCopyEXT> 2702 { operator ()std::hash2703 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryToImageCopyEXT const & memoryToImageCopyEXT ) const VULKAN_HPP_NOEXCEPT 2704 { 2705 std::size_t seed = 0; 2706 VULKAN_HPP_HASH_COMBINE( seed, memoryToImageCopyEXT.sType ); 2707 VULKAN_HPP_HASH_COMBINE( seed, memoryToImageCopyEXT.pNext ); 2708 VULKAN_HPP_HASH_COMBINE( seed, memoryToImageCopyEXT.pHostPointer ); 2709 VULKAN_HPP_HASH_COMBINE( seed, memoryToImageCopyEXT.memoryRowLength ); 2710 VULKAN_HPP_HASH_COMBINE( seed, memoryToImageCopyEXT.memoryImageHeight ); 2711 VULKAN_HPP_HASH_COMBINE( seed, memoryToImageCopyEXT.imageSubresource ); 2712 VULKAN_HPP_HASH_COMBINE( seed, memoryToImageCopyEXT.imageOffset ); 2713 VULKAN_HPP_HASH_COMBINE( seed, memoryToImageCopyEXT.imageExtent ); 2714 return seed; 2715 } 2716 }; 2717 2718 template <> 2719 struct hash<VULKAN_HPP_NAMESPACE::CopyMemoryToImageInfoEXT> 2720 { operator ()std::hash2721 std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyMemoryToImageInfoEXT const & copyMemoryToImageInfoEXT ) const VULKAN_HPP_NOEXCEPT 2722 { 2723 std::size_t seed = 0; 2724 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageInfoEXT.sType ); 2725 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageInfoEXT.pNext ); 2726 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageInfoEXT.flags ); 2727 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageInfoEXT.dstImage ); 2728 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageInfoEXT.dstImageLayout ); 2729 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageInfoEXT.regionCount ); 2730 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageInfoEXT.pRegions ); 2731 return seed; 2732 } 2733 }; 2734 2735 template <> 2736 struct hash<VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT> 2737 { operator ()std::hash2738 std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT const & copyMicromapInfoEXT ) const VULKAN_HPP_NOEXCEPT 2739 { 2740 std::size_t seed = 0; 2741 VULKAN_HPP_HASH_COMBINE( seed, copyMicromapInfoEXT.sType ); 2742 VULKAN_HPP_HASH_COMBINE( seed, copyMicromapInfoEXT.pNext ); 2743 VULKAN_HPP_HASH_COMBINE( seed, copyMicromapInfoEXT.src ); 2744 VULKAN_HPP_HASH_COMBINE( seed, copyMicromapInfoEXT.dst ); 2745 VULKAN_HPP_HASH_COMBINE( seed, copyMicromapInfoEXT.mode ); 2746 return seed; 2747 } 2748 }; 2749 2750 template <> 2751 struct hash<VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX> 2752 { operator ()std::hash2753 std::size_t operator()( VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX const & cuFunctionCreateInfoNVX ) const VULKAN_HPP_NOEXCEPT 2754 { 2755 std::size_t seed = 0; 2756 VULKAN_HPP_HASH_COMBINE( seed, cuFunctionCreateInfoNVX.sType ); 2757 VULKAN_HPP_HASH_COMBINE( seed, cuFunctionCreateInfoNVX.pNext ); 2758 VULKAN_HPP_HASH_COMBINE( seed, cuFunctionCreateInfoNVX.module ); 2759 for ( const char * p = cuFunctionCreateInfoNVX.pName; *p != '\0'; ++p ) 2760 { 2761 VULKAN_HPP_HASH_COMBINE( seed, *p ); 2762 } 2763 return seed; 2764 } 2765 }; 2766 2767 template <> 2768 struct hash<VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX> 2769 { operator ()std::hash2770 std::size_t operator()( VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX const & cuLaunchInfoNVX ) const VULKAN_HPP_NOEXCEPT 2771 { 2772 std::size_t seed = 0; 2773 VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.sType ); 2774 VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.pNext ); 2775 VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.function ); 2776 VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.gridDimX ); 2777 VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.gridDimY ); 2778 VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.gridDimZ ); 2779 VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.blockDimX ); 2780 VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.blockDimY ); 2781 VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.blockDimZ ); 2782 VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.sharedMemBytes ); 2783 VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.paramCount ); 2784 VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.pParams ); 2785 VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.extraCount ); 2786 VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.pExtras ); 2787 return seed; 2788 } 2789 }; 2790 2791 template <> 2792 struct hash<VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX> 2793 { operator ()std::hash2794 std::size_t operator()( VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX const & cuModuleCreateInfoNVX ) const VULKAN_HPP_NOEXCEPT 2795 { 2796 std::size_t seed = 0; 2797 VULKAN_HPP_HASH_COMBINE( seed, cuModuleCreateInfoNVX.sType ); 2798 VULKAN_HPP_HASH_COMBINE( seed, cuModuleCreateInfoNVX.pNext ); 2799 VULKAN_HPP_HASH_COMBINE( seed, cuModuleCreateInfoNVX.dataSize ); 2800 VULKAN_HPP_HASH_COMBINE( seed, cuModuleCreateInfoNVX.pData ); 2801 return seed; 2802 } 2803 }; 2804 2805 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 2806 template <> 2807 struct hash<VULKAN_HPP_NAMESPACE::CudaFunctionCreateInfoNV> 2808 { operator ()std::hash2809 std::size_t operator()( VULKAN_HPP_NAMESPACE::CudaFunctionCreateInfoNV const & cudaFunctionCreateInfoNV ) const VULKAN_HPP_NOEXCEPT 2810 { 2811 std::size_t seed = 0; 2812 VULKAN_HPP_HASH_COMBINE( seed, cudaFunctionCreateInfoNV.sType ); 2813 VULKAN_HPP_HASH_COMBINE( seed, cudaFunctionCreateInfoNV.pNext ); 2814 VULKAN_HPP_HASH_COMBINE( seed, cudaFunctionCreateInfoNV.module ); 2815 for ( const char * p = cudaFunctionCreateInfoNV.pName; *p != '\0'; ++p ) 2816 { 2817 VULKAN_HPP_HASH_COMBINE( seed, *p ); 2818 } 2819 return seed; 2820 } 2821 }; 2822 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 2823 2824 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 2825 template <> 2826 struct hash<VULKAN_HPP_NAMESPACE::CudaLaunchInfoNV> 2827 { operator ()std::hash2828 std::size_t operator()( VULKAN_HPP_NAMESPACE::CudaLaunchInfoNV const & cudaLaunchInfoNV ) const VULKAN_HPP_NOEXCEPT 2829 { 2830 std::size_t seed = 0; 2831 VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.sType ); 2832 VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.pNext ); 2833 VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.function ); 2834 VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.gridDimX ); 2835 VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.gridDimY ); 2836 VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.gridDimZ ); 2837 VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.blockDimX ); 2838 VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.blockDimY ); 2839 VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.blockDimZ ); 2840 VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.sharedMemBytes ); 2841 VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.paramCount ); 2842 VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.pParams ); 2843 VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.extraCount ); 2844 VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.pExtras ); 2845 return seed; 2846 } 2847 }; 2848 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 2849 2850 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 2851 template <> 2852 struct hash<VULKAN_HPP_NAMESPACE::CudaModuleCreateInfoNV> 2853 { operator ()std::hash2854 std::size_t operator()( VULKAN_HPP_NAMESPACE::CudaModuleCreateInfoNV const & cudaModuleCreateInfoNV ) const VULKAN_HPP_NOEXCEPT 2855 { 2856 std::size_t seed = 0; 2857 VULKAN_HPP_HASH_COMBINE( seed, cudaModuleCreateInfoNV.sType ); 2858 VULKAN_HPP_HASH_COMBINE( seed, cudaModuleCreateInfoNV.pNext ); 2859 VULKAN_HPP_HASH_COMBINE( seed, cudaModuleCreateInfoNV.dataSize ); 2860 VULKAN_HPP_HASH_COMBINE( seed, cudaModuleCreateInfoNV.pData ); 2861 return seed; 2862 } 2863 }; 2864 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 2865 2866 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 2867 template <> 2868 struct hash<VULKAN_HPP_NAMESPACE::D3D12FenceSubmitInfoKHR> 2869 { operator ()std::hash2870 std::size_t operator()( VULKAN_HPP_NAMESPACE::D3D12FenceSubmitInfoKHR const & d3D12FenceSubmitInfoKHR ) const VULKAN_HPP_NOEXCEPT 2871 { 2872 std::size_t seed = 0; 2873 VULKAN_HPP_HASH_COMBINE( seed, d3D12FenceSubmitInfoKHR.sType ); 2874 VULKAN_HPP_HASH_COMBINE( seed, d3D12FenceSubmitInfoKHR.pNext ); 2875 VULKAN_HPP_HASH_COMBINE( seed, d3D12FenceSubmitInfoKHR.waitSemaphoreValuesCount ); 2876 VULKAN_HPP_HASH_COMBINE( seed, d3D12FenceSubmitInfoKHR.pWaitSemaphoreValues ); 2877 VULKAN_HPP_HASH_COMBINE( seed, d3D12FenceSubmitInfoKHR.signalSemaphoreValuesCount ); 2878 VULKAN_HPP_HASH_COMBINE( seed, d3D12FenceSubmitInfoKHR.pSignalSemaphoreValues ); 2879 return seed; 2880 } 2881 }; 2882 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 2883 2884 template <> 2885 struct hash<VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT> 2886 { operator ()std::hash2887 std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT const & debugMarkerMarkerInfoEXT ) const VULKAN_HPP_NOEXCEPT 2888 { 2889 std::size_t seed = 0; 2890 VULKAN_HPP_HASH_COMBINE( seed, debugMarkerMarkerInfoEXT.sType ); 2891 VULKAN_HPP_HASH_COMBINE( seed, debugMarkerMarkerInfoEXT.pNext ); 2892 for ( const char * p = debugMarkerMarkerInfoEXT.pMarkerName; *p != '\0'; ++p ) 2893 { 2894 VULKAN_HPP_HASH_COMBINE( seed, *p ); 2895 } 2896 for ( size_t i = 0; i < 4; ++i ) 2897 { 2898 VULKAN_HPP_HASH_COMBINE( seed, debugMarkerMarkerInfoEXT.color[i] ); 2899 } 2900 return seed; 2901 } 2902 }; 2903 2904 template <> 2905 struct hash<VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT> 2906 { operator ()std::hash2907 std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT const & debugMarkerObjectNameInfoEXT ) const VULKAN_HPP_NOEXCEPT 2908 { 2909 std::size_t seed = 0; 2910 VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectNameInfoEXT.sType ); 2911 VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectNameInfoEXT.pNext ); 2912 VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectNameInfoEXT.objectType ); 2913 VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectNameInfoEXT.object ); 2914 for ( const char * p = debugMarkerObjectNameInfoEXT.pObjectName; *p != '\0'; ++p ) 2915 { 2916 VULKAN_HPP_HASH_COMBINE( seed, *p ); 2917 } 2918 return seed; 2919 } 2920 }; 2921 2922 template <> 2923 struct hash<VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT> 2924 { operator ()std::hash2925 std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT const & debugMarkerObjectTagInfoEXT ) const VULKAN_HPP_NOEXCEPT 2926 { 2927 std::size_t seed = 0; 2928 VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectTagInfoEXT.sType ); 2929 VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectTagInfoEXT.pNext ); 2930 VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectTagInfoEXT.objectType ); 2931 VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectTagInfoEXT.object ); 2932 VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectTagInfoEXT.tagName ); 2933 VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectTagInfoEXT.tagSize ); 2934 VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectTagInfoEXT.pTag ); 2935 return seed; 2936 } 2937 }; 2938 2939 template <> 2940 struct hash<VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT> 2941 { operator ()std::hash2942 std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT const & debugReportCallbackCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 2943 { 2944 std::size_t seed = 0; 2945 VULKAN_HPP_HASH_COMBINE( seed, debugReportCallbackCreateInfoEXT.sType ); 2946 VULKAN_HPP_HASH_COMBINE( seed, debugReportCallbackCreateInfoEXT.pNext ); 2947 VULKAN_HPP_HASH_COMBINE( seed, debugReportCallbackCreateInfoEXT.flags ); 2948 VULKAN_HPP_HASH_COMBINE( seed, debugReportCallbackCreateInfoEXT.pfnCallback ); 2949 VULKAN_HPP_HASH_COMBINE( seed, debugReportCallbackCreateInfoEXT.pUserData ); 2950 return seed; 2951 } 2952 }; 2953 2954 template <> 2955 struct hash<VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT> 2956 { operator ()std::hash2957 std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT const & debugUtilsLabelEXT ) const VULKAN_HPP_NOEXCEPT 2958 { 2959 std::size_t seed = 0; 2960 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsLabelEXT.sType ); 2961 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsLabelEXT.pNext ); 2962 for ( const char * p = debugUtilsLabelEXT.pLabelName; *p != '\0'; ++p ) 2963 { 2964 VULKAN_HPP_HASH_COMBINE( seed, *p ); 2965 } 2966 for ( size_t i = 0; i < 4; ++i ) 2967 { 2968 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsLabelEXT.color[i] ); 2969 } 2970 return seed; 2971 } 2972 }; 2973 2974 template <> 2975 struct hash<VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT> 2976 { operator ()std::hash2977 std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT const & debugUtilsObjectNameInfoEXT ) const VULKAN_HPP_NOEXCEPT 2978 { 2979 std::size_t seed = 0; 2980 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectNameInfoEXT.sType ); 2981 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectNameInfoEXT.pNext ); 2982 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectNameInfoEXT.objectType ); 2983 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectNameInfoEXT.objectHandle ); 2984 for ( const char * p = debugUtilsObjectNameInfoEXT.pObjectName; *p != '\0'; ++p ) 2985 { 2986 VULKAN_HPP_HASH_COMBINE( seed, *p ); 2987 } 2988 return seed; 2989 } 2990 }; 2991 2992 template <> 2993 struct hash<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataEXT> 2994 { operator ()std::hash2995 std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataEXT const & debugUtilsMessengerCallbackDataEXT ) const VULKAN_HPP_NOEXCEPT 2996 { 2997 std::size_t seed = 0; 2998 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.sType ); 2999 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.pNext ); 3000 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.flags ); 3001 for ( const char * p = debugUtilsMessengerCallbackDataEXT.pMessageIdName; *p != '\0'; ++p ) 3002 { 3003 VULKAN_HPP_HASH_COMBINE( seed, *p ); 3004 } 3005 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.messageIdNumber ); 3006 for ( const char * p = debugUtilsMessengerCallbackDataEXT.pMessage; *p != '\0'; ++p ) 3007 { 3008 VULKAN_HPP_HASH_COMBINE( seed, *p ); 3009 } 3010 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.queueLabelCount ); 3011 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.pQueueLabels ); 3012 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.cmdBufLabelCount ); 3013 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.pCmdBufLabels ); 3014 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.objectCount ); 3015 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.pObjects ); 3016 return seed; 3017 } 3018 }; 3019 3020 template <> 3021 struct hash<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT> 3022 { operator ()std::hash3023 std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT const & debugUtilsMessengerCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 3024 { 3025 std::size_t seed = 0; 3026 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCreateInfoEXT.sType ); 3027 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCreateInfoEXT.pNext ); 3028 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCreateInfoEXT.flags ); 3029 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCreateInfoEXT.messageSeverity ); 3030 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCreateInfoEXT.messageType ); 3031 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCreateInfoEXT.pfnUserCallback ); 3032 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCreateInfoEXT.pUserData ); 3033 return seed; 3034 } 3035 }; 3036 3037 template <> 3038 struct hash<VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT> 3039 { operator ()std::hash3040 std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT const & debugUtilsObjectTagInfoEXT ) const VULKAN_HPP_NOEXCEPT 3041 { 3042 std::size_t seed = 0; 3043 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectTagInfoEXT.sType ); 3044 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectTagInfoEXT.pNext ); 3045 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectTagInfoEXT.objectType ); 3046 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectTagInfoEXT.objectHandle ); 3047 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectTagInfoEXT.tagName ); 3048 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectTagInfoEXT.tagSize ); 3049 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectTagInfoEXT.pTag ); 3050 return seed; 3051 } 3052 }; 3053 3054 template <> 3055 struct hash<VULKAN_HPP_NAMESPACE::DecompressMemoryRegionNV> 3056 { operator ()std::hash3057 std::size_t operator()( VULKAN_HPP_NAMESPACE::DecompressMemoryRegionNV const & decompressMemoryRegionNV ) const VULKAN_HPP_NOEXCEPT 3058 { 3059 std::size_t seed = 0; 3060 VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryRegionNV.srcAddress ); 3061 VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryRegionNV.dstAddress ); 3062 VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryRegionNV.compressedSize ); 3063 VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryRegionNV.decompressedSize ); 3064 VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryRegionNV.decompressionMethod ); 3065 return seed; 3066 } 3067 }; 3068 3069 template <> 3070 struct hash<VULKAN_HPP_NAMESPACE::DedicatedAllocationBufferCreateInfoNV> 3071 { 3072 std::size_t operator ()std::hash3073 operator()( VULKAN_HPP_NAMESPACE::DedicatedAllocationBufferCreateInfoNV const & dedicatedAllocationBufferCreateInfoNV ) const VULKAN_HPP_NOEXCEPT 3074 { 3075 std::size_t seed = 0; 3076 VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationBufferCreateInfoNV.sType ); 3077 VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationBufferCreateInfoNV.pNext ); 3078 VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationBufferCreateInfoNV.dedicatedAllocation ); 3079 return seed; 3080 } 3081 }; 3082 3083 template <> 3084 struct hash<VULKAN_HPP_NAMESPACE::DedicatedAllocationImageCreateInfoNV> 3085 { operator ()std::hash3086 std::size_t operator()( VULKAN_HPP_NAMESPACE::DedicatedAllocationImageCreateInfoNV const & dedicatedAllocationImageCreateInfoNV ) const VULKAN_HPP_NOEXCEPT 3087 { 3088 std::size_t seed = 0; 3089 VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationImageCreateInfoNV.sType ); 3090 VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationImageCreateInfoNV.pNext ); 3091 VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationImageCreateInfoNV.dedicatedAllocation ); 3092 return seed; 3093 } 3094 }; 3095 3096 template <> 3097 struct hash<VULKAN_HPP_NAMESPACE::DedicatedAllocationMemoryAllocateInfoNV> 3098 { 3099 std::size_t operator ()std::hash3100 operator()( VULKAN_HPP_NAMESPACE::DedicatedAllocationMemoryAllocateInfoNV const & dedicatedAllocationMemoryAllocateInfoNV ) const VULKAN_HPP_NOEXCEPT 3101 { 3102 std::size_t seed = 0; 3103 VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationMemoryAllocateInfoNV.sType ); 3104 VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationMemoryAllocateInfoNV.pNext ); 3105 VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationMemoryAllocateInfoNV.image ); 3106 VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationMemoryAllocateInfoNV.buffer ); 3107 return seed; 3108 } 3109 }; 3110 3111 template <> 3112 struct hash<VULKAN_HPP_NAMESPACE::MemoryBarrier2> 3113 { operator ()std::hash3114 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryBarrier2 const & memoryBarrier2 ) const VULKAN_HPP_NOEXCEPT 3115 { 3116 std::size_t seed = 0; 3117 VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier2.sType ); 3118 VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier2.pNext ); 3119 VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier2.srcStageMask ); 3120 VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier2.srcAccessMask ); 3121 VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier2.dstStageMask ); 3122 VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier2.dstAccessMask ); 3123 return seed; 3124 } 3125 }; 3126 3127 template <> 3128 struct hash<VULKAN_HPP_NAMESPACE::ImageSubresourceRange> 3129 { operator ()std::hash3130 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageSubresourceRange const & imageSubresourceRange ) const VULKAN_HPP_NOEXCEPT 3131 { 3132 std::size_t seed = 0; 3133 VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceRange.aspectMask ); 3134 VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceRange.baseMipLevel ); 3135 VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceRange.levelCount ); 3136 VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceRange.baseArrayLayer ); 3137 VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceRange.layerCount ); 3138 return seed; 3139 } 3140 }; 3141 3142 template <> 3143 struct hash<VULKAN_HPP_NAMESPACE::ImageMemoryBarrier2> 3144 { operator ()std::hash3145 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageMemoryBarrier2 const & imageMemoryBarrier2 ) const VULKAN_HPP_NOEXCEPT 3146 { 3147 std::size_t seed = 0; 3148 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.sType ); 3149 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.pNext ); 3150 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.srcStageMask ); 3151 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.srcAccessMask ); 3152 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.dstStageMask ); 3153 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.dstAccessMask ); 3154 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.oldLayout ); 3155 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.newLayout ); 3156 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.srcQueueFamilyIndex ); 3157 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.dstQueueFamilyIndex ); 3158 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.image ); 3159 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.subresourceRange ); 3160 return seed; 3161 } 3162 }; 3163 3164 template <> 3165 struct hash<VULKAN_HPP_NAMESPACE::DependencyInfo> 3166 { operator ()std::hash3167 std::size_t operator()( VULKAN_HPP_NAMESPACE::DependencyInfo const & dependencyInfo ) const VULKAN_HPP_NOEXCEPT 3168 { 3169 std::size_t seed = 0; 3170 VULKAN_HPP_HASH_COMBINE( seed, dependencyInfo.sType ); 3171 VULKAN_HPP_HASH_COMBINE( seed, dependencyInfo.pNext ); 3172 VULKAN_HPP_HASH_COMBINE( seed, dependencyInfo.dependencyFlags ); 3173 VULKAN_HPP_HASH_COMBINE( seed, dependencyInfo.memoryBarrierCount ); 3174 VULKAN_HPP_HASH_COMBINE( seed, dependencyInfo.pMemoryBarriers ); 3175 VULKAN_HPP_HASH_COMBINE( seed, dependencyInfo.bufferMemoryBarrierCount ); 3176 VULKAN_HPP_HASH_COMBINE( seed, dependencyInfo.pBufferMemoryBarriers ); 3177 VULKAN_HPP_HASH_COMBINE( seed, dependencyInfo.imageMemoryBarrierCount ); 3178 VULKAN_HPP_HASH_COMBINE( seed, dependencyInfo.pImageMemoryBarriers ); 3179 return seed; 3180 } 3181 }; 3182 3183 template <> 3184 struct hash<VULKAN_HPP_NAMESPACE::DepthBiasInfoEXT> 3185 { operator ()std::hash3186 std::size_t operator()( VULKAN_HPP_NAMESPACE::DepthBiasInfoEXT const & depthBiasInfoEXT ) const VULKAN_HPP_NOEXCEPT 3187 { 3188 std::size_t seed = 0; 3189 VULKAN_HPP_HASH_COMBINE( seed, depthBiasInfoEXT.sType ); 3190 VULKAN_HPP_HASH_COMBINE( seed, depthBiasInfoEXT.pNext ); 3191 VULKAN_HPP_HASH_COMBINE( seed, depthBiasInfoEXT.depthBiasConstantFactor ); 3192 VULKAN_HPP_HASH_COMBINE( seed, depthBiasInfoEXT.depthBiasClamp ); 3193 VULKAN_HPP_HASH_COMBINE( seed, depthBiasInfoEXT.depthBiasSlopeFactor ); 3194 return seed; 3195 } 3196 }; 3197 3198 template <> 3199 struct hash<VULKAN_HPP_NAMESPACE::DepthBiasRepresentationInfoEXT> 3200 { operator ()std::hash3201 std::size_t operator()( VULKAN_HPP_NAMESPACE::DepthBiasRepresentationInfoEXT const & depthBiasRepresentationInfoEXT ) const VULKAN_HPP_NOEXCEPT 3202 { 3203 std::size_t seed = 0; 3204 VULKAN_HPP_HASH_COMBINE( seed, depthBiasRepresentationInfoEXT.sType ); 3205 VULKAN_HPP_HASH_COMBINE( seed, depthBiasRepresentationInfoEXT.pNext ); 3206 VULKAN_HPP_HASH_COMBINE( seed, depthBiasRepresentationInfoEXT.depthBiasRepresentation ); 3207 VULKAN_HPP_HASH_COMBINE( seed, depthBiasRepresentationInfoEXT.depthBiasExact ); 3208 return seed; 3209 } 3210 }; 3211 3212 template <> 3213 struct hash<VULKAN_HPP_NAMESPACE::DescriptorAddressInfoEXT> 3214 { operator ()std::hash3215 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorAddressInfoEXT const & descriptorAddressInfoEXT ) const VULKAN_HPP_NOEXCEPT 3216 { 3217 std::size_t seed = 0; 3218 VULKAN_HPP_HASH_COMBINE( seed, descriptorAddressInfoEXT.sType ); 3219 VULKAN_HPP_HASH_COMBINE( seed, descriptorAddressInfoEXT.pNext ); 3220 VULKAN_HPP_HASH_COMBINE( seed, descriptorAddressInfoEXT.address ); 3221 VULKAN_HPP_HASH_COMBINE( seed, descriptorAddressInfoEXT.range ); 3222 VULKAN_HPP_HASH_COMBINE( seed, descriptorAddressInfoEXT.format ); 3223 return seed; 3224 } 3225 }; 3226 3227 template <> 3228 struct hash<VULKAN_HPP_NAMESPACE::DescriptorBufferBindingInfoEXT> 3229 { operator ()std::hash3230 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorBufferBindingInfoEXT const & descriptorBufferBindingInfoEXT ) const VULKAN_HPP_NOEXCEPT 3231 { 3232 std::size_t seed = 0; 3233 VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferBindingInfoEXT.sType ); 3234 VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferBindingInfoEXT.pNext ); 3235 VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferBindingInfoEXT.address ); 3236 VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferBindingInfoEXT.usage ); 3237 return seed; 3238 } 3239 }; 3240 3241 template <> 3242 struct hash<VULKAN_HPP_NAMESPACE::DescriptorBufferBindingPushDescriptorBufferHandleEXT> 3243 { operator ()std::hash3244 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorBufferBindingPushDescriptorBufferHandleEXT const & 3245 descriptorBufferBindingPushDescriptorBufferHandleEXT ) const VULKAN_HPP_NOEXCEPT 3246 { 3247 std::size_t seed = 0; 3248 VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferBindingPushDescriptorBufferHandleEXT.sType ); 3249 VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferBindingPushDescriptorBufferHandleEXT.pNext ); 3250 VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferBindingPushDescriptorBufferHandleEXT.buffer ); 3251 return seed; 3252 } 3253 }; 3254 3255 template <> 3256 struct hash<VULKAN_HPP_NAMESPACE::DescriptorBufferInfo> 3257 { operator ()std::hash3258 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorBufferInfo const & descriptorBufferInfo ) const VULKAN_HPP_NOEXCEPT 3259 { 3260 std::size_t seed = 0; 3261 VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferInfo.buffer ); 3262 VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferInfo.offset ); 3263 VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferInfo.range ); 3264 return seed; 3265 } 3266 }; 3267 3268 template <> 3269 struct hash<VULKAN_HPP_NAMESPACE::DescriptorImageInfo> 3270 { operator ()std::hash3271 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorImageInfo const & descriptorImageInfo ) const VULKAN_HPP_NOEXCEPT 3272 { 3273 std::size_t seed = 0; 3274 VULKAN_HPP_HASH_COMBINE( seed, descriptorImageInfo.sampler ); 3275 VULKAN_HPP_HASH_COMBINE( seed, descriptorImageInfo.imageView ); 3276 VULKAN_HPP_HASH_COMBINE( seed, descriptorImageInfo.imageLayout ); 3277 return seed; 3278 } 3279 }; 3280 3281 template <> 3282 struct hash<VULKAN_HPP_NAMESPACE::DescriptorPoolSize> 3283 { operator ()std::hash3284 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorPoolSize const & descriptorPoolSize ) const VULKAN_HPP_NOEXCEPT 3285 { 3286 std::size_t seed = 0; 3287 VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolSize.type ); 3288 VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolSize.descriptorCount ); 3289 return seed; 3290 } 3291 }; 3292 3293 template <> 3294 struct hash<VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo> 3295 { operator ()std::hash3296 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo const & descriptorPoolCreateInfo ) const VULKAN_HPP_NOEXCEPT 3297 { 3298 std::size_t seed = 0; 3299 VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolCreateInfo.sType ); 3300 VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolCreateInfo.pNext ); 3301 VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolCreateInfo.flags ); 3302 VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolCreateInfo.maxSets ); 3303 VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolCreateInfo.poolSizeCount ); 3304 VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolCreateInfo.pPoolSizes ); 3305 return seed; 3306 } 3307 }; 3308 3309 template <> 3310 struct hash<VULKAN_HPP_NAMESPACE::DescriptorPoolInlineUniformBlockCreateInfo> 3311 { operator ()std::hash3312 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorPoolInlineUniformBlockCreateInfo const & descriptorPoolInlineUniformBlockCreateInfo ) const 3313 VULKAN_HPP_NOEXCEPT 3314 { 3315 std::size_t seed = 0; 3316 VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolInlineUniformBlockCreateInfo.sType ); 3317 VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolInlineUniformBlockCreateInfo.pNext ); 3318 VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolInlineUniformBlockCreateInfo.maxInlineUniformBlockBindings ); 3319 return seed; 3320 } 3321 }; 3322 3323 template <> 3324 struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo> 3325 { operator ()std::hash3326 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo const & descriptorSetAllocateInfo ) const VULKAN_HPP_NOEXCEPT 3327 { 3328 std::size_t seed = 0; 3329 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetAllocateInfo.sType ); 3330 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetAllocateInfo.pNext ); 3331 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetAllocateInfo.descriptorPool ); 3332 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetAllocateInfo.descriptorSetCount ); 3333 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetAllocateInfo.pSetLayouts ); 3334 return seed; 3335 } 3336 }; 3337 3338 template <> 3339 struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetBindingReferenceVALVE> 3340 { operator ()std::hash3341 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetBindingReferenceVALVE const & descriptorSetBindingReferenceVALVE ) const VULKAN_HPP_NOEXCEPT 3342 { 3343 std::size_t seed = 0; 3344 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetBindingReferenceVALVE.sType ); 3345 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetBindingReferenceVALVE.pNext ); 3346 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetBindingReferenceVALVE.descriptorSetLayout ); 3347 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetBindingReferenceVALVE.binding ); 3348 return seed; 3349 } 3350 }; 3351 3352 template <> 3353 struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBinding> 3354 { operator ()std::hash3355 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBinding const & descriptorSetLayoutBinding ) const VULKAN_HPP_NOEXCEPT 3356 { 3357 std::size_t seed = 0; 3358 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutBinding.binding ); 3359 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutBinding.descriptorType ); 3360 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutBinding.descriptorCount ); 3361 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutBinding.stageFlags ); 3362 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutBinding.pImmutableSamplers ); 3363 return seed; 3364 } 3365 }; 3366 3367 template <> 3368 struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBindingFlagsCreateInfo> 3369 { 3370 std::size_t operator ()std::hash3371 operator()( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBindingFlagsCreateInfo const & descriptorSetLayoutBindingFlagsCreateInfo ) const VULKAN_HPP_NOEXCEPT 3372 { 3373 std::size_t seed = 0; 3374 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutBindingFlagsCreateInfo.sType ); 3375 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutBindingFlagsCreateInfo.pNext ); 3376 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutBindingFlagsCreateInfo.bindingCount ); 3377 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutBindingFlagsCreateInfo.pBindingFlags ); 3378 return seed; 3379 } 3380 }; 3381 3382 template <> 3383 struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo> 3384 { operator ()std::hash3385 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo const & descriptorSetLayoutCreateInfo ) const VULKAN_HPP_NOEXCEPT 3386 { 3387 std::size_t seed = 0; 3388 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutCreateInfo.sType ); 3389 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutCreateInfo.pNext ); 3390 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutCreateInfo.flags ); 3391 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutCreateInfo.bindingCount ); 3392 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutCreateInfo.pBindings ); 3393 return seed; 3394 } 3395 }; 3396 3397 template <> 3398 struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutHostMappingInfoVALVE> 3399 { 3400 std::size_t operator ()std::hash3401 operator()( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutHostMappingInfoVALVE const & descriptorSetLayoutHostMappingInfoVALVE ) const VULKAN_HPP_NOEXCEPT 3402 { 3403 std::size_t seed = 0; 3404 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutHostMappingInfoVALVE.sType ); 3405 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutHostMappingInfoVALVE.pNext ); 3406 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutHostMappingInfoVALVE.descriptorOffset ); 3407 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutHostMappingInfoVALVE.descriptorSize ); 3408 return seed; 3409 } 3410 }; 3411 3412 template <> 3413 struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport> 3414 { operator ()std::hash3415 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport const & descriptorSetLayoutSupport ) const VULKAN_HPP_NOEXCEPT 3416 { 3417 std::size_t seed = 0; 3418 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutSupport.sType ); 3419 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutSupport.pNext ); 3420 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutSupport.supported ); 3421 return seed; 3422 } 3423 }; 3424 3425 template <> 3426 struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetVariableDescriptorCountAllocateInfo> 3427 { operator ()std::hash3428 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetVariableDescriptorCountAllocateInfo const & descriptorSetVariableDescriptorCountAllocateInfo ) 3429 const VULKAN_HPP_NOEXCEPT 3430 { 3431 std::size_t seed = 0; 3432 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetVariableDescriptorCountAllocateInfo.sType ); 3433 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetVariableDescriptorCountAllocateInfo.pNext ); 3434 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetVariableDescriptorCountAllocateInfo.descriptorSetCount ); 3435 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetVariableDescriptorCountAllocateInfo.pDescriptorCounts ); 3436 return seed; 3437 } 3438 }; 3439 3440 template <> 3441 struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetVariableDescriptorCountLayoutSupport> 3442 { operator ()std::hash3443 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetVariableDescriptorCountLayoutSupport const & descriptorSetVariableDescriptorCountLayoutSupport ) 3444 const VULKAN_HPP_NOEXCEPT 3445 { 3446 std::size_t seed = 0; 3447 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetVariableDescriptorCountLayoutSupport.sType ); 3448 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetVariableDescriptorCountLayoutSupport.pNext ); 3449 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetVariableDescriptorCountLayoutSupport.maxVariableDescriptorCount ); 3450 return seed; 3451 } 3452 }; 3453 3454 template <> 3455 struct hash<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateEntry> 3456 { operator ()std::hash3457 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateEntry const & descriptorUpdateTemplateEntry ) const VULKAN_HPP_NOEXCEPT 3458 { 3459 std::size_t seed = 0; 3460 VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateEntry.dstBinding ); 3461 VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateEntry.dstArrayElement ); 3462 VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateEntry.descriptorCount ); 3463 VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateEntry.descriptorType ); 3464 VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateEntry.offset ); 3465 VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateEntry.stride ); 3466 return seed; 3467 } 3468 }; 3469 3470 template <> 3471 struct hash<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo> 3472 { operator ()std::hash3473 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo const & descriptorUpdateTemplateCreateInfo ) const VULKAN_HPP_NOEXCEPT 3474 { 3475 std::size_t seed = 0; 3476 VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.sType ); 3477 VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.pNext ); 3478 VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.flags ); 3479 VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.descriptorUpdateEntryCount ); 3480 VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.pDescriptorUpdateEntries ); 3481 VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.templateType ); 3482 VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.descriptorSetLayout ); 3483 VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.pipelineBindPoint ); 3484 VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.pipelineLayout ); 3485 VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.set ); 3486 return seed; 3487 } 3488 }; 3489 3490 template <> 3491 struct hash<VULKAN_HPP_NAMESPACE::DeviceAddressBindingCallbackDataEXT> 3492 { operator ()std::hash3493 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceAddressBindingCallbackDataEXT const & deviceAddressBindingCallbackDataEXT ) const VULKAN_HPP_NOEXCEPT 3494 { 3495 std::size_t seed = 0; 3496 VULKAN_HPP_HASH_COMBINE( seed, deviceAddressBindingCallbackDataEXT.sType ); 3497 VULKAN_HPP_HASH_COMBINE( seed, deviceAddressBindingCallbackDataEXT.pNext ); 3498 VULKAN_HPP_HASH_COMBINE( seed, deviceAddressBindingCallbackDataEXT.flags ); 3499 VULKAN_HPP_HASH_COMBINE( seed, deviceAddressBindingCallbackDataEXT.baseAddress ); 3500 VULKAN_HPP_HASH_COMBINE( seed, deviceAddressBindingCallbackDataEXT.size ); 3501 VULKAN_HPP_HASH_COMBINE( seed, deviceAddressBindingCallbackDataEXT.bindingType ); 3502 return seed; 3503 } 3504 }; 3505 3506 template <> 3507 struct hash<VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements> 3508 { operator ()std::hash3509 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements const & deviceBufferMemoryRequirements ) const VULKAN_HPP_NOEXCEPT 3510 { 3511 std::size_t seed = 0; 3512 VULKAN_HPP_HASH_COMBINE( seed, deviceBufferMemoryRequirements.sType ); 3513 VULKAN_HPP_HASH_COMBINE( seed, deviceBufferMemoryRequirements.pNext ); 3514 VULKAN_HPP_HASH_COMBINE( seed, deviceBufferMemoryRequirements.pCreateInfo ); 3515 return seed; 3516 } 3517 }; 3518 3519 template <> 3520 struct hash<VULKAN_HPP_NAMESPACE::DeviceQueueCreateInfo> 3521 { operator ()std::hash3522 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceQueueCreateInfo const & deviceQueueCreateInfo ) const VULKAN_HPP_NOEXCEPT 3523 { 3524 std::size_t seed = 0; 3525 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueCreateInfo.sType ); 3526 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueCreateInfo.pNext ); 3527 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueCreateInfo.flags ); 3528 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueCreateInfo.queueFamilyIndex ); 3529 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueCreateInfo.queueCount ); 3530 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueCreateInfo.pQueuePriorities ); 3531 return seed; 3532 } 3533 }; 3534 3535 template <> 3536 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures> 3537 { operator ()std::hash3538 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures const & physicalDeviceFeatures ) const VULKAN_HPP_NOEXCEPT 3539 { 3540 std::size_t seed = 0; 3541 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.robustBufferAccess ); 3542 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.fullDrawIndexUint32 ); 3543 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.imageCubeArray ); 3544 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.independentBlend ); 3545 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.geometryShader ); 3546 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.tessellationShader ); 3547 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sampleRateShading ); 3548 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.dualSrcBlend ); 3549 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.logicOp ); 3550 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.multiDrawIndirect ); 3551 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.drawIndirectFirstInstance ); 3552 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.depthClamp ); 3553 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.depthBiasClamp ); 3554 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.fillModeNonSolid ); 3555 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.depthBounds ); 3556 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.wideLines ); 3557 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.largePoints ); 3558 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.alphaToOne ); 3559 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.multiViewport ); 3560 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.samplerAnisotropy ); 3561 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.textureCompressionETC2 ); 3562 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.textureCompressionASTC_LDR ); 3563 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.textureCompressionBC ); 3564 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.occlusionQueryPrecise ); 3565 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.pipelineStatisticsQuery ); 3566 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.vertexPipelineStoresAndAtomics ); 3567 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.fragmentStoresAndAtomics ); 3568 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderTessellationAndGeometryPointSize ); 3569 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderImageGatherExtended ); 3570 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderStorageImageExtendedFormats ); 3571 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderStorageImageMultisample ); 3572 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderStorageImageReadWithoutFormat ); 3573 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderStorageImageWriteWithoutFormat ); 3574 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderUniformBufferArrayDynamicIndexing ); 3575 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderSampledImageArrayDynamicIndexing ); 3576 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderStorageBufferArrayDynamicIndexing ); 3577 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderStorageImageArrayDynamicIndexing ); 3578 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderClipDistance ); 3579 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderCullDistance ); 3580 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderFloat64 ); 3581 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderInt64 ); 3582 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderInt16 ); 3583 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderResourceResidency ); 3584 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderResourceMinLod ); 3585 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sparseBinding ); 3586 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sparseResidencyBuffer ); 3587 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sparseResidencyImage2D ); 3588 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sparseResidencyImage3D ); 3589 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sparseResidency2Samples ); 3590 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sparseResidency4Samples ); 3591 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sparseResidency8Samples ); 3592 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sparseResidency16Samples ); 3593 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sparseResidencyAliased ); 3594 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.variableMultisampleRate ); 3595 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.inheritedQueries ); 3596 return seed; 3597 } 3598 }; 3599 3600 template <> 3601 struct hash<VULKAN_HPP_NAMESPACE::DeviceCreateInfo> 3602 { operator ()std::hash3603 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceCreateInfo const & deviceCreateInfo ) const VULKAN_HPP_NOEXCEPT 3604 { 3605 std::size_t seed = 0; 3606 VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.sType ); 3607 VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.pNext ); 3608 VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.flags ); 3609 VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.queueCreateInfoCount ); 3610 VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.pQueueCreateInfos ); 3611 VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.enabledLayerCount ); 3612 for ( size_t i = 0; i < deviceCreateInfo.enabledLayerCount; ++i ) 3613 { 3614 for ( const char * p = deviceCreateInfo.ppEnabledLayerNames[i]; *p != '\0'; ++p ) 3615 { 3616 VULKAN_HPP_HASH_COMBINE( seed, *p ); 3617 } 3618 } 3619 VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.enabledExtensionCount ); 3620 for ( size_t i = 0; i < deviceCreateInfo.enabledExtensionCount; ++i ) 3621 { 3622 for ( const char * p = deviceCreateInfo.ppEnabledExtensionNames[i]; *p != '\0'; ++p ) 3623 { 3624 VULKAN_HPP_HASH_COMBINE( seed, *p ); 3625 } 3626 } 3627 VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.pEnabledFeatures ); 3628 return seed; 3629 } 3630 }; 3631 3632 template <> 3633 struct hash<VULKAN_HPP_NAMESPACE::DeviceDeviceMemoryReportCreateInfoEXT> 3634 { 3635 std::size_t operator ()std::hash3636 operator()( VULKAN_HPP_NAMESPACE::DeviceDeviceMemoryReportCreateInfoEXT const & deviceDeviceMemoryReportCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 3637 { 3638 std::size_t seed = 0; 3639 VULKAN_HPP_HASH_COMBINE( seed, deviceDeviceMemoryReportCreateInfoEXT.sType ); 3640 VULKAN_HPP_HASH_COMBINE( seed, deviceDeviceMemoryReportCreateInfoEXT.pNext ); 3641 VULKAN_HPP_HASH_COMBINE( seed, deviceDeviceMemoryReportCreateInfoEXT.flags ); 3642 VULKAN_HPP_HASH_COMBINE( seed, deviceDeviceMemoryReportCreateInfoEXT.pfnUserCallback ); 3643 VULKAN_HPP_HASH_COMBINE( seed, deviceDeviceMemoryReportCreateInfoEXT.pUserData ); 3644 return seed; 3645 } 3646 }; 3647 3648 template <> 3649 struct hash<VULKAN_HPP_NAMESPACE::DeviceDiagnosticsConfigCreateInfoNV> 3650 { operator ()std::hash3651 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceDiagnosticsConfigCreateInfoNV const & deviceDiagnosticsConfigCreateInfoNV ) const VULKAN_HPP_NOEXCEPT 3652 { 3653 std::size_t seed = 0; 3654 VULKAN_HPP_HASH_COMBINE( seed, deviceDiagnosticsConfigCreateInfoNV.sType ); 3655 VULKAN_HPP_HASH_COMBINE( seed, deviceDiagnosticsConfigCreateInfoNV.pNext ); 3656 VULKAN_HPP_HASH_COMBINE( seed, deviceDiagnosticsConfigCreateInfoNV.flags ); 3657 return seed; 3658 } 3659 }; 3660 3661 template <> 3662 struct hash<VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT> 3663 { operator ()std::hash3664 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT const & deviceEventInfoEXT ) const VULKAN_HPP_NOEXCEPT 3665 { 3666 std::size_t seed = 0; 3667 VULKAN_HPP_HASH_COMBINE( seed, deviceEventInfoEXT.sType ); 3668 VULKAN_HPP_HASH_COMBINE( seed, deviceEventInfoEXT.pNext ); 3669 VULKAN_HPP_HASH_COMBINE( seed, deviceEventInfoEXT.deviceEvent ); 3670 return seed; 3671 } 3672 }; 3673 3674 template <> 3675 struct hash<VULKAN_HPP_NAMESPACE::DeviceFaultAddressInfoEXT> 3676 { operator ()std::hash3677 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceFaultAddressInfoEXT const & deviceFaultAddressInfoEXT ) const VULKAN_HPP_NOEXCEPT 3678 { 3679 std::size_t seed = 0; 3680 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultAddressInfoEXT.addressType ); 3681 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultAddressInfoEXT.reportedAddress ); 3682 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultAddressInfoEXT.addressPrecision ); 3683 return seed; 3684 } 3685 }; 3686 3687 template <> 3688 struct hash<VULKAN_HPP_NAMESPACE::DeviceFaultCountsEXT> 3689 { operator ()std::hash3690 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceFaultCountsEXT const & deviceFaultCountsEXT ) const VULKAN_HPP_NOEXCEPT 3691 { 3692 std::size_t seed = 0; 3693 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultCountsEXT.sType ); 3694 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultCountsEXT.pNext ); 3695 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultCountsEXT.addressInfoCount ); 3696 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultCountsEXT.vendorInfoCount ); 3697 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultCountsEXT.vendorBinarySize ); 3698 return seed; 3699 } 3700 }; 3701 3702 template <> 3703 struct hash<VULKAN_HPP_NAMESPACE::DeviceFaultVendorInfoEXT> 3704 { operator ()std::hash3705 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceFaultVendorInfoEXT const & deviceFaultVendorInfoEXT ) const VULKAN_HPP_NOEXCEPT 3706 { 3707 std::size_t seed = 0; 3708 for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) 3709 { 3710 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorInfoEXT.description[i] ); 3711 } 3712 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorInfoEXT.vendorFaultCode ); 3713 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorInfoEXT.vendorFaultData ); 3714 return seed; 3715 } 3716 }; 3717 3718 template <> 3719 struct hash<VULKAN_HPP_NAMESPACE::DeviceFaultInfoEXT> 3720 { operator ()std::hash3721 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceFaultInfoEXT const & deviceFaultInfoEXT ) const VULKAN_HPP_NOEXCEPT 3722 { 3723 std::size_t seed = 0; 3724 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultInfoEXT.sType ); 3725 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultInfoEXT.pNext ); 3726 for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) 3727 { 3728 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultInfoEXT.description[i] ); 3729 } 3730 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultInfoEXT.pAddressInfos ); 3731 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultInfoEXT.pVendorInfos ); 3732 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultInfoEXT.pVendorBinaryData ); 3733 return seed; 3734 } 3735 }; 3736 3737 template <> 3738 struct hash<VULKAN_HPP_NAMESPACE::DeviceFaultVendorBinaryHeaderVersionOneEXT> 3739 { operator ()std::hash3740 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceFaultVendorBinaryHeaderVersionOneEXT const & deviceFaultVendorBinaryHeaderVersionOneEXT ) const 3741 VULKAN_HPP_NOEXCEPT 3742 { 3743 std::size_t seed = 0; 3744 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.headerSize ); 3745 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.headerVersion ); 3746 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.vendorID ); 3747 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.deviceID ); 3748 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.driverVersion ); 3749 for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) 3750 { 3751 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.pipelineCacheUUID[i] ); 3752 } 3753 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.applicationNameOffset ); 3754 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.applicationVersion ); 3755 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.engineNameOffset ); 3756 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.engineVersion ); 3757 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.apiVersion ); 3758 return seed; 3759 } 3760 }; 3761 3762 template <> 3763 struct hash<VULKAN_HPP_NAMESPACE::DeviceGroupBindSparseInfo> 3764 { operator ()std::hash3765 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupBindSparseInfo const & deviceGroupBindSparseInfo ) const VULKAN_HPP_NOEXCEPT 3766 { 3767 std::size_t seed = 0; 3768 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupBindSparseInfo.sType ); 3769 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupBindSparseInfo.pNext ); 3770 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupBindSparseInfo.resourceDeviceIndex ); 3771 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupBindSparseInfo.memoryDeviceIndex ); 3772 return seed; 3773 } 3774 }; 3775 3776 template <> 3777 struct hash<VULKAN_HPP_NAMESPACE::DeviceGroupCommandBufferBeginInfo> 3778 { operator ()std::hash3779 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupCommandBufferBeginInfo const & deviceGroupCommandBufferBeginInfo ) const VULKAN_HPP_NOEXCEPT 3780 { 3781 std::size_t seed = 0; 3782 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupCommandBufferBeginInfo.sType ); 3783 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupCommandBufferBeginInfo.pNext ); 3784 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupCommandBufferBeginInfo.deviceMask ); 3785 return seed; 3786 } 3787 }; 3788 3789 template <> 3790 struct hash<VULKAN_HPP_NAMESPACE::DeviceGroupDeviceCreateInfo> 3791 { operator ()std::hash3792 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupDeviceCreateInfo const & deviceGroupDeviceCreateInfo ) const VULKAN_HPP_NOEXCEPT 3793 { 3794 std::size_t seed = 0; 3795 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupDeviceCreateInfo.sType ); 3796 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupDeviceCreateInfo.pNext ); 3797 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupDeviceCreateInfo.physicalDeviceCount ); 3798 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupDeviceCreateInfo.pPhysicalDevices ); 3799 return seed; 3800 } 3801 }; 3802 3803 template <> 3804 struct hash<VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR> 3805 { operator ()std::hash3806 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR const & deviceGroupPresentCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT 3807 { 3808 std::size_t seed = 0; 3809 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupPresentCapabilitiesKHR.sType ); 3810 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupPresentCapabilitiesKHR.pNext ); 3811 for ( size_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; ++i ) 3812 { 3813 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupPresentCapabilitiesKHR.presentMask[i] ); 3814 } 3815 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupPresentCapabilitiesKHR.modes ); 3816 return seed; 3817 } 3818 }; 3819 3820 template <> 3821 struct hash<VULKAN_HPP_NAMESPACE::DeviceGroupPresentInfoKHR> 3822 { operator ()std::hash3823 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupPresentInfoKHR const & deviceGroupPresentInfoKHR ) const VULKAN_HPP_NOEXCEPT 3824 { 3825 std::size_t seed = 0; 3826 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupPresentInfoKHR.sType ); 3827 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupPresentInfoKHR.pNext ); 3828 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupPresentInfoKHR.swapchainCount ); 3829 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupPresentInfoKHR.pDeviceMasks ); 3830 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupPresentInfoKHR.mode ); 3831 return seed; 3832 } 3833 }; 3834 3835 template <> 3836 struct hash<VULKAN_HPP_NAMESPACE::DeviceGroupRenderPassBeginInfo> 3837 { operator ()std::hash3838 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupRenderPassBeginInfo const & deviceGroupRenderPassBeginInfo ) const VULKAN_HPP_NOEXCEPT 3839 { 3840 std::size_t seed = 0; 3841 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupRenderPassBeginInfo.sType ); 3842 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupRenderPassBeginInfo.pNext ); 3843 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupRenderPassBeginInfo.deviceMask ); 3844 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupRenderPassBeginInfo.deviceRenderAreaCount ); 3845 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupRenderPassBeginInfo.pDeviceRenderAreas ); 3846 return seed; 3847 } 3848 }; 3849 3850 template <> 3851 struct hash<VULKAN_HPP_NAMESPACE::DeviceGroupSubmitInfo> 3852 { operator ()std::hash3853 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupSubmitInfo const & deviceGroupSubmitInfo ) const VULKAN_HPP_NOEXCEPT 3854 { 3855 std::size_t seed = 0; 3856 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSubmitInfo.sType ); 3857 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSubmitInfo.pNext ); 3858 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSubmitInfo.waitSemaphoreCount ); 3859 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSubmitInfo.pWaitSemaphoreDeviceIndices ); 3860 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSubmitInfo.commandBufferCount ); 3861 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSubmitInfo.pCommandBufferDeviceMasks ); 3862 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSubmitInfo.signalSemaphoreCount ); 3863 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSubmitInfo.pSignalSemaphoreDeviceIndices ); 3864 return seed; 3865 } 3866 }; 3867 3868 template <> 3869 struct hash<VULKAN_HPP_NAMESPACE::DeviceGroupSwapchainCreateInfoKHR> 3870 { operator ()std::hash3871 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupSwapchainCreateInfoKHR const & deviceGroupSwapchainCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 3872 { 3873 std::size_t seed = 0; 3874 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSwapchainCreateInfoKHR.sType ); 3875 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSwapchainCreateInfoKHR.pNext ); 3876 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSwapchainCreateInfoKHR.modes ); 3877 return seed; 3878 } 3879 }; 3880 3881 template <> 3882 struct hash<VULKAN_HPP_NAMESPACE::ImageCreateInfo> 3883 { operator ()std::hash3884 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageCreateInfo const & imageCreateInfo ) const VULKAN_HPP_NOEXCEPT 3885 { 3886 std::size_t seed = 0; 3887 VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.sType ); 3888 VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.pNext ); 3889 VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.flags ); 3890 VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.imageType ); 3891 VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.format ); 3892 VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.extent ); 3893 VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.mipLevels ); 3894 VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.arrayLayers ); 3895 VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.samples ); 3896 VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.tiling ); 3897 VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.usage ); 3898 VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.sharingMode ); 3899 VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.queueFamilyIndexCount ); 3900 VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.pQueueFamilyIndices ); 3901 VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.initialLayout ); 3902 return seed; 3903 } 3904 }; 3905 3906 template <> 3907 struct hash<VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements> 3908 { operator ()std::hash3909 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements const & deviceImageMemoryRequirements ) const VULKAN_HPP_NOEXCEPT 3910 { 3911 std::size_t seed = 0; 3912 VULKAN_HPP_HASH_COMBINE( seed, deviceImageMemoryRequirements.sType ); 3913 VULKAN_HPP_HASH_COMBINE( seed, deviceImageMemoryRequirements.pNext ); 3914 VULKAN_HPP_HASH_COMBINE( seed, deviceImageMemoryRequirements.pCreateInfo ); 3915 VULKAN_HPP_HASH_COMBINE( seed, deviceImageMemoryRequirements.planeAspect ); 3916 return seed; 3917 } 3918 }; 3919 3920 template <> 3921 struct hash<VULKAN_HPP_NAMESPACE::ImageSubresource2KHR> 3922 { operator ()std::hash3923 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageSubresource2KHR const & imageSubresource2KHR ) const VULKAN_HPP_NOEXCEPT 3924 { 3925 std::size_t seed = 0; 3926 VULKAN_HPP_HASH_COMBINE( seed, imageSubresource2KHR.sType ); 3927 VULKAN_HPP_HASH_COMBINE( seed, imageSubresource2KHR.pNext ); 3928 VULKAN_HPP_HASH_COMBINE( seed, imageSubresource2KHR.imageSubresource ); 3929 return seed; 3930 } 3931 }; 3932 3933 template <> 3934 struct hash<VULKAN_HPP_NAMESPACE::DeviceImageSubresourceInfoKHR> 3935 { operator ()std::hash3936 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceImageSubresourceInfoKHR const & deviceImageSubresourceInfoKHR ) const VULKAN_HPP_NOEXCEPT 3937 { 3938 std::size_t seed = 0; 3939 VULKAN_HPP_HASH_COMBINE( seed, deviceImageSubresourceInfoKHR.sType ); 3940 VULKAN_HPP_HASH_COMBINE( seed, deviceImageSubresourceInfoKHR.pNext ); 3941 VULKAN_HPP_HASH_COMBINE( seed, deviceImageSubresourceInfoKHR.pCreateInfo ); 3942 VULKAN_HPP_HASH_COMBINE( seed, deviceImageSubresourceInfoKHR.pSubresource ); 3943 return seed; 3944 } 3945 }; 3946 3947 template <> 3948 struct hash<VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo> 3949 { operator ()std::hash3950 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo const & deviceMemoryOpaqueCaptureAddressInfo ) const VULKAN_HPP_NOEXCEPT 3951 { 3952 std::size_t seed = 0; 3953 VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryOpaqueCaptureAddressInfo.sType ); 3954 VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryOpaqueCaptureAddressInfo.pNext ); 3955 VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryOpaqueCaptureAddressInfo.memory ); 3956 return seed; 3957 } 3958 }; 3959 3960 template <> 3961 struct hash<VULKAN_HPP_NAMESPACE::DeviceMemoryOverallocationCreateInfoAMD> 3962 { 3963 std::size_t operator ()std::hash3964 operator()( VULKAN_HPP_NAMESPACE::DeviceMemoryOverallocationCreateInfoAMD const & deviceMemoryOverallocationCreateInfoAMD ) const VULKAN_HPP_NOEXCEPT 3965 { 3966 std::size_t seed = 0; 3967 VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryOverallocationCreateInfoAMD.sType ); 3968 VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryOverallocationCreateInfoAMD.pNext ); 3969 VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryOverallocationCreateInfoAMD.overallocationBehavior ); 3970 return seed; 3971 } 3972 }; 3973 3974 template <> 3975 struct hash<VULKAN_HPP_NAMESPACE::DeviceMemoryReportCallbackDataEXT> 3976 { operator ()std::hash3977 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceMemoryReportCallbackDataEXT const & deviceMemoryReportCallbackDataEXT ) const VULKAN_HPP_NOEXCEPT 3978 { 3979 std::size_t seed = 0; 3980 VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryReportCallbackDataEXT.sType ); 3981 VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryReportCallbackDataEXT.pNext ); 3982 VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryReportCallbackDataEXT.flags ); 3983 VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryReportCallbackDataEXT.type ); 3984 VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryReportCallbackDataEXT.memoryObjectId ); 3985 VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryReportCallbackDataEXT.size ); 3986 VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryReportCallbackDataEXT.objectType ); 3987 VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryReportCallbackDataEXT.objectHandle ); 3988 VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryReportCallbackDataEXT.heapIndex ); 3989 return seed; 3990 } 3991 }; 3992 3993 template <> 3994 struct hash<VULKAN_HPP_NAMESPACE::DevicePrivateDataCreateInfo> 3995 { operator ()std::hash3996 std::size_t operator()( VULKAN_HPP_NAMESPACE::DevicePrivateDataCreateInfo const & devicePrivateDataCreateInfo ) const VULKAN_HPP_NOEXCEPT 3997 { 3998 std::size_t seed = 0; 3999 VULKAN_HPP_HASH_COMBINE( seed, devicePrivateDataCreateInfo.sType ); 4000 VULKAN_HPP_HASH_COMBINE( seed, devicePrivateDataCreateInfo.pNext ); 4001 VULKAN_HPP_HASH_COMBINE( seed, devicePrivateDataCreateInfo.privateDataSlotRequestCount ); 4002 return seed; 4003 } 4004 }; 4005 4006 template <> 4007 struct hash<VULKAN_HPP_NAMESPACE::DeviceQueueGlobalPriorityCreateInfoKHR> 4008 { 4009 std::size_t operator ()std::hash4010 operator()( VULKAN_HPP_NAMESPACE::DeviceQueueGlobalPriorityCreateInfoKHR const & deviceQueueGlobalPriorityCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 4011 { 4012 std::size_t seed = 0; 4013 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueGlobalPriorityCreateInfoKHR.sType ); 4014 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueGlobalPriorityCreateInfoKHR.pNext ); 4015 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueGlobalPriorityCreateInfoKHR.globalPriority ); 4016 return seed; 4017 } 4018 }; 4019 4020 template <> 4021 struct hash<VULKAN_HPP_NAMESPACE::DeviceQueueInfo2> 4022 { operator ()std::hash4023 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceQueueInfo2 const & deviceQueueInfo2 ) const VULKAN_HPP_NOEXCEPT 4024 { 4025 std::size_t seed = 0; 4026 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueInfo2.sType ); 4027 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueInfo2.pNext ); 4028 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueInfo2.flags ); 4029 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueInfo2.queueFamilyIndex ); 4030 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueInfo2.queueIndex ); 4031 return seed; 4032 } 4033 }; 4034 4035 template <> 4036 struct hash<VULKAN_HPP_NAMESPACE::DeviceQueueShaderCoreControlCreateInfoARM> 4037 { 4038 std::size_t operator ()std::hash4039 operator()( VULKAN_HPP_NAMESPACE::DeviceQueueShaderCoreControlCreateInfoARM const & deviceQueueShaderCoreControlCreateInfoARM ) const VULKAN_HPP_NOEXCEPT 4040 { 4041 std::size_t seed = 0; 4042 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueShaderCoreControlCreateInfoARM.sType ); 4043 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueShaderCoreControlCreateInfoARM.pNext ); 4044 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueShaderCoreControlCreateInfoARM.shaderCoreCount ); 4045 return seed; 4046 } 4047 }; 4048 4049 template <> 4050 struct hash<VULKAN_HPP_NAMESPACE::DirectDriverLoadingInfoLUNARG> 4051 { operator ()std::hash4052 std::size_t operator()( VULKAN_HPP_NAMESPACE::DirectDriverLoadingInfoLUNARG const & directDriverLoadingInfoLUNARG ) const VULKAN_HPP_NOEXCEPT 4053 { 4054 std::size_t seed = 0; 4055 VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingInfoLUNARG.sType ); 4056 VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingInfoLUNARG.pNext ); 4057 VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingInfoLUNARG.flags ); 4058 VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingInfoLUNARG.pfnGetInstanceProcAddr ); 4059 return seed; 4060 } 4061 }; 4062 4063 template <> 4064 struct hash<VULKAN_HPP_NAMESPACE::DirectDriverLoadingListLUNARG> 4065 { operator ()std::hash4066 std::size_t operator()( VULKAN_HPP_NAMESPACE::DirectDriverLoadingListLUNARG const & directDriverLoadingListLUNARG ) const VULKAN_HPP_NOEXCEPT 4067 { 4068 std::size_t seed = 0; 4069 VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingListLUNARG.sType ); 4070 VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingListLUNARG.pNext ); 4071 VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingListLUNARG.mode ); 4072 VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingListLUNARG.driverCount ); 4073 VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingListLUNARG.pDrivers ); 4074 return seed; 4075 } 4076 }; 4077 4078 # if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) 4079 template <> 4080 struct hash<VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT> 4081 { operator ()std::hash4082 std::size_t operator()( VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT const & directFBSurfaceCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 4083 { 4084 std::size_t seed = 0; 4085 VULKAN_HPP_HASH_COMBINE( seed, directFBSurfaceCreateInfoEXT.sType ); 4086 VULKAN_HPP_HASH_COMBINE( seed, directFBSurfaceCreateInfoEXT.pNext ); 4087 VULKAN_HPP_HASH_COMBINE( seed, directFBSurfaceCreateInfoEXT.flags ); 4088 VULKAN_HPP_HASH_COMBINE( seed, directFBSurfaceCreateInfoEXT.dfb ); 4089 VULKAN_HPP_HASH_COMBINE( seed, directFBSurfaceCreateInfoEXT.surface ); 4090 return seed; 4091 } 4092 }; 4093 # endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ 4094 4095 template <> 4096 struct hash<VULKAN_HPP_NAMESPACE::DispatchIndirectCommand> 4097 { operator ()std::hash4098 std::size_t operator()( VULKAN_HPP_NAMESPACE::DispatchIndirectCommand const & dispatchIndirectCommand ) const VULKAN_HPP_NOEXCEPT 4099 { 4100 std::size_t seed = 0; 4101 VULKAN_HPP_HASH_COMBINE( seed, dispatchIndirectCommand.x ); 4102 VULKAN_HPP_HASH_COMBINE( seed, dispatchIndirectCommand.y ); 4103 VULKAN_HPP_HASH_COMBINE( seed, dispatchIndirectCommand.z ); 4104 return seed; 4105 } 4106 }; 4107 4108 template <> 4109 struct hash<VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT> 4110 { operator ()std::hash4111 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT const & displayEventInfoEXT ) const VULKAN_HPP_NOEXCEPT 4112 { 4113 std::size_t seed = 0; 4114 VULKAN_HPP_HASH_COMBINE( seed, displayEventInfoEXT.sType ); 4115 VULKAN_HPP_HASH_COMBINE( seed, displayEventInfoEXT.pNext ); 4116 VULKAN_HPP_HASH_COMBINE( seed, displayEventInfoEXT.displayEvent ); 4117 return seed; 4118 } 4119 }; 4120 4121 template <> 4122 struct hash<VULKAN_HPP_NAMESPACE::DisplayModeParametersKHR> 4123 { operator ()std::hash4124 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayModeParametersKHR const & displayModeParametersKHR ) const VULKAN_HPP_NOEXCEPT 4125 { 4126 std::size_t seed = 0; 4127 VULKAN_HPP_HASH_COMBINE( seed, displayModeParametersKHR.visibleRegion ); 4128 VULKAN_HPP_HASH_COMBINE( seed, displayModeParametersKHR.refreshRate ); 4129 return seed; 4130 } 4131 }; 4132 4133 template <> 4134 struct hash<VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR> 4135 { operator ()std::hash4136 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR const & displayModeCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 4137 { 4138 std::size_t seed = 0; 4139 VULKAN_HPP_HASH_COMBINE( seed, displayModeCreateInfoKHR.sType ); 4140 VULKAN_HPP_HASH_COMBINE( seed, displayModeCreateInfoKHR.pNext ); 4141 VULKAN_HPP_HASH_COMBINE( seed, displayModeCreateInfoKHR.flags ); 4142 VULKAN_HPP_HASH_COMBINE( seed, displayModeCreateInfoKHR.parameters ); 4143 return seed; 4144 } 4145 }; 4146 4147 template <> 4148 struct hash<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR> 4149 { operator ()std::hash4150 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR const & displayModePropertiesKHR ) const VULKAN_HPP_NOEXCEPT 4151 { 4152 std::size_t seed = 0; 4153 VULKAN_HPP_HASH_COMBINE( seed, displayModePropertiesKHR.displayMode ); 4154 VULKAN_HPP_HASH_COMBINE( seed, displayModePropertiesKHR.parameters ); 4155 return seed; 4156 } 4157 }; 4158 4159 template <> 4160 struct hash<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR> 4161 { operator ()std::hash4162 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR const & displayModeProperties2KHR ) const VULKAN_HPP_NOEXCEPT 4163 { 4164 std::size_t seed = 0; 4165 VULKAN_HPP_HASH_COMBINE( seed, displayModeProperties2KHR.sType ); 4166 VULKAN_HPP_HASH_COMBINE( seed, displayModeProperties2KHR.pNext ); 4167 VULKAN_HPP_HASH_COMBINE( seed, displayModeProperties2KHR.displayModeProperties ); 4168 return seed; 4169 } 4170 }; 4171 4172 template <> 4173 struct hash<VULKAN_HPP_NAMESPACE::DisplayNativeHdrSurfaceCapabilitiesAMD> 4174 { 4175 std::size_t operator ()std::hash4176 operator()( VULKAN_HPP_NAMESPACE::DisplayNativeHdrSurfaceCapabilitiesAMD const & displayNativeHdrSurfaceCapabilitiesAMD ) const VULKAN_HPP_NOEXCEPT 4177 { 4178 std::size_t seed = 0; 4179 VULKAN_HPP_HASH_COMBINE( seed, displayNativeHdrSurfaceCapabilitiesAMD.sType ); 4180 VULKAN_HPP_HASH_COMBINE( seed, displayNativeHdrSurfaceCapabilitiesAMD.pNext ); 4181 VULKAN_HPP_HASH_COMBINE( seed, displayNativeHdrSurfaceCapabilitiesAMD.localDimmingSupport ); 4182 return seed; 4183 } 4184 }; 4185 4186 template <> 4187 struct hash<VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR> 4188 { operator ()std::hash4189 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR const & displayPlaneCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT 4190 { 4191 std::size_t seed = 0; 4192 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilitiesKHR.supportedAlpha ); 4193 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilitiesKHR.minSrcPosition ); 4194 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilitiesKHR.maxSrcPosition ); 4195 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilitiesKHR.minSrcExtent ); 4196 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilitiesKHR.maxSrcExtent ); 4197 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilitiesKHR.minDstPosition ); 4198 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilitiesKHR.maxDstPosition ); 4199 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilitiesKHR.minDstExtent ); 4200 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilitiesKHR.maxDstExtent ); 4201 return seed; 4202 } 4203 }; 4204 4205 template <> 4206 struct hash<VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR> 4207 { operator ()std::hash4208 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR const & displayPlaneCapabilities2KHR ) const VULKAN_HPP_NOEXCEPT 4209 { 4210 std::size_t seed = 0; 4211 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilities2KHR.sType ); 4212 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilities2KHR.pNext ); 4213 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilities2KHR.capabilities ); 4214 return seed; 4215 } 4216 }; 4217 4218 template <> 4219 struct hash<VULKAN_HPP_NAMESPACE::DisplayPlaneInfo2KHR> 4220 { operator ()std::hash4221 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPlaneInfo2KHR const & displayPlaneInfo2KHR ) const VULKAN_HPP_NOEXCEPT 4222 { 4223 std::size_t seed = 0; 4224 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneInfo2KHR.sType ); 4225 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneInfo2KHR.pNext ); 4226 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneInfo2KHR.mode ); 4227 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneInfo2KHR.planeIndex ); 4228 return seed; 4229 } 4230 }; 4231 4232 template <> 4233 struct hash<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR> 4234 { operator ()std::hash4235 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR const & displayPlanePropertiesKHR ) const VULKAN_HPP_NOEXCEPT 4236 { 4237 std::size_t seed = 0; 4238 VULKAN_HPP_HASH_COMBINE( seed, displayPlanePropertiesKHR.currentDisplay ); 4239 VULKAN_HPP_HASH_COMBINE( seed, displayPlanePropertiesKHR.currentStackIndex ); 4240 return seed; 4241 } 4242 }; 4243 4244 template <> 4245 struct hash<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR> 4246 { operator ()std::hash4247 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR const & displayPlaneProperties2KHR ) const VULKAN_HPP_NOEXCEPT 4248 { 4249 std::size_t seed = 0; 4250 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneProperties2KHR.sType ); 4251 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneProperties2KHR.pNext ); 4252 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneProperties2KHR.displayPlaneProperties ); 4253 return seed; 4254 } 4255 }; 4256 4257 template <> 4258 struct hash<VULKAN_HPP_NAMESPACE::DisplayPowerInfoEXT> 4259 { operator ()std::hash4260 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPowerInfoEXT const & displayPowerInfoEXT ) const VULKAN_HPP_NOEXCEPT 4261 { 4262 std::size_t seed = 0; 4263 VULKAN_HPP_HASH_COMBINE( seed, displayPowerInfoEXT.sType ); 4264 VULKAN_HPP_HASH_COMBINE( seed, displayPowerInfoEXT.pNext ); 4265 VULKAN_HPP_HASH_COMBINE( seed, displayPowerInfoEXT.powerState ); 4266 return seed; 4267 } 4268 }; 4269 4270 template <> 4271 struct hash<VULKAN_HPP_NAMESPACE::DisplayPresentInfoKHR> 4272 { operator ()std::hash4273 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPresentInfoKHR const & displayPresentInfoKHR ) const VULKAN_HPP_NOEXCEPT 4274 { 4275 std::size_t seed = 0; 4276 VULKAN_HPP_HASH_COMBINE( seed, displayPresentInfoKHR.sType ); 4277 VULKAN_HPP_HASH_COMBINE( seed, displayPresentInfoKHR.pNext ); 4278 VULKAN_HPP_HASH_COMBINE( seed, displayPresentInfoKHR.srcRect ); 4279 VULKAN_HPP_HASH_COMBINE( seed, displayPresentInfoKHR.dstRect ); 4280 VULKAN_HPP_HASH_COMBINE( seed, displayPresentInfoKHR.persistent ); 4281 return seed; 4282 } 4283 }; 4284 4285 template <> 4286 struct hash<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR> 4287 { operator ()std::hash4288 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR const & displayPropertiesKHR ) const VULKAN_HPP_NOEXCEPT 4289 { 4290 std::size_t seed = 0; 4291 VULKAN_HPP_HASH_COMBINE( seed, displayPropertiesKHR.display ); 4292 for ( const char * p = displayPropertiesKHR.displayName; *p != '\0'; ++p ) 4293 { 4294 VULKAN_HPP_HASH_COMBINE( seed, *p ); 4295 } 4296 VULKAN_HPP_HASH_COMBINE( seed, displayPropertiesKHR.physicalDimensions ); 4297 VULKAN_HPP_HASH_COMBINE( seed, displayPropertiesKHR.physicalResolution ); 4298 VULKAN_HPP_HASH_COMBINE( seed, displayPropertiesKHR.supportedTransforms ); 4299 VULKAN_HPP_HASH_COMBINE( seed, displayPropertiesKHR.planeReorderPossible ); 4300 VULKAN_HPP_HASH_COMBINE( seed, displayPropertiesKHR.persistentContent ); 4301 return seed; 4302 } 4303 }; 4304 4305 template <> 4306 struct hash<VULKAN_HPP_NAMESPACE::DisplayProperties2KHR> 4307 { operator ()std::hash4308 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayProperties2KHR const & displayProperties2KHR ) const VULKAN_HPP_NOEXCEPT 4309 { 4310 std::size_t seed = 0; 4311 VULKAN_HPP_HASH_COMBINE( seed, displayProperties2KHR.sType ); 4312 VULKAN_HPP_HASH_COMBINE( seed, displayProperties2KHR.pNext ); 4313 VULKAN_HPP_HASH_COMBINE( seed, displayProperties2KHR.displayProperties ); 4314 return seed; 4315 } 4316 }; 4317 4318 template <> 4319 struct hash<VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR> 4320 { operator ()std::hash4321 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR const & displaySurfaceCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 4322 { 4323 std::size_t seed = 0; 4324 VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.sType ); 4325 VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.pNext ); 4326 VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.flags ); 4327 VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.displayMode ); 4328 VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.planeIndex ); 4329 VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.planeStackIndex ); 4330 VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.transform ); 4331 VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.globalAlpha ); 4332 VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.alphaMode ); 4333 VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.imageExtent ); 4334 return seed; 4335 } 4336 }; 4337 4338 template <> 4339 struct hash<VULKAN_HPP_NAMESPACE::DrawIndexedIndirectCommand> 4340 { operator ()std::hash4341 std::size_t operator()( VULKAN_HPP_NAMESPACE::DrawIndexedIndirectCommand const & drawIndexedIndirectCommand ) const VULKAN_HPP_NOEXCEPT 4342 { 4343 std::size_t seed = 0; 4344 VULKAN_HPP_HASH_COMBINE( seed, drawIndexedIndirectCommand.indexCount ); 4345 VULKAN_HPP_HASH_COMBINE( seed, drawIndexedIndirectCommand.instanceCount ); 4346 VULKAN_HPP_HASH_COMBINE( seed, drawIndexedIndirectCommand.firstIndex ); 4347 VULKAN_HPP_HASH_COMBINE( seed, drawIndexedIndirectCommand.vertexOffset ); 4348 VULKAN_HPP_HASH_COMBINE( seed, drawIndexedIndirectCommand.firstInstance ); 4349 return seed; 4350 } 4351 }; 4352 4353 template <> 4354 struct hash<VULKAN_HPP_NAMESPACE::DrawIndirectCommand> 4355 { operator ()std::hash4356 std::size_t operator()( VULKAN_HPP_NAMESPACE::DrawIndirectCommand const & drawIndirectCommand ) const VULKAN_HPP_NOEXCEPT 4357 { 4358 std::size_t seed = 0; 4359 VULKAN_HPP_HASH_COMBINE( seed, drawIndirectCommand.vertexCount ); 4360 VULKAN_HPP_HASH_COMBINE( seed, drawIndirectCommand.instanceCount ); 4361 VULKAN_HPP_HASH_COMBINE( seed, drawIndirectCommand.firstVertex ); 4362 VULKAN_HPP_HASH_COMBINE( seed, drawIndirectCommand.firstInstance ); 4363 return seed; 4364 } 4365 }; 4366 4367 template <> 4368 struct hash<VULKAN_HPP_NAMESPACE::DrawMeshTasksIndirectCommandEXT> 4369 { operator ()std::hash4370 std::size_t operator()( VULKAN_HPP_NAMESPACE::DrawMeshTasksIndirectCommandEXT const & drawMeshTasksIndirectCommandEXT ) const VULKAN_HPP_NOEXCEPT 4371 { 4372 std::size_t seed = 0; 4373 VULKAN_HPP_HASH_COMBINE( seed, drawMeshTasksIndirectCommandEXT.groupCountX ); 4374 VULKAN_HPP_HASH_COMBINE( seed, drawMeshTasksIndirectCommandEXT.groupCountY ); 4375 VULKAN_HPP_HASH_COMBINE( seed, drawMeshTasksIndirectCommandEXT.groupCountZ ); 4376 return seed; 4377 } 4378 }; 4379 4380 template <> 4381 struct hash<VULKAN_HPP_NAMESPACE::DrawMeshTasksIndirectCommandNV> 4382 { operator ()std::hash4383 std::size_t operator()( VULKAN_HPP_NAMESPACE::DrawMeshTasksIndirectCommandNV const & drawMeshTasksIndirectCommandNV ) const VULKAN_HPP_NOEXCEPT 4384 { 4385 std::size_t seed = 0; 4386 VULKAN_HPP_HASH_COMBINE( seed, drawMeshTasksIndirectCommandNV.taskCount ); 4387 VULKAN_HPP_HASH_COMBINE( seed, drawMeshTasksIndirectCommandNV.firstTask ); 4388 return seed; 4389 } 4390 }; 4391 4392 template <> 4393 struct hash<VULKAN_HPP_NAMESPACE::DrmFormatModifierProperties2EXT> 4394 { operator ()std::hash4395 std::size_t operator()( VULKAN_HPP_NAMESPACE::DrmFormatModifierProperties2EXT const & drmFormatModifierProperties2EXT ) const VULKAN_HPP_NOEXCEPT 4396 { 4397 std::size_t seed = 0; 4398 VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierProperties2EXT.drmFormatModifier ); 4399 VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierProperties2EXT.drmFormatModifierPlaneCount ); 4400 VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierProperties2EXT.drmFormatModifierTilingFeatures ); 4401 return seed; 4402 } 4403 }; 4404 4405 template <> 4406 struct hash<VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesEXT> 4407 { operator ()std::hash4408 std::size_t operator()( VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesEXT const & drmFormatModifierPropertiesEXT ) const VULKAN_HPP_NOEXCEPT 4409 { 4410 std::size_t seed = 0; 4411 VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesEXT.drmFormatModifier ); 4412 VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesEXT.drmFormatModifierPlaneCount ); 4413 VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesEXT.drmFormatModifierTilingFeatures ); 4414 return seed; 4415 } 4416 }; 4417 4418 template <> 4419 struct hash<VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesList2EXT> 4420 { operator ()std::hash4421 std::size_t operator()( VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesList2EXT const & drmFormatModifierPropertiesList2EXT ) const VULKAN_HPP_NOEXCEPT 4422 { 4423 std::size_t seed = 0; 4424 VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesList2EXT.sType ); 4425 VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesList2EXT.pNext ); 4426 VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesList2EXT.drmFormatModifierCount ); 4427 VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesList2EXT.pDrmFormatModifierProperties ); 4428 return seed; 4429 } 4430 }; 4431 4432 template <> 4433 struct hash<VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesListEXT> 4434 { operator ()std::hash4435 std::size_t operator()( VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesListEXT const & drmFormatModifierPropertiesListEXT ) const VULKAN_HPP_NOEXCEPT 4436 { 4437 std::size_t seed = 0; 4438 VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesListEXT.sType ); 4439 VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesListEXT.pNext ); 4440 VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesListEXT.drmFormatModifierCount ); 4441 VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesListEXT.pDrmFormatModifierProperties ); 4442 return seed; 4443 } 4444 }; 4445 4446 template <> 4447 struct hash<VULKAN_HPP_NAMESPACE::EventCreateInfo> 4448 { operator ()std::hash4449 std::size_t operator()( VULKAN_HPP_NAMESPACE::EventCreateInfo const & eventCreateInfo ) const VULKAN_HPP_NOEXCEPT 4450 { 4451 std::size_t seed = 0; 4452 VULKAN_HPP_HASH_COMBINE( seed, eventCreateInfo.sType ); 4453 VULKAN_HPP_HASH_COMBINE( seed, eventCreateInfo.pNext ); 4454 VULKAN_HPP_HASH_COMBINE( seed, eventCreateInfo.flags ); 4455 return seed; 4456 } 4457 }; 4458 4459 template <> 4460 struct hash<VULKAN_HPP_NAMESPACE::PipelineLibraryCreateInfoKHR> 4461 { operator ()std::hash4462 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineLibraryCreateInfoKHR const & pipelineLibraryCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 4463 { 4464 std::size_t seed = 0; 4465 VULKAN_HPP_HASH_COMBINE( seed, pipelineLibraryCreateInfoKHR.sType ); 4466 VULKAN_HPP_HASH_COMBINE( seed, pipelineLibraryCreateInfoKHR.pNext ); 4467 VULKAN_HPP_HASH_COMBINE( seed, pipelineLibraryCreateInfoKHR.libraryCount ); 4468 VULKAN_HPP_HASH_COMBINE( seed, pipelineLibraryCreateInfoKHR.pLibraries ); 4469 return seed; 4470 } 4471 }; 4472 4473 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 4474 template <> 4475 struct hash<VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX> 4476 { operator ()std::hash4477 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX const & executionGraphPipelineCreateInfoAMDX ) const VULKAN_HPP_NOEXCEPT 4478 { 4479 std::size_t seed = 0; 4480 VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineCreateInfoAMDX.sType ); 4481 VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineCreateInfoAMDX.pNext ); 4482 VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineCreateInfoAMDX.flags ); 4483 VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineCreateInfoAMDX.stageCount ); 4484 VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineCreateInfoAMDX.pStages ); 4485 VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineCreateInfoAMDX.pLibraryInfo ); 4486 VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineCreateInfoAMDX.layout ); 4487 VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineCreateInfoAMDX.basePipelineHandle ); 4488 VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineCreateInfoAMDX.basePipelineIndex ); 4489 return seed; 4490 } 4491 }; 4492 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 4493 4494 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 4495 template <> 4496 struct hash<VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineScratchSizeAMDX> 4497 { 4498 std::size_t operator ()std::hash4499 operator()( VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineScratchSizeAMDX const & executionGraphPipelineScratchSizeAMDX ) const VULKAN_HPP_NOEXCEPT 4500 { 4501 std::size_t seed = 0; 4502 VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineScratchSizeAMDX.sType ); 4503 VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineScratchSizeAMDX.pNext ); 4504 VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineScratchSizeAMDX.size ); 4505 return seed; 4506 } 4507 }; 4508 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 4509 4510 template <> 4511 struct hash<VULKAN_HPP_NAMESPACE::ExportFenceCreateInfo> 4512 { operator ()std::hash4513 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportFenceCreateInfo const & exportFenceCreateInfo ) const VULKAN_HPP_NOEXCEPT 4514 { 4515 std::size_t seed = 0; 4516 VULKAN_HPP_HASH_COMBINE( seed, exportFenceCreateInfo.sType ); 4517 VULKAN_HPP_HASH_COMBINE( seed, exportFenceCreateInfo.pNext ); 4518 VULKAN_HPP_HASH_COMBINE( seed, exportFenceCreateInfo.handleTypes ); 4519 return seed; 4520 } 4521 }; 4522 4523 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 4524 template <> 4525 struct hash<VULKAN_HPP_NAMESPACE::ExportFenceWin32HandleInfoKHR> 4526 { operator ()std::hash4527 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportFenceWin32HandleInfoKHR const & exportFenceWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT 4528 { 4529 std::size_t seed = 0; 4530 VULKAN_HPP_HASH_COMBINE( seed, exportFenceWin32HandleInfoKHR.sType ); 4531 VULKAN_HPP_HASH_COMBINE( seed, exportFenceWin32HandleInfoKHR.pNext ); 4532 VULKAN_HPP_HASH_COMBINE( seed, exportFenceWin32HandleInfoKHR.pAttributes ); 4533 VULKAN_HPP_HASH_COMBINE( seed, exportFenceWin32HandleInfoKHR.dwAccess ); 4534 VULKAN_HPP_HASH_COMBINE( seed, exportFenceWin32HandleInfoKHR.name ); 4535 return seed; 4536 } 4537 }; 4538 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 4539 4540 template <> 4541 struct hash<VULKAN_HPP_NAMESPACE::ExportMemoryAllocateInfo> 4542 { operator ()std::hash4543 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMemoryAllocateInfo const & exportMemoryAllocateInfo ) const VULKAN_HPP_NOEXCEPT 4544 { 4545 std::size_t seed = 0; 4546 VULKAN_HPP_HASH_COMBINE( seed, exportMemoryAllocateInfo.sType ); 4547 VULKAN_HPP_HASH_COMBINE( seed, exportMemoryAllocateInfo.pNext ); 4548 VULKAN_HPP_HASH_COMBINE( seed, exportMemoryAllocateInfo.handleTypes ); 4549 return seed; 4550 } 4551 }; 4552 4553 template <> 4554 struct hash<VULKAN_HPP_NAMESPACE::ExportMemoryAllocateInfoNV> 4555 { operator ()std::hash4556 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMemoryAllocateInfoNV const & exportMemoryAllocateInfoNV ) const VULKAN_HPP_NOEXCEPT 4557 { 4558 std::size_t seed = 0; 4559 VULKAN_HPP_HASH_COMBINE( seed, exportMemoryAllocateInfoNV.sType ); 4560 VULKAN_HPP_HASH_COMBINE( seed, exportMemoryAllocateInfoNV.pNext ); 4561 VULKAN_HPP_HASH_COMBINE( seed, exportMemoryAllocateInfoNV.handleTypes ); 4562 return seed; 4563 } 4564 }; 4565 4566 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 4567 template <> 4568 struct hash<VULKAN_HPP_NAMESPACE::ExportMemoryWin32HandleInfoKHR> 4569 { operator ()std::hash4570 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMemoryWin32HandleInfoKHR const & exportMemoryWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT 4571 { 4572 std::size_t seed = 0; 4573 VULKAN_HPP_HASH_COMBINE( seed, exportMemoryWin32HandleInfoKHR.sType ); 4574 VULKAN_HPP_HASH_COMBINE( seed, exportMemoryWin32HandleInfoKHR.pNext ); 4575 VULKAN_HPP_HASH_COMBINE( seed, exportMemoryWin32HandleInfoKHR.pAttributes ); 4576 VULKAN_HPP_HASH_COMBINE( seed, exportMemoryWin32HandleInfoKHR.dwAccess ); 4577 VULKAN_HPP_HASH_COMBINE( seed, exportMemoryWin32HandleInfoKHR.name ); 4578 return seed; 4579 } 4580 }; 4581 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 4582 4583 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 4584 template <> 4585 struct hash<VULKAN_HPP_NAMESPACE::ExportMemoryWin32HandleInfoNV> 4586 { operator ()std::hash4587 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMemoryWin32HandleInfoNV const & exportMemoryWin32HandleInfoNV ) const VULKAN_HPP_NOEXCEPT 4588 { 4589 std::size_t seed = 0; 4590 VULKAN_HPP_HASH_COMBINE( seed, exportMemoryWin32HandleInfoNV.sType ); 4591 VULKAN_HPP_HASH_COMBINE( seed, exportMemoryWin32HandleInfoNV.pNext ); 4592 VULKAN_HPP_HASH_COMBINE( seed, exportMemoryWin32HandleInfoNV.pAttributes ); 4593 VULKAN_HPP_HASH_COMBINE( seed, exportMemoryWin32HandleInfoNV.dwAccess ); 4594 return seed; 4595 } 4596 }; 4597 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 4598 4599 # if defined( VK_USE_PLATFORM_METAL_EXT ) 4600 template <> 4601 struct hash<VULKAN_HPP_NAMESPACE::ExportMetalBufferInfoEXT> 4602 { operator ()std::hash4603 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMetalBufferInfoEXT const & exportMetalBufferInfoEXT ) const VULKAN_HPP_NOEXCEPT 4604 { 4605 std::size_t seed = 0; 4606 VULKAN_HPP_HASH_COMBINE( seed, exportMetalBufferInfoEXT.sType ); 4607 VULKAN_HPP_HASH_COMBINE( seed, exportMetalBufferInfoEXT.pNext ); 4608 VULKAN_HPP_HASH_COMBINE( seed, exportMetalBufferInfoEXT.memory ); 4609 VULKAN_HPP_HASH_COMBINE( seed, exportMetalBufferInfoEXT.mtlBuffer ); 4610 return seed; 4611 } 4612 }; 4613 # endif /*VK_USE_PLATFORM_METAL_EXT*/ 4614 4615 # if defined( VK_USE_PLATFORM_METAL_EXT ) 4616 template <> 4617 struct hash<VULKAN_HPP_NAMESPACE::ExportMetalCommandQueueInfoEXT> 4618 { operator ()std::hash4619 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMetalCommandQueueInfoEXT const & exportMetalCommandQueueInfoEXT ) const VULKAN_HPP_NOEXCEPT 4620 { 4621 std::size_t seed = 0; 4622 VULKAN_HPP_HASH_COMBINE( seed, exportMetalCommandQueueInfoEXT.sType ); 4623 VULKAN_HPP_HASH_COMBINE( seed, exportMetalCommandQueueInfoEXT.pNext ); 4624 VULKAN_HPP_HASH_COMBINE( seed, exportMetalCommandQueueInfoEXT.queue ); 4625 VULKAN_HPP_HASH_COMBINE( seed, exportMetalCommandQueueInfoEXT.mtlCommandQueue ); 4626 return seed; 4627 } 4628 }; 4629 # endif /*VK_USE_PLATFORM_METAL_EXT*/ 4630 4631 # if defined( VK_USE_PLATFORM_METAL_EXT ) 4632 template <> 4633 struct hash<VULKAN_HPP_NAMESPACE::ExportMetalDeviceInfoEXT> 4634 { operator ()std::hash4635 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMetalDeviceInfoEXT const & exportMetalDeviceInfoEXT ) const VULKAN_HPP_NOEXCEPT 4636 { 4637 std::size_t seed = 0; 4638 VULKAN_HPP_HASH_COMBINE( seed, exportMetalDeviceInfoEXT.sType ); 4639 VULKAN_HPP_HASH_COMBINE( seed, exportMetalDeviceInfoEXT.pNext ); 4640 VULKAN_HPP_HASH_COMBINE( seed, exportMetalDeviceInfoEXT.mtlDevice ); 4641 return seed; 4642 } 4643 }; 4644 # endif /*VK_USE_PLATFORM_METAL_EXT*/ 4645 4646 # if defined( VK_USE_PLATFORM_METAL_EXT ) 4647 template <> 4648 struct hash<VULKAN_HPP_NAMESPACE::ExportMetalIOSurfaceInfoEXT> 4649 { operator ()std::hash4650 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMetalIOSurfaceInfoEXT const & exportMetalIOSurfaceInfoEXT ) const VULKAN_HPP_NOEXCEPT 4651 { 4652 std::size_t seed = 0; 4653 VULKAN_HPP_HASH_COMBINE( seed, exportMetalIOSurfaceInfoEXT.sType ); 4654 VULKAN_HPP_HASH_COMBINE( seed, exportMetalIOSurfaceInfoEXT.pNext ); 4655 VULKAN_HPP_HASH_COMBINE( seed, exportMetalIOSurfaceInfoEXT.image ); 4656 VULKAN_HPP_HASH_COMBINE( seed, exportMetalIOSurfaceInfoEXT.ioSurface ); 4657 return seed; 4658 } 4659 }; 4660 # endif /*VK_USE_PLATFORM_METAL_EXT*/ 4661 4662 # if defined( VK_USE_PLATFORM_METAL_EXT ) 4663 template <> 4664 struct hash<VULKAN_HPP_NAMESPACE::ExportMetalObjectCreateInfoEXT> 4665 { operator ()std::hash4666 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMetalObjectCreateInfoEXT const & exportMetalObjectCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 4667 { 4668 std::size_t seed = 0; 4669 VULKAN_HPP_HASH_COMBINE( seed, exportMetalObjectCreateInfoEXT.sType ); 4670 VULKAN_HPP_HASH_COMBINE( seed, exportMetalObjectCreateInfoEXT.pNext ); 4671 VULKAN_HPP_HASH_COMBINE( seed, exportMetalObjectCreateInfoEXT.exportObjectType ); 4672 return seed; 4673 } 4674 }; 4675 # endif /*VK_USE_PLATFORM_METAL_EXT*/ 4676 4677 # if defined( VK_USE_PLATFORM_METAL_EXT ) 4678 template <> 4679 struct hash<VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT> 4680 { operator ()std::hash4681 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT const & exportMetalObjectsInfoEXT ) const VULKAN_HPP_NOEXCEPT 4682 { 4683 std::size_t seed = 0; 4684 VULKAN_HPP_HASH_COMBINE( seed, exportMetalObjectsInfoEXT.sType ); 4685 VULKAN_HPP_HASH_COMBINE( seed, exportMetalObjectsInfoEXT.pNext ); 4686 return seed; 4687 } 4688 }; 4689 # endif /*VK_USE_PLATFORM_METAL_EXT*/ 4690 4691 # if defined( VK_USE_PLATFORM_METAL_EXT ) 4692 template <> 4693 struct hash<VULKAN_HPP_NAMESPACE::ExportMetalSharedEventInfoEXT> 4694 { operator ()std::hash4695 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMetalSharedEventInfoEXT const & exportMetalSharedEventInfoEXT ) const VULKAN_HPP_NOEXCEPT 4696 { 4697 std::size_t seed = 0; 4698 VULKAN_HPP_HASH_COMBINE( seed, exportMetalSharedEventInfoEXT.sType ); 4699 VULKAN_HPP_HASH_COMBINE( seed, exportMetalSharedEventInfoEXT.pNext ); 4700 VULKAN_HPP_HASH_COMBINE( seed, exportMetalSharedEventInfoEXT.semaphore ); 4701 VULKAN_HPP_HASH_COMBINE( seed, exportMetalSharedEventInfoEXT.event ); 4702 VULKAN_HPP_HASH_COMBINE( seed, exportMetalSharedEventInfoEXT.mtlSharedEvent ); 4703 return seed; 4704 } 4705 }; 4706 # endif /*VK_USE_PLATFORM_METAL_EXT*/ 4707 4708 # if defined( VK_USE_PLATFORM_METAL_EXT ) 4709 template <> 4710 struct hash<VULKAN_HPP_NAMESPACE::ExportMetalTextureInfoEXT> 4711 { operator ()std::hash4712 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMetalTextureInfoEXT const & exportMetalTextureInfoEXT ) const VULKAN_HPP_NOEXCEPT 4713 { 4714 std::size_t seed = 0; 4715 VULKAN_HPP_HASH_COMBINE( seed, exportMetalTextureInfoEXT.sType ); 4716 VULKAN_HPP_HASH_COMBINE( seed, exportMetalTextureInfoEXT.pNext ); 4717 VULKAN_HPP_HASH_COMBINE( seed, exportMetalTextureInfoEXT.image ); 4718 VULKAN_HPP_HASH_COMBINE( seed, exportMetalTextureInfoEXT.imageView ); 4719 VULKAN_HPP_HASH_COMBINE( seed, exportMetalTextureInfoEXT.bufferView ); 4720 VULKAN_HPP_HASH_COMBINE( seed, exportMetalTextureInfoEXT.plane ); 4721 VULKAN_HPP_HASH_COMBINE( seed, exportMetalTextureInfoEXT.mtlTexture ); 4722 return seed; 4723 } 4724 }; 4725 # endif /*VK_USE_PLATFORM_METAL_EXT*/ 4726 4727 template <> 4728 struct hash<VULKAN_HPP_NAMESPACE::ExportSemaphoreCreateInfo> 4729 { operator ()std::hash4730 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportSemaphoreCreateInfo const & exportSemaphoreCreateInfo ) const VULKAN_HPP_NOEXCEPT 4731 { 4732 std::size_t seed = 0; 4733 VULKAN_HPP_HASH_COMBINE( seed, exportSemaphoreCreateInfo.sType ); 4734 VULKAN_HPP_HASH_COMBINE( seed, exportSemaphoreCreateInfo.pNext ); 4735 VULKAN_HPP_HASH_COMBINE( seed, exportSemaphoreCreateInfo.handleTypes ); 4736 return seed; 4737 } 4738 }; 4739 4740 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 4741 template <> 4742 struct hash<VULKAN_HPP_NAMESPACE::ExportSemaphoreWin32HandleInfoKHR> 4743 { operator ()std::hash4744 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportSemaphoreWin32HandleInfoKHR const & exportSemaphoreWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT 4745 { 4746 std::size_t seed = 0; 4747 VULKAN_HPP_HASH_COMBINE( seed, exportSemaphoreWin32HandleInfoKHR.sType ); 4748 VULKAN_HPP_HASH_COMBINE( seed, exportSemaphoreWin32HandleInfoKHR.pNext ); 4749 VULKAN_HPP_HASH_COMBINE( seed, exportSemaphoreWin32HandleInfoKHR.pAttributes ); 4750 VULKAN_HPP_HASH_COMBINE( seed, exportSemaphoreWin32HandleInfoKHR.dwAccess ); 4751 VULKAN_HPP_HASH_COMBINE( seed, exportSemaphoreWin32HandleInfoKHR.name ); 4752 return seed; 4753 } 4754 }; 4755 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 4756 4757 template <> 4758 struct hash<VULKAN_HPP_NAMESPACE::ExtensionProperties> 4759 { operator ()std::hash4760 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExtensionProperties const & extensionProperties ) const VULKAN_HPP_NOEXCEPT 4761 { 4762 std::size_t seed = 0; 4763 for ( size_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i ) 4764 { 4765 VULKAN_HPP_HASH_COMBINE( seed, extensionProperties.extensionName[i] ); 4766 } 4767 VULKAN_HPP_HASH_COMBINE( seed, extensionProperties.specVersion ); 4768 return seed; 4769 } 4770 }; 4771 4772 template <> 4773 struct hash<VULKAN_HPP_NAMESPACE::ExternalMemoryProperties> 4774 { operator ()std::hash4775 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalMemoryProperties const & externalMemoryProperties ) const VULKAN_HPP_NOEXCEPT 4776 { 4777 std::size_t seed = 0; 4778 VULKAN_HPP_HASH_COMBINE( seed, externalMemoryProperties.externalMemoryFeatures ); 4779 VULKAN_HPP_HASH_COMBINE( seed, externalMemoryProperties.exportFromImportedHandleTypes ); 4780 VULKAN_HPP_HASH_COMBINE( seed, externalMemoryProperties.compatibleHandleTypes ); 4781 return seed; 4782 } 4783 }; 4784 4785 template <> 4786 struct hash<VULKAN_HPP_NAMESPACE::ExternalBufferProperties> 4787 { operator ()std::hash4788 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalBufferProperties const & externalBufferProperties ) const VULKAN_HPP_NOEXCEPT 4789 { 4790 std::size_t seed = 0; 4791 VULKAN_HPP_HASH_COMBINE( seed, externalBufferProperties.sType ); 4792 VULKAN_HPP_HASH_COMBINE( seed, externalBufferProperties.pNext ); 4793 VULKAN_HPP_HASH_COMBINE( seed, externalBufferProperties.externalMemoryProperties ); 4794 return seed; 4795 } 4796 }; 4797 4798 template <> 4799 struct hash<VULKAN_HPP_NAMESPACE::ExternalFenceProperties> 4800 { operator ()std::hash4801 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalFenceProperties const & externalFenceProperties ) const VULKAN_HPP_NOEXCEPT 4802 { 4803 std::size_t seed = 0; 4804 VULKAN_HPP_HASH_COMBINE( seed, externalFenceProperties.sType ); 4805 VULKAN_HPP_HASH_COMBINE( seed, externalFenceProperties.pNext ); 4806 VULKAN_HPP_HASH_COMBINE( seed, externalFenceProperties.exportFromImportedHandleTypes ); 4807 VULKAN_HPP_HASH_COMBINE( seed, externalFenceProperties.compatibleHandleTypes ); 4808 VULKAN_HPP_HASH_COMBINE( seed, externalFenceProperties.externalFenceFeatures ); 4809 return seed; 4810 } 4811 }; 4812 4813 # if defined( VK_USE_PLATFORM_ANDROID_KHR ) 4814 template <> 4815 struct hash<VULKAN_HPP_NAMESPACE::ExternalFormatANDROID> 4816 { operator ()std::hash4817 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalFormatANDROID const & externalFormatANDROID ) const VULKAN_HPP_NOEXCEPT 4818 { 4819 std::size_t seed = 0; 4820 VULKAN_HPP_HASH_COMBINE( seed, externalFormatANDROID.sType ); 4821 VULKAN_HPP_HASH_COMBINE( seed, externalFormatANDROID.pNext ); 4822 VULKAN_HPP_HASH_COMBINE( seed, externalFormatANDROID.externalFormat ); 4823 return seed; 4824 } 4825 }; 4826 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ 4827 4828 # if defined( VK_USE_PLATFORM_SCREEN_QNX ) 4829 template <> 4830 struct hash<VULKAN_HPP_NAMESPACE::ExternalFormatQNX> 4831 { operator ()std::hash4832 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalFormatQNX const & externalFormatQNX ) const VULKAN_HPP_NOEXCEPT 4833 { 4834 std::size_t seed = 0; 4835 VULKAN_HPP_HASH_COMBINE( seed, externalFormatQNX.sType ); 4836 VULKAN_HPP_HASH_COMBINE( seed, externalFormatQNX.pNext ); 4837 VULKAN_HPP_HASH_COMBINE( seed, externalFormatQNX.externalFormat ); 4838 return seed; 4839 } 4840 }; 4841 # endif /*VK_USE_PLATFORM_SCREEN_QNX*/ 4842 4843 template <> 4844 struct hash<VULKAN_HPP_NAMESPACE::ExternalImageFormatProperties> 4845 { operator ()std::hash4846 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalImageFormatProperties const & externalImageFormatProperties ) const VULKAN_HPP_NOEXCEPT 4847 { 4848 std::size_t seed = 0; 4849 VULKAN_HPP_HASH_COMBINE( seed, externalImageFormatProperties.sType ); 4850 VULKAN_HPP_HASH_COMBINE( seed, externalImageFormatProperties.pNext ); 4851 VULKAN_HPP_HASH_COMBINE( seed, externalImageFormatProperties.externalMemoryProperties ); 4852 return seed; 4853 } 4854 }; 4855 4856 template <> 4857 struct hash<VULKAN_HPP_NAMESPACE::ImageFormatProperties> 4858 { operator ()std::hash4859 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageFormatProperties const & imageFormatProperties ) const VULKAN_HPP_NOEXCEPT 4860 { 4861 std::size_t seed = 0; 4862 VULKAN_HPP_HASH_COMBINE( seed, imageFormatProperties.maxExtent ); 4863 VULKAN_HPP_HASH_COMBINE( seed, imageFormatProperties.maxMipLevels ); 4864 VULKAN_HPP_HASH_COMBINE( seed, imageFormatProperties.maxArrayLayers ); 4865 VULKAN_HPP_HASH_COMBINE( seed, imageFormatProperties.sampleCounts ); 4866 VULKAN_HPP_HASH_COMBINE( seed, imageFormatProperties.maxResourceSize ); 4867 return seed; 4868 } 4869 }; 4870 4871 template <> 4872 struct hash<VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV> 4873 { operator ()std::hash4874 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV const & externalImageFormatPropertiesNV ) const VULKAN_HPP_NOEXCEPT 4875 { 4876 std::size_t seed = 0; 4877 VULKAN_HPP_HASH_COMBINE( seed, externalImageFormatPropertiesNV.imageFormatProperties ); 4878 VULKAN_HPP_HASH_COMBINE( seed, externalImageFormatPropertiesNV.externalMemoryFeatures ); 4879 VULKAN_HPP_HASH_COMBINE( seed, externalImageFormatPropertiesNV.exportFromImportedHandleTypes ); 4880 VULKAN_HPP_HASH_COMBINE( seed, externalImageFormatPropertiesNV.compatibleHandleTypes ); 4881 return seed; 4882 } 4883 }; 4884 4885 template <> 4886 struct hash<VULKAN_HPP_NAMESPACE::ExternalMemoryAcquireUnmodifiedEXT> 4887 { operator ()std::hash4888 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalMemoryAcquireUnmodifiedEXT const & externalMemoryAcquireUnmodifiedEXT ) const VULKAN_HPP_NOEXCEPT 4889 { 4890 std::size_t seed = 0; 4891 VULKAN_HPP_HASH_COMBINE( seed, externalMemoryAcquireUnmodifiedEXT.sType ); 4892 VULKAN_HPP_HASH_COMBINE( seed, externalMemoryAcquireUnmodifiedEXT.pNext ); 4893 VULKAN_HPP_HASH_COMBINE( seed, externalMemoryAcquireUnmodifiedEXT.acquireUnmodifiedMemory ); 4894 return seed; 4895 } 4896 }; 4897 4898 template <> 4899 struct hash<VULKAN_HPP_NAMESPACE::ExternalMemoryBufferCreateInfo> 4900 { operator ()std::hash4901 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalMemoryBufferCreateInfo const & externalMemoryBufferCreateInfo ) const VULKAN_HPP_NOEXCEPT 4902 { 4903 std::size_t seed = 0; 4904 VULKAN_HPP_HASH_COMBINE( seed, externalMemoryBufferCreateInfo.sType ); 4905 VULKAN_HPP_HASH_COMBINE( seed, externalMemoryBufferCreateInfo.pNext ); 4906 VULKAN_HPP_HASH_COMBINE( seed, externalMemoryBufferCreateInfo.handleTypes ); 4907 return seed; 4908 } 4909 }; 4910 4911 template <> 4912 struct hash<VULKAN_HPP_NAMESPACE::ExternalMemoryImageCreateInfo> 4913 { operator ()std::hash4914 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalMemoryImageCreateInfo const & externalMemoryImageCreateInfo ) const VULKAN_HPP_NOEXCEPT 4915 { 4916 std::size_t seed = 0; 4917 VULKAN_HPP_HASH_COMBINE( seed, externalMemoryImageCreateInfo.sType ); 4918 VULKAN_HPP_HASH_COMBINE( seed, externalMemoryImageCreateInfo.pNext ); 4919 VULKAN_HPP_HASH_COMBINE( seed, externalMemoryImageCreateInfo.handleTypes ); 4920 return seed; 4921 } 4922 }; 4923 4924 template <> 4925 struct hash<VULKAN_HPP_NAMESPACE::ExternalMemoryImageCreateInfoNV> 4926 { operator ()std::hash4927 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalMemoryImageCreateInfoNV const & externalMemoryImageCreateInfoNV ) const VULKAN_HPP_NOEXCEPT 4928 { 4929 std::size_t seed = 0; 4930 VULKAN_HPP_HASH_COMBINE( seed, externalMemoryImageCreateInfoNV.sType ); 4931 VULKAN_HPP_HASH_COMBINE( seed, externalMemoryImageCreateInfoNV.pNext ); 4932 VULKAN_HPP_HASH_COMBINE( seed, externalMemoryImageCreateInfoNV.handleTypes ); 4933 return seed; 4934 } 4935 }; 4936 4937 template <> 4938 struct hash<VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties> 4939 { operator ()std::hash4940 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties const & externalSemaphoreProperties ) const VULKAN_HPP_NOEXCEPT 4941 { 4942 std::size_t seed = 0; 4943 VULKAN_HPP_HASH_COMBINE( seed, externalSemaphoreProperties.sType ); 4944 VULKAN_HPP_HASH_COMBINE( seed, externalSemaphoreProperties.pNext ); 4945 VULKAN_HPP_HASH_COMBINE( seed, externalSemaphoreProperties.exportFromImportedHandleTypes ); 4946 VULKAN_HPP_HASH_COMBINE( seed, externalSemaphoreProperties.compatibleHandleTypes ); 4947 VULKAN_HPP_HASH_COMBINE( seed, externalSemaphoreProperties.externalSemaphoreFeatures ); 4948 return seed; 4949 } 4950 }; 4951 4952 template <> 4953 struct hash<VULKAN_HPP_NAMESPACE::FenceCreateInfo> 4954 { operator ()std::hash4955 std::size_t operator()( VULKAN_HPP_NAMESPACE::FenceCreateInfo const & fenceCreateInfo ) const VULKAN_HPP_NOEXCEPT 4956 { 4957 std::size_t seed = 0; 4958 VULKAN_HPP_HASH_COMBINE( seed, fenceCreateInfo.sType ); 4959 VULKAN_HPP_HASH_COMBINE( seed, fenceCreateInfo.pNext ); 4960 VULKAN_HPP_HASH_COMBINE( seed, fenceCreateInfo.flags ); 4961 return seed; 4962 } 4963 }; 4964 4965 template <> 4966 struct hash<VULKAN_HPP_NAMESPACE::FenceGetFdInfoKHR> 4967 { operator ()std::hash4968 std::size_t operator()( VULKAN_HPP_NAMESPACE::FenceGetFdInfoKHR const & fenceGetFdInfoKHR ) const VULKAN_HPP_NOEXCEPT 4969 { 4970 std::size_t seed = 0; 4971 VULKAN_HPP_HASH_COMBINE( seed, fenceGetFdInfoKHR.sType ); 4972 VULKAN_HPP_HASH_COMBINE( seed, fenceGetFdInfoKHR.pNext ); 4973 VULKAN_HPP_HASH_COMBINE( seed, fenceGetFdInfoKHR.fence ); 4974 VULKAN_HPP_HASH_COMBINE( seed, fenceGetFdInfoKHR.handleType ); 4975 return seed; 4976 } 4977 }; 4978 4979 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 4980 template <> 4981 struct hash<VULKAN_HPP_NAMESPACE::FenceGetWin32HandleInfoKHR> 4982 { operator ()std::hash4983 std::size_t operator()( VULKAN_HPP_NAMESPACE::FenceGetWin32HandleInfoKHR const & fenceGetWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT 4984 { 4985 std::size_t seed = 0; 4986 VULKAN_HPP_HASH_COMBINE( seed, fenceGetWin32HandleInfoKHR.sType ); 4987 VULKAN_HPP_HASH_COMBINE( seed, fenceGetWin32HandleInfoKHR.pNext ); 4988 VULKAN_HPP_HASH_COMBINE( seed, fenceGetWin32HandleInfoKHR.fence ); 4989 VULKAN_HPP_HASH_COMBINE( seed, fenceGetWin32HandleInfoKHR.handleType ); 4990 return seed; 4991 } 4992 }; 4993 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 4994 4995 template <> 4996 struct hash<VULKAN_HPP_NAMESPACE::FilterCubicImageViewImageFormatPropertiesEXT> 4997 { operator ()std::hash4998 std::size_t operator()( VULKAN_HPP_NAMESPACE::FilterCubicImageViewImageFormatPropertiesEXT const & filterCubicImageViewImageFormatPropertiesEXT ) const 4999 VULKAN_HPP_NOEXCEPT 5000 { 5001 std::size_t seed = 0; 5002 VULKAN_HPP_HASH_COMBINE( seed, filterCubicImageViewImageFormatPropertiesEXT.sType ); 5003 VULKAN_HPP_HASH_COMBINE( seed, filterCubicImageViewImageFormatPropertiesEXT.pNext ); 5004 VULKAN_HPP_HASH_COMBINE( seed, filterCubicImageViewImageFormatPropertiesEXT.filterCubic ); 5005 VULKAN_HPP_HASH_COMBINE( seed, filterCubicImageViewImageFormatPropertiesEXT.filterCubicMinmax ); 5006 return seed; 5007 } 5008 }; 5009 5010 template <> 5011 struct hash<VULKAN_HPP_NAMESPACE::FormatProperties> 5012 { operator ()std::hash5013 std::size_t operator()( VULKAN_HPP_NAMESPACE::FormatProperties const & formatProperties ) const VULKAN_HPP_NOEXCEPT 5014 { 5015 std::size_t seed = 0; 5016 VULKAN_HPP_HASH_COMBINE( seed, formatProperties.linearTilingFeatures ); 5017 VULKAN_HPP_HASH_COMBINE( seed, formatProperties.optimalTilingFeatures ); 5018 VULKAN_HPP_HASH_COMBINE( seed, formatProperties.bufferFeatures ); 5019 return seed; 5020 } 5021 }; 5022 5023 template <> 5024 struct hash<VULKAN_HPP_NAMESPACE::FormatProperties2> 5025 { operator ()std::hash5026 std::size_t operator()( VULKAN_HPP_NAMESPACE::FormatProperties2 const & formatProperties2 ) const VULKAN_HPP_NOEXCEPT 5027 { 5028 std::size_t seed = 0; 5029 VULKAN_HPP_HASH_COMBINE( seed, formatProperties2.sType ); 5030 VULKAN_HPP_HASH_COMBINE( seed, formatProperties2.pNext ); 5031 VULKAN_HPP_HASH_COMBINE( seed, formatProperties2.formatProperties ); 5032 return seed; 5033 } 5034 }; 5035 5036 template <> 5037 struct hash<VULKAN_HPP_NAMESPACE::FormatProperties3> 5038 { operator ()std::hash5039 std::size_t operator()( VULKAN_HPP_NAMESPACE::FormatProperties3 const & formatProperties3 ) const VULKAN_HPP_NOEXCEPT 5040 { 5041 std::size_t seed = 0; 5042 VULKAN_HPP_HASH_COMBINE( seed, formatProperties3.sType ); 5043 VULKAN_HPP_HASH_COMBINE( seed, formatProperties3.pNext ); 5044 VULKAN_HPP_HASH_COMBINE( seed, formatProperties3.linearTilingFeatures ); 5045 VULKAN_HPP_HASH_COMBINE( seed, formatProperties3.optimalTilingFeatures ); 5046 VULKAN_HPP_HASH_COMBINE( seed, formatProperties3.bufferFeatures ); 5047 return seed; 5048 } 5049 }; 5050 5051 template <> 5052 struct hash<VULKAN_HPP_NAMESPACE::FragmentShadingRateAttachmentInfoKHR> 5053 { operator ()std::hash5054 std::size_t operator()( VULKAN_HPP_NAMESPACE::FragmentShadingRateAttachmentInfoKHR const & fragmentShadingRateAttachmentInfoKHR ) const VULKAN_HPP_NOEXCEPT 5055 { 5056 std::size_t seed = 0; 5057 VULKAN_HPP_HASH_COMBINE( seed, fragmentShadingRateAttachmentInfoKHR.sType ); 5058 VULKAN_HPP_HASH_COMBINE( seed, fragmentShadingRateAttachmentInfoKHR.pNext ); 5059 VULKAN_HPP_HASH_COMBINE( seed, fragmentShadingRateAttachmentInfoKHR.pFragmentShadingRateAttachment ); 5060 VULKAN_HPP_HASH_COMBINE( seed, fragmentShadingRateAttachmentInfoKHR.shadingRateAttachmentTexelSize ); 5061 return seed; 5062 } 5063 }; 5064 5065 template <> 5066 struct hash<VULKAN_HPP_NAMESPACE::FrameBoundaryEXT> 5067 { operator ()std::hash5068 std::size_t operator()( VULKAN_HPP_NAMESPACE::FrameBoundaryEXT const & frameBoundaryEXT ) const VULKAN_HPP_NOEXCEPT 5069 { 5070 std::size_t seed = 0; 5071 VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.sType ); 5072 VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.pNext ); 5073 VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.flags ); 5074 VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.frameID ); 5075 VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.imageCount ); 5076 VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.pImages ); 5077 VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.bufferCount ); 5078 VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.pBuffers ); 5079 VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.tagName ); 5080 VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.tagSize ); 5081 VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.pTag ); 5082 return seed; 5083 } 5084 }; 5085 5086 template <> 5087 struct hash<VULKAN_HPP_NAMESPACE::FramebufferAttachmentImageInfo> 5088 { operator ()std::hash5089 std::size_t operator()( VULKAN_HPP_NAMESPACE::FramebufferAttachmentImageInfo const & framebufferAttachmentImageInfo ) const VULKAN_HPP_NOEXCEPT 5090 { 5091 std::size_t seed = 0; 5092 VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentImageInfo.sType ); 5093 VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentImageInfo.pNext ); 5094 VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentImageInfo.flags ); 5095 VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentImageInfo.usage ); 5096 VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentImageInfo.width ); 5097 VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentImageInfo.height ); 5098 VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentImageInfo.layerCount ); 5099 VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentImageInfo.viewFormatCount ); 5100 VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentImageInfo.pViewFormats ); 5101 return seed; 5102 } 5103 }; 5104 5105 template <> 5106 struct hash<VULKAN_HPP_NAMESPACE::FramebufferAttachmentsCreateInfo> 5107 { operator ()std::hash5108 std::size_t operator()( VULKAN_HPP_NAMESPACE::FramebufferAttachmentsCreateInfo const & framebufferAttachmentsCreateInfo ) const VULKAN_HPP_NOEXCEPT 5109 { 5110 std::size_t seed = 0; 5111 VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentsCreateInfo.sType ); 5112 VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentsCreateInfo.pNext ); 5113 VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentsCreateInfo.attachmentImageInfoCount ); 5114 VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentsCreateInfo.pAttachmentImageInfos ); 5115 return seed; 5116 } 5117 }; 5118 5119 template <> 5120 struct hash<VULKAN_HPP_NAMESPACE::FramebufferCreateInfo> 5121 { operator ()std::hash5122 std::size_t operator()( VULKAN_HPP_NAMESPACE::FramebufferCreateInfo const & framebufferCreateInfo ) const VULKAN_HPP_NOEXCEPT 5123 { 5124 std::size_t seed = 0; 5125 VULKAN_HPP_HASH_COMBINE( seed, framebufferCreateInfo.sType ); 5126 VULKAN_HPP_HASH_COMBINE( seed, framebufferCreateInfo.pNext ); 5127 VULKAN_HPP_HASH_COMBINE( seed, framebufferCreateInfo.flags ); 5128 VULKAN_HPP_HASH_COMBINE( seed, framebufferCreateInfo.renderPass ); 5129 VULKAN_HPP_HASH_COMBINE( seed, framebufferCreateInfo.attachmentCount ); 5130 VULKAN_HPP_HASH_COMBINE( seed, framebufferCreateInfo.pAttachments ); 5131 VULKAN_HPP_HASH_COMBINE( seed, framebufferCreateInfo.width ); 5132 VULKAN_HPP_HASH_COMBINE( seed, framebufferCreateInfo.height ); 5133 VULKAN_HPP_HASH_COMBINE( seed, framebufferCreateInfo.layers ); 5134 return seed; 5135 } 5136 }; 5137 5138 template <> 5139 struct hash<VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV> 5140 { operator ()std::hash5141 std::size_t operator()( VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV const & framebufferMixedSamplesCombinationNV ) const VULKAN_HPP_NOEXCEPT 5142 { 5143 std::size_t seed = 0; 5144 VULKAN_HPP_HASH_COMBINE( seed, framebufferMixedSamplesCombinationNV.sType ); 5145 VULKAN_HPP_HASH_COMBINE( seed, framebufferMixedSamplesCombinationNV.pNext ); 5146 VULKAN_HPP_HASH_COMBINE( seed, framebufferMixedSamplesCombinationNV.coverageReductionMode ); 5147 VULKAN_HPP_HASH_COMBINE( seed, framebufferMixedSamplesCombinationNV.rasterizationSamples ); 5148 VULKAN_HPP_HASH_COMBINE( seed, framebufferMixedSamplesCombinationNV.depthStencilSamples ); 5149 VULKAN_HPP_HASH_COMBINE( seed, framebufferMixedSamplesCombinationNV.colorSamples ); 5150 return seed; 5151 } 5152 }; 5153 5154 template <> 5155 struct hash<VULKAN_HPP_NAMESPACE::IndirectCommandsStreamNV> 5156 { operator ()std::hash5157 std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectCommandsStreamNV const & indirectCommandsStreamNV ) const VULKAN_HPP_NOEXCEPT 5158 { 5159 std::size_t seed = 0; 5160 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsStreamNV.buffer ); 5161 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsStreamNV.offset ); 5162 return seed; 5163 } 5164 }; 5165 5166 template <> 5167 struct hash<VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV> 5168 { operator ()std::hash5169 std::size_t operator()( VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV const & generatedCommandsInfoNV ) const VULKAN_HPP_NOEXCEPT 5170 { 5171 std::size_t seed = 0; 5172 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.sType ); 5173 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.pNext ); 5174 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.pipelineBindPoint ); 5175 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.pipeline ); 5176 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.indirectCommandsLayout ); 5177 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.streamCount ); 5178 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.pStreams ); 5179 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.sequencesCount ); 5180 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.preprocessBuffer ); 5181 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.preprocessOffset ); 5182 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.preprocessSize ); 5183 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.sequencesCountBuffer ); 5184 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.sequencesCountOffset ); 5185 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.sequencesIndexBuffer ); 5186 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.sequencesIndexOffset ); 5187 return seed; 5188 } 5189 }; 5190 5191 template <> 5192 struct hash<VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV> 5193 { 5194 std::size_t operator ()std::hash5195 operator()( VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV const & generatedCommandsMemoryRequirementsInfoNV ) const VULKAN_HPP_NOEXCEPT 5196 { 5197 std::size_t seed = 0; 5198 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsMemoryRequirementsInfoNV.sType ); 5199 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsMemoryRequirementsInfoNV.pNext ); 5200 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsMemoryRequirementsInfoNV.pipelineBindPoint ); 5201 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsMemoryRequirementsInfoNV.pipeline ); 5202 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsMemoryRequirementsInfoNV.indirectCommandsLayout ); 5203 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsMemoryRequirementsInfoNV.maxSequencesCount ); 5204 return seed; 5205 } 5206 }; 5207 5208 template <> 5209 struct hash<VULKAN_HPP_NAMESPACE::LatencyTimingsFrameReportNV> 5210 { operator ()std::hash5211 std::size_t operator()( VULKAN_HPP_NAMESPACE::LatencyTimingsFrameReportNV const & latencyTimingsFrameReportNV ) const VULKAN_HPP_NOEXCEPT 5212 { 5213 std::size_t seed = 0; 5214 VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.sType ); 5215 VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.pNext ); 5216 VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.presentID ); 5217 VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.inputSampleTimeUs ); 5218 VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.simStartTimeUs ); 5219 VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.simEndTimeUs ); 5220 VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.renderSubmitStartTimeUs ); 5221 VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.renderSubmitEndTimeUs ); 5222 VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.presentStartTimeUs ); 5223 VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.presentEndTimeUs ); 5224 VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.driverStartTimeUs ); 5225 VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.driverEndTimeUs ); 5226 VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.osRenderQueueStartTimeUs ); 5227 VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.osRenderQueueEndTimeUs ); 5228 VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.gpuRenderStartTimeUs ); 5229 VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.gpuRenderEndTimeUs ); 5230 return seed; 5231 } 5232 }; 5233 5234 template <> 5235 struct hash<VULKAN_HPP_NAMESPACE::GetLatencyMarkerInfoNV> 5236 { operator ()std::hash5237 std::size_t operator()( VULKAN_HPP_NAMESPACE::GetLatencyMarkerInfoNV const & getLatencyMarkerInfoNV ) const VULKAN_HPP_NOEXCEPT 5238 { 5239 std::size_t seed = 0; 5240 VULKAN_HPP_HASH_COMBINE( seed, getLatencyMarkerInfoNV.sType ); 5241 VULKAN_HPP_HASH_COMBINE( seed, getLatencyMarkerInfoNV.pNext ); 5242 VULKAN_HPP_HASH_COMBINE( seed, getLatencyMarkerInfoNV.timingCount ); 5243 VULKAN_HPP_HASH_COMBINE( seed, getLatencyMarkerInfoNV.pTimings ); 5244 return seed; 5245 } 5246 }; 5247 5248 template <> 5249 struct hash<VULKAN_HPP_NAMESPACE::VertexInputBindingDescription> 5250 { operator ()std::hash5251 std::size_t operator()( VULKAN_HPP_NAMESPACE::VertexInputBindingDescription const & vertexInputBindingDescription ) const VULKAN_HPP_NOEXCEPT 5252 { 5253 std::size_t seed = 0; 5254 VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDescription.binding ); 5255 VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDescription.stride ); 5256 VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDescription.inputRate ); 5257 return seed; 5258 } 5259 }; 5260 5261 template <> 5262 struct hash<VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription> 5263 { operator ()std::hash5264 std::size_t operator()( VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription const & vertexInputAttributeDescription ) const VULKAN_HPP_NOEXCEPT 5265 { 5266 std::size_t seed = 0; 5267 VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription.location ); 5268 VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription.binding ); 5269 VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription.format ); 5270 VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription.offset ); 5271 return seed; 5272 } 5273 }; 5274 5275 template <> 5276 struct hash<VULKAN_HPP_NAMESPACE::PipelineVertexInputStateCreateInfo> 5277 { operator ()std::hash5278 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineVertexInputStateCreateInfo const & pipelineVertexInputStateCreateInfo ) const VULKAN_HPP_NOEXCEPT 5279 { 5280 std::size_t seed = 0; 5281 VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputStateCreateInfo.sType ); 5282 VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputStateCreateInfo.pNext ); 5283 VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputStateCreateInfo.flags ); 5284 VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputStateCreateInfo.vertexBindingDescriptionCount ); 5285 VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputStateCreateInfo.pVertexBindingDescriptions ); 5286 VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputStateCreateInfo.vertexAttributeDescriptionCount ); 5287 VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputStateCreateInfo.pVertexAttributeDescriptions ); 5288 return seed; 5289 } 5290 }; 5291 5292 template <> 5293 struct hash<VULKAN_HPP_NAMESPACE::PipelineInputAssemblyStateCreateInfo> 5294 { operator ()std::hash5295 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineInputAssemblyStateCreateInfo const & pipelineInputAssemblyStateCreateInfo ) const VULKAN_HPP_NOEXCEPT 5296 { 5297 std::size_t seed = 0; 5298 VULKAN_HPP_HASH_COMBINE( seed, pipelineInputAssemblyStateCreateInfo.sType ); 5299 VULKAN_HPP_HASH_COMBINE( seed, pipelineInputAssemblyStateCreateInfo.pNext ); 5300 VULKAN_HPP_HASH_COMBINE( seed, pipelineInputAssemblyStateCreateInfo.flags ); 5301 VULKAN_HPP_HASH_COMBINE( seed, pipelineInputAssemblyStateCreateInfo.topology ); 5302 VULKAN_HPP_HASH_COMBINE( seed, pipelineInputAssemblyStateCreateInfo.primitiveRestartEnable ); 5303 return seed; 5304 } 5305 }; 5306 5307 template <> 5308 struct hash<VULKAN_HPP_NAMESPACE::PipelineTessellationStateCreateInfo> 5309 { operator ()std::hash5310 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineTessellationStateCreateInfo const & pipelineTessellationStateCreateInfo ) const VULKAN_HPP_NOEXCEPT 5311 { 5312 std::size_t seed = 0; 5313 VULKAN_HPP_HASH_COMBINE( seed, pipelineTessellationStateCreateInfo.sType ); 5314 VULKAN_HPP_HASH_COMBINE( seed, pipelineTessellationStateCreateInfo.pNext ); 5315 VULKAN_HPP_HASH_COMBINE( seed, pipelineTessellationStateCreateInfo.flags ); 5316 VULKAN_HPP_HASH_COMBINE( seed, pipelineTessellationStateCreateInfo.patchControlPoints ); 5317 return seed; 5318 } 5319 }; 5320 5321 template <> 5322 struct hash<VULKAN_HPP_NAMESPACE::PipelineViewportStateCreateInfo> 5323 { operator ()std::hash5324 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineViewportStateCreateInfo const & pipelineViewportStateCreateInfo ) const VULKAN_HPP_NOEXCEPT 5325 { 5326 std::size_t seed = 0; 5327 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportStateCreateInfo.sType ); 5328 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportStateCreateInfo.pNext ); 5329 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportStateCreateInfo.flags ); 5330 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportStateCreateInfo.viewportCount ); 5331 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportStateCreateInfo.pViewports ); 5332 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportStateCreateInfo.scissorCount ); 5333 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportStateCreateInfo.pScissors ); 5334 return seed; 5335 } 5336 }; 5337 5338 template <> 5339 struct hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationStateCreateInfo> 5340 { operator ()std::hash5341 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationStateCreateInfo const & pipelineRasterizationStateCreateInfo ) const VULKAN_HPP_NOEXCEPT 5342 { 5343 std::size_t seed = 0; 5344 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.sType ); 5345 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.pNext ); 5346 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.flags ); 5347 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.depthClampEnable ); 5348 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.rasterizerDiscardEnable ); 5349 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.polygonMode ); 5350 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.cullMode ); 5351 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.frontFace ); 5352 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.depthBiasEnable ); 5353 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.depthBiasConstantFactor ); 5354 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.depthBiasClamp ); 5355 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.depthBiasSlopeFactor ); 5356 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.lineWidth ); 5357 return seed; 5358 } 5359 }; 5360 5361 template <> 5362 struct hash<VULKAN_HPP_NAMESPACE::PipelineMultisampleStateCreateInfo> 5363 { operator ()std::hash5364 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineMultisampleStateCreateInfo const & pipelineMultisampleStateCreateInfo ) const VULKAN_HPP_NOEXCEPT 5365 { 5366 std::size_t seed = 0; 5367 VULKAN_HPP_HASH_COMBINE( seed, pipelineMultisampleStateCreateInfo.sType ); 5368 VULKAN_HPP_HASH_COMBINE( seed, pipelineMultisampleStateCreateInfo.pNext ); 5369 VULKAN_HPP_HASH_COMBINE( seed, pipelineMultisampleStateCreateInfo.flags ); 5370 VULKAN_HPP_HASH_COMBINE( seed, pipelineMultisampleStateCreateInfo.rasterizationSamples ); 5371 VULKAN_HPP_HASH_COMBINE( seed, pipelineMultisampleStateCreateInfo.sampleShadingEnable ); 5372 VULKAN_HPP_HASH_COMBINE( seed, pipelineMultisampleStateCreateInfo.minSampleShading ); 5373 VULKAN_HPP_HASH_COMBINE( seed, pipelineMultisampleStateCreateInfo.pSampleMask ); 5374 VULKAN_HPP_HASH_COMBINE( seed, pipelineMultisampleStateCreateInfo.alphaToCoverageEnable ); 5375 VULKAN_HPP_HASH_COMBINE( seed, pipelineMultisampleStateCreateInfo.alphaToOneEnable ); 5376 return seed; 5377 } 5378 }; 5379 5380 template <> 5381 struct hash<VULKAN_HPP_NAMESPACE::StencilOpState> 5382 { operator ()std::hash5383 std::size_t operator()( VULKAN_HPP_NAMESPACE::StencilOpState const & stencilOpState ) const VULKAN_HPP_NOEXCEPT 5384 { 5385 std::size_t seed = 0; 5386 VULKAN_HPP_HASH_COMBINE( seed, stencilOpState.failOp ); 5387 VULKAN_HPP_HASH_COMBINE( seed, stencilOpState.passOp ); 5388 VULKAN_HPP_HASH_COMBINE( seed, stencilOpState.depthFailOp ); 5389 VULKAN_HPP_HASH_COMBINE( seed, stencilOpState.compareOp ); 5390 VULKAN_HPP_HASH_COMBINE( seed, stencilOpState.compareMask ); 5391 VULKAN_HPP_HASH_COMBINE( seed, stencilOpState.writeMask ); 5392 VULKAN_HPP_HASH_COMBINE( seed, stencilOpState.reference ); 5393 return seed; 5394 } 5395 }; 5396 5397 template <> 5398 struct hash<VULKAN_HPP_NAMESPACE::PipelineDepthStencilStateCreateInfo> 5399 { operator ()std::hash5400 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineDepthStencilStateCreateInfo const & pipelineDepthStencilStateCreateInfo ) const VULKAN_HPP_NOEXCEPT 5401 { 5402 std::size_t seed = 0; 5403 VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.sType ); 5404 VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.pNext ); 5405 VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.flags ); 5406 VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.depthTestEnable ); 5407 VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.depthWriteEnable ); 5408 VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.depthCompareOp ); 5409 VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.depthBoundsTestEnable ); 5410 VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.stencilTestEnable ); 5411 VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.front ); 5412 VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.back ); 5413 VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.minDepthBounds ); 5414 VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.maxDepthBounds ); 5415 return seed; 5416 } 5417 }; 5418 5419 template <> 5420 struct hash<VULKAN_HPP_NAMESPACE::PipelineColorBlendAttachmentState> 5421 { operator ()std::hash5422 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineColorBlendAttachmentState const & pipelineColorBlendAttachmentState ) const VULKAN_HPP_NOEXCEPT 5423 { 5424 std::size_t seed = 0; 5425 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAttachmentState.blendEnable ); 5426 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAttachmentState.srcColorBlendFactor ); 5427 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAttachmentState.dstColorBlendFactor ); 5428 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAttachmentState.colorBlendOp ); 5429 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAttachmentState.srcAlphaBlendFactor ); 5430 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAttachmentState.dstAlphaBlendFactor ); 5431 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAttachmentState.alphaBlendOp ); 5432 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAttachmentState.colorWriteMask ); 5433 return seed; 5434 } 5435 }; 5436 5437 template <> 5438 struct hash<VULKAN_HPP_NAMESPACE::PipelineColorBlendStateCreateInfo> 5439 { operator ()std::hash5440 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineColorBlendStateCreateInfo const & pipelineColorBlendStateCreateInfo ) const VULKAN_HPP_NOEXCEPT 5441 { 5442 std::size_t seed = 0; 5443 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendStateCreateInfo.sType ); 5444 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendStateCreateInfo.pNext ); 5445 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendStateCreateInfo.flags ); 5446 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendStateCreateInfo.logicOpEnable ); 5447 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendStateCreateInfo.logicOp ); 5448 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendStateCreateInfo.attachmentCount ); 5449 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendStateCreateInfo.pAttachments ); 5450 for ( size_t i = 0; i < 4; ++i ) 5451 { 5452 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendStateCreateInfo.blendConstants[i] ); 5453 } 5454 return seed; 5455 } 5456 }; 5457 5458 template <> 5459 struct hash<VULKAN_HPP_NAMESPACE::PipelineDynamicStateCreateInfo> 5460 { operator ()std::hash5461 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineDynamicStateCreateInfo const & pipelineDynamicStateCreateInfo ) const VULKAN_HPP_NOEXCEPT 5462 { 5463 std::size_t seed = 0; 5464 VULKAN_HPP_HASH_COMBINE( seed, pipelineDynamicStateCreateInfo.sType ); 5465 VULKAN_HPP_HASH_COMBINE( seed, pipelineDynamicStateCreateInfo.pNext ); 5466 VULKAN_HPP_HASH_COMBINE( seed, pipelineDynamicStateCreateInfo.flags ); 5467 VULKAN_HPP_HASH_COMBINE( seed, pipelineDynamicStateCreateInfo.dynamicStateCount ); 5468 VULKAN_HPP_HASH_COMBINE( seed, pipelineDynamicStateCreateInfo.pDynamicStates ); 5469 return seed; 5470 } 5471 }; 5472 5473 template <> 5474 struct hash<VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> 5475 { operator ()std::hash5476 std::size_t operator()( VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo const & graphicsPipelineCreateInfo ) const VULKAN_HPP_NOEXCEPT 5477 { 5478 std::size_t seed = 0; 5479 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.sType ); 5480 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pNext ); 5481 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.flags ); 5482 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.stageCount ); 5483 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pStages ); 5484 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pVertexInputState ); 5485 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pInputAssemblyState ); 5486 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pTessellationState ); 5487 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pViewportState ); 5488 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pRasterizationState ); 5489 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pMultisampleState ); 5490 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pDepthStencilState ); 5491 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pColorBlendState ); 5492 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pDynamicState ); 5493 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.layout ); 5494 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.renderPass ); 5495 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.subpass ); 5496 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.basePipelineHandle ); 5497 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.basePipelineIndex ); 5498 return seed; 5499 } 5500 }; 5501 5502 template <> 5503 struct hash<VULKAN_HPP_NAMESPACE::GraphicsPipelineLibraryCreateInfoEXT> 5504 { operator ()std::hash5505 std::size_t operator()( VULKAN_HPP_NAMESPACE::GraphicsPipelineLibraryCreateInfoEXT const & graphicsPipelineLibraryCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 5506 { 5507 std::size_t seed = 0; 5508 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineLibraryCreateInfoEXT.sType ); 5509 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineLibraryCreateInfoEXT.pNext ); 5510 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineLibraryCreateInfoEXT.flags ); 5511 return seed; 5512 } 5513 }; 5514 5515 template <> 5516 struct hash<VULKAN_HPP_NAMESPACE::GraphicsShaderGroupCreateInfoNV> 5517 { operator ()std::hash5518 std::size_t operator()( VULKAN_HPP_NAMESPACE::GraphicsShaderGroupCreateInfoNV const & graphicsShaderGroupCreateInfoNV ) const VULKAN_HPP_NOEXCEPT 5519 { 5520 std::size_t seed = 0; 5521 VULKAN_HPP_HASH_COMBINE( seed, graphicsShaderGroupCreateInfoNV.sType ); 5522 VULKAN_HPP_HASH_COMBINE( seed, graphicsShaderGroupCreateInfoNV.pNext ); 5523 VULKAN_HPP_HASH_COMBINE( seed, graphicsShaderGroupCreateInfoNV.stageCount ); 5524 VULKAN_HPP_HASH_COMBINE( seed, graphicsShaderGroupCreateInfoNV.pStages ); 5525 VULKAN_HPP_HASH_COMBINE( seed, graphicsShaderGroupCreateInfoNV.pVertexInputState ); 5526 VULKAN_HPP_HASH_COMBINE( seed, graphicsShaderGroupCreateInfoNV.pTessellationState ); 5527 return seed; 5528 } 5529 }; 5530 5531 template <> 5532 struct hash<VULKAN_HPP_NAMESPACE::GraphicsPipelineShaderGroupsCreateInfoNV> 5533 { 5534 std::size_t operator ()std::hash5535 operator()( VULKAN_HPP_NAMESPACE::GraphicsPipelineShaderGroupsCreateInfoNV const & graphicsPipelineShaderGroupsCreateInfoNV ) const VULKAN_HPP_NOEXCEPT 5536 { 5537 std::size_t seed = 0; 5538 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineShaderGroupsCreateInfoNV.sType ); 5539 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineShaderGroupsCreateInfoNV.pNext ); 5540 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineShaderGroupsCreateInfoNV.groupCount ); 5541 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineShaderGroupsCreateInfoNV.pGroups ); 5542 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineShaderGroupsCreateInfoNV.pipelineCount ); 5543 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineShaderGroupsCreateInfoNV.pPipelines ); 5544 return seed; 5545 } 5546 }; 5547 5548 template <> 5549 struct hash<VULKAN_HPP_NAMESPACE::XYColorEXT> 5550 { operator ()std::hash5551 std::size_t operator()( VULKAN_HPP_NAMESPACE::XYColorEXT const & xYColorEXT ) const VULKAN_HPP_NOEXCEPT 5552 { 5553 std::size_t seed = 0; 5554 VULKAN_HPP_HASH_COMBINE( seed, xYColorEXT.x ); 5555 VULKAN_HPP_HASH_COMBINE( seed, xYColorEXT.y ); 5556 return seed; 5557 } 5558 }; 5559 5560 template <> 5561 struct hash<VULKAN_HPP_NAMESPACE::HdrMetadataEXT> 5562 { operator ()std::hash5563 std::size_t operator()( VULKAN_HPP_NAMESPACE::HdrMetadataEXT const & hdrMetadataEXT ) const VULKAN_HPP_NOEXCEPT 5564 { 5565 std::size_t seed = 0; 5566 VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.sType ); 5567 VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.pNext ); 5568 VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.displayPrimaryRed ); 5569 VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.displayPrimaryGreen ); 5570 VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.displayPrimaryBlue ); 5571 VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.whitePoint ); 5572 VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.maxLuminance ); 5573 VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.minLuminance ); 5574 VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.maxContentLightLevel ); 5575 VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.maxFrameAverageLightLevel ); 5576 return seed; 5577 } 5578 }; 5579 5580 template <> 5581 struct hash<VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT> 5582 { operator ()std::hash5583 std::size_t operator()( VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT const & headlessSurfaceCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 5584 { 5585 std::size_t seed = 0; 5586 VULKAN_HPP_HASH_COMBINE( seed, headlessSurfaceCreateInfoEXT.sType ); 5587 VULKAN_HPP_HASH_COMBINE( seed, headlessSurfaceCreateInfoEXT.pNext ); 5588 VULKAN_HPP_HASH_COMBINE( seed, headlessSurfaceCreateInfoEXT.flags ); 5589 return seed; 5590 } 5591 }; 5592 5593 template <> 5594 struct hash<VULKAN_HPP_NAMESPACE::HostImageCopyDevicePerformanceQueryEXT> 5595 { 5596 std::size_t operator ()std::hash5597 operator()( VULKAN_HPP_NAMESPACE::HostImageCopyDevicePerformanceQueryEXT const & hostImageCopyDevicePerformanceQueryEXT ) const VULKAN_HPP_NOEXCEPT 5598 { 5599 std::size_t seed = 0; 5600 VULKAN_HPP_HASH_COMBINE( seed, hostImageCopyDevicePerformanceQueryEXT.sType ); 5601 VULKAN_HPP_HASH_COMBINE( seed, hostImageCopyDevicePerformanceQueryEXT.pNext ); 5602 VULKAN_HPP_HASH_COMBINE( seed, hostImageCopyDevicePerformanceQueryEXT.optimalDeviceAccess ); 5603 VULKAN_HPP_HASH_COMBINE( seed, hostImageCopyDevicePerformanceQueryEXT.identicalMemoryLayout ); 5604 return seed; 5605 } 5606 }; 5607 5608 template <> 5609 struct hash<VULKAN_HPP_NAMESPACE::HostImageLayoutTransitionInfoEXT> 5610 { operator ()std::hash5611 std::size_t operator()( VULKAN_HPP_NAMESPACE::HostImageLayoutTransitionInfoEXT const & hostImageLayoutTransitionInfoEXT ) const VULKAN_HPP_NOEXCEPT 5612 { 5613 std::size_t seed = 0; 5614 VULKAN_HPP_HASH_COMBINE( seed, hostImageLayoutTransitionInfoEXT.sType ); 5615 VULKAN_HPP_HASH_COMBINE( seed, hostImageLayoutTransitionInfoEXT.pNext ); 5616 VULKAN_HPP_HASH_COMBINE( seed, hostImageLayoutTransitionInfoEXT.image ); 5617 VULKAN_HPP_HASH_COMBINE( seed, hostImageLayoutTransitionInfoEXT.oldLayout ); 5618 VULKAN_HPP_HASH_COMBINE( seed, hostImageLayoutTransitionInfoEXT.newLayout ); 5619 VULKAN_HPP_HASH_COMBINE( seed, hostImageLayoutTransitionInfoEXT.subresourceRange ); 5620 return seed; 5621 } 5622 }; 5623 5624 # if defined( VK_USE_PLATFORM_IOS_MVK ) 5625 template <> 5626 struct hash<VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK> 5627 { operator ()std::hash5628 std::size_t operator()( VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK const & iOSSurfaceCreateInfoMVK ) const VULKAN_HPP_NOEXCEPT 5629 { 5630 std::size_t seed = 0; 5631 VULKAN_HPP_HASH_COMBINE( seed, iOSSurfaceCreateInfoMVK.sType ); 5632 VULKAN_HPP_HASH_COMBINE( seed, iOSSurfaceCreateInfoMVK.pNext ); 5633 VULKAN_HPP_HASH_COMBINE( seed, iOSSurfaceCreateInfoMVK.flags ); 5634 VULKAN_HPP_HASH_COMBINE( seed, iOSSurfaceCreateInfoMVK.pView ); 5635 return seed; 5636 } 5637 }; 5638 # endif /*VK_USE_PLATFORM_IOS_MVK*/ 5639 5640 template <> 5641 struct hash<VULKAN_HPP_NAMESPACE::ImageAlignmentControlCreateInfoMESA> 5642 { operator ()std::hash5643 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageAlignmentControlCreateInfoMESA const & imageAlignmentControlCreateInfoMESA ) const VULKAN_HPP_NOEXCEPT 5644 { 5645 std::size_t seed = 0; 5646 VULKAN_HPP_HASH_COMBINE( seed, imageAlignmentControlCreateInfoMESA.sType ); 5647 VULKAN_HPP_HASH_COMBINE( seed, imageAlignmentControlCreateInfoMESA.pNext ); 5648 VULKAN_HPP_HASH_COMBINE( seed, imageAlignmentControlCreateInfoMESA.maximumRequestedAlignment ); 5649 return seed; 5650 } 5651 }; 5652 5653 template <> 5654 struct hash<VULKAN_HPP_NAMESPACE::ImageBlit> 5655 { operator ()std::hash5656 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageBlit const & imageBlit ) const VULKAN_HPP_NOEXCEPT 5657 { 5658 std::size_t seed = 0; 5659 VULKAN_HPP_HASH_COMBINE( seed, imageBlit.srcSubresource ); 5660 for ( size_t i = 0; i < 2; ++i ) 5661 { 5662 VULKAN_HPP_HASH_COMBINE( seed, imageBlit.srcOffsets[i] ); 5663 } 5664 VULKAN_HPP_HASH_COMBINE( seed, imageBlit.dstSubresource ); 5665 for ( size_t i = 0; i < 2; ++i ) 5666 { 5667 VULKAN_HPP_HASH_COMBINE( seed, imageBlit.dstOffsets[i] ); 5668 } 5669 return seed; 5670 } 5671 }; 5672 5673 template <> 5674 struct hash<VULKAN_HPP_NAMESPACE::ImageCaptureDescriptorDataInfoEXT> 5675 { operator ()std::hash5676 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageCaptureDescriptorDataInfoEXT const & imageCaptureDescriptorDataInfoEXT ) const VULKAN_HPP_NOEXCEPT 5677 { 5678 std::size_t seed = 0; 5679 VULKAN_HPP_HASH_COMBINE( seed, imageCaptureDescriptorDataInfoEXT.sType ); 5680 VULKAN_HPP_HASH_COMBINE( seed, imageCaptureDescriptorDataInfoEXT.pNext ); 5681 VULKAN_HPP_HASH_COMBINE( seed, imageCaptureDescriptorDataInfoEXT.image ); 5682 return seed; 5683 } 5684 }; 5685 5686 template <> 5687 struct hash<VULKAN_HPP_NAMESPACE::ImageCompressionControlEXT> 5688 { operator ()std::hash5689 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageCompressionControlEXT const & imageCompressionControlEXT ) const VULKAN_HPP_NOEXCEPT 5690 { 5691 std::size_t seed = 0; 5692 VULKAN_HPP_HASH_COMBINE( seed, imageCompressionControlEXT.sType ); 5693 VULKAN_HPP_HASH_COMBINE( seed, imageCompressionControlEXT.pNext ); 5694 VULKAN_HPP_HASH_COMBINE( seed, imageCompressionControlEXT.flags ); 5695 VULKAN_HPP_HASH_COMBINE( seed, imageCompressionControlEXT.compressionControlPlaneCount ); 5696 VULKAN_HPP_HASH_COMBINE( seed, imageCompressionControlEXT.pFixedRateFlags ); 5697 return seed; 5698 } 5699 }; 5700 5701 template <> 5702 struct hash<VULKAN_HPP_NAMESPACE::ImageCompressionPropertiesEXT> 5703 { operator ()std::hash5704 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageCompressionPropertiesEXT const & imageCompressionPropertiesEXT ) const VULKAN_HPP_NOEXCEPT 5705 { 5706 std::size_t seed = 0; 5707 VULKAN_HPP_HASH_COMBINE( seed, imageCompressionPropertiesEXT.sType ); 5708 VULKAN_HPP_HASH_COMBINE( seed, imageCompressionPropertiesEXT.pNext ); 5709 VULKAN_HPP_HASH_COMBINE( seed, imageCompressionPropertiesEXT.imageCompressionFlags ); 5710 VULKAN_HPP_HASH_COMBINE( seed, imageCompressionPropertiesEXT.imageCompressionFixedRateFlags ); 5711 return seed; 5712 } 5713 }; 5714 5715 # if defined( VK_USE_PLATFORM_FUCHSIA ) 5716 template <> 5717 struct hash<VULKAN_HPP_NAMESPACE::ImageFormatConstraintsInfoFUCHSIA> 5718 { operator ()std::hash5719 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageFormatConstraintsInfoFUCHSIA const & imageFormatConstraintsInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT 5720 { 5721 std::size_t seed = 0; 5722 VULKAN_HPP_HASH_COMBINE( seed, imageFormatConstraintsInfoFUCHSIA.sType ); 5723 VULKAN_HPP_HASH_COMBINE( seed, imageFormatConstraintsInfoFUCHSIA.pNext ); 5724 VULKAN_HPP_HASH_COMBINE( seed, imageFormatConstraintsInfoFUCHSIA.imageCreateInfo ); 5725 VULKAN_HPP_HASH_COMBINE( seed, imageFormatConstraintsInfoFUCHSIA.requiredFormatFeatures ); 5726 VULKAN_HPP_HASH_COMBINE( seed, imageFormatConstraintsInfoFUCHSIA.flags ); 5727 VULKAN_HPP_HASH_COMBINE( seed, imageFormatConstraintsInfoFUCHSIA.sysmemPixelFormat ); 5728 VULKAN_HPP_HASH_COMBINE( seed, imageFormatConstraintsInfoFUCHSIA.colorSpaceCount ); 5729 VULKAN_HPP_HASH_COMBINE( seed, imageFormatConstraintsInfoFUCHSIA.pColorSpaces ); 5730 return seed; 5731 } 5732 }; 5733 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 5734 5735 # if defined( VK_USE_PLATFORM_FUCHSIA ) 5736 template <> 5737 struct hash<VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFUCHSIA> 5738 { operator ()std::hash5739 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFUCHSIA const & imageConstraintsInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT 5740 { 5741 std::size_t seed = 0; 5742 VULKAN_HPP_HASH_COMBINE( seed, imageConstraintsInfoFUCHSIA.sType ); 5743 VULKAN_HPP_HASH_COMBINE( seed, imageConstraintsInfoFUCHSIA.pNext ); 5744 VULKAN_HPP_HASH_COMBINE( seed, imageConstraintsInfoFUCHSIA.formatConstraintsCount ); 5745 VULKAN_HPP_HASH_COMBINE( seed, imageConstraintsInfoFUCHSIA.pFormatConstraints ); 5746 VULKAN_HPP_HASH_COMBINE( seed, imageConstraintsInfoFUCHSIA.bufferCollectionConstraints ); 5747 VULKAN_HPP_HASH_COMBINE( seed, imageConstraintsInfoFUCHSIA.flags ); 5748 return seed; 5749 } 5750 }; 5751 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 5752 5753 template <> 5754 struct hash<VULKAN_HPP_NAMESPACE::ImageCopy> 5755 { operator ()std::hash5756 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageCopy const & imageCopy ) const VULKAN_HPP_NOEXCEPT 5757 { 5758 std::size_t seed = 0; 5759 VULKAN_HPP_HASH_COMBINE( seed, imageCopy.srcSubresource ); 5760 VULKAN_HPP_HASH_COMBINE( seed, imageCopy.srcOffset ); 5761 VULKAN_HPP_HASH_COMBINE( seed, imageCopy.dstSubresource ); 5762 VULKAN_HPP_HASH_COMBINE( seed, imageCopy.dstOffset ); 5763 VULKAN_HPP_HASH_COMBINE( seed, imageCopy.extent ); 5764 return seed; 5765 } 5766 }; 5767 5768 template <> 5769 struct hash<VULKAN_HPP_NAMESPACE::SubresourceLayout> 5770 { operator ()std::hash5771 std::size_t operator()( VULKAN_HPP_NAMESPACE::SubresourceLayout const & subresourceLayout ) const VULKAN_HPP_NOEXCEPT 5772 { 5773 std::size_t seed = 0; 5774 VULKAN_HPP_HASH_COMBINE( seed, subresourceLayout.offset ); 5775 VULKAN_HPP_HASH_COMBINE( seed, subresourceLayout.size ); 5776 VULKAN_HPP_HASH_COMBINE( seed, subresourceLayout.rowPitch ); 5777 VULKAN_HPP_HASH_COMBINE( seed, subresourceLayout.arrayPitch ); 5778 VULKAN_HPP_HASH_COMBINE( seed, subresourceLayout.depthPitch ); 5779 return seed; 5780 } 5781 }; 5782 5783 template <> 5784 struct hash<VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierExplicitCreateInfoEXT> 5785 { operator ()std::hash5786 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierExplicitCreateInfoEXT const & imageDrmFormatModifierExplicitCreateInfoEXT ) const 5787 VULKAN_HPP_NOEXCEPT 5788 { 5789 std::size_t seed = 0; 5790 VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierExplicitCreateInfoEXT.sType ); 5791 VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierExplicitCreateInfoEXT.pNext ); 5792 VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierExplicitCreateInfoEXT.drmFormatModifier ); 5793 VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierExplicitCreateInfoEXT.drmFormatModifierPlaneCount ); 5794 VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierExplicitCreateInfoEXT.pPlaneLayouts ); 5795 return seed; 5796 } 5797 }; 5798 5799 template <> 5800 struct hash<VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierListCreateInfoEXT> 5801 { 5802 std::size_t operator ()std::hash5803 operator()( VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierListCreateInfoEXT const & imageDrmFormatModifierListCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 5804 { 5805 std::size_t seed = 0; 5806 VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierListCreateInfoEXT.sType ); 5807 VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierListCreateInfoEXT.pNext ); 5808 VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierListCreateInfoEXT.drmFormatModifierCount ); 5809 VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierListCreateInfoEXT.pDrmFormatModifiers ); 5810 return seed; 5811 } 5812 }; 5813 5814 template <> 5815 struct hash<VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT> 5816 { operator ()std::hash5817 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT const & imageDrmFormatModifierPropertiesEXT ) const VULKAN_HPP_NOEXCEPT 5818 { 5819 std::size_t seed = 0; 5820 VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierPropertiesEXT.sType ); 5821 VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierPropertiesEXT.pNext ); 5822 VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierPropertiesEXT.drmFormatModifier ); 5823 return seed; 5824 } 5825 }; 5826 5827 template <> 5828 struct hash<VULKAN_HPP_NAMESPACE::ImageFormatListCreateInfo> 5829 { operator ()std::hash5830 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageFormatListCreateInfo const & imageFormatListCreateInfo ) const VULKAN_HPP_NOEXCEPT 5831 { 5832 std::size_t seed = 0; 5833 VULKAN_HPP_HASH_COMBINE( seed, imageFormatListCreateInfo.sType ); 5834 VULKAN_HPP_HASH_COMBINE( seed, imageFormatListCreateInfo.pNext ); 5835 VULKAN_HPP_HASH_COMBINE( seed, imageFormatListCreateInfo.viewFormatCount ); 5836 VULKAN_HPP_HASH_COMBINE( seed, imageFormatListCreateInfo.pViewFormats ); 5837 return seed; 5838 } 5839 }; 5840 5841 template <> 5842 struct hash<VULKAN_HPP_NAMESPACE::ImageFormatProperties2> 5843 { operator ()std::hash5844 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageFormatProperties2 const & imageFormatProperties2 ) const VULKAN_HPP_NOEXCEPT 5845 { 5846 std::size_t seed = 0; 5847 VULKAN_HPP_HASH_COMBINE( seed, imageFormatProperties2.sType ); 5848 VULKAN_HPP_HASH_COMBINE( seed, imageFormatProperties2.pNext ); 5849 VULKAN_HPP_HASH_COMBINE( seed, imageFormatProperties2.imageFormatProperties ); 5850 return seed; 5851 } 5852 }; 5853 5854 template <> 5855 struct hash<VULKAN_HPP_NAMESPACE::ImageMemoryBarrier> 5856 { operator ()std::hash5857 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageMemoryBarrier const & imageMemoryBarrier ) const VULKAN_HPP_NOEXCEPT 5858 { 5859 std::size_t seed = 0; 5860 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.sType ); 5861 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.pNext ); 5862 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.srcAccessMask ); 5863 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.dstAccessMask ); 5864 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.oldLayout ); 5865 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.newLayout ); 5866 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.srcQueueFamilyIndex ); 5867 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.dstQueueFamilyIndex ); 5868 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.image ); 5869 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.subresourceRange ); 5870 return seed; 5871 } 5872 }; 5873 5874 template <> 5875 struct hash<VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2> 5876 { operator ()std::hash5877 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 const & imageMemoryRequirementsInfo2 ) const VULKAN_HPP_NOEXCEPT 5878 { 5879 std::size_t seed = 0; 5880 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryRequirementsInfo2.sType ); 5881 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryRequirementsInfo2.pNext ); 5882 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryRequirementsInfo2.image ); 5883 return seed; 5884 } 5885 }; 5886 5887 # if defined( VK_USE_PLATFORM_FUCHSIA ) 5888 template <> 5889 struct hash<VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA> 5890 { operator ()std::hash5891 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA const & imagePipeSurfaceCreateInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT 5892 { 5893 std::size_t seed = 0; 5894 VULKAN_HPP_HASH_COMBINE( seed, imagePipeSurfaceCreateInfoFUCHSIA.sType ); 5895 VULKAN_HPP_HASH_COMBINE( seed, imagePipeSurfaceCreateInfoFUCHSIA.pNext ); 5896 VULKAN_HPP_HASH_COMBINE( seed, imagePipeSurfaceCreateInfoFUCHSIA.flags ); 5897 VULKAN_HPP_HASH_COMBINE( seed, imagePipeSurfaceCreateInfoFUCHSIA.imagePipeHandle ); 5898 return seed; 5899 } 5900 }; 5901 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 5902 5903 template <> 5904 struct hash<VULKAN_HPP_NAMESPACE::ImagePlaneMemoryRequirementsInfo> 5905 { operator ()std::hash5906 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImagePlaneMemoryRequirementsInfo const & imagePlaneMemoryRequirementsInfo ) const VULKAN_HPP_NOEXCEPT 5907 { 5908 std::size_t seed = 0; 5909 VULKAN_HPP_HASH_COMBINE( seed, imagePlaneMemoryRequirementsInfo.sType ); 5910 VULKAN_HPP_HASH_COMBINE( seed, imagePlaneMemoryRequirementsInfo.pNext ); 5911 VULKAN_HPP_HASH_COMBINE( seed, imagePlaneMemoryRequirementsInfo.planeAspect ); 5912 return seed; 5913 } 5914 }; 5915 5916 template <> 5917 struct hash<VULKAN_HPP_NAMESPACE::ImageResolve> 5918 { operator ()std::hash5919 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageResolve const & imageResolve ) const VULKAN_HPP_NOEXCEPT 5920 { 5921 std::size_t seed = 0; 5922 VULKAN_HPP_HASH_COMBINE( seed, imageResolve.srcSubresource ); 5923 VULKAN_HPP_HASH_COMBINE( seed, imageResolve.srcOffset ); 5924 VULKAN_HPP_HASH_COMBINE( seed, imageResolve.dstSubresource ); 5925 VULKAN_HPP_HASH_COMBINE( seed, imageResolve.dstOffset ); 5926 VULKAN_HPP_HASH_COMBINE( seed, imageResolve.extent ); 5927 return seed; 5928 } 5929 }; 5930 5931 template <> 5932 struct hash<VULKAN_HPP_NAMESPACE::ImageResolve2> 5933 { operator ()std::hash5934 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageResolve2 const & imageResolve2 ) const VULKAN_HPP_NOEXCEPT 5935 { 5936 std::size_t seed = 0; 5937 VULKAN_HPP_HASH_COMBINE( seed, imageResolve2.sType ); 5938 VULKAN_HPP_HASH_COMBINE( seed, imageResolve2.pNext ); 5939 VULKAN_HPP_HASH_COMBINE( seed, imageResolve2.srcSubresource ); 5940 VULKAN_HPP_HASH_COMBINE( seed, imageResolve2.srcOffset ); 5941 VULKAN_HPP_HASH_COMBINE( seed, imageResolve2.dstSubresource ); 5942 VULKAN_HPP_HASH_COMBINE( seed, imageResolve2.dstOffset ); 5943 VULKAN_HPP_HASH_COMBINE( seed, imageResolve2.extent ); 5944 return seed; 5945 } 5946 }; 5947 5948 template <> 5949 struct hash<VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2> 5950 { operator ()std::hash5951 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 const & imageSparseMemoryRequirementsInfo2 ) const VULKAN_HPP_NOEXCEPT 5952 { 5953 std::size_t seed = 0; 5954 VULKAN_HPP_HASH_COMBINE( seed, imageSparseMemoryRequirementsInfo2.sType ); 5955 VULKAN_HPP_HASH_COMBINE( seed, imageSparseMemoryRequirementsInfo2.pNext ); 5956 VULKAN_HPP_HASH_COMBINE( seed, imageSparseMemoryRequirementsInfo2.image ); 5957 return seed; 5958 } 5959 }; 5960 5961 template <> 5962 struct hash<VULKAN_HPP_NAMESPACE::ImageStencilUsageCreateInfo> 5963 { operator ()std::hash5964 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageStencilUsageCreateInfo const & imageStencilUsageCreateInfo ) const VULKAN_HPP_NOEXCEPT 5965 { 5966 std::size_t seed = 0; 5967 VULKAN_HPP_HASH_COMBINE( seed, imageStencilUsageCreateInfo.sType ); 5968 VULKAN_HPP_HASH_COMBINE( seed, imageStencilUsageCreateInfo.pNext ); 5969 VULKAN_HPP_HASH_COMBINE( seed, imageStencilUsageCreateInfo.stencilUsage ); 5970 return seed; 5971 } 5972 }; 5973 5974 template <> 5975 struct hash<VULKAN_HPP_NAMESPACE::ImageSwapchainCreateInfoKHR> 5976 { operator ()std::hash5977 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageSwapchainCreateInfoKHR const & imageSwapchainCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 5978 { 5979 std::size_t seed = 0; 5980 VULKAN_HPP_HASH_COMBINE( seed, imageSwapchainCreateInfoKHR.sType ); 5981 VULKAN_HPP_HASH_COMBINE( seed, imageSwapchainCreateInfoKHR.pNext ); 5982 VULKAN_HPP_HASH_COMBINE( seed, imageSwapchainCreateInfoKHR.swapchain ); 5983 return seed; 5984 } 5985 }; 5986 5987 template <> 5988 struct hash<VULKAN_HPP_NAMESPACE::ImageViewASTCDecodeModeEXT> 5989 { operator ()std::hash5990 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewASTCDecodeModeEXT const & imageViewASTCDecodeModeEXT ) const VULKAN_HPP_NOEXCEPT 5991 { 5992 std::size_t seed = 0; 5993 VULKAN_HPP_HASH_COMBINE( seed, imageViewASTCDecodeModeEXT.sType ); 5994 VULKAN_HPP_HASH_COMBINE( seed, imageViewASTCDecodeModeEXT.pNext ); 5995 VULKAN_HPP_HASH_COMBINE( seed, imageViewASTCDecodeModeEXT.decodeMode ); 5996 return seed; 5997 } 5998 }; 5999 6000 template <> 6001 struct hash<VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX> 6002 { operator ()std::hash6003 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX const & imageViewAddressPropertiesNVX ) const VULKAN_HPP_NOEXCEPT 6004 { 6005 std::size_t seed = 0; 6006 VULKAN_HPP_HASH_COMBINE( seed, imageViewAddressPropertiesNVX.sType ); 6007 VULKAN_HPP_HASH_COMBINE( seed, imageViewAddressPropertiesNVX.pNext ); 6008 VULKAN_HPP_HASH_COMBINE( seed, imageViewAddressPropertiesNVX.deviceAddress ); 6009 VULKAN_HPP_HASH_COMBINE( seed, imageViewAddressPropertiesNVX.size ); 6010 return seed; 6011 } 6012 }; 6013 6014 template <> 6015 struct hash<VULKAN_HPP_NAMESPACE::ImageViewCaptureDescriptorDataInfoEXT> 6016 { 6017 std::size_t operator ()std::hash6018 operator()( VULKAN_HPP_NAMESPACE::ImageViewCaptureDescriptorDataInfoEXT const & imageViewCaptureDescriptorDataInfoEXT ) const VULKAN_HPP_NOEXCEPT 6019 { 6020 std::size_t seed = 0; 6021 VULKAN_HPP_HASH_COMBINE( seed, imageViewCaptureDescriptorDataInfoEXT.sType ); 6022 VULKAN_HPP_HASH_COMBINE( seed, imageViewCaptureDescriptorDataInfoEXT.pNext ); 6023 VULKAN_HPP_HASH_COMBINE( seed, imageViewCaptureDescriptorDataInfoEXT.imageView ); 6024 return seed; 6025 } 6026 }; 6027 6028 template <> 6029 struct hash<VULKAN_HPP_NAMESPACE::ImageViewCreateInfo> 6030 { operator ()std::hash6031 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewCreateInfo const & imageViewCreateInfo ) const VULKAN_HPP_NOEXCEPT 6032 { 6033 std::size_t seed = 0; 6034 VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.sType ); 6035 VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.pNext ); 6036 VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.flags ); 6037 VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.image ); 6038 VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.viewType ); 6039 VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.format ); 6040 VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.components ); 6041 VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.subresourceRange ); 6042 return seed; 6043 } 6044 }; 6045 6046 template <> 6047 struct hash<VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX> 6048 { operator ()std::hash6049 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX const & imageViewHandleInfoNVX ) const VULKAN_HPP_NOEXCEPT 6050 { 6051 std::size_t seed = 0; 6052 VULKAN_HPP_HASH_COMBINE( seed, imageViewHandleInfoNVX.sType ); 6053 VULKAN_HPP_HASH_COMBINE( seed, imageViewHandleInfoNVX.pNext ); 6054 VULKAN_HPP_HASH_COMBINE( seed, imageViewHandleInfoNVX.imageView ); 6055 VULKAN_HPP_HASH_COMBINE( seed, imageViewHandleInfoNVX.descriptorType ); 6056 VULKAN_HPP_HASH_COMBINE( seed, imageViewHandleInfoNVX.sampler ); 6057 return seed; 6058 } 6059 }; 6060 6061 template <> 6062 struct hash<VULKAN_HPP_NAMESPACE::ImageViewMinLodCreateInfoEXT> 6063 { operator ()std::hash6064 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewMinLodCreateInfoEXT const & imageViewMinLodCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 6065 { 6066 std::size_t seed = 0; 6067 VULKAN_HPP_HASH_COMBINE( seed, imageViewMinLodCreateInfoEXT.sType ); 6068 VULKAN_HPP_HASH_COMBINE( seed, imageViewMinLodCreateInfoEXT.pNext ); 6069 VULKAN_HPP_HASH_COMBINE( seed, imageViewMinLodCreateInfoEXT.minLod ); 6070 return seed; 6071 } 6072 }; 6073 6074 template <> 6075 struct hash<VULKAN_HPP_NAMESPACE::ImageViewSampleWeightCreateInfoQCOM> 6076 { operator ()std::hash6077 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewSampleWeightCreateInfoQCOM const & imageViewSampleWeightCreateInfoQCOM ) const VULKAN_HPP_NOEXCEPT 6078 { 6079 std::size_t seed = 0; 6080 VULKAN_HPP_HASH_COMBINE( seed, imageViewSampleWeightCreateInfoQCOM.sType ); 6081 VULKAN_HPP_HASH_COMBINE( seed, imageViewSampleWeightCreateInfoQCOM.pNext ); 6082 VULKAN_HPP_HASH_COMBINE( seed, imageViewSampleWeightCreateInfoQCOM.filterCenter ); 6083 VULKAN_HPP_HASH_COMBINE( seed, imageViewSampleWeightCreateInfoQCOM.filterSize ); 6084 VULKAN_HPP_HASH_COMBINE( seed, imageViewSampleWeightCreateInfoQCOM.numPhases ); 6085 return seed; 6086 } 6087 }; 6088 6089 template <> 6090 struct hash<VULKAN_HPP_NAMESPACE::ImageViewSlicedCreateInfoEXT> 6091 { operator ()std::hash6092 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewSlicedCreateInfoEXT const & imageViewSlicedCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 6093 { 6094 std::size_t seed = 0; 6095 VULKAN_HPP_HASH_COMBINE( seed, imageViewSlicedCreateInfoEXT.sType ); 6096 VULKAN_HPP_HASH_COMBINE( seed, imageViewSlicedCreateInfoEXT.pNext ); 6097 VULKAN_HPP_HASH_COMBINE( seed, imageViewSlicedCreateInfoEXT.sliceOffset ); 6098 VULKAN_HPP_HASH_COMBINE( seed, imageViewSlicedCreateInfoEXT.sliceCount ); 6099 return seed; 6100 } 6101 }; 6102 6103 template <> 6104 struct hash<VULKAN_HPP_NAMESPACE::ImageViewUsageCreateInfo> 6105 { operator ()std::hash6106 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewUsageCreateInfo const & imageViewUsageCreateInfo ) const VULKAN_HPP_NOEXCEPT 6107 { 6108 std::size_t seed = 0; 6109 VULKAN_HPP_HASH_COMBINE( seed, imageViewUsageCreateInfo.sType ); 6110 VULKAN_HPP_HASH_COMBINE( seed, imageViewUsageCreateInfo.pNext ); 6111 VULKAN_HPP_HASH_COMBINE( seed, imageViewUsageCreateInfo.usage ); 6112 return seed; 6113 } 6114 }; 6115 6116 # if defined( VK_USE_PLATFORM_ANDROID_KHR ) 6117 template <> 6118 struct hash<VULKAN_HPP_NAMESPACE::ImportAndroidHardwareBufferInfoANDROID> 6119 { 6120 std::size_t operator ()std::hash6121 operator()( VULKAN_HPP_NAMESPACE::ImportAndroidHardwareBufferInfoANDROID const & importAndroidHardwareBufferInfoANDROID ) const VULKAN_HPP_NOEXCEPT 6122 { 6123 std::size_t seed = 0; 6124 VULKAN_HPP_HASH_COMBINE( seed, importAndroidHardwareBufferInfoANDROID.sType ); 6125 VULKAN_HPP_HASH_COMBINE( seed, importAndroidHardwareBufferInfoANDROID.pNext ); 6126 VULKAN_HPP_HASH_COMBINE( seed, importAndroidHardwareBufferInfoANDROID.buffer ); 6127 return seed; 6128 } 6129 }; 6130 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ 6131 6132 template <> 6133 struct hash<VULKAN_HPP_NAMESPACE::ImportFenceFdInfoKHR> 6134 { operator ()std::hash6135 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportFenceFdInfoKHR const & importFenceFdInfoKHR ) const VULKAN_HPP_NOEXCEPT 6136 { 6137 std::size_t seed = 0; 6138 VULKAN_HPP_HASH_COMBINE( seed, importFenceFdInfoKHR.sType ); 6139 VULKAN_HPP_HASH_COMBINE( seed, importFenceFdInfoKHR.pNext ); 6140 VULKAN_HPP_HASH_COMBINE( seed, importFenceFdInfoKHR.fence ); 6141 VULKAN_HPP_HASH_COMBINE( seed, importFenceFdInfoKHR.flags ); 6142 VULKAN_HPP_HASH_COMBINE( seed, importFenceFdInfoKHR.handleType ); 6143 VULKAN_HPP_HASH_COMBINE( seed, importFenceFdInfoKHR.fd ); 6144 return seed; 6145 } 6146 }; 6147 6148 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 6149 template <> 6150 struct hash<VULKAN_HPP_NAMESPACE::ImportFenceWin32HandleInfoKHR> 6151 { operator ()std::hash6152 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportFenceWin32HandleInfoKHR const & importFenceWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT 6153 { 6154 std::size_t seed = 0; 6155 VULKAN_HPP_HASH_COMBINE( seed, importFenceWin32HandleInfoKHR.sType ); 6156 VULKAN_HPP_HASH_COMBINE( seed, importFenceWin32HandleInfoKHR.pNext ); 6157 VULKAN_HPP_HASH_COMBINE( seed, importFenceWin32HandleInfoKHR.fence ); 6158 VULKAN_HPP_HASH_COMBINE( seed, importFenceWin32HandleInfoKHR.flags ); 6159 VULKAN_HPP_HASH_COMBINE( seed, importFenceWin32HandleInfoKHR.handleType ); 6160 VULKAN_HPP_HASH_COMBINE( seed, importFenceWin32HandleInfoKHR.handle ); 6161 VULKAN_HPP_HASH_COMBINE( seed, importFenceWin32HandleInfoKHR.name ); 6162 return seed; 6163 } 6164 }; 6165 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 6166 6167 # if defined( VK_USE_PLATFORM_FUCHSIA ) 6168 template <> 6169 struct hash<VULKAN_HPP_NAMESPACE::ImportMemoryBufferCollectionFUCHSIA> 6170 { operator ()std::hash6171 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMemoryBufferCollectionFUCHSIA const & importMemoryBufferCollectionFUCHSIA ) const VULKAN_HPP_NOEXCEPT 6172 { 6173 std::size_t seed = 0; 6174 VULKAN_HPP_HASH_COMBINE( seed, importMemoryBufferCollectionFUCHSIA.sType ); 6175 VULKAN_HPP_HASH_COMBINE( seed, importMemoryBufferCollectionFUCHSIA.pNext ); 6176 VULKAN_HPP_HASH_COMBINE( seed, importMemoryBufferCollectionFUCHSIA.collection ); 6177 VULKAN_HPP_HASH_COMBINE( seed, importMemoryBufferCollectionFUCHSIA.index ); 6178 return seed; 6179 } 6180 }; 6181 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 6182 6183 template <> 6184 struct hash<VULKAN_HPP_NAMESPACE::ImportMemoryFdInfoKHR> 6185 { operator ()std::hash6186 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMemoryFdInfoKHR const & importMemoryFdInfoKHR ) const VULKAN_HPP_NOEXCEPT 6187 { 6188 std::size_t seed = 0; 6189 VULKAN_HPP_HASH_COMBINE( seed, importMemoryFdInfoKHR.sType ); 6190 VULKAN_HPP_HASH_COMBINE( seed, importMemoryFdInfoKHR.pNext ); 6191 VULKAN_HPP_HASH_COMBINE( seed, importMemoryFdInfoKHR.handleType ); 6192 VULKAN_HPP_HASH_COMBINE( seed, importMemoryFdInfoKHR.fd ); 6193 return seed; 6194 } 6195 }; 6196 6197 template <> 6198 struct hash<VULKAN_HPP_NAMESPACE::ImportMemoryHostPointerInfoEXT> 6199 { operator ()std::hash6200 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMemoryHostPointerInfoEXT const & importMemoryHostPointerInfoEXT ) const VULKAN_HPP_NOEXCEPT 6201 { 6202 std::size_t seed = 0; 6203 VULKAN_HPP_HASH_COMBINE( seed, importMemoryHostPointerInfoEXT.sType ); 6204 VULKAN_HPP_HASH_COMBINE( seed, importMemoryHostPointerInfoEXT.pNext ); 6205 VULKAN_HPP_HASH_COMBINE( seed, importMemoryHostPointerInfoEXT.handleType ); 6206 VULKAN_HPP_HASH_COMBINE( seed, importMemoryHostPointerInfoEXT.pHostPointer ); 6207 return seed; 6208 } 6209 }; 6210 6211 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 6212 template <> 6213 struct hash<VULKAN_HPP_NAMESPACE::ImportMemoryWin32HandleInfoKHR> 6214 { operator ()std::hash6215 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMemoryWin32HandleInfoKHR const & importMemoryWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT 6216 { 6217 std::size_t seed = 0; 6218 VULKAN_HPP_HASH_COMBINE( seed, importMemoryWin32HandleInfoKHR.sType ); 6219 VULKAN_HPP_HASH_COMBINE( seed, importMemoryWin32HandleInfoKHR.pNext ); 6220 VULKAN_HPP_HASH_COMBINE( seed, importMemoryWin32HandleInfoKHR.handleType ); 6221 VULKAN_HPP_HASH_COMBINE( seed, importMemoryWin32HandleInfoKHR.handle ); 6222 VULKAN_HPP_HASH_COMBINE( seed, importMemoryWin32HandleInfoKHR.name ); 6223 return seed; 6224 } 6225 }; 6226 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 6227 6228 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 6229 template <> 6230 struct hash<VULKAN_HPP_NAMESPACE::ImportMemoryWin32HandleInfoNV> 6231 { operator ()std::hash6232 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMemoryWin32HandleInfoNV const & importMemoryWin32HandleInfoNV ) const VULKAN_HPP_NOEXCEPT 6233 { 6234 std::size_t seed = 0; 6235 VULKAN_HPP_HASH_COMBINE( seed, importMemoryWin32HandleInfoNV.sType ); 6236 VULKAN_HPP_HASH_COMBINE( seed, importMemoryWin32HandleInfoNV.pNext ); 6237 VULKAN_HPP_HASH_COMBINE( seed, importMemoryWin32HandleInfoNV.handleType ); 6238 VULKAN_HPP_HASH_COMBINE( seed, importMemoryWin32HandleInfoNV.handle ); 6239 return seed; 6240 } 6241 }; 6242 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 6243 6244 # if defined( VK_USE_PLATFORM_FUCHSIA ) 6245 template <> 6246 struct hash<VULKAN_HPP_NAMESPACE::ImportMemoryZirconHandleInfoFUCHSIA> 6247 { operator ()std::hash6248 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMemoryZirconHandleInfoFUCHSIA const & importMemoryZirconHandleInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT 6249 { 6250 std::size_t seed = 0; 6251 VULKAN_HPP_HASH_COMBINE( seed, importMemoryZirconHandleInfoFUCHSIA.sType ); 6252 VULKAN_HPP_HASH_COMBINE( seed, importMemoryZirconHandleInfoFUCHSIA.pNext ); 6253 VULKAN_HPP_HASH_COMBINE( seed, importMemoryZirconHandleInfoFUCHSIA.handleType ); 6254 VULKAN_HPP_HASH_COMBINE( seed, importMemoryZirconHandleInfoFUCHSIA.handle ); 6255 return seed; 6256 } 6257 }; 6258 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 6259 6260 # if defined( VK_USE_PLATFORM_METAL_EXT ) 6261 template <> 6262 struct hash<VULKAN_HPP_NAMESPACE::ImportMetalBufferInfoEXT> 6263 { operator ()std::hash6264 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMetalBufferInfoEXT const & importMetalBufferInfoEXT ) const VULKAN_HPP_NOEXCEPT 6265 { 6266 std::size_t seed = 0; 6267 VULKAN_HPP_HASH_COMBINE( seed, importMetalBufferInfoEXT.sType ); 6268 VULKAN_HPP_HASH_COMBINE( seed, importMetalBufferInfoEXT.pNext ); 6269 VULKAN_HPP_HASH_COMBINE( seed, importMetalBufferInfoEXT.mtlBuffer ); 6270 return seed; 6271 } 6272 }; 6273 # endif /*VK_USE_PLATFORM_METAL_EXT*/ 6274 6275 # if defined( VK_USE_PLATFORM_METAL_EXT ) 6276 template <> 6277 struct hash<VULKAN_HPP_NAMESPACE::ImportMetalIOSurfaceInfoEXT> 6278 { operator ()std::hash6279 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMetalIOSurfaceInfoEXT const & importMetalIOSurfaceInfoEXT ) const VULKAN_HPP_NOEXCEPT 6280 { 6281 std::size_t seed = 0; 6282 VULKAN_HPP_HASH_COMBINE( seed, importMetalIOSurfaceInfoEXT.sType ); 6283 VULKAN_HPP_HASH_COMBINE( seed, importMetalIOSurfaceInfoEXT.pNext ); 6284 VULKAN_HPP_HASH_COMBINE( seed, importMetalIOSurfaceInfoEXT.ioSurface ); 6285 return seed; 6286 } 6287 }; 6288 # endif /*VK_USE_PLATFORM_METAL_EXT*/ 6289 6290 # if defined( VK_USE_PLATFORM_METAL_EXT ) 6291 template <> 6292 struct hash<VULKAN_HPP_NAMESPACE::ImportMetalSharedEventInfoEXT> 6293 { operator ()std::hash6294 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMetalSharedEventInfoEXT const & importMetalSharedEventInfoEXT ) const VULKAN_HPP_NOEXCEPT 6295 { 6296 std::size_t seed = 0; 6297 VULKAN_HPP_HASH_COMBINE( seed, importMetalSharedEventInfoEXT.sType ); 6298 VULKAN_HPP_HASH_COMBINE( seed, importMetalSharedEventInfoEXT.pNext ); 6299 VULKAN_HPP_HASH_COMBINE( seed, importMetalSharedEventInfoEXT.mtlSharedEvent ); 6300 return seed; 6301 } 6302 }; 6303 # endif /*VK_USE_PLATFORM_METAL_EXT*/ 6304 6305 # if defined( VK_USE_PLATFORM_METAL_EXT ) 6306 template <> 6307 struct hash<VULKAN_HPP_NAMESPACE::ImportMetalTextureInfoEXT> 6308 { operator ()std::hash6309 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMetalTextureInfoEXT const & importMetalTextureInfoEXT ) const VULKAN_HPP_NOEXCEPT 6310 { 6311 std::size_t seed = 0; 6312 VULKAN_HPP_HASH_COMBINE( seed, importMetalTextureInfoEXT.sType ); 6313 VULKAN_HPP_HASH_COMBINE( seed, importMetalTextureInfoEXT.pNext ); 6314 VULKAN_HPP_HASH_COMBINE( seed, importMetalTextureInfoEXT.plane ); 6315 VULKAN_HPP_HASH_COMBINE( seed, importMetalTextureInfoEXT.mtlTexture ); 6316 return seed; 6317 } 6318 }; 6319 # endif /*VK_USE_PLATFORM_METAL_EXT*/ 6320 6321 # if defined( VK_USE_PLATFORM_SCREEN_QNX ) 6322 template <> 6323 struct hash<VULKAN_HPP_NAMESPACE::ImportScreenBufferInfoQNX> 6324 { operator ()std::hash6325 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportScreenBufferInfoQNX const & importScreenBufferInfoQNX ) const VULKAN_HPP_NOEXCEPT 6326 { 6327 std::size_t seed = 0; 6328 VULKAN_HPP_HASH_COMBINE( seed, importScreenBufferInfoQNX.sType ); 6329 VULKAN_HPP_HASH_COMBINE( seed, importScreenBufferInfoQNX.pNext ); 6330 VULKAN_HPP_HASH_COMBINE( seed, importScreenBufferInfoQNX.buffer ); 6331 return seed; 6332 } 6333 }; 6334 # endif /*VK_USE_PLATFORM_SCREEN_QNX*/ 6335 6336 template <> 6337 struct hash<VULKAN_HPP_NAMESPACE::ImportSemaphoreFdInfoKHR> 6338 { operator ()std::hash6339 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportSemaphoreFdInfoKHR const & importSemaphoreFdInfoKHR ) const VULKAN_HPP_NOEXCEPT 6340 { 6341 std::size_t seed = 0; 6342 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreFdInfoKHR.sType ); 6343 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreFdInfoKHR.pNext ); 6344 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreFdInfoKHR.semaphore ); 6345 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreFdInfoKHR.flags ); 6346 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreFdInfoKHR.handleType ); 6347 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreFdInfoKHR.fd ); 6348 return seed; 6349 } 6350 }; 6351 6352 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 6353 template <> 6354 struct hash<VULKAN_HPP_NAMESPACE::ImportSemaphoreWin32HandleInfoKHR> 6355 { operator ()std::hash6356 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportSemaphoreWin32HandleInfoKHR const & importSemaphoreWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT 6357 { 6358 std::size_t seed = 0; 6359 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreWin32HandleInfoKHR.sType ); 6360 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreWin32HandleInfoKHR.pNext ); 6361 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreWin32HandleInfoKHR.semaphore ); 6362 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreWin32HandleInfoKHR.flags ); 6363 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreWin32HandleInfoKHR.handleType ); 6364 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreWin32HandleInfoKHR.handle ); 6365 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreWin32HandleInfoKHR.name ); 6366 return seed; 6367 } 6368 }; 6369 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 6370 6371 # if defined( VK_USE_PLATFORM_FUCHSIA ) 6372 template <> 6373 struct hash<VULKAN_HPP_NAMESPACE::ImportSemaphoreZirconHandleInfoFUCHSIA> 6374 { 6375 std::size_t operator ()std::hash6376 operator()( VULKAN_HPP_NAMESPACE::ImportSemaphoreZirconHandleInfoFUCHSIA const & importSemaphoreZirconHandleInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT 6377 { 6378 std::size_t seed = 0; 6379 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreZirconHandleInfoFUCHSIA.sType ); 6380 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreZirconHandleInfoFUCHSIA.pNext ); 6381 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreZirconHandleInfoFUCHSIA.semaphore ); 6382 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreZirconHandleInfoFUCHSIA.flags ); 6383 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreZirconHandleInfoFUCHSIA.handleType ); 6384 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreZirconHandleInfoFUCHSIA.zirconHandle ); 6385 return seed; 6386 } 6387 }; 6388 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 6389 6390 template <> 6391 struct hash<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutTokenNV> 6392 { operator ()std::hash6393 std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutTokenNV const & indirectCommandsLayoutTokenNV ) const VULKAN_HPP_NOEXCEPT 6394 { 6395 std::size_t seed = 0; 6396 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.sType ); 6397 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.pNext ); 6398 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.tokenType ); 6399 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.stream ); 6400 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.offset ); 6401 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.vertexBindingUnit ); 6402 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.vertexDynamicStride ); 6403 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.pushconstantPipelineLayout ); 6404 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.pushconstantShaderStageFlags ); 6405 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.pushconstantOffset ); 6406 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.pushconstantSize ); 6407 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.indirectStateFlags ); 6408 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.indexTypeCount ); 6409 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.pIndexTypes ); 6410 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.pIndexTypeValues ); 6411 return seed; 6412 } 6413 }; 6414 6415 template <> 6416 struct hash<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV> 6417 { operator ()std::hash6418 std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV const & indirectCommandsLayoutCreateInfoNV ) const VULKAN_HPP_NOEXCEPT 6419 { 6420 std::size_t seed = 0; 6421 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoNV.sType ); 6422 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoNV.pNext ); 6423 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoNV.flags ); 6424 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoNV.pipelineBindPoint ); 6425 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoNV.tokenCount ); 6426 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoNV.pTokens ); 6427 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoNV.streamCount ); 6428 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoNV.pStreamStrides ); 6429 return seed; 6430 } 6431 }; 6432 6433 template <> 6434 struct hash<VULKAN_HPP_NAMESPACE::InitializePerformanceApiInfoINTEL> 6435 { operator ()std::hash6436 std::size_t operator()( VULKAN_HPP_NAMESPACE::InitializePerformanceApiInfoINTEL const & initializePerformanceApiInfoINTEL ) const VULKAN_HPP_NOEXCEPT 6437 { 6438 std::size_t seed = 0; 6439 VULKAN_HPP_HASH_COMBINE( seed, initializePerformanceApiInfoINTEL.sType ); 6440 VULKAN_HPP_HASH_COMBINE( seed, initializePerformanceApiInfoINTEL.pNext ); 6441 VULKAN_HPP_HASH_COMBINE( seed, initializePerformanceApiInfoINTEL.pUserData ); 6442 return seed; 6443 } 6444 }; 6445 6446 template <> 6447 struct hash<VULKAN_HPP_NAMESPACE::InputAttachmentAspectReference> 6448 { operator ()std::hash6449 std::size_t operator()( VULKAN_HPP_NAMESPACE::InputAttachmentAspectReference const & inputAttachmentAspectReference ) const VULKAN_HPP_NOEXCEPT 6450 { 6451 std::size_t seed = 0; 6452 VULKAN_HPP_HASH_COMBINE( seed, inputAttachmentAspectReference.subpass ); 6453 VULKAN_HPP_HASH_COMBINE( seed, inputAttachmentAspectReference.inputAttachmentIndex ); 6454 VULKAN_HPP_HASH_COMBINE( seed, inputAttachmentAspectReference.aspectMask ); 6455 return seed; 6456 } 6457 }; 6458 6459 template <> 6460 struct hash<VULKAN_HPP_NAMESPACE::InstanceCreateInfo> 6461 { operator ()std::hash6462 std::size_t operator()( VULKAN_HPP_NAMESPACE::InstanceCreateInfo const & instanceCreateInfo ) const VULKAN_HPP_NOEXCEPT 6463 { 6464 std::size_t seed = 0; 6465 VULKAN_HPP_HASH_COMBINE( seed, instanceCreateInfo.sType ); 6466 VULKAN_HPP_HASH_COMBINE( seed, instanceCreateInfo.pNext ); 6467 VULKAN_HPP_HASH_COMBINE( seed, instanceCreateInfo.flags ); 6468 VULKAN_HPP_HASH_COMBINE( seed, instanceCreateInfo.pApplicationInfo ); 6469 VULKAN_HPP_HASH_COMBINE( seed, instanceCreateInfo.enabledLayerCount ); 6470 for ( size_t i = 0; i < instanceCreateInfo.enabledLayerCount; ++i ) 6471 { 6472 for ( const char * p = instanceCreateInfo.ppEnabledLayerNames[i]; *p != '\0'; ++p ) 6473 { 6474 VULKAN_HPP_HASH_COMBINE( seed, *p ); 6475 } 6476 } 6477 VULKAN_HPP_HASH_COMBINE( seed, instanceCreateInfo.enabledExtensionCount ); 6478 for ( size_t i = 0; i < instanceCreateInfo.enabledExtensionCount; ++i ) 6479 { 6480 for ( const char * p = instanceCreateInfo.ppEnabledExtensionNames[i]; *p != '\0'; ++p ) 6481 { 6482 VULKAN_HPP_HASH_COMBINE( seed, *p ); 6483 } 6484 } 6485 return seed; 6486 } 6487 }; 6488 6489 template <> 6490 struct hash<VULKAN_HPP_NAMESPACE::LatencySleepInfoNV> 6491 { operator ()std::hash6492 std::size_t operator()( VULKAN_HPP_NAMESPACE::LatencySleepInfoNV const & latencySleepInfoNV ) const VULKAN_HPP_NOEXCEPT 6493 { 6494 std::size_t seed = 0; 6495 VULKAN_HPP_HASH_COMBINE( seed, latencySleepInfoNV.sType ); 6496 VULKAN_HPP_HASH_COMBINE( seed, latencySleepInfoNV.pNext ); 6497 VULKAN_HPP_HASH_COMBINE( seed, latencySleepInfoNV.signalSemaphore ); 6498 VULKAN_HPP_HASH_COMBINE( seed, latencySleepInfoNV.value ); 6499 return seed; 6500 } 6501 }; 6502 6503 template <> 6504 struct hash<VULKAN_HPP_NAMESPACE::LatencySleepModeInfoNV> 6505 { operator ()std::hash6506 std::size_t operator()( VULKAN_HPP_NAMESPACE::LatencySleepModeInfoNV const & latencySleepModeInfoNV ) const VULKAN_HPP_NOEXCEPT 6507 { 6508 std::size_t seed = 0; 6509 VULKAN_HPP_HASH_COMBINE( seed, latencySleepModeInfoNV.sType ); 6510 VULKAN_HPP_HASH_COMBINE( seed, latencySleepModeInfoNV.pNext ); 6511 VULKAN_HPP_HASH_COMBINE( seed, latencySleepModeInfoNV.lowLatencyMode ); 6512 VULKAN_HPP_HASH_COMBINE( seed, latencySleepModeInfoNV.lowLatencyBoost ); 6513 VULKAN_HPP_HASH_COMBINE( seed, latencySleepModeInfoNV.minimumIntervalUs ); 6514 return seed; 6515 } 6516 }; 6517 6518 template <> 6519 struct hash<VULKAN_HPP_NAMESPACE::LatencySubmissionPresentIdNV> 6520 { operator ()std::hash6521 std::size_t operator()( VULKAN_HPP_NAMESPACE::LatencySubmissionPresentIdNV const & latencySubmissionPresentIdNV ) const VULKAN_HPP_NOEXCEPT 6522 { 6523 std::size_t seed = 0; 6524 VULKAN_HPP_HASH_COMBINE( seed, latencySubmissionPresentIdNV.sType ); 6525 VULKAN_HPP_HASH_COMBINE( seed, latencySubmissionPresentIdNV.pNext ); 6526 VULKAN_HPP_HASH_COMBINE( seed, latencySubmissionPresentIdNV.presentID ); 6527 return seed; 6528 } 6529 }; 6530 6531 template <> 6532 struct hash<VULKAN_HPP_NAMESPACE::LatencySurfaceCapabilitiesNV> 6533 { operator ()std::hash6534 std::size_t operator()( VULKAN_HPP_NAMESPACE::LatencySurfaceCapabilitiesNV const & latencySurfaceCapabilitiesNV ) const VULKAN_HPP_NOEXCEPT 6535 { 6536 std::size_t seed = 0; 6537 VULKAN_HPP_HASH_COMBINE( seed, latencySurfaceCapabilitiesNV.sType ); 6538 VULKAN_HPP_HASH_COMBINE( seed, latencySurfaceCapabilitiesNV.pNext ); 6539 VULKAN_HPP_HASH_COMBINE( seed, latencySurfaceCapabilitiesNV.presentModeCount ); 6540 VULKAN_HPP_HASH_COMBINE( seed, latencySurfaceCapabilitiesNV.pPresentModes ); 6541 return seed; 6542 } 6543 }; 6544 6545 template <> 6546 struct hash<VULKAN_HPP_NAMESPACE::LayerProperties> 6547 { operator ()std::hash6548 std::size_t operator()( VULKAN_HPP_NAMESPACE::LayerProperties const & layerProperties ) const VULKAN_HPP_NOEXCEPT 6549 { 6550 std::size_t seed = 0; 6551 for ( size_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i ) 6552 { 6553 VULKAN_HPP_HASH_COMBINE( seed, layerProperties.layerName[i] ); 6554 } 6555 VULKAN_HPP_HASH_COMBINE( seed, layerProperties.specVersion ); 6556 VULKAN_HPP_HASH_COMBINE( seed, layerProperties.implementationVersion ); 6557 for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) 6558 { 6559 VULKAN_HPP_HASH_COMBINE( seed, layerProperties.description[i] ); 6560 } 6561 return seed; 6562 } 6563 }; 6564 6565 template <> 6566 struct hash<VULKAN_HPP_NAMESPACE::LayerSettingEXT> 6567 { operator ()std::hash6568 std::size_t operator()( VULKAN_HPP_NAMESPACE::LayerSettingEXT const & layerSettingEXT ) const VULKAN_HPP_NOEXCEPT 6569 { 6570 std::size_t seed = 0; 6571 for ( const char * p = layerSettingEXT.pLayerName; *p != '\0'; ++p ) 6572 { 6573 VULKAN_HPP_HASH_COMBINE( seed, *p ); 6574 } 6575 for ( const char * p = layerSettingEXT.pSettingName; *p != '\0'; ++p ) 6576 { 6577 VULKAN_HPP_HASH_COMBINE( seed, *p ); 6578 } 6579 VULKAN_HPP_HASH_COMBINE( seed, layerSettingEXT.type ); 6580 VULKAN_HPP_HASH_COMBINE( seed, layerSettingEXT.valueCount ); 6581 VULKAN_HPP_HASH_COMBINE( seed, layerSettingEXT.pValues ); 6582 return seed; 6583 } 6584 }; 6585 6586 template <> 6587 struct hash<VULKAN_HPP_NAMESPACE::LayerSettingsCreateInfoEXT> 6588 { operator ()std::hash6589 std::size_t operator()( VULKAN_HPP_NAMESPACE::LayerSettingsCreateInfoEXT const & layerSettingsCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 6590 { 6591 std::size_t seed = 0; 6592 VULKAN_HPP_HASH_COMBINE( seed, layerSettingsCreateInfoEXT.sType ); 6593 VULKAN_HPP_HASH_COMBINE( seed, layerSettingsCreateInfoEXT.pNext ); 6594 VULKAN_HPP_HASH_COMBINE( seed, layerSettingsCreateInfoEXT.settingCount ); 6595 VULKAN_HPP_HASH_COMBINE( seed, layerSettingsCreateInfoEXT.pSettings ); 6596 return seed; 6597 } 6598 }; 6599 6600 # if defined( VK_USE_PLATFORM_MACOS_MVK ) 6601 template <> 6602 struct hash<VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK> 6603 { operator ()std::hash6604 std::size_t operator()( VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK const & macOSSurfaceCreateInfoMVK ) const VULKAN_HPP_NOEXCEPT 6605 { 6606 std::size_t seed = 0; 6607 VULKAN_HPP_HASH_COMBINE( seed, macOSSurfaceCreateInfoMVK.sType ); 6608 VULKAN_HPP_HASH_COMBINE( seed, macOSSurfaceCreateInfoMVK.pNext ); 6609 VULKAN_HPP_HASH_COMBINE( seed, macOSSurfaceCreateInfoMVK.flags ); 6610 VULKAN_HPP_HASH_COMBINE( seed, macOSSurfaceCreateInfoMVK.pView ); 6611 return seed; 6612 } 6613 }; 6614 # endif /*VK_USE_PLATFORM_MACOS_MVK*/ 6615 6616 template <> 6617 struct hash<VULKAN_HPP_NAMESPACE::MappedMemoryRange> 6618 { operator ()std::hash6619 std::size_t operator()( VULKAN_HPP_NAMESPACE::MappedMemoryRange const & mappedMemoryRange ) const VULKAN_HPP_NOEXCEPT 6620 { 6621 std::size_t seed = 0; 6622 VULKAN_HPP_HASH_COMBINE( seed, mappedMemoryRange.sType ); 6623 VULKAN_HPP_HASH_COMBINE( seed, mappedMemoryRange.pNext ); 6624 VULKAN_HPP_HASH_COMBINE( seed, mappedMemoryRange.memory ); 6625 VULKAN_HPP_HASH_COMBINE( seed, mappedMemoryRange.offset ); 6626 VULKAN_HPP_HASH_COMBINE( seed, mappedMemoryRange.size ); 6627 return seed; 6628 } 6629 }; 6630 6631 template <> 6632 struct hash<VULKAN_HPP_NAMESPACE::MemoryAllocateFlagsInfo> 6633 { operator ()std::hash6634 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryAllocateFlagsInfo const & memoryAllocateFlagsInfo ) const VULKAN_HPP_NOEXCEPT 6635 { 6636 std::size_t seed = 0; 6637 VULKAN_HPP_HASH_COMBINE( seed, memoryAllocateFlagsInfo.sType ); 6638 VULKAN_HPP_HASH_COMBINE( seed, memoryAllocateFlagsInfo.pNext ); 6639 VULKAN_HPP_HASH_COMBINE( seed, memoryAllocateFlagsInfo.flags ); 6640 VULKAN_HPP_HASH_COMBINE( seed, memoryAllocateFlagsInfo.deviceMask ); 6641 return seed; 6642 } 6643 }; 6644 6645 template <> 6646 struct hash<VULKAN_HPP_NAMESPACE::MemoryAllocateInfo> 6647 { operator ()std::hash6648 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryAllocateInfo const & memoryAllocateInfo ) const VULKAN_HPP_NOEXCEPT 6649 { 6650 std::size_t seed = 0; 6651 VULKAN_HPP_HASH_COMBINE( seed, memoryAllocateInfo.sType ); 6652 VULKAN_HPP_HASH_COMBINE( seed, memoryAllocateInfo.pNext ); 6653 VULKAN_HPP_HASH_COMBINE( seed, memoryAllocateInfo.allocationSize ); 6654 VULKAN_HPP_HASH_COMBINE( seed, memoryAllocateInfo.memoryTypeIndex ); 6655 return seed; 6656 } 6657 }; 6658 6659 template <> 6660 struct hash<VULKAN_HPP_NAMESPACE::MemoryBarrier> 6661 { operator ()std::hash6662 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryBarrier const & memoryBarrier ) const VULKAN_HPP_NOEXCEPT 6663 { 6664 std::size_t seed = 0; 6665 VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier.sType ); 6666 VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier.pNext ); 6667 VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier.srcAccessMask ); 6668 VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier.dstAccessMask ); 6669 return seed; 6670 } 6671 }; 6672 6673 template <> 6674 struct hash<VULKAN_HPP_NAMESPACE::MemoryDedicatedAllocateInfo> 6675 { operator ()std::hash6676 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryDedicatedAllocateInfo const & memoryDedicatedAllocateInfo ) const VULKAN_HPP_NOEXCEPT 6677 { 6678 std::size_t seed = 0; 6679 VULKAN_HPP_HASH_COMBINE( seed, memoryDedicatedAllocateInfo.sType ); 6680 VULKAN_HPP_HASH_COMBINE( seed, memoryDedicatedAllocateInfo.pNext ); 6681 VULKAN_HPP_HASH_COMBINE( seed, memoryDedicatedAllocateInfo.image ); 6682 VULKAN_HPP_HASH_COMBINE( seed, memoryDedicatedAllocateInfo.buffer ); 6683 return seed; 6684 } 6685 }; 6686 6687 template <> 6688 struct hash<VULKAN_HPP_NAMESPACE::MemoryDedicatedRequirements> 6689 { operator ()std::hash6690 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryDedicatedRequirements const & memoryDedicatedRequirements ) const VULKAN_HPP_NOEXCEPT 6691 { 6692 std::size_t seed = 0; 6693 VULKAN_HPP_HASH_COMBINE( seed, memoryDedicatedRequirements.sType ); 6694 VULKAN_HPP_HASH_COMBINE( seed, memoryDedicatedRequirements.pNext ); 6695 VULKAN_HPP_HASH_COMBINE( seed, memoryDedicatedRequirements.prefersDedicatedAllocation ); 6696 VULKAN_HPP_HASH_COMBINE( seed, memoryDedicatedRequirements.requiresDedicatedAllocation ); 6697 return seed; 6698 } 6699 }; 6700 6701 template <> 6702 struct hash<VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR> 6703 { operator ()std::hash6704 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR const & memoryFdPropertiesKHR ) const VULKAN_HPP_NOEXCEPT 6705 { 6706 std::size_t seed = 0; 6707 VULKAN_HPP_HASH_COMBINE( seed, memoryFdPropertiesKHR.sType ); 6708 VULKAN_HPP_HASH_COMBINE( seed, memoryFdPropertiesKHR.pNext ); 6709 VULKAN_HPP_HASH_COMBINE( seed, memoryFdPropertiesKHR.memoryTypeBits ); 6710 return seed; 6711 } 6712 }; 6713 6714 # if defined( VK_USE_PLATFORM_ANDROID_KHR ) 6715 template <> 6716 struct hash<VULKAN_HPP_NAMESPACE::MemoryGetAndroidHardwareBufferInfoANDROID> 6717 { 6718 std::size_t operator ()std::hash6719 operator()( VULKAN_HPP_NAMESPACE::MemoryGetAndroidHardwareBufferInfoANDROID const & memoryGetAndroidHardwareBufferInfoANDROID ) const VULKAN_HPP_NOEXCEPT 6720 { 6721 std::size_t seed = 0; 6722 VULKAN_HPP_HASH_COMBINE( seed, memoryGetAndroidHardwareBufferInfoANDROID.sType ); 6723 VULKAN_HPP_HASH_COMBINE( seed, memoryGetAndroidHardwareBufferInfoANDROID.pNext ); 6724 VULKAN_HPP_HASH_COMBINE( seed, memoryGetAndroidHardwareBufferInfoANDROID.memory ); 6725 return seed; 6726 } 6727 }; 6728 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ 6729 6730 template <> 6731 struct hash<VULKAN_HPP_NAMESPACE::MemoryGetFdInfoKHR> 6732 { operator ()std::hash6733 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryGetFdInfoKHR const & memoryGetFdInfoKHR ) const VULKAN_HPP_NOEXCEPT 6734 { 6735 std::size_t seed = 0; 6736 VULKAN_HPP_HASH_COMBINE( seed, memoryGetFdInfoKHR.sType ); 6737 VULKAN_HPP_HASH_COMBINE( seed, memoryGetFdInfoKHR.pNext ); 6738 VULKAN_HPP_HASH_COMBINE( seed, memoryGetFdInfoKHR.memory ); 6739 VULKAN_HPP_HASH_COMBINE( seed, memoryGetFdInfoKHR.handleType ); 6740 return seed; 6741 } 6742 }; 6743 6744 template <> 6745 struct hash<VULKAN_HPP_NAMESPACE::MemoryGetRemoteAddressInfoNV> 6746 { operator ()std::hash6747 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryGetRemoteAddressInfoNV const & memoryGetRemoteAddressInfoNV ) const VULKAN_HPP_NOEXCEPT 6748 { 6749 std::size_t seed = 0; 6750 VULKAN_HPP_HASH_COMBINE( seed, memoryGetRemoteAddressInfoNV.sType ); 6751 VULKAN_HPP_HASH_COMBINE( seed, memoryGetRemoteAddressInfoNV.pNext ); 6752 VULKAN_HPP_HASH_COMBINE( seed, memoryGetRemoteAddressInfoNV.memory ); 6753 VULKAN_HPP_HASH_COMBINE( seed, memoryGetRemoteAddressInfoNV.handleType ); 6754 return seed; 6755 } 6756 }; 6757 6758 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 6759 template <> 6760 struct hash<VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR> 6761 { operator ()std::hash6762 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR const & memoryGetWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT 6763 { 6764 std::size_t seed = 0; 6765 VULKAN_HPP_HASH_COMBINE( seed, memoryGetWin32HandleInfoKHR.sType ); 6766 VULKAN_HPP_HASH_COMBINE( seed, memoryGetWin32HandleInfoKHR.pNext ); 6767 VULKAN_HPP_HASH_COMBINE( seed, memoryGetWin32HandleInfoKHR.memory ); 6768 VULKAN_HPP_HASH_COMBINE( seed, memoryGetWin32HandleInfoKHR.handleType ); 6769 return seed; 6770 } 6771 }; 6772 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 6773 6774 # if defined( VK_USE_PLATFORM_FUCHSIA ) 6775 template <> 6776 struct hash<VULKAN_HPP_NAMESPACE::MemoryGetZirconHandleInfoFUCHSIA> 6777 { operator ()std::hash6778 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryGetZirconHandleInfoFUCHSIA const & memoryGetZirconHandleInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT 6779 { 6780 std::size_t seed = 0; 6781 VULKAN_HPP_HASH_COMBINE( seed, memoryGetZirconHandleInfoFUCHSIA.sType ); 6782 VULKAN_HPP_HASH_COMBINE( seed, memoryGetZirconHandleInfoFUCHSIA.pNext ); 6783 VULKAN_HPP_HASH_COMBINE( seed, memoryGetZirconHandleInfoFUCHSIA.memory ); 6784 VULKAN_HPP_HASH_COMBINE( seed, memoryGetZirconHandleInfoFUCHSIA.handleType ); 6785 return seed; 6786 } 6787 }; 6788 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 6789 6790 template <> 6791 struct hash<VULKAN_HPP_NAMESPACE::MemoryHeap> 6792 { operator ()std::hash6793 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryHeap const & memoryHeap ) const VULKAN_HPP_NOEXCEPT 6794 { 6795 std::size_t seed = 0; 6796 VULKAN_HPP_HASH_COMBINE( seed, memoryHeap.size ); 6797 VULKAN_HPP_HASH_COMBINE( seed, memoryHeap.flags ); 6798 return seed; 6799 } 6800 }; 6801 6802 template <> 6803 struct hash<VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT> 6804 { operator ()std::hash6805 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT const & memoryHostPointerPropertiesEXT ) const VULKAN_HPP_NOEXCEPT 6806 { 6807 std::size_t seed = 0; 6808 VULKAN_HPP_HASH_COMBINE( seed, memoryHostPointerPropertiesEXT.sType ); 6809 VULKAN_HPP_HASH_COMBINE( seed, memoryHostPointerPropertiesEXT.pNext ); 6810 VULKAN_HPP_HASH_COMBINE( seed, memoryHostPointerPropertiesEXT.memoryTypeBits ); 6811 return seed; 6812 } 6813 }; 6814 6815 template <> 6816 struct hash<VULKAN_HPP_NAMESPACE::MemoryMapInfoKHR> 6817 { operator ()std::hash6818 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryMapInfoKHR const & memoryMapInfoKHR ) const VULKAN_HPP_NOEXCEPT 6819 { 6820 std::size_t seed = 0; 6821 VULKAN_HPP_HASH_COMBINE( seed, memoryMapInfoKHR.sType ); 6822 VULKAN_HPP_HASH_COMBINE( seed, memoryMapInfoKHR.pNext ); 6823 VULKAN_HPP_HASH_COMBINE( seed, memoryMapInfoKHR.flags ); 6824 VULKAN_HPP_HASH_COMBINE( seed, memoryMapInfoKHR.memory ); 6825 VULKAN_HPP_HASH_COMBINE( seed, memoryMapInfoKHR.offset ); 6826 VULKAN_HPP_HASH_COMBINE( seed, memoryMapInfoKHR.size ); 6827 return seed; 6828 } 6829 }; 6830 6831 template <> 6832 struct hash<VULKAN_HPP_NAMESPACE::MemoryMapPlacedInfoEXT> 6833 { operator ()std::hash6834 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryMapPlacedInfoEXT const & memoryMapPlacedInfoEXT ) const VULKAN_HPP_NOEXCEPT 6835 { 6836 std::size_t seed = 0; 6837 VULKAN_HPP_HASH_COMBINE( seed, memoryMapPlacedInfoEXT.sType ); 6838 VULKAN_HPP_HASH_COMBINE( seed, memoryMapPlacedInfoEXT.pNext ); 6839 VULKAN_HPP_HASH_COMBINE( seed, memoryMapPlacedInfoEXT.pPlacedAddress ); 6840 return seed; 6841 } 6842 }; 6843 6844 template <> 6845 struct hash<VULKAN_HPP_NAMESPACE::MemoryOpaqueCaptureAddressAllocateInfo> 6846 { 6847 std::size_t operator ()std::hash6848 operator()( VULKAN_HPP_NAMESPACE::MemoryOpaqueCaptureAddressAllocateInfo const & memoryOpaqueCaptureAddressAllocateInfo ) const VULKAN_HPP_NOEXCEPT 6849 { 6850 std::size_t seed = 0; 6851 VULKAN_HPP_HASH_COMBINE( seed, memoryOpaqueCaptureAddressAllocateInfo.sType ); 6852 VULKAN_HPP_HASH_COMBINE( seed, memoryOpaqueCaptureAddressAllocateInfo.pNext ); 6853 VULKAN_HPP_HASH_COMBINE( seed, memoryOpaqueCaptureAddressAllocateInfo.opaqueCaptureAddress ); 6854 return seed; 6855 } 6856 }; 6857 6858 template <> 6859 struct hash<VULKAN_HPP_NAMESPACE::MemoryPriorityAllocateInfoEXT> 6860 { operator ()std::hash6861 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryPriorityAllocateInfoEXT const & memoryPriorityAllocateInfoEXT ) const VULKAN_HPP_NOEXCEPT 6862 { 6863 std::size_t seed = 0; 6864 VULKAN_HPP_HASH_COMBINE( seed, memoryPriorityAllocateInfoEXT.sType ); 6865 VULKAN_HPP_HASH_COMBINE( seed, memoryPriorityAllocateInfoEXT.pNext ); 6866 VULKAN_HPP_HASH_COMBINE( seed, memoryPriorityAllocateInfoEXT.priority ); 6867 return seed; 6868 } 6869 }; 6870 6871 template <> 6872 struct hash<VULKAN_HPP_NAMESPACE::MemoryRequirements> 6873 { operator ()std::hash6874 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryRequirements const & memoryRequirements ) const VULKAN_HPP_NOEXCEPT 6875 { 6876 std::size_t seed = 0; 6877 VULKAN_HPP_HASH_COMBINE( seed, memoryRequirements.size ); 6878 VULKAN_HPP_HASH_COMBINE( seed, memoryRequirements.alignment ); 6879 VULKAN_HPP_HASH_COMBINE( seed, memoryRequirements.memoryTypeBits ); 6880 return seed; 6881 } 6882 }; 6883 6884 template <> 6885 struct hash<VULKAN_HPP_NAMESPACE::MemoryRequirements2> 6886 { operator ()std::hash6887 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryRequirements2 const & memoryRequirements2 ) const VULKAN_HPP_NOEXCEPT 6888 { 6889 std::size_t seed = 0; 6890 VULKAN_HPP_HASH_COMBINE( seed, memoryRequirements2.sType ); 6891 VULKAN_HPP_HASH_COMBINE( seed, memoryRequirements2.pNext ); 6892 VULKAN_HPP_HASH_COMBINE( seed, memoryRequirements2.memoryRequirements ); 6893 return seed; 6894 } 6895 }; 6896 6897 template <> 6898 struct hash<VULKAN_HPP_NAMESPACE::MemoryType> 6899 { operator ()std::hash6900 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryType const & memoryType ) const VULKAN_HPP_NOEXCEPT 6901 { 6902 std::size_t seed = 0; 6903 VULKAN_HPP_HASH_COMBINE( seed, memoryType.propertyFlags ); 6904 VULKAN_HPP_HASH_COMBINE( seed, memoryType.heapIndex ); 6905 return seed; 6906 } 6907 }; 6908 6909 template <> 6910 struct hash<VULKAN_HPP_NAMESPACE::MemoryUnmapInfoKHR> 6911 { operator ()std::hash6912 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryUnmapInfoKHR const & memoryUnmapInfoKHR ) const VULKAN_HPP_NOEXCEPT 6913 { 6914 std::size_t seed = 0; 6915 VULKAN_HPP_HASH_COMBINE( seed, memoryUnmapInfoKHR.sType ); 6916 VULKAN_HPP_HASH_COMBINE( seed, memoryUnmapInfoKHR.pNext ); 6917 VULKAN_HPP_HASH_COMBINE( seed, memoryUnmapInfoKHR.flags ); 6918 VULKAN_HPP_HASH_COMBINE( seed, memoryUnmapInfoKHR.memory ); 6919 return seed; 6920 } 6921 }; 6922 6923 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 6924 template <> 6925 struct hash<VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR> 6926 { operator ()std::hash6927 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR const & memoryWin32HandlePropertiesKHR ) const VULKAN_HPP_NOEXCEPT 6928 { 6929 std::size_t seed = 0; 6930 VULKAN_HPP_HASH_COMBINE( seed, memoryWin32HandlePropertiesKHR.sType ); 6931 VULKAN_HPP_HASH_COMBINE( seed, memoryWin32HandlePropertiesKHR.pNext ); 6932 VULKAN_HPP_HASH_COMBINE( seed, memoryWin32HandlePropertiesKHR.memoryTypeBits ); 6933 return seed; 6934 } 6935 }; 6936 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 6937 6938 # if defined( VK_USE_PLATFORM_FUCHSIA ) 6939 template <> 6940 struct hash<VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA> 6941 { operator ()std::hash6942 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA const & memoryZirconHandlePropertiesFUCHSIA ) const VULKAN_HPP_NOEXCEPT 6943 { 6944 std::size_t seed = 0; 6945 VULKAN_HPP_HASH_COMBINE( seed, memoryZirconHandlePropertiesFUCHSIA.sType ); 6946 VULKAN_HPP_HASH_COMBINE( seed, memoryZirconHandlePropertiesFUCHSIA.pNext ); 6947 VULKAN_HPP_HASH_COMBINE( seed, memoryZirconHandlePropertiesFUCHSIA.memoryTypeBits ); 6948 return seed; 6949 } 6950 }; 6951 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 6952 6953 # if defined( VK_USE_PLATFORM_METAL_EXT ) 6954 template <> 6955 struct hash<VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT> 6956 { operator ()std::hash6957 std::size_t operator()( VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT const & metalSurfaceCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 6958 { 6959 std::size_t seed = 0; 6960 VULKAN_HPP_HASH_COMBINE( seed, metalSurfaceCreateInfoEXT.sType ); 6961 VULKAN_HPP_HASH_COMBINE( seed, metalSurfaceCreateInfoEXT.pNext ); 6962 VULKAN_HPP_HASH_COMBINE( seed, metalSurfaceCreateInfoEXT.flags ); 6963 VULKAN_HPP_HASH_COMBINE( seed, metalSurfaceCreateInfoEXT.pLayer ); 6964 return seed; 6965 } 6966 }; 6967 # endif /*VK_USE_PLATFORM_METAL_EXT*/ 6968 6969 template <> 6970 struct hash<VULKAN_HPP_NAMESPACE::MicromapBuildSizesInfoEXT> 6971 { operator ()std::hash6972 std::size_t operator()( VULKAN_HPP_NAMESPACE::MicromapBuildSizesInfoEXT const & micromapBuildSizesInfoEXT ) const VULKAN_HPP_NOEXCEPT 6973 { 6974 std::size_t seed = 0; 6975 VULKAN_HPP_HASH_COMBINE( seed, micromapBuildSizesInfoEXT.sType ); 6976 VULKAN_HPP_HASH_COMBINE( seed, micromapBuildSizesInfoEXT.pNext ); 6977 VULKAN_HPP_HASH_COMBINE( seed, micromapBuildSizesInfoEXT.micromapSize ); 6978 VULKAN_HPP_HASH_COMBINE( seed, micromapBuildSizesInfoEXT.buildScratchSize ); 6979 VULKAN_HPP_HASH_COMBINE( seed, micromapBuildSizesInfoEXT.discardable ); 6980 return seed; 6981 } 6982 }; 6983 6984 template <> 6985 struct hash<VULKAN_HPP_NAMESPACE::MicromapCreateInfoEXT> 6986 { operator ()std::hash6987 std::size_t operator()( VULKAN_HPP_NAMESPACE::MicromapCreateInfoEXT const & micromapCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 6988 { 6989 std::size_t seed = 0; 6990 VULKAN_HPP_HASH_COMBINE( seed, micromapCreateInfoEXT.sType ); 6991 VULKAN_HPP_HASH_COMBINE( seed, micromapCreateInfoEXT.pNext ); 6992 VULKAN_HPP_HASH_COMBINE( seed, micromapCreateInfoEXT.createFlags ); 6993 VULKAN_HPP_HASH_COMBINE( seed, micromapCreateInfoEXT.buffer ); 6994 VULKAN_HPP_HASH_COMBINE( seed, micromapCreateInfoEXT.offset ); 6995 VULKAN_HPP_HASH_COMBINE( seed, micromapCreateInfoEXT.size ); 6996 VULKAN_HPP_HASH_COMBINE( seed, micromapCreateInfoEXT.type ); 6997 VULKAN_HPP_HASH_COMBINE( seed, micromapCreateInfoEXT.deviceAddress ); 6998 return seed; 6999 } 7000 }; 7001 7002 template <> 7003 struct hash<VULKAN_HPP_NAMESPACE::MicromapTriangleEXT> 7004 { operator ()std::hash7005 std::size_t operator()( VULKAN_HPP_NAMESPACE::MicromapTriangleEXT const & micromapTriangleEXT ) const VULKAN_HPP_NOEXCEPT 7006 { 7007 std::size_t seed = 0; 7008 VULKAN_HPP_HASH_COMBINE( seed, micromapTriangleEXT.dataOffset ); 7009 VULKAN_HPP_HASH_COMBINE( seed, micromapTriangleEXT.subdivisionLevel ); 7010 VULKAN_HPP_HASH_COMBINE( seed, micromapTriangleEXT.format ); 7011 return seed; 7012 } 7013 }; 7014 7015 template <> 7016 struct hash<VULKAN_HPP_NAMESPACE::MicromapVersionInfoEXT> 7017 { operator ()std::hash7018 std::size_t operator()( VULKAN_HPP_NAMESPACE::MicromapVersionInfoEXT const & micromapVersionInfoEXT ) const VULKAN_HPP_NOEXCEPT 7019 { 7020 std::size_t seed = 0; 7021 VULKAN_HPP_HASH_COMBINE( seed, micromapVersionInfoEXT.sType ); 7022 VULKAN_HPP_HASH_COMBINE( seed, micromapVersionInfoEXT.pNext ); 7023 VULKAN_HPP_HASH_COMBINE( seed, micromapVersionInfoEXT.pVersionData ); 7024 return seed; 7025 } 7026 }; 7027 7028 template <> 7029 struct hash<VULKAN_HPP_NAMESPACE::MultiDrawIndexedInfoEXT> 7030 { operator ()std::hash7031 std::size_t operator()( VULKAN_HPP_NAMESPACE::MultiDrawIndexedInfoEXT const & multiDrawIndexedInfoEXT ) const VULKAN_HPP_NOEXCEPT 7032 { 7033 std::size_t seed = 0; 7034 VULKAN_HPP_HASH_COMBINE( seed, multiDrawIndexedInfoEXT.firstIndex ); 7035 VULKAN_HPP_HASH_COMBINE( seed, multiDrawIndexedInfoEXT.indexCount ); 7036 VULKAN_HPP_HASH_COMBINE( seed, multiDrawIndexedInfoEXT.vertexOffset ); 7037 return seed; 7038 } 7039 }; 7040 7041 template <> 7042 struct hash<VULKAN_HPP_NAMESPACE::MultiDrawInfoEXT> 7043 { operator ()std::hash7044 std::size_t operator()( VULKAN_HPP_NAMESPACE::MultiDrawInfoEXT const & multiDrawInfoEXT ) const VULKAN_HPP_NOEXCEPT 7045 { 7046 std::size_t seed = 0; 7047 VULKAN_HPP_HASH_COMBINE( seed, multiDrawInfoEXT.firstVertex ); 7048 VULKAN_HPP_HASH_COMBINE( seed, multiDrawInfoEXT.vertexCount ); 7049 return seed; 7050 } 7051 }; 7052 7053 template <> 7054 struct hash<VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT> 7055 { operator ()std::hash7056 std::size_t operator()( VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT const & multisamplePropertiesEXT ) const VULKAN_HPP_NOEXCEPT 7057 { 7058 std::size_t seed = 0; 7059 VULKAN_HPP_HASH_COMBINE( seed, multisamplePropertiesEXT.sType ); 7060 VULKAN_HPP_HASH_COMBINE( seed, multisamplePropertiesEXT.pNext ); 7061 VULKAN_HPP_HASH_COMBINE( seed, multisamplePropertiesEXT.maxSampleLocationGridSize ); 7062 return seed; 7063 } 7064 }; 7065 7066 template <> 7067 struct hash<VULKAN_HPP_NAMESPACE::MultisampledRenderToSingleSampledInfoEXT> 7068 { 7069 std::size_t operator ()std::hash7070 operator()( VULKAN_HPP_NAMESPACE::MultisampledRenderToSingleSampledInfoEXT const & multisampledRenderToSingleSampledInfoEXT ) const VULKAN_HPP_NOEXCEPT 7071 { 7072 std::size_t seed = 0; 7073 VULKAN_HPP_HASH_COMBINE( seed, multisampledRenderToSingleSampledInfoEXT.sType ); 7074 VULKAN_HPP_HASH_COMBINE( seed, multisampledRenderToSingleSampledInfoEXT.pNext ); 7075 VULKAN_HPP_HASH_COMBINE( seed, multisampledRenderToSingleSampledInfoEXT.multisampledRenderToSingleSampledEnable ); 7076 VULKAN_HPP_HASH_COMBINE( seed, multisampledRenderToSingleSampledInfoEXT.rasterizationSamples ); 7077 return seed; 7078 } 7079 }; 7080 7081 template <> 7082 struct hash<VULKAN_HPP_NAMESPACE::MultiviewPerViewAttributesInfoNVX> 7083 { operator ()std::hash7084 std::size_t operator()( VULKAN_HPP_NAMESPACE::MultiviewPerViewAttributesInfoNVX const & multiviewPerViewAttributesInfoNVX ) const VULKAN_HPP_NOEXCEPT 7085 { 7086 std::size_t seed = 0; 7087 VULKAN_HPP_HASH_COMBINE( seed, multiviewPerViewAttributesInfoNVX.sType ); 7088 VULKAN_HPP_HASH_COMBINE( seed, multiviewPerViewAttributesInfoNVX.pNext ); 7089 VULKAN_HPP_HASH_COMBINE( seed, multiviewPerViewAttributesInfoNVX.perViewAttributes ); 7090 VULKAN_HPP_HASH_COMBINE( seed, multiviewPerViewAttributesInfoNVX.perViewAttributesPositionXOnly ); 7091 return seed; 7092 } 7093 }; 7094 7095 template <> 7096 struct hash<VULKAN_HPP_NAMESPACE::MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM> 7097 { 7098 std::size_t operator ()std::hash7099 operator()( VULKAN_HPP_NAMESPACE::MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM const & multiviewPerViewRenderAreasRenderPassBeginInfoQCOM ) const 7100 VULKAN_HPP_NOEXCEPT 7101 { 7102 std::size_t seed = 0; 7103 VULKAN_HPP_HASH_COMBINE( seed, multiviewPerViewRenderAreasRenderPassBeginInfoQCOM.sType ); 7104 VULKAN_HPP_HASH_COMBINE( seed, multiviewPerViewRenderAreasRenderPassBeginInfoQCOM.pNext ); 7105 VULKAN_HPP_HASH_COMBINE( seed, multiviewPerViewRenderAreasRenderPassBeginInfoQCOM.perViewRenderAreaCount ); 7106 VULKAN_HPP_HASH_COMBINE( seed, multiviewPerViewRenderAreasRenderPassBeginInfoQCOM.pPerViewRenderAreas ); 7107 return seed; 7108 } 7109 }; 7110 7111 template <> 7112 struct hash<VULKAN_HPP_NAMESPACE::MutableDescriptorTypeListEXT> 7113 { operator ()std::hash7114 std::size_t operator()( VULKAN_HPP_NAMESPACE::MutableDescriptorTypeListEXT const & mutableDescriptorTypeListEXT ) const VULKAN_HPP_NOEXCEPT 7115 { 7116 std::size_t seed = 0; 7117 VULKAN_HPP_HASH_COMBINE( seed, mutableDescriptorTypeListEXT.descriptorTypeCount ); 7118 VULKAN_HPP_HASH_COMBINE( seed, mutableDescriptorTypeListEXT.pDescriptorTypes ); 7119 return seed; 7120 } 7121 }; 7122 7123 template <> 7124 struct hash<VULKAN_HPP_NAMESPACE::MutableDescriptorTypeCreateInfoEXT> 7125 { operator ()std::hash7126 std::size_t operator()( VULKAN_HPP_NAMESPACE::MutableDescriptorTypeCreateInfoEXT const & mutableDescriptorTypeCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 7127 { 7128 std::size_t seed = 0; 7129 VULKAN_HPP_HASH_COMBINE( seed, mutableDescriptorTypeCreateInfoEXT.sType ); 7130 VULKAN_HPP_HASH_COMBINE( seed, mutableDescriptorTypeCreateInfoEXT.pNext ); 7131 VULKAN_HPP_HASH_COMBINE( seed, mutableDescriptorTypeCreateInfoEXT.mutableDescriptorTypeListCount ); 7132 VULKAN_HPP_HASH_COMBINE( seed, mutableDescriptorTypeCreateInfoEXT.pMutableDescriptorTypeLists ); 7133 return seed; 7134 } 7135 }; 7136 7137 template <> 7138 struct hash<VULKAN_HPP_NAMESPACE::OpaqueCaptureDescriptorDataCreateInfoEXT> 7139 { 7140 std::size_t operator ()std::hash7141 operator()( VULKAN_HPP_NAMESPACE::OpaqueCaptureDescriptorDataCreateInfoEXT const & opaqueCaptureDescriptorDataCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 7142 { 7143 std::size_t seed = 0; 7144 VULKAN_HPP_HASH_COMBINE( seed, opaqueCaptureDescriptorDataCreateInfoEXT.sType ); 7145 VULKAN_HPP_HASH_COMBINE( seed, opaqueCaptureDescriptorDataCreateInfoEXT.pNext ); 7146 VULKAN_HPP_HASH_COMBINE( seed, opaqueCaptureDescriptorDataCreateInfoEXT.opaqueCaptureDescriptorData ); 7147 return seed; 7148 } 7149 }; 7150 7151 template <> 7152 struct hash<VULKAN_HPP_NAMESPACE::OpticalFlowExecuteInfoNV> 7153 { operator ()std::hash7154 std::size_t operator()( VULKAN_HPP_NAMESPACE::OpticalFlowExecuteInfoNV const & opticalFlowExecuteInfoNV ) const VULKAN_HPP_NOEXCEPT 7155 { 7156 std::size_t seed = 0; 7157 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowExecuteInfoNV.sType ); 7158 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowExecuteInfoNV.pNext ); 7159 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowExecuteInfoNV.flags ); 7160 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowExecuteInfoNV.regionCount ); 7161 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowExecuteInfoNV.pRegions ); 7162 return seed; 7163 } 7164 }; 7165 7166 template <> 7167 struct hash<VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatInfoNV> 7168 { operator ()std::hash7169 std::size_t operator()( VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatInfoNV const & opticalFlowImageFormatInfoNV ) const VULKAN_HPP_NOEXCEPT 7170 { 7171 std::size_t seed = 0; 7172 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowImageFormatInfoNV.sType ); 7173 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowImageFormatInfoNV.pNext ); 7174 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowImageFormatInfoNV.usage ); 7175 return seed; 7176 } 7177 }; 7178 7179 template <> 7180 struct hash<VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV> 7181 { operator ()std::hash7182 std::size_t operator()( VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV const & opticalFlowImageFormatPropertiesNV ) const VULKAN_HPP_NOEXCEPT 7183 { 7184 std::size_t seed = 0; 7185 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowImageFormatPropertiesNV.sType ); 7186 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowImageFormatPropertiesNV.pNext ); 7187 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowImageFormatPropertiesNV.format ); 7188 return seed; 7189 } 7190 }; 7191 7192 template <> 7193 struct hash<VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreateInfoNV> 7194 { operator ()std::hash7195 std::size_t operator()( VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreateInfoNV const & opticalFlowSessionCreateInfoNV ) const VULKAN_HPP_NOEXCEPT 7196 { 7197 std::size_t seed = 0; 7198 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.sType ); 7199 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.pNext ); 7200 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.width ); 7201 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.height ); 7202 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.imageFormat ); 7203 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.flowVectorFormat ); 7204 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.costFormat ); 7205 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.outputGridSize ); 7206 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.hintGridSize ); 7207 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.performanceLevel ); 7208 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.flags ); 7209 return seed; 7210 } 7211 }; 7212 7213 template <> 7214 struct hash<VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreatePrivateDataInfoNV> 7215 { 7216 std::size_t operator ()std::hash7217 operator()( VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreatePrivateDataInfoNV const & opticalFlowSessionCreatePrivateDataInfoNV ) const VULKAN_HPP_NOEXCEPT 7218 { 7219 std::size_t seed = 0; 7220 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreatePrivateDataInfoNV.sType ); 7221 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreatePrivateDataInfoNV.pNext ); 7222 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreatePrivateDataInfoNV.id ); 7223 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreatePrivateDataInfoNV.size ); 7224 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreatePrivateDataInfoNV.pPrivateData ); 7225 return seed; 7226 } 7227 }; 7228 7229 template <> 7230 struct hash<VULKAN_HPP_NAMESPACE::OutOfBandQueueTypeInfoNV> 7231 { operator ()std::hash7232 std::size_t operator()( VULKAN_HPP_NAMESPACE::OutOfBandQueueTypeInfoNV const & outOfBandQueueTypeInfoNV ) const VULKAN_HPP_NOEXCEPT 7233 { 7234 std::size_t seed = 0; 7235 VULKAN_HPP_HASH_COMBINE( seed, outOfBandQueueTypeInfoNV.sType ); 7236 VULKAN_HPP_HASH_COMBINE( seed, outOfBandQueueTypeInfoNV.pNext ); 7237 VULKAN_HPP_HASH_COMBINE( seed, outOfBandQueueTypeInfoNV.queueType ); 7238 return seed; 7239 } 7240 }; 7241 7242 template <> 7243 struct hash<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE> 7244 { operator ()std::hash7245 std::size_t operator()( VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE const & pastPresentationTimingGOOGLE ) const VULKAN_HPP_NOEXCEPT 7246 { 7247 std::size_t seed = 0; 7248 VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingGOOGLE.presentID ); 7249 VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingGOOGLE.desiredPresentTime ); 7250 VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingGOOGLE.actualPresentTime ); 7251 VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingGOOGLE.earliestPresentTime ); 7252 VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingGOOGLE.presentMargin ); 7253 return seed; 7254 } 7255 }; 7256 7257 template <> 7258 struct hash<VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL> 7259 { 7260 std::size_t operator ()std::hash7261 operator()( VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL const & performanceConfigurationAcquireInfoINTEL ) const VULKAN_HPP_NOEXCEPT 7262 { 7263 std::size_t seed = 0; 7264 VULKAN_HPP_HASH_COMBINE( seed, performanceConfigurationAcquireInfoINTEL.sType ); 7265 VULKAN_HPP_HASH_COMBINE( seed, performanceConfigurationAcquireInfoINTEL.pNext ); 7266 VULKAN_HPP_HASH_COMBINE( seed, performanceConfigurationAcquireInfoINTEL.type ); 7267 return seed; 7268 } 7269 }; 7270 7271 template <> 7272 struct hash<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR> 7273 { operator ()std::hash7274 std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR const & performanceCounterDescriptionKHR ) const VULKAN_HPP_NOEXCEPT 7275 { 7276 std::size_t seed = 0; 7277 VULKAN_HPP_HASH_COMBINE( seed, performanceCounterDescriptionKHR.sType ); 7278 VULKAN_HPP_HASH_COMBINE( seed, performanceCounterDescriptionKHR.pNext ); 7279 VULKAN_HPP_HASH_COMBINE( seed, performanceCounterDescriptionKHR.flags ); 7280 for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) 7281 { 7282 VULKAN_HPP_HASH_COMBINE( seed, performanceCounterDescriptionKHR.name[i] ); 7283 } 7284 for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) 7285 { 7286 VULKAN_HPP_HASH_COMBINE( seed, performanceCounterDescriptionKHR.category[i] ); 7287 } 7288 for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) 7289 { 7290 VULKAN_HPP_HASH_COMBINE( seed, performanceCounterDescriptionKHR.description[i] ); 7291 } 7292 return seed; 7293 } 7294 }; 7295 7296 template <> 7297 struct hash<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR> 7298 { operator ()std::hash7299 std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceCounterKHR const & performanceCounterKHR ) const VULKAN_HPP_NOEXCEPT 7300 { 7301 std::size_t seed = 0; 7302 VULKAN_HPP_HASH_COMBINE( seed, performanceCounterKHR.sType ); 7303 VULKAN_HPP_HASH_COMBINE( seed, performanceCounterKHR.pNext ); 7304 VULKAN_HPP_HASH_COMBINE( seed, performanceCounterKHR.unit ); 7305 VULKAN_HPP_HASH_COMBINE( seed, performanceCounterKHR.scope ); 7306 VULKAN_HPP_HASH_COMBINE( seed, performanceCounterKHR.storage ); 7307 for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) 7308 { 7309 VULKAN_HPP_HASH_COMBINE( seed, performanceCounterKHR.uuid[i] ); 7310 } 7311 return seed; 7312 } 7313 }; 7314 7315 template <> 7316 struct hash<VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL> 7317 { operator ()std::hash7318 std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL const & performanceMarkerInfoINTEL ) const VULKAN_HPP_NOEXCEPT 7319 { 7320 std::size_t seed = 0; 7321 VULKAN_HPP_HASH_COMBINE( seed, performanceMarkerInfoINTEL.sType ); 7322 VULKAN_HPP_HASH_COMBINE( seed, performanceMarkerInfoINTEL.pNext ); 7323 VULKAN_HPP_HASH_COMBINE( seed, performanceMarkerInfoINTEL.marker ); 7324 return seed; 7325 } 7326 }; 7327 7328 template <> 7329 struct hash<VULKAN_HPP_NAMESPACE::PerformanceOverrideInfoINTEL> 7330 { operator ()std::hash7331 std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceOverrideInfoINTEL const & performanceOverrideInfoINTEL ) const VULKAN_HPP_NOEXCEPT 7332 { 7333 std::size_t seed = 0; 7334 VULKAN_HPP_HASH_COMBINE( seed, performanceOverrideInfoINTEL.sType ); 7335 VULKAN_HPP_HASH_COMBINE( seed, performanceOverrideInfoINTEL.pNext ); 7336 VULKAN_HPP_HASH_COMBINE( seed, performanceOverrideInfoINTEL.type ); 7337 VULKAN_HPP_HASH_COMBINE( seed, performanceOverrideInfoINTEL.enable ); 7338 VULKAN_HPP_HASH_COMBINE( seed, performanceOverrideInfoINTEL.parameter ); 7339 return seed; 7340 } 7341 }; 7342 7343 template <> 7344 struct hash<VULKAN_HPP_NAMESPACE::PerformanceQuerySubmitInfoKHR> 7345 { operator ()std::hash7346 std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceQuerySubmitInfoKHR const & performanceQuerySubmitInfoKHR ) const VULKAN_HPP_NOEXCEPT 7347 { 7348 std::size_t seed = 0; 7349 VULKAN_HPP_HASH_COMBINE( seed, performanceQuerySubmitInfoKHR.sType ); 7350 VULKAN_HPP_HASH_COMBINE( seed, performanceQuerySubmitInfoKHR.pNext ); 7351 VULKAN_HPP_HASH_COMBINE( seed, performanceQuerySubmitInfoKHR.counterPassIndex ); 7352 return seed; 7353 } 7354 }; 7355 7356 template <> 7357 struct hash<VULKAN_HPP_NAMESPACE::PerformanceStreamMarkerInfoINTEL> 7358 { operator ()std::hash7359 std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceStreamMarkerInfoINTEL const & performanceStreamMarkerInfoINTEL ) const VULKAN_HPP_NOEXCEPT 7360 { 7361 std::size_t seed = 0; 7362 VULKAN_HPP_HASH_COMBINE( seed, performanceStreamMarkerInfoINTEL.sType ); 7363 VULKAN_HPP_HASH_COMBINE( seed, performanceStreamMarkerInfoINTEL.pNext ); 7364 VULKAN_HPP_HASH_COMBINE( seed, performanceStreamMarkerInfoINTEL.marker ); 7365 return seed; 7366 } 7367 }; 7368 7369 template <> 7370 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevice16BitStorageFeatures> 7371 { operator ()std::hash7372 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevice16BitStorageFeatures const & physicalDevice16BitStorageFeatures ) const VULKAN_HPP_NOEXCEPT 7373 { 7374 std::size_t seed = 0; 7375 VULKAN_HPP_HASH_COMBINE( seed, physicalDevice16BitStorageFeatures.sType ); 7376 VULKAN_HPP_HASH_COMBINE( seed, physicalDevice16BitStorageFeatures.pNext ); 7377 VULKAN_HPP_HASH_COMBINE( seed, physicalDevice16BitStorageFeatures.storageBuffer16BitAccess ); 7378 VULKAN_HPP_HASH_COMBINE( seed, physicalDevice16BitStorageFeatures.uniformAndStorageBuffer16BitAccess ); 7379 VULKAN_HPP_HASH_COMBINE( seed, physicalDevice16BitStorageFeatures.storagePushConstant16 ); 7380 VULKAN_HPP_HASH_COMBINE( seed, physicalDevice16BitStorageFeatures.storageInputOutput16 ); 7381 return seed; 7382 } 7383 }; 7384 7385 template <> 7386 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevice4444FormatsFeaturesEXT> 7387 { operator ()std::hash7388 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevice4444FormatsFeaturesEXT const & physicalDevice4444FormatsFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 7389 { 7390 std::size_t seed = 0; 7391 VULKAN_HPP_HASH_COMBINE( seed, physicalDevice4444FormatsFeaturesEXT.sType ); 7392 VULKAN_HPP_HASH_COMBINE( seed, physicalDevice4444FormatsFeaturesEXT.pNext ); 7393 VULKAN_HPP_HASH_COMBINE( seed, physicalDevice4444FormatsFeaturesEXT.formatA4R4G4B4 ); 7394 VULKAN_HPP_HASH_COMBINE( seed, physicalDevice4444FormatsFeaturesEXT.formatA4B4G4R4 ); 7395 return seed; 7396 } 7397 }; 7398 7399 template <> 7400 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevice8BitStorageFeatures> 7401 { operator ()std::hash7402 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevice8BitStorageFeatures const & physicalDevice8BitStorageFeatures ) const VULKAN_HPP_NOEXCEPT 7403 { 7404 std::size_t seed = 0; 7405 VULKAN_HPP_HASH_COMBINE( seed, physicalDevice8BitStorageFeatures.sType ); 7406 VULKAN_HPP_HASH_COMBINE( seed, physicalDevice8BitStorageFeatures.pNext ); 7407 VULKAN_HPP_HASH_COMBINE( seed, physicalDevice8BitStorageFeatures.storageBuffer8BitAccess ); 7408 VULKAN_HPP_HASH_COMBINE( seed, physicalDevice8BitStorageFeatures.uniformAndStorageBuffer8BitAccess ); 7409 VULKAN_HPP_HASH_COMBINE( seed, physicalDevice8BitStorageFeatures.storagePushConstant8 ); 7410 return seed; 7411 } 7412 }; 7413 7414 template <> 7415 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceASTCDecodeFeaturesEXT> 7416 { operator ()std::hash7417 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceASTCDecodeFeaturesEXT const & physicalDeviceASTCDecodeFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 7418 { 7419 std::size_t seed = 0; 7420 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceASTCDecodeFeaturesEXT.sType ); 7421 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceASTCDecodeFeaturesEXT.pNext ); 7422 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceASTCDecodeFeaturesEXT.decodeModeSharedExponent ); 7423 return seed; 7424 } 7425 }; 7426 7427 template <> 7428 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceAccelerationStructureFeaturesKHR> 7429 { operator ()std::hash7430 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceAccelerationStructureFeaturesKHR const & physicalDeviceAccelerationStructureFeaturesKHR ) const 7431 VULKAN_HPP_NOEXCEPT 7432 { 7433 std::size_t seed = 0; 7434 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructureFeaturesKHR.sType ); 7435 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructureFeaturesKHR.pNext ); 7436 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructureFeaturesKHR.accelerationStructure ); 7437 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructureFeaturesKHR.accelerationStructureCaptureReplay ); 7438 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructureFeaturesKHR.accelerationStructureIndirectBuild ); 7439 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructureFeaturesKHR.accelerationStructureHostCommands ); 7440 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructureFeaturesKHR.descriptorBindingAccelerationStructureUpdateAfterBind ); 7441 return seed; 7442 } 7443 }; 7444 7445 template <> 7446 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceAccelerationStructurePropertiesKHR> 7447 { operator ()std::hash7448 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceAccelerationStructurePropertiesKHR const & physicalDeviceAccelerationStructurePropertiesKHR ) 7449 const VULKAN_HPP_NOEXCEPT 7450 { 7451 std::size_t seed = 0; 7452 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.sType ); 7453 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.pNext ); 7454 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.maxGeometryCount ); 7455 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.maxInstanceCount ); 7456 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.maxPrimitiveCount ); 7457 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.maxPerStageDescriptorAccelerationStructures ); 7458 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.maxPerStageDescriptorUpdateAfterBindAccelerationStructures ); 7459 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.maxDescriptorSetAccelerationStructures ); 7460 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.maxDescriptorSetUpdateAfterBindAccelerationStructures ); 7461 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.minAccelerationStructureScratchOffsetAlignment ); 7462 return seed; 7463 } 7464 }; 7465 7466 template <> 7467 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceAddressBindingReportFeaturesEXT> 7468 { operator ()std::hash7469 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceAddressBindingReportFeaturesEXT const & physicalDeviceAddressBindingReportFeaturesEXT ) const 7470 VULKAN_HPP_NOEXCEPT 7471 { 7472 std::size_t seed = 0; 7473 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAddressBindingReportFeaturesEXT.sType ); 7474 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAddressBindingReportFeaturesEXT.pNext ); 7475 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAddressBindingReportFeaturesEXT.reportAddressBinding ); 7476 return seed; 7477 } 7478 }; 7479 7480 template <> 7481 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceAmigoProfilingFeaturesSEC> 7482 { 7483 std::size_t operator ()std::hash7484 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceAmigoProfilingFeaturesSEC const & physicalDeviceAmigoProfilingFeaturesSEC ) const VULKAN_HPP_NOEXCEPT 7485 { 7486 std::size_t seed = 0; 7487 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAmigoProfilingFeaturesSEC.sType ); 7488 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAmigoProfilingFeaturesSEC.pNext ); 7489 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAmigoProfilingFeaturesSEC.amigoProfiling ); 7490 return seed; 7491 } 7492 }; 7493 7494 template <> 7495 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT> 7496 { operator ()std::hash7497 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT const & 7498 physicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 7499 { 7500 std::size_t seed = 0; 7501 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT.sType ); 7502 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT.pNext ); 7503 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT.attachmentFeedbackLoopDynamicState ); 7504 return seed; 7505 } 7506 }; 7507 7508 template <> 7509 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT> 7510 { operator ()std::hash7511 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT const & 7512 physicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 7513 { 7514 std::size_t seed = 0; 7515 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT.sType ); 7516 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT.pNext ); 7517 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT.attachmentFeedbackLoopLayout ); 7518 return seed; 7519 } 7520 }; 7521 7522 template <> 7523 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceBlendOperationAdvancedFeaturesEXT> 7524 { operator ()std::hash7525 std::size_t operator()( 7526 VULKAN_HPP_NAMESPACE::PhysicalDeviceBlendOperationAdvancedFeaturesEXT const & physicalDeviceBlendOperationAdvancedFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 7527 { 7528 std::size_t seed = 0; 7529 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedFeaturesEXT.sType ); 7530 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedFeaturesEXT.pNext ); 7531 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedFeaturesEXT.advancedBlendCoherentOperations ); 7532 return seed; 7533 } 7534 }; 7535 7536 template <> 7537 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceBlendOperationAdvancedPropertiesEXT> 7538 { operator ()std::hash7539 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceBlendOperationAdvancedPropertiesEXT const & physicalDeviceBlendOperationAdvancedPropertiesEXT ) 7540 const VULKAN_HPP_NOEXCEPT 7541 { 7542 std::size_t seed = 0; 7543 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.sType ); 7544 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.pNext ); 7545 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendMaxColorAttachments ); 7546 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendIndependentBlend ); 7547 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendNonPremultipliedSrcColor ); 7548 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendNonPremultipliedDstColor ); 7549 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendCorrelatedOverlap ); 7550 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendAllOperations ); 7551 return seed; 7552 } 7553 }; 7554 7555 template <> 7556 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceBorderColorSwizzleFeaturesEXT> 7557 { operator ()std::hash7558 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceBorderColorSwizzleFeaturesEXT const & physicalDeviceBorderColorSwizzleFeaturesEXT ) const 7559 VULKAN_HPP_NOEXCEPT 7560 { 7561 std::size_t seed = 0; 7562 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBorderColorSwizzleFeaturesEXT.sType ); 7563 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBorderColorSwizzleFeaturesEXT.pNext ); 7564 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBorderColorSwizzleFeaturesEXT.borderColorSwizzle ); 7565 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBorderColorSwizzleFeaturesEXT.borderColorSwizzleFromImage ); 7566 return seed; 7567 } 7568 }; 7569 7570 template <> 7571 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceBufferDeviceAddressFeatures> 7572 { 7573 std::size_t operator ()std::hash7574 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceBufferDeviceAddressFeatures const & physicalDeviceBufferDeviceAddressFeatures ) const VULKAN_HPP_NOEXCEPT 7575 { 7576 std::size_t seed = 0; 7577 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeatures.sType ); 7578 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeatures.pNext ); 7579 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeatures.bufferDeviceAddress ); 7580 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeatures.bufferDeviceAddressCaptureReplay ); 7581 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeatures.bufferDeviceAddressMultiDevice ); 7582 return seed; 7583 } 7584 }; 7585 7586 template <> 7587 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceBufferDeviceAddressFeaturesEXT> 7588 { operator ()std::hash7589 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceBufferDeviceAddressFeaturesEXT const & physicalDeviceBufferDeviceAddressFeaturesEXT ) const 7590 VULKAN_HPP_NOEXCEPT 7591 { 7592 std::size_t seed = 0; 7593 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeaturesEXT.sType ); 7594 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeaturesEXT.pNext ); 7595 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeaturesEXT.bufferDeviceAddress ); 7596 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeaturesEXT.bufferDeviceAddressCaptureReplay ); 7597 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeaturesEXT.bufferDeviceAddressMultiDevice ); 7598 return seed; 7599 } 7600 }; 7601 7602 template <> 7603 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterCullingShaderFeaturesHUAWEI> 7604 { operator ()std::hash7605 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterCullingShaderFeaturesHUAWEI const & physicalDeviceClusterCullingShaderFeaturesHUAWEI ) 7606 const VULKAN_HPP_NOEXCEPT 7607 { 7608 std::size_t seed = 0; 7609 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderFeaturesHUAWEI.sType ); 7610 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderFeaturesHUAWEI.pNext ); 7611 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderFeaturesHUAWEI.clustercullingShader ); 7612 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderFeaturesHUAWEI.multiviewClusterCullingShader ); 7613 return seed; 7614 } 7615 }; 7616 7617 template <> 7618 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterCullingShaderPropertiesHUAWEI> 7619 { 7620 std::size_t operator ()std::hash7621 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterCullingShaderPropertiesHUAWEI const & physicalDeviceClusterCullingShaderPropertiesHUAWEI ) const 7622 VULKAN_HPP_NOEXCEPT 7623 { 7624 std::size_t seed = 0; 7625 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderPropertiesHUAWEI.sType ); 7626 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderPropertiesHUAWEI.pNext ); 7627 for ( size_t i = 0; i < 3; ++i ) 7628 { 7629 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderPropertiesHUAWEI.maxWorkGroupCount[i] ); 7630 } 7631 for ( size_t i = 0; i < 3; ++i ) 7632 { 7633 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderPropertiesHUAWEI.maxWorkGroupSize[i] ); 7634 } 7635 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderPropertiesHUAWEI.maxOutputClusterCount ); 7636 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderPropertiesHUAWEI.indirectBufferOffsetAlignment ); 7637 return seed; 7638 } 7639 }; 7640 7641 template <> 7642 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI> 7643 { 7644 std::size_t operator ()std::hash7645 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI const & physicalDeviceClusterCullingShaderVrsFeaturesHUAWEI ) const 7646 VULKAN_HPP_NOEXCEPT 7647 { 7648 std::size_t seed = 0; 7649 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderVrsFeaturesHUAWEI.sType ); 7650 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderVrsFeaturesHUAWEI.pNext ); 7651 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderVrsFeaturesHUAWEI.clusterShadingRate ); 7652 return seed; 7653 } 7654 }; 7655 7656 template <> 7657 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCoherentMemoryFeaturesAMD> 7658 { 7659 std::size_t operator ()std::hash7660 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCoherentMemoryFeaturesAMD const & physicalDeviceCoherentMemoryFeaturesAMD ) const VULKAN_HPP_NOEXCEPT 7661 { 7662 std::size_t seed = 0; 7663 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCoherentMemoryFeaturesAMD.sType ); 7664 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCoherentMemoryFeaturesAMD.pNext ); 7665 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCoherentMemoryFeaturesAMD.deviceCoherentMemory ); 7666 return seed; 7667 } 7668 }; 7669 7670 template <> 7671 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceColorWriteEnableFeaturesEXT> 7672 { 7673 std::size_t operator ()std::hash7674 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceColorWriteEnableFeaturesEXT const & physicalDeviceColorWriteEnableFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 7675 { 7676 std::size_t seed = 0; 7677 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceColorWriteEnableFeaturesEXT.sType ); 7678 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceColorWriteEnableFeaturesEXT.pNext ); 7679 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceColorWriteEnableFeaturesEXT.colorWriteEnable ); 7680 return seed; 7681 } 7682 }; 7683 7684 template <> 7685 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceComputeShaderDerivativesFeaturesNV> 7686 { operator ()std::hash7687 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceComputeShaderDerivativesFeaturesNV const & physicalDeviceComputeShaderDerivativesFeaturesNV ) 7688 const VULKAN_HPP_NOEXCEPT 7689 { 7690 std::size_t seed = 0; 7691 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceComputeShaderDerivativesFeaturesNV.sType ); 7692 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceComputeShaderDerivativesFeaturesNV.pNext ); 7693 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceComputeShaderDerivativesFeaturesNV.computeDerivativeGroupQuads ); 7694 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceComputeShaderDerivativesFeaturesNV.computeDerivativeGroupLinear ); 7695 return seed; 7696 } 7697 }; 7698 7699 template <> 7700 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceConditionalRenderingFeaturesEXT> 7701 { operator ()std::hash7702 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceConditionalRenderingFeaturesEXT const & physicalDeviceConditionalRenderingFeaturesEXT ) const 7703 VULKAN_HPP_NOEXCEPT 7704 { 7705 std::size_t seed = 0; 7706 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConditionalRenderingFeaturesEXT.sType ); 7707 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConditionalRenderingFeaturesEXT.pNext ); 7708 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConditionalRenderingFeaturesEXT.conditionalRendering ); 7709 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConditionalRenderingFeaturesEXT.inheritedConditionalRendering ); 7710 return seed; 7711 } 7712 }; 7713 7714 template <> 7715 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceConservativeRasterizationPropertiesEXT> 7716 { operator ()std::hash7717 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceConservativeRasterizationPropertiesEXT const & 7718 physicalDeviceConservativeRasterizationPropertiesEXT ) const VULKAN_HPP_NOEXCEPT 7719 { 7720 std::size_t seed = 0; 7721 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.sType ); 7722 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.pNext ); 7723 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.primitiveOverestimationSize ); 7724 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.maxExtraPrimitiveOverestimationSize ); 7725 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.extraPrimitiveOverestimationSizeGranularity ); 7726 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.primitiveUnderestimation ); 7727 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.conservativePointAndLineRasterization ); 7728 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.degenerateTrianglesRasterized ); 7729 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.degenerateLinesRasterized ); 7730 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.fullyCoveredFragmentShaderInputVariable ); 7731 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.conservativeRasterizationPostDepthCoverage ); 7732 return seed; 7733 } 7734 }; 7735 7736 template <> 7737 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixFeaturesKHR> 7738 { operator ()std::hash7739 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixFeaturesKHR const & physicalDeviceCooperativeMatrixFeaturesKHR ) const 7740 VULKAN_HPP_NOEXCEPT 7741 { 7742 std::size_t seed = 0; 7743 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixFeaturesKHR.sType ); 7744 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixFeaturesKHR.pNext ); 7745 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixFeaturesKHR.cooperativeMatrix ); 7746 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixFeaturesKHR.cooperativeMatrixRobustBufferAccess ); 7747 return seed; 7748 } 7749 }; 7750 7751 template <> 7752 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixFeaturesNV> 7753 { 7754 std::size_t operator ()std::hash7755 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixFeaturesNV const & physicalDeviceCooperativeMatrixFeaturesNV ) const VULKAN_HPP_NOEXCEPT 7756 { 7757 std::size_t seed = 0; 7758 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixFeaturesNV.sType ); 7759 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixFeaturesNV.pNext ); 7760 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixFeaturesNV.cooperativeMatrix ); 7761 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixFeaturesNV.cooperativeMatrixRobustBufferAccess ); 7762 return seed; 7763 } 7764 }; 7765 7766 template <> 7767 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixPropertiesKHR> 7768 { operator ()std::hash7769 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixPropertiesKHR const & physicalDeviceCooperativeMatrixPropertiesKHR ) const 7770 VULKAN_HPP_NOEXCEPT 7771 { 7772 std::size_t seed = 0; 7773 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixPropertiesKHR.sType ); 7774 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixPropertiesKHR.pNext ); 7775 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixPropertiesKHR.cooperativeMatrixSupportedStages ); 7776 return seed; 7777 } 7778 }; 7779 7780 template <> 7781 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixPropertiesNV> 7782 { operator ()std::hash7783 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixPropertiesNV const & physicalDeviceCooperativeMatrixPropertiesNV ) const 7784 VULKAN_HPP_NOEXCEPT 7785 { 7786 std::size_t seed = 0; 7787 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixPropertiesNV.sType ); 7788 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixPropertiesNV.pNext ); 7789 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixPropertiesNV.cooperativeMatrixSupportedStages ); 7790 return seed; 7791 } 7792 }; 7793 7794 template <> 7795 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectFeaturesNV> 7796 { operator ()std::hash7797 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectFeaturesNV const & physicalDeviceCopyMemoryIndirectFeaturesNV ) const 7798 VULKAN_HPP_NOEXCEPT 7799 { 7800 std::size_t seed = 0; 7801 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCopyMemoryIndirectFeaturesNV.sType ); 7802 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCopyMemoryIndirectFeaturesNV.pNext ); 7803 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCopyMemoryIndirectFeaturesNV.indirectCopy ); 7804 return seed; 7805 } 7806 }; 7807 7808 template <> 7809 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectPropertiesNV> 7810 { operator ()std::hash7811 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectPropertiesNV const & physicalDeviceCopyMemoryIndirectPropertiesNV ) const 7812 VULKAN_HPP_NOEXCEPT 7813 { 7814 std::size_t seed = 0; 7815 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCopyMemoryIndirectPropertiesNV.sType ); 7816 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCopyMemoryIndirectPropertiesNV.pNext ); 7817 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCopyMemoryIndirectPropertiesNV.supportedQueues ); 7818 return seed; 7819 } 7820 }; 7821 7822 template <> 7823 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCornerSampledImageFeaturesNV> 7824 { operator ()std::hash7825 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCornerSampledImageFeaturesNV const & physicalDeviceCornerSampledImageFeaturesNV ) const 7826 VULKAN_HPP_NOEXCEPT 7827 { 7828 std::size_t seed = 0; 7829 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCornerSampledImageFeaturesNV.sType ); 7830 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCornerSampledImageFeaturesNV.pNext ); 7831 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCornerSampledImageFeaturesNV.cornerSampledImage ); 7832 return seed; 7833 } 7834 }; 7835 7836 template <> 7837 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCoverageReductionModeFeaturesNV> 7838 { operator ()std::hash7839 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCoverageReductionModeFeaturesNV const & physicalDeviceCoverageReductionModeFeaturesNV ) const 7840 VULKAN_HPP_NOEXCEPT 7841 { 7842 std::size_t seed = 0; 7843 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCoverageReductionModeFeaturesNV.sType ); 7844 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCoverageReductionModeFeaturesNV.pNext ); 7845 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCoverageReductionModeFeaturesNV.coverageReductionMode ); 7846 return seed; 7847 } 7848 }; 7849 7850 template <> 7851 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCubicClampFeaturesQCOM> 7852 { operator ()std::hash7853 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCubicClampFeaturesQCOM const & physicalDeviceCubicClampFeaturesQCOM ) const VULKAN_HPP_NOEXCEPT 7854 { 7855 std::size_t seed = 0; 7856 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCubicClampFeaturesQCOM.sType ); 7857 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCubicClampFeaturesQCOM.pNext ); 7858 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCubicClampFeaturesQCOM.cubicRangeClamp ); 7859 return seed; 7860 } 7861 }; 7862 7863 template <> 7864 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCubicWeightsFeaturesQCOM> 7865 { 7866 std::size_t operator ()std::hash7867 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCubicWeightsFeaturesQCOM const & physicalDeviceCubicWeightsFeaturesQCOM ) const VULKAN_HPP_NOEXCEPT 7868 { 7869 std::size_t seed = 0; 7870 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCubicWeightsFeaturesQCOM.sType ); 7871 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCubicWeightsFeaturesQCOM.pNext ); 7872 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCubicWeightsFeaturesQCOM.selectableCubicWeights ); 7873 return seed; 7874 } 7875 }; 7876 7877 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 7878 template <> 7879 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCudaKernelLaunchFeaturesNV> 7880 { 7881 std::size_t operator ()std::hash7882 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCudaKernelLaunchFeaturesNV const & physicalDeviceCudaKernelLaunchFeaturesNV ) const VULKAN_HPP_NOEXCEPT 7883 { 7884 std::size_t seed = 0; 7885 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCudaKernelLaunchFeaturesNV.sType ); 7886 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCudaKernelLaunchFeaturesNV.pNext ); 7887 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCudaKernelLaunchFeaturesNV.cudaKernelLaunchFeatures ); 7888 return seed; 7889 } 7890 }; 7891 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 7892 7893 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 7894 template <> 7895 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCudaKernelLaunchPropertiesNV> 7896 { operator ()std::hash7897 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCudaKernelLaunchPropertiesNV const & physicalDeviceCudaKernelLaunchPropertiesNV ) const 7898 VULKAN_HPP_NOEXCEPT 7899 { 7900 std::size_t seed = 0; 7901 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCudaKernelLaunchPropertiesNV.sType ); 7902 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCudaKernelLaunchPropertiesNV.pNext ); 7903 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCudaKernelLaunchPropertiesNV.computeCapabilityMinor ); 7904 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCudaKernelLaunchPropertiesNV.computeCapabilityMajor ); 7905 return seed; 7906 } 7907 }; 7908 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 7909 7910 template <> 7911 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomBorderColorFeaturesEXT> 7912 { operator ()std::hash7913 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomBorderColorFeaturesEXT const & physicalDeviceCustomBorderColorFeaturesEXT ) const 7914 VULKAN_HPP_NOEXCEPT 7915 { 7916 std::size_t seed = 0; 7917 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCustomBorderColorFeaturesEXT.sType ); 7918 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCustomBorderColorFeaturesEXT.pNext ); 7919 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCustomBorderColorFeaturesEXT.customBorderColors ); 7920 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCustomBorderColorFeaturesEXT.customBorderColorWithoutFormat ); 7921 return seed; 7922 } 7923 }; 7924 7925 template <> 7926 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomBorderColorPropertiesEXT> 7927 { operator ()std::hash7928 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomBorderColorPropertiesEXT const & physicalDeviceCustomBorderColorPropertiesEXT ) const 7929 VULKAN_HPP_NOEXCEPT 7930 { 7931 std::size_t seed = 0; 7932 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCustomBorderColorPropertiesEXT.sType ); 7933 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCustomBorderColorPropertiesEXT.pNext ); 7934 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCustomBorderColorPropertiesEXT.maxCustomBorderColorSamplers ); 7935 return seed; 7936 } 7937 }; 7938 7939 template <> 7940 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV> 7941 { operator ()std::hash7942 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const & 7943 physicalDeviceDedicatedAllocationImageAliasingFeaturesNV ) const VULKAN_HPP_NOEXCEPT 7944 { 7945 std::size_t seed = 0; 7946 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDedicatedAllocationImageAliasingFeaturesNV.sType ); 7947 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDedicatedAllocationImageAliasingFeaturesNV.pNext ); 7948 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDedicatedAllocationImageAliasingFeaturesNV.dedicatedAllocationImageAliasing ); 7949 return seed; 7950 } 7951 }; 7952 7953 template <> 7954 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthBiasControlFeaturesEXT> 7955 { 7956 std::size_t operator ()std::hash7957 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthBiasControlFeaturesEXT const & physicalDeviceDepthBiasControlFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 7958 { 7959 std::size_t seed = 0; 7960 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthBiasControlFeaturesEXT.sType ); 7961 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthBiasControlFeaturesEXT.pNext ); 7962 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthBiasControlFeaturesEXT.depthBiasControl ); 7963 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthBiasControlFeaturesEXT.leastRepresentableValueForceUnormRepresentation ); 7964 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthBiasControlFeaturesEXT.floatRepresentation ); 7965 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthBiasControlFeaturesEXT.depthBiasExact ); 7966 return seed; 7967 } 7968 }; 7969 7970 template <> 7971 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClampZeroOneFeaturesEXT> 7972 { operator ()std::hash7973 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClampZeroOneFeaturesEXT const & physicalDeviceDepthClampZeroOneFeaturesEXT ) const 7974 VULKAN_HPP_NOEXCEPT 7975 { 7976 std::size_t seed = 0; 7977 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClampZeroOneFeaturesEXT.sType ); 7978 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClampZeroOneFeaturesEXT.pNext ); 7979 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClampZeroOneFeaturesEXT.depthClampZeroOne ); 7980 return seed; 7981 } 7982 }; 7983 7984 template <> 7985 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClipControlFeaturesEXT> 7986 { 7987 std::size_t operator ()std::hash7988 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClipControlFeaturesEXT const & physicalDeviceDepthClipControlFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 7989 { 7990 std::size_t seed = 0; 7991 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClipControlFeaturesEXT.sType ); 7992 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClipControlFeaturesEXT.pNext ); 7993 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClipControlFeaturesEXT.depthClipControl ); 7994 return seed; 7995 } 7996 }; 7997 7998 template <> 7999 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClipEnableFeaturesEXT> 8000 { 8001 std::size_t operator ()std::hash8002 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClipEnableFeaturesEXT const & physicalDeviceDepthClipEnableFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 8003 { 8004 std::size_t seed = 0; 8005 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClipEnableFeaturesEXT.sType ); 8006 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClipEnableFeaturesEXT.pNext ); 8007 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClipEnableFeaturesEXT.depthClipEnable ); 8008 return seed; 8009 } 8010 }; 8011 8012 template <> 8013 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthStencilResolveProperties> 8014 { operator ()std::hash8015 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthStencilResolveProperties const & physicalDeviceDepthStencilResolveProperties ) const 8016 VULKAN_HPP_NOEXCEPT 8017 { 8018 std::size_t seed = 0; 8019 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthStencilResolveProperties.sType ); 8020 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthStencilResolveProperties.pNext ); 8021 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthStencilResolveProperties.supportedDepthResolveModes ); 8022 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthStencilResolveProperties.supportedStencilResolveModes ); 8023 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthStencilResolveProperties.independentResolveNone ); 8024 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthStencilResolveProperties.independentResolve ); 8025 return seed; 8026 } 8027 }; 8028 8029 template <> 8030 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT> 8031 { operator ()std::hash8032 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT const & 8033 physicalDeviceDescriptorBufferDensityMapPropertiesEXT ) const VULKAN_HPP_NOEXCEPT 8034 { 8035 std::size_t seed = 0; 8036 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferDensityMapPropertiesEXT.sType ); 8037 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferDensityMapPropertiesEXT.pNext ); 8038 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferDensityMapPropertiesEXT.combinedImageSamplerDensityMapDescriptorSize ); 8039 return seed; 8040 } 8041 }; 8042 8043 template <> 8044 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferFeaturesEXT> 8045 { 8046 std::size_t operator ()std::hash8047 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferFeaturesEXT const & physicalDeviceDescriptorBufferFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 8048 { 8049 std::size_t seed = 0; 8050 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferFeaturesEXT.sType ); 8051 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferFeaturesEXT.pNext ); 8052 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferFeaturesEXT.descriptorBuffer ); 8053 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferFeaturesEXT.descriptorBufferCaptureReplay ); 8054 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferFeaturesEXT.descriptorBufferImageLayoutIgnored ); 8055 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferFeaturesEXT.descriptorBufferPushDescriptors ); 8056 return seed; 8057 } 8058 }; 8059 8060 template <> 8061 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferPropertiesEXT> 8062 { operator ()std::hash8063 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferPropertiesEXT const & physicalDeviceDescriptorBufferPropertiesEXT ) const 8064 VULKAN_HPP_NOEXCEPT 8065 { 8066 std::size_t seed = 0; 8067 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.sType ); 8068 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.pNext ); 8069 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.combinedImageSamplerDescriptorSingleArray ); 8070 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.bufferlessPushDescriptors ); 8071 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.allowSamplerImageViewPostSubmitCreation ); 8072 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.descriptorBufferOffsetAlignment ); 8073 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.maxDescriptorBufferBindings ); 8074 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.maxResourceDescriptorBufferBindings ); 8075 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.maxSamplerDescriptorBufferBindings ); 8076 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.maxEmbeddedImmutableSamplerBindings ); 8077 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.maxEmbeddedImmutableSamplers ); 8078 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.bufferCaptureReplayDescriptorDataSize ); 8079 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.imageCaptureReplayDescriptorDataSize ); 8080 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.imageViewCaptureReplayDescriptorDataSize ); 8081 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.samplerCaptureReplayDescriptorDataSize ); 8082 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.accelerationStructureCaptureReplayDescriptorDataSize ); 8083 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.samplerDescriptorSize ); 8084 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.combinedImageSamplerDescriptorSize ); 8085 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.sampledImageDescriptorSize ); 8086 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.storageImageDescriptorSize ); 8087 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.uniformTexelBufferDescriptorSize ); 8088 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.robustUniformTexelBufferDescriptorSize ); 8089 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.storageTexelBufferDescriptorSize ); 8090 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.robustStorageTexelBufferDescriptorSize ); 8091 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.uniformBufferDescriptorSize ); 8092 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.robustUniformBufferDescriptorSize ); 8093 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.storageBufferDescriptorSize ); 8094 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.robustStorageBufferDescriptorSize ); 8095 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.inputAttachmentDescriptorSize ); 8096 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.accelerationStructureDescriptorSize ); 8097 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.maxSamplerDescriptorBufferRange ); 8098 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.maxResourceDescriptorBufferRange ); 8099 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.samplerDescriptorBufferAddressSpaceSize ); 8100 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.resourceDescriptorBufferAddressSpaceSize ); 8101 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.descriptorBufferAddressSpaceSize ); 8102 return seed; 8103 } 8104 }; 8105 8106 template <> 8107 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorIndexingFeatures> 8108 { 8109 std::size_t operator ()std::hash8110 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorIndexingFeatures const & physicalDeviceDescriptorIndexingFeatures ) const VULKAN_HPP_NOEXCEPT 8111 { 8112 std::size_t seed = 0; 8113 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.sType ); 8114 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.pNext ); 8115 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderInputAttachmentArrayDynamicIndexing ); 8116 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderUniformTexelBufferArrayDynamicIndexing ); 8117 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderStorageTexelBufferArrayDynamicIndexing ); 8118 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderUniformBufferArrayNonUniformIndexing ); 8119 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderSampledImageArrayNonUniformIndexing ); 8120 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderStorageBufferArrayNonUniformIndexing ); 8121 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderStorageImageArrayNonUniformIndexing ); 8122 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderInputAttachmentArrayNonUniformIndexing ); 8123 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderUniformTexelBufferArrayNonUniformIndexing ); 8124 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderStorageTexelBufferArrayNonUniformIndexing ); 8125 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingUniformBufferUpdateAfterBind ); 8126 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingSampledImageUpdateAfterBind ); 8127 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingStorageImageUpdateAfterBind ); 8128 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingStorageBufferUpdateAfterBind ); 8129 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingUniformTexelBufferUpdateAfterBind ); 8130 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingStorageTexelBufferUpdateAfterBind ); 8131 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingUpdateUnusedWhilePending ); 8132 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingPartiallyBound ); 8133 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingVariableDescriptorCount ); 8134 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.runtimeDescriptorArray ); 8135 return seed; 8136 } 8137 }; 8138 8139 template <> 8140 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorIndexingProperties> 8141 { operator ()std::hash8142 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorIndexingProperties const & physicalDeviceDescriptorIndexingProperties ) const 8143 VULKAN_HPP_NOEXCEPT 8144 { 8145 std::size_t seed = 0; 8146 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.sType ); 8147 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.pNext ); 8148 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxUpdateAfterBindDescriptorsInAllPools ); 8149 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.shaderUniformBufferArrayNonUniformIndexingNative ); 8150 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.shaderSampledImageArrayNonUniformIndexingNative ); 8151 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.shaderStorageBufferArrayNonUniformIndexingNative ); 8152 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.shaderStorageImageArrayNonUniformIndexingNative ); 8153 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.shaderInputAttachmentArrayNonUniformIndexingNative ); 8154 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.robustBufferAccessUpdateAfterBind ); 8155 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.quadDivergentImplicitLod ); 8156 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindSamplers ); 8157 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindUniformBuffers ); 8158 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindStorageBuffers ); 8159 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindSampledImages ); 8160 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindStorageImages ); 8161 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindInputAttachments ); 8162 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxPerStageUpdateAfterBindResources ); 8163 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindSamplers ); 8164 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindUniformBuffers ); 8165 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic ); 8166 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindStorageBuffers ); 8167 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic ); 8168 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindSampledImages ); 8169 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindStorageImages ); 8170 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindInputAttachments ); 8171 return seed; 8172 } 8173 }; 8174 8175 template <> 8176 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorPoolOverallocationFeaturesNV> 8177 { operator ()std::hash8178 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorPoolOverallocationFeaturesNV const & 8179 physicalDeviceDescriptorPoolOverallocationFeaturesNV ) const VULKAN_HPP_NOEXCEPT 8180 { 8181 std::size_t seed = 0; 8182 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorPoolOverallocationFeaturesNV.sType ); 8183 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorPoolOverallocationFeaturesNV.pNext ); 8184 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorPoolOverallocationFeaturesNV.descriptorPoolOverallocation ); 8185 return seed; 8186 } 8187 }; 8188 8189 template <> 8190 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE> 8191 { 8192 std::size_t operator ()std::hash8193 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE const & physicalDeviceDescriptorSetHostMappingFeaturesVALVE ) const 8194 VULKAN_HPP_NOEXCEPT 8195 { 8196 std::size_t seed = 0; 8197 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorSetHostMappingFeaturesVALVE.sType ); 8198 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorSetHostMappingFeaturesVALVE.pNext ); 8199 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorSetHostMappingFeaturesVALVE.descriptorSetHostMapping ); 8200 return seed; 8201 } 8202 }; 8203 8204 template <> 8205 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV> 8206 { operator ()std::hash8207 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV const & 8208 physicalDeviceDeviceGeneratedCommandsComputeFeaturesNV ) const VULKAN_HPP_NOEXCEPT 8209 { 8210 std::size_t seed = 0; 8211 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsComputeFeaturesNV.sType ); 8212 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsComputeFeaturesNV.pNext ); 8213 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsComputeFeaturesNV.deviceGeneratedCompute ); 8214 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsComputeFeaturesNV.deviceGeneratedComputePipelines ); 8215 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsComputeFeaturesNV.deviceGeneratedComputeCaptureReplay ); 8216 return seed; 8217 } 8218 }; 8219 8220 template <> 8221 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsFeaturesNV> 8222 { operator ()std::hash8223 std::size_t operator()( 8224 VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsFeaturesNV const & physicalDeviceDeviceGeneratedCommandsFeaturesNV ) const VULKAN_HPP_NOEXCEPT 8225 { 8226 std::size_t seed = 0; 8227 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsFeaturesNV.sType ); 8228 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsFeaturesNV.pNext ); 8229 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsFeaturesNV.deviceGeneratedCommands ); 8230 return seed; 8231 } 8232 }; 8233 8234 template <> 8235 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsPropertiesNV> 8236 { operator ()std::hash8237 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsPropertiesNV const & physicalDeviceDeviceGeneratedCommandsPropertiesNV ) 8238 const VULKAN_HPP_NOEXCEPT 8239 { 8240 std::size_t seed = 0; 8241 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.sType ); 8242 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.pNext ); 8243 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxGraphicsShaderGroupCount ); 8244 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxIndirectSequenceCount ); 8245 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxIndirectCommandsTokenCount ); 8246 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxIndirectCommandsStreamCount ); 8247 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxIndirectCommandsTokenOffset ); 8248 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxIndirectCommandsStreamStride ); 8249 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.minSequencesCountBufferOffsetAlignment ); 8250 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.minSequencesIndexBufferOffsetAlignment ); 8251 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.minIndirectCommandsBufferOffsetAlignment ); 8252 return seed; 8253 } 8254 }; 8255 8256 template <> 8257 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceMemoryReportFeaturesEXT> 8258 { operator ()std::hash8259 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceMemoryReportFeaturesEXT const & physicalDeviceDeviceMemoryReportFeaturesEXT ) const 8260 VULKAN_HPP_NOEXCEPT 8261 { 8262 std::size_t seed = 0; 8263 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceMemoryReportFeaturesEXT.sType ); 8264 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceMemoryReportFeaturesEXT.pNext ); 8265 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceMemoryReportFeaturesEXT.deviceMemoryReport ); 8266 return seed; 8267 } 8268 }; 8269 8270 template <> 8271 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDiagnosticsConfigFeaturesNV> 8272 { 8273 std::size_t operator ()std::hash8274 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDiagnosticsConfigFeaturesNV const & physicalDeviceDiagnosticsConfigFeaturesNV ) const VULKAN_HPP_NOEXCEPT 8275 { 8276 std::size_t seed = 0; 8277 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDiagnosticsConfigFeaturesNV.sType ); 8278 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDiagnosticsConfigFeaturesNV.pNext ); 8279 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDiagnosticsConfigFeaturesNV.diagnosticsConfig ); 8280 return seed; 8281 } 8282 }; 8283 8284 template <> 8285 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDiscardRectanglePropertiesEXT> 8286 { operator ()std::hash8287 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDiscardRectanglePropertiesEXT const & physicalDeviceDiscardRectanglePropertiesEXT ) const 8288 VULKAN_HPP_NOEXCEPT 8289 { 8290 std::size_t seed = 0; 8291 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDiscardRectanglePropertiesEXT.sType ); 8292 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDiscardRectanglePropertiesEXT.pNext ); 8293 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDiscardRectanglePropertiesEXT.maxDiscardRectangles ); 8294 return seed; 8295 } 8296 }; 8297 8298 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 8299 template <> 8300 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDisplacementMicromapFeaturesNV> 8301 { operator ()std::hash8302 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDisplacementMicromapFeaturesNV const & physicalDeviceDisplacementMicromapFeaturesNV ) const 8303 VULKAN_HPP_NOEXCEPT 8304 { 8305 std::size_t seed = 0; 8306 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDisplacementMicromapFeaturesNV.sType ); 8307 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDisplacementMicromapFeaturesNV.pNext ); 8308 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDisplacementMicromapFeaturesNV.displacementMicromap ); 8309 return seed; 8310 } 8311 }; 8312 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 8313 8314 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 8315 template <> 8316 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDisplacementMicromapPropertiesNV> 8317 { operator ()std::hash8318 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDisplacementMicromapPropertiesNV const & physicalDeviceDisplacementMicromapPropertiesNV ) const 8319 VULKAN_HPP_NOEXCEPT 8320 { 8321 std::size_t seed = 0; 8322 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDisplacementMicromapPropertiesNV.sType ); 8323 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDisplacementMicromapPropertiesNV.pNext ); 8324 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDisplacementMicromapPropertiesNV.maxDisplacementMicromapSubdivisionLevel ); 8325 return seed; 8326 } 8327 }; 8328 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 8329 8330 template <> 8331 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDriverProperties> 8332 { operator ()std::hash8333 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDriverProperties const & physicalDeviceDriverProperties ) const VULKAN_HPP_NOEXCEPT 8334 { 8335 std::size_t seed = 0; 8336 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDriverProperties.sType ); 8337 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDriverProperties.pNext ); 8338 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDriverProperties.driverID ); 8339 for ( size_t i = 0; i < VK_MAX_DRIVER_NAME_SIZE; ++i ) 8340 { 8341 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDriverProperties.driverName[i] ); 8342 } 8343 for ( size_t i = 0; i < VK_MAX_DRIVER_INFO_SIZE; ++i ) 8344 { 8345 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDriverProperties.driverInfo[i] ); 8346 } 8347 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDriverProperties.conformanceVersion ); 8348 return seed; 8349 } 8350 }; 8351 8352 template <> 8353 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDrmPropertiesEXT> 8354 { operator ()std::hash8355 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDrmPropertiesEXT const & physicalDeviceDrmPropertiesEXT ) const VULKAN_HPP_NOEXCEPT 8356 { 8357 std::size_t seed = 0; 8358 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDrmPropertiesEXT.sType ); 8359 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDrmPropertiesEXT.pNext ); 8360 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDrmPropertiesEXT.hasPrimary ); 8361 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDrmPropertiesEXT.hasRender ); 8362 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDrmPropertiesEXT.primaryMajor ); 8363 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDrmPropertiesEXT.primaryMinor ); 8364 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDrmPropertiesEXT.renderMajor ); 8365 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDrmPropertiesEXT.renderMinor ); 8366 return seed; 8367 } 8368 }; 8369 8370 template <> 8371 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingFeatures> 8372 { 8373 std::size_t operator ()std::hash8374 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingFeatures const & physicalDeviceDynamicRenderingFeatures ) const VULKAN_HPP_NOEXCEPT 8375 { 8376 std::size_t seed = 0; 8377 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDynamicRenderingFeatures.sType ); 8378 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDynamicRenderingFeatures.pNext ); 8379 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDynamicRenderingFeatures.dynamicRendering ); 8380 return seed; 8381 } 8382 }; 8383 8384 template <> 8385 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR> 8386 { 8387 std::size_t operator ()std::hash8388 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR const & physicalDeviceDynamicRenderingLocalReadFeaturesKHR ) const 8389 VULKAN_HPP_NOEXCEPT 8390 { 8391 std::size_t seed = 0; 8392 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDynamicRenderingLocalReadFeaturesKHR.sType ); 8393 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDynamicRenderingLocalReadFeaturesKHR.pNext ); 8394 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDynamicRenderingLocalReadFeaturesKHR.dynamicRenderingLocalRead ); 8395 return seed; 8396 } 8397 }; 8398 8399 template <> 8400 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT> 8401 { operator ()std::hash8402 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT const & 8403 physicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 8404 { 8405 std::size_t seed = 0; 8406 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT.sType ); 8407 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT.pNext ); 8408 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT.dynamicRenderingUnusedAttachments ); 8409 return seed; 8410 } 8411 }; 8412 8413 template <> 8414 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExclusiveScissorFeaturesNV> 8415 { 8416 std::size_t operator ()std::hash8417 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExclusiveScissorFeaturesNV const & physicalDeviceExclusiveScissorFeaturesNV ) const VULKAN_HPP_NOEXCEPT 8418 { 8419 std::size_t seed = 0; 8420 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExclusiveScissorFeaturesNV.sType ); 8421 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExclusiveScissorFeaturesNV.pNext ); 8422 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExclusiveScissorFeaturesNV.exclusiveScissor ); 8423 return seed; 8424 } 8425 }; 8426 8427 template <> 8428 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState2FeaturesEXT> 8429 { operator ()std::hash8430 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState2FeaturesEXT const & physicalDeviceExtendedDynamicState2FeaturesEXT ) const 8431 VULKAN_HPP_NOEXCEPT 8432 { 8433 std::size_t seed = 0; 8434 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState2FeaturesEXT.sType ); 8435 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState2FeaturesEXT.pNext ); 8436 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState2FeaturesEXT.extendedDynamicState2 ); 8437 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState2FeaturesEXT.extendedDynamicState2LogicOp ); 8438 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState2FeaturesEXT.extendedDynamicState2PatchControlPoints ); 8439 return seed; 8440 } 8441 }; 8442 8443 template <> 8444 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState3FeaturesEXT> 8445 { operator ()std::hash8446 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState3FeaturesEXT const & physicalDeviceExtendedDynamicState3FeaturesEXT ) const 8447 VULKAN_HPP_NOEXCEPT 8448 { 8449 std::size_t seed = 0; 8450 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.sType ); 8451 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.pNext ); 8452 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3TessellationDomainOrigin ); 8453 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3DepthClampEnable ); 8454 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3PolygonMode ); 8455 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3RasterizationSamples ); 8456 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3SampleMask ); 8457 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3AlphaToCoverageEnable ); 8458 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3AlphaToOneEnable ); 8459 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3LogicOpEnable ); 8460 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ColorBlendEnable ); 8461 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ColorBlendEquation ); 8462 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ColorWriteMask ); 8463 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3RasterizationStream ); 8464 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ConservativeRasterizationMode ); 8465 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ExtraPrimitiveOverestimationSize ); 8466 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3DepthClipEnable ); 8467 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3SampleLocationsEnable ); 8468 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ColorBlendAdvanced ); 8469 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ProvokingVertexMode ); 8470 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3LineRasterizationMode ); 8471 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3LineStippleEnable ); 8472 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3DepthClipNegativeOneToOne ); 8473 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ViewportWScalingEnable ); 8474 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ViewportSwizzle ); 8475 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3CoverageToColorEnable ); 8476 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3CoverageToColorLocation ); 8477 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3CoverageModulationMode ); 8478 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3CoverageModulationTableEnable ); 8479 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3CoverageModulationTable ); 8480 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3CoverageReductionMode ); 8481 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3RepresentativeFragmentTestEnable ); 8482 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ShadingRateImageEnable ); 8483 return seed; 8484 } 8485 }; 8486 8487 template <> 8488 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState3PropertiesEXT> 8489 { operator ()std::hash8490 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState3PropertiesEXT const & physicalDeviceExtendedDynamicState3PropertiesEXT ) 8491 const VULKAN_HPP_NOEXCEPT 8492 { 8493 std::size_t seed = 0; 8494 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3PropertiesEXT.sType ); 8495 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3PropertiesEXT.pNext ); 8496 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3PropertiesEXT.dynamicPrimitiveTopologyUnrestricted ); 8497 return seed; 8498 } 8499 }; 8500 8501 template <> 8502 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicStateFeaturesEXT> 8503 { operator ()std::hash8504 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicStateFeaturesEXT const & physicalDeviceExtendedDynamicStateFeaturesEXT ) const 8505 VULKAN_HPP_NOEXCEPT 8506 { 8507 std::size_t seed = 0; 8508 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicStateFeaturesEXT.sType ); 8509 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicStateFeaturesEXT.pNext ); 8510 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicStateFeaturesEXT.extendedDynamicState ); 8511 return seed; 8512 } 8513 }; 8514 8515 template <> 8516 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV> 8517 { 8518 std::size_t operator ()std::hash8519 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV const & physicalDeviceExtendedSparseAddressSpaceFeaturesNV ) const 8520 VULKAN_HPP_NOEXCEPT 8521 { 8522 std::size_t seed = 0; 8523 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedSparseAddressSpaceFeaturesNV.sType ); 8524 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedSparseAddressSpaceFeaturesNV.pNext ); 8525 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedSparseAddressSpaceFeaturesNV.extendedSparseAddressSpace ); 8526 return seed; 8527 } 8528 }; 8529 8530 template <> 8531 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedSparseAddressSpacePropertiesNV> 8532 { operator ()std::hash8533 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedSparseAddressSpacePropertiesNV const & 8534 physicalDeviceExtendedSparseAddressSpacePropertiesNV ) const VULKAN_HPP_NOEXCEPT 8535 { 8536 std::size_t seed = 0; 8537 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedSparseAddressSpacePropertiesNV.sType ); 8538 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedSparseAddressSpacePropertiesNV.pNext ); 8539 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedSparseAddressSpacePropertiesNV.extendedSparseAddressSpaceSize ); 8540 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedSparseAddressSpacePropertiesNV.extendedSparseImageUsageFlags ); 8541 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedSparseAddressSpacePropertiesNV.extendedSparseBufferUsageFlags ); 8542 return seed; 8543 } 8544 }; 8545 8546 template <> 8547 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo> 8548 { operator ()std::hash8549 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo const & physicalDeviceExternalBufferInfo ) const VULKAN_HPP_NOEXCEPT 8550 { 8551 std::size_t seed = 0; 8552 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalBufferInfo.sType ); 8553 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalBufferInfo.pNext ); 8554 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalBufferInfo.flags ); 8555 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalBufferInfo.usage ); 8556 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalBufferInfo.handleType ); 8557 return seed; 8558 } 8559 }; 8560 8561 template <> 8562 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo> 8563 { operator ()std::hash8564 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo const & physicalDeviceExternalFenceInfo ) const VULKAN_HPP_NOEXCEPT 8565 { 8566 std::size_t seed = 0; 8567 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFenceInfo.sType ); 8568 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFenceInfo.pNext ); 8569 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFenceInfo.handleType ); 8570 return seed; 8571 } 8572 }; 8573 8574 # if defined( VK_USE_PLATFORM_ANDROID_KHR ) 8575 template <> 8576 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFormatResolveFeaturesANDROID> 8577 { 8578 std::size_t operator ()std::hash8579 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFormatResolveFeaturesANDROID const & physicalDeviceExternalFormatResolveFeaturesANDROID ) const 8580 VULKAN_HPP_NOEXCEPT 8581 { 8582 std::size_t seed = 0; 8583 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFormatResolveFeaturesANDROID.sType ); 8584 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFormatResolveFeaturesANDROID.pNext ); 8585 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFormatResolveFeaturesANDROID.externalFormatResolve ); 8586 return seed; 8587 } 8588 }; 8589 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ 8590 8591 # if defined( VK_USE_PLATFORM_ANDROID_KHR ) 8592 template <> 8593 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFormatResolvePropertiesANDROID> 8594 { operator ()std::hash8595 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFormatResolvePropertiesANDROID const & 8596 physicalDeviceExternalFormatResolvePropertiesANDROID ) const VULKAN_HPP_NOEXCEPT 8597 { 8598 std::size_t seed = 0; 8599 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFormatResolvePropertiesANDROID.sType ); 8600 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFormatResolvePropertiesANDROID.pNext ); 8601 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFormatResolvePropertiesANDROID.nullColorAttachmentWithExternalFormatResolve ); 8602 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFormatResolvePropertiesANDROID.externalFormatResolveChromaOffsetX ); 8603 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFormatResolvePropertiesANDROID.externalFormatResolveChromaOffsetY ); 8604 return seed; 8605 } 8606 }; 8607 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ 8608 8609 template <> 8610 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalImageFormatInfo> 8611 { 8612 std::size_t operator ()std::hash8613 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalImageFormatInfo const & physicalDeviceExternalImageFormatInfo ) const VULKAN_HPP_NOEXCEPT 8614 { 8615 std::size_t seed = 0; 8616 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalImageFormatInfo.sType ); 8617 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalImageFormatInfo.pNext ); 8618 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalImageFormatInfo.handleType ); 8619 return seed; 8620 } 8621 }; 8622 8623 template <> 8624 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryHostPropertiesEXT> 8625 { operator ()std::hash8626 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryHostPropertiesEXT const & physicalDeviceExternalMemoryHostPropertiesEXT ) const 8627 VULKAN_HPP_NOEXCEPT 8628 { 8629 std::size_t seed = 0; 8630 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalMemoryHostPropertiesEXT.sType ); 8631 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalMemoryHostPropertiesEXT.pNext ); 8632 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalMemoryHostPropertiesEXT.minImportedHostPointerAlignment ); 8633 return seed; 8634 } 8635 }; 8636 8637 template <> 8638 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryRDMAFeaturesNV> 8639 { operator ()std::hash8640 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryRDMAFeaturesNV const & physicalDeviceExternalMemoryRDMAFeaturesNV ) const 8641 VULKAN_HPP_NOEXCEPT 8642 { 8643 std::size_t seed = 0; 8644 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalMemoryRDMAFeaturesNV.sType ); 8645 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalMemoryRDMAFeaturesNV.pNext ); 8646 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalMemoryRDMAFeaturesNV.externalMemoryRDMA ); 8647 return seed; 8648 } 8649 }; 8650 8651 # if defined( VK_USE_PLATFORM_SCREEN_QNX ) 8652 template <> 8653 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX> 8654 { 8655 std::size_t operator ()std::hash8656 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX const & physicalDeviceExternalMemoryScreenBufferFeaturesQNX ) const 8657 VULKAN_HPP_NOEXCEPT 8658 { 8659 std::size_t seed = 0; 8660 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalMemoryScreenBufferFeaturesQNX.sType ); 8661 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalMemoryScreenBufferFeaturesQNX.pNext ); 8662 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalMemoryScreenBufferFeaturesQNX.screenBufferImport ); 8663 return seed; 8664 } 8665 }; 8666 # endif /*VK_USE_PLATFORM_SCREEN_QNX*/ 8667 8668 template <> 8669 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo> 8670 { operator ()std::hash8671 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo const & physicalDeviceExternalSemaphoreInfo ) const VULKAN_HPP_NOEXCEPT 8672 { 8673 std::size_t seed = 0; 8674 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalSemaphoreInfo.sType ); 8675 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalSemaphoreInfo.pNext ); 8676 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalSemaphoreInfo.handleType ); 8677 return seed; 8678 } 8679 }; 8680 8681 template <> 8682 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFaultFeaturesEXT> 8683 { operator ()std::hash8684 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFaultFeaturesEXT const & physicalDeviceFaultFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 8685 { 8686 std::size_t seed = 0; 8687 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFaultFeaturesEXT.sType ); 8688 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFaultFeaturesEXT.pNext ); 8689 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFaultFeaturesEXT.deviceFault ); 8690 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFaultFeaturesEXT.deviceFaultVendorBinary ); 8691 return seed; 8692 } 8693 }; 8694 8695 template <> 8696 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2> 8697 { operator ()std::hash8698 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 const & physicalDeviceFeatures2 ) const VULKAN_HPP_NOEXCEPT 8699 { 8700 std::size_t seed = 0; 8701 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures2.sType ); 8702 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures2.pNext ); 8703 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures2.features ); 8704 return seed; 8705 } 8706 }; 8707 8708 template <> 8709 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFloatControlsProperties> 8710 { 8711 std::size_t operator ()std::hash8712 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFloatControlsProperties const & physicalDeviceFloatControlsProperties ) const VULKAN_HPP_NOEXCEPT 8713 { 8714 std::size_t seed = 0; 8715 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.sType ); 8716 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.pNext ); 8717 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.denormBehaviorIndependence ); 8718 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.roundingModeIndependence ); 8719 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderSignedZeroInfNanPreserveFloat16 ); 8720 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderSignedZeroInfNanPreserveFloat32 ); 8721 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderSignedZeroInfNanPreserveFloat64 ); 8722 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderDenormPreserveFloat16 ); 8723 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderDenormPreserveFloat32 ); 8724 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderDenormPreserveFloat64 ); 8725 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderDenormFlushToZeroFloat16 ); 8726 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderDenormFlushToZeroFloat32 ); 8727 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderDenormFlushToZeroFloat64 ); 8728 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTEFloat16 ); 8729 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTEFloat32 ); 8730 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTEFloat64 ); 8731 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTZFloat16 ); 8732 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTZFloat32 ); 8733 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTZFloat64 ); 8734 return seed; 8735 } 8736 }; 8737 8738 template <> 8739 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMap2FeaturesEXT> 8740 { operator ()std::hash8741 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMap2FeaturesEXT const & physicalDeviceFragmentDensityMap2FeaturesEXT ) const 8742 VULKAN_HPP_NOEXCEPT 8743 { 8744 std::size_t seed = 0; 8745 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMap2FeaturesEXT.sType ); 8746 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMap2FeaturesEXT.pNext ); 8747 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMap2FeaturesEXT.fragmentDensityMapDeferred ); 8748 return seed; 8749 } 8750 }; 8751 8752 template <> 8753 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMap2PropertiesEXT> 8754 { operator ()std::hash8755 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMap2PropertiesEXT const & physicalDeviceFragmentDensityMap2PropertiesEXT ) const 8756 VULKAN_HPP_NOEXCEPT 8757 { 8758 std::size_t seed = 0; 8759 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMap2PropertiesEXT.sType ); 8760 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMap2PropertiesEXT.pNext ); 8761 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMap2PropertiesEXT.subsampledLoads ); 8762 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMap2PropertiesEXT.subsampledCoarseReconstructionEarlyAccess ); 8763 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMap2PropertiesEXT.maxSubsampledArrayLayers ); 8764 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMap2PropertiesEXT.maxDescriptorSetSubsampledSamplers ); 8765 return seed; 8766 } 8767 }; 8768 8769 template <> 8770 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapFeaturesEXT> 8771 { operator ()std::hash8772 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapFeaturesEXT const & physicalDeviceFragmentDensityMapFeaturesEXT ) const 8773 VULKAN_HPP_NOEXCEPT 8774 { 8775 std::size_t seed = 0; 8776 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapFeaturesEXT.sType ); 8777 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapFeaturesEXT.pNext ); 8778 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapFeaturesEXT.fragmentDensityMap ); 8779 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapFeaturesEXT.fragmentDensityMapDynamic ); 8780 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapFeaturesEXT.fragmentDensityMapNonSubsampledImages ); 8781 return seed; 8782 } 8783 }; 8784 8785 template <> 8786 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM> 8787 { 8788 std::size_t operator ()std::hash8789 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM const & physicalDeviceFragmentDensityMapOffsetFeaturesQCOM ) const 8790 VULKAN_HPP_NOEXCEPT 8791 { 8792 std::size_t seed = 0; 8793 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetFeaturesQCOM.sType ); 8794 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetFeaturesQCOM.pNext ); 8795 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetFeaturesQCOM.fragmentDensityMapOffset ); 8796 return seed; 8797 } 8798 }; 8799 8800 template <> 8801 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM> 8802 { operator ()std::hash8803 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM const & 8804 physicalDeviceFragmentDensityMapOffsetPropertiesQCOM ) const VULKAN_HPP_NOEXCEPT 8805 { 8806 std::size_t seed = 0; 8807 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetPropertiesQCOM.sType ); 8808 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetPropertiesQCOM.pNext ); 8809 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetPropertiesQCOM.fragmentDensityOffsetGranularity ); 8810 return seed; 8811 } 8812 }; 8813 8814 template <> 8815 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapPropertiesEXT> 8816 { operator ()std::hash8817 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapPropertiesEXT const & physicalDeviceFragmentDensityMapPropertiesEXT ) const 8818 VULKAN_HPP_NOEXCEPT 8819 { 8820 std::size_t seed = 0; 8821 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapPropertiesEXT.sType ); 8822 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapPropertiesEXT.pNext ); 8823 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapPropertiesEXT.minFragmentDensityTexelSize ); 8824 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapPropertiesEXT.maxFragmentDensityTexelSize ); 8825 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapPropertiesEXT.fragmentDensityInvocations ); 8826 return seed; 8827 } 8828 }; 8829 8830 template <> 8831 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderBarycentricFeaturesKHR> 8832 { 8833 std::size_t operator ()std::hash8834 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderBarycentricFeaturesKHR const & physicalDeviceFragmentShaderBarycentricFeaturesKHR ) const 8835 VULKAN_HPP_NOEXCEPT 8836 { 8837 std::size_t seed = 0; 8838 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderBarycentricFeaturesKHR.sType ); 8839 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderBarycentricFeaturesKHR.pNext ); 8840 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderBarycentricFeaturesKHR.fragmentShaderBarycentric ); 8841 return seed; 8842 } 8843 }; 8844 8845 template <> 8846 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderBarycentricPropertiesKHR> 8847 { operator ()std::hash8848 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderBarycentricPropertiesKHR const & 8849 physicalDeviceFragmentShaderBarycentricPropertiesKHR ) const VULKAN_HPP_NOEXCEPT 8850 { 8851 std::size_t seed = 0; 8852 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderBarycentricPropertiesKHR.sType ); 8853 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderBarycentricPropertiesKHR.pNext ); 8854 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderBarycentricPropertiesKHR.triStripVertexOrderIndependentOfProvokingVertex ); 8855 return seed; 8856 } 8857 }; 8858 8859 template <> 8860 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderInterlockFeaturesEXT> 8861 { operator ()std::hash8862 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderInterlockFeaturesEXT const & physicalDeviceFragmentShaderInterlockFeaturesEXT ) 8863 const VULKAN_HPP_NOEXCEPT 8864 { 8865 std::size_t seed = 0; 8866 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderInterlockFeaturesEXT.sType ); 8867 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderInterlockFeaturesEXT.pNext ); 8868 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderInterlockFeaturesEXT.fragmentShaderSampleInterlock ); 8869 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderInterlockFeaturesEXT.fragmentShaderPixelInterlock ); 8870 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderInterlockFeaturesEXT.fragmentShaderShadingRateInterlock ); 8871 return seed; 8872 } 8873 }; 8874 8875 template <> 8876 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateEnumsFeaturesNV> 8877 { operator ()std::hash8878 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateEnumsFeaturesNV const & physicalDeviceFragmentShadingRateEnumsFeaturesNV ) 8879 const VULKAN_HPP_NOEXCEPT 8880 { 8881 std::size_t seed = 0; 8882 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateEnumsFeaturesNV.sType ); 8883 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateEnumsFeaturesNV.pNext ); 8884 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateEnumsFeaturesNV.fragmentShadingRateEnums ); 8885 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateEnumsFeaturesNV.supersampleFragmentShadingRates ); 8886 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateEnumsFeaturesNV.noInvocationFragmentShadingRates ); 8887 return seed; 8888 } 8889 }; 8890 8891 template <> 8892 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateEnumsPropertiesNV> 8893 { 8894 std::size_t operator ()std::hash8895 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateEnumsPropertiesNV const & physicalDeviceFragmentShadingRateEnumsPropertiesNV ) const 8896 VULKAN_HPP_NOEXCEPT 8897 { 8898 std::size_t seed = 0; 8899 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateEnumsPropertiesNV.sType ); 8900 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateEnumsPropertiesNV.pNext ); 8901 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateEnumsPropertiesNV.maxFragmentShadingRateInvocationCount ); 8902 return seed; 8903 } 8904 }; 8905 8906 template <> 8907 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateFeaturesKHR> 8908 { operator ()std::hash8909 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateFeaturesKHR const & physicalDeviceFragmentShadingRateFeaturesKHR ) const 8910 VULKAN_HPP_NOEXCEPT 8911 { 8912 std::size_t seed = 0; 8913 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateFeaturesKHR.sType ); 8914 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateFeaturesKHR.pNext ); 8915 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateFeaturesKHR.pipelineFragmentShadingRate ); 8916 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateFeaturesKHR.primitiveFragmentShadingRate ); 8917 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateFeaturesKHR.attachmentFragmentShadingRate ); 8918 return seed; 8919 } 8920 }; 8921 8922 template <> 8923 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR> 8924 { operator ()std::hash8925 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR const & physicalDeviceFragmentShadingRateKHR ) const VULKAN_HPP_NOEXCEPT 8926 { 8927 std::size_t seed = 0; 8928 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateKHR.sType ); 8929 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateKHR.pNext ); 8930 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateKHR.sampleCounts ); 8931 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateKHR.fragmentSize ); 8932 return seed; 8933 } 8934 }; 8935 8936 template <> 8937 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRatePropertiesKHR> 8938 { operator ()std::hash8939 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRatePropertiesKHR const & physicalDeviceFragmentShadingRatePropertiesKHR ) const 8940 VULKAN_HPP_NOEXCEPT 8941 { 8942 std::size_t seed = 0; 8943 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.sType ); 8944 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.pNext ); 8945 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.minFragmentShadingRateAttachmentTexelSize ); 8946 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentShadingRateAttachmentTexelSize ); 8947 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentShadingRateAttachmentTexelSizeAspectRatio ); 8948 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.primitiveFragmentShadingRateWithMultipleViewports ); 8949 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.layeredShadingRateAttachments ); 8950 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateNonTrivialCombinerOps ); 8951 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentSize ); 8952 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentSizeAspectRatio ); 8953 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentShadingRateCoverageSamples ); 8954 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentShadingRateRasterizationSamples ); 8955 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithShaderDepthStencilWrites ); 8956 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithSampleMask ); 8957 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithShaderSampleMask ); 8958 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithConservativeRasterization ); 8959 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithFragmentShaderInterlock ); 8960 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithCustomSampleLocations ); 8961 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateStrictMultiplyCombiner ); 8962 return seed; 8963 } 8964 }; 8965 8966 template <> 8967 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFrameBoundaryFeaturesEXT> 8968 { 8969 std::size_t operator ()std::hash8970 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFrameBoundaryFeaturesEXT const & physicalDeviceFrameBoundaryFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 8971 { 8972 std::size_t seed = 0; 8973 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFrameBoundaryFeaturesEXT.sType ); 8974 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFrameBoundaryFeaturesEXT.pNext ); 8975 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFrameBoundaryFeaturesEXT.frameBoundary ); 8976 return seed; 8977 } 8978 }; 8979 8980 template <> 8981 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceGlobalPriorityQueryFeaturesKHR> 8982 { operator ()std::hash8983 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceGlobalPriorityQueryFeaturesKHR const & physicalDeviceGlobalPriorityQueryFeaturesKHR ) const 8984 VULKAN_HPP_NOEXCEPT 8985 { 8986 std::size_t seed = 0; 8987 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGlobalPriorityQueryFeaturesKHR.sType ); 8988 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGlobalPriorityQueryFeaturesKHR.pNext ); 8989 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGlobalPriorityQueryFeaturesKHR.globalPriorityQuery ); 8990 return seed; 8991 } 8992 }; 8993 8994 template <> 8995 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT> 8996 { operator ()std::hash8997 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT const & physicalDeviceGraphicsPipelineLibraryFeaturesEXT ) 8998 const VULKAN_HPP_NOEXCEPT 8999 { 9000 std::size_t seed = 0; 9001 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGraphicsPipelineLibraryFeaturesEXT.sType ); 9002 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGraphicsPipelineLibraryFeaturesEXT.pNext ); 9003 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGraphicsPipelineLibraryFeaturesEXT.graphicsPipelineLibrary ); 9004 return seed; 9005 } 9006 }; 9007 9008 template <> 9009 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT> 9010 { 9011 std::size_t operator ()std::hash9012 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT const & physicalDeviceGraphicsPipelineLibraryPropertiesEXT ) const 9013 VULKAN_HPP_NOEXCEPT 9014 { 9015 std::size_t seed = 0; 9016 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGraphicsPipelineLibraryPropertiesEXT.sType ); 9017 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGraphicsPipelineLibraryPropertiesEXT.pNext ); 9018 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGraphicsPipelineLibraryPropertiesEXT.graphicsPipelineLibraryFastLinking ); 9019 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGraphicsPipelineLibraryPropertiesEXT.graphicsPipelineLibraryIndependentInterpolationDecoration ); 9020 return seed; 9021 } 9022 }; 9023 9024 template <> 9025 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties> 9026 { operator ()std::hash9027 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties const & physicalDeviceGroupProperties ) const VULKAN_HPP_NOEXCEPT 9028 { 9029 std::size_t seed = 0; 9030 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGroupProperties.sType ); 9031 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGroupProperties.pNext ); 9032 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGroupProperties.physicalDeviceCount ); 9033 for ( size_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; ++i ) 9034 { 9035 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGroupProperties.physicalDevices[i] ); 9036 } 9037 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGroupProperties.subsetAllocation ); 9038 return seed; 9039 } 9040 }; 9041 9042 template <> 9043 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceHostImageCopyFeaturesEXT> 9044 { 9045 std::size_t operator ()std::hash9046 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceHostImageCopyFeaturesEXT const & physicalDeviceHostImageCopyFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 9047 { 9048 std::size_t seed = 0; 9049 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyFeaturesEXT.sType ); 9050 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyFeaturesEXT.pNext ); 9051 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyFeaturesEXT.hostImageCopy ); 9052 return seed; 9053 } 9054 }; 9055 9056 template <> 9057 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceHostImageCopyPropertiesEXT> 9058 { 9059 std::size_t operator ()std::hash9060 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceHostImageCopyPropertiesEXT const & physicalDeviceHostImageCopyPropertiesEXT ) const VULKAN_HPP_NOEXCEPT 9061 { 9062 std::size_t seed = 0; 9063 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyPropertiesEXT.sType ); 9064 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyPropertiesEXT.pNext ); 9065 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyPropertiesEXT.copySrcLayoutCount ); 9066 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyPropertiesEXT.pCopySrcLayouts ); 9067 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyPropertiesEXT.copyDstLayoutCount ); 9068 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyPropertiesEXT.pCopyDstLayouts ); 9069 for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) 9070 { 9071 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyPropertiesEXT.optimalTilingLayoutUUID[i] ); 9072 } 9073 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyPropertiesEXT.identicalMemoryTypeRequirements ); 9074 return seed; 9075 } 9076 }; 9077 9078 template <> 9079 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceHostQueryResetFeatures> 9080 { operator ()std::hash9081 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceHostQueryResetFeatures const & physicalDeviceHostQueryResetFeatures ) const VULKAN_HPP_NOEXCEPT 9082 { 9083 std::size_t seed = 0; 9084 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostQueryResetFeatures.sType ); 9085 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostQueryResetFeatures.pNext ); 9086 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostQueryResetFeatures.hostQueryReset ); 9087 return seed; 9088 } 9089 }; 9090 9091 template <> 9092 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceIDProperties> 9093 { operator ()std::hash9094 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceIDProperties const & physicalDeviceIDProperties ) const VULKAN_HPP_NOEXCEPT 9095 { 9096 std::size_t seed = 0; 9097 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIDProperties.sType ); 9098 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIDProperties.pNext ); 9099 for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) 9100 { 9101 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIDProperties.deviceUUID[i] ); 9102 } 9103 for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) 9104 { 9105 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIDProperties.driverUUID[i] ); 9106 } 9107 for ( size_t i = 0; i < VK_LUID_SIZE; ++i ) 9108 { 9109 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIDProperties.deviceLUID[i] ); 9110 } 9111 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIDProperties.deviceNodeMask ); 9112 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIDProperties.deviceLUIDValid ); 9113 return seed; 9114 } 9115 }; 9116 9117 template <> 9118 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImage2DViewOf3DFeaturesEXT> 9119 { 9120 std::size_t operator ()std::hash9121 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImage2DViewOf3DFeaturesEXT const & physicalDeviceImage2DViewOf3DFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 9122 { 9123 std::size_t seed = 0; 9124 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImage2DViewOf3DFeaturesEXT.sType ); 9125 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImage2DViewOf3DFeaturesEXT.pNext ); 9126 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImage2DViewOf3DFeaturesEXT.image2DViewOf3D ); 9127 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImage2DViewOf3DFeaturesEXT.sampler2DViewOf3D ); 9128 return seed; 9129 } 9130 }; 9131 9132 template <> 9133 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageAlignmentControlFeaturesMESA> 9134 { operator ()std::hash9135 std::size_t operator()( 9136 VULKAN_HPP_NAMESPACE::PhysicalDeviceImageAlignmentControlFeaturesMESA const & physicalDeviceImageAlignmentControlFeaturesMESA ) const VULKAN_HPP_NOEXCEPT 9137 { 9138 std::size_t seed = 0; 9139 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageAlignmentControlFeaturesMESA.sType ); 9140 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageAlignmentControlFeaturesMESA.pNext ); 9141 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageAlignmentControlFeaturesMESA.imageAlignmentControl ); 9142 return seed; 9143 } 9144 }; 9145 9146 template <> 9147 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageAlignmentControlPropertiesMESA> 9148 { operator ()std::hash9149 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageAlignmentControlPropertiesMESA const & physicalDeviceImageAlignmentControlPropertiesMESA ) 9150 const VULKAN_HPP_NOEXCEPT 9151 { 9152 std::size_t seed = 0; 9153 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageAlignmentControlPropertiesMESA.sType ); 9154 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageAlignmentControlPropertiesMESA.pNext ); 9155 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageAlignmentControlPropertiesMESA.supportedImageAlignmentMask ); 9156 return seed; 9157 } 9158 }; 9159 9160 template <> 9161 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageCompressionControlFeaturesEXT> 9162 { operator ()std::hash9163 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageCompressionControlFeaturesEXT const & physicalDeviceImageCompressionControlFeaturesEXT ) 9164 const VULKAN_HPP_NOEXCEPT 9165 { 9166 std::size_t seed = 0; 9167 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageCompressionControlFeaturesEXT.sType ); 9168 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageCompressionControlFeaturesEXT.pNext ); 9169 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageCompressionControlFeaturesEXT.imageCompressionControl ); 9170 return seed; 9171 } 9172 }; 9173 9174 template <> 9175 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT> 9176 { operator ()std::hash9177 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT const & 9178 physicalDeviceImageCompressionControlSwapchainFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 9179 { 9180 std::size_t seed = 0; 9181 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageCompressionControlSwapchainFeaturesEXT.sType ); 9182 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageCompressionControlSwapchainFeaturesEXT.pNext ); 9183 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageCompressionControlSwapchainFeaturesEXT.imageCompressionControlSwapchain ); 9184 return seed; 9185 } 9186 }; 9187 9188 template <> 9189 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageDrmFormatModifierInfoEXT> 9190 { operator ()std::hash9191 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageDrmFormatModifierInfoEXT const & physicalDeviceImageDrmFormatModifierInfoEXT ) const 9192 VULKAN_HPP_NOEXCEPT 9193 { 9194 std::size_t seed = 0; 9195 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageDrmFormatModifierInfoEXT.sType ); 9196 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageDrmFormatModifierInfoEXT.pNext ); 9197 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageDrmFormatModifierInfoEXT.drmFormatModifier ); 9198 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageDrmFormatModifierInfoEXT.sharingMode ); 9199 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageDrmFormatModifierInfoEXT.queueFamilyIndexCount ); 9200 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageDrmFormatModifierInfoEXT.pQueueFamilyIndices ); 9201 return seed; 9202 } 9203 }; 9204 9205 template <> 9206 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2> 9207 { operator ()std::hash9208 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 const & physicalDeviceImageFormatInfo2 ) const VULKAN_HPP_NOEXCEPT 9209 { 9210 std::size_t seed = 0; 9211 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageFormatInfo2.sType ); 9212 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageFormatInfo2.pNext ); 9213 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageFormatInfo2.format ); 9214 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageFormatInfo2.type ); 9215 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageFormatInfo2.tiling ); 9216 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageFormatInfo2.usage ); 9217 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageFormatInfo2.flags ); 9218 return seed; 9219 } 9220 }; 9221 9222 template <> 9223 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessing2FeaturesQCOM> 9224 { operator ()std::hash9225 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessing2FeaturesQCOM const & physicalDeviceImageProcessing2FeaturesQCOM ) const 9226 VULKAN_HPP_NOEXCEPT 9227 { 9228 std::size_t seed = 0; 9229 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessing2FeaturesQCOM.sType ); 9230 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessing2FeaturesQCOM.pNext ); 9231 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessing2FeaturesQCOM.textureBlockMatch2 ); 9232 return seed; 9233 } 9234 }; 9235 9236 template <> 9237 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessing2PropertiesQCOM> 9238 { operator ()std::hash9239 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessing2PropertiesQCOM const & physicalDeviceImageProcessing2PropertiesQCOM ) const 9240 VULKAN_HPP_NOEXCEPT 9241 { 9242 std::size_t seed = 0; 9243 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessing2PropertiesQCOM.sType ); 9244 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessing2PropertiesQCOM.pNext ); 9245 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessing2PropertiesQCOM.maxBlockMatchWindow ); 9246 return seed; 9247 } 9248 }; 9249 9250 template <> 9251 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessingFeaturesQCOM> 9252 { 9253 std::size_t operator ()std::hash9254 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessingFeaturesQCOM const & physicalDeviceImageProcessingFeaturesQCOM ) const VULKAN_HPP_NOEXCEPT 9255 { 9256 std::size_t seed = 0; 9257 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingFeaturesQCOM.sType ); 9258 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingFeaturesQCOM.pNext ); 9259 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingFeaturesQCOM.textureSampleWeighted ); 9260 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingFeaturesQCOM.textureBoxFilter ); 9261 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingFeaturesQCOM.textureBlockMatch ); 9262 return seed; 9263 } 9264 }; 9265 9266 template <> 9267 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessingPropertiesQCOM> 9268 { operator ()std::hash9269 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessingPropertiesQCOM const & physicalDeviceImageProcessingPropertiesQCOM ) const 9270 VULKAN_HPP_NOEXCEPT 9271 { 9272 std::size_t seed = 0; 9273 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingPropertiesQCOM.sType ); 9274 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingPropertiesQCOM.pNext ); 9275 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingPropertiesQCOM.maxWeightFilterPhases ); 9276 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingPropertiesQCOM.maxWeightFilterDimension ); 9277 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingPropertiesQCOM.maxBlockMatchRegion ); 9278 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingPropertiesQCOM.maxBoxFilterBlockSize ); 9279 return seed; 9280 } 9281 }; 9282 9283 template <> 9284 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageRobustnessFeatures> 9285 { 9286 std::size_t operator ()std::hash9287 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageRobustnessFeatures const & physicalDeviceImageRobustnessFeatures ) const VULKAN_HPP_NOEXCEPT 9288 { 9289 std::size_t seed = 0; 9290 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageRobustnessFeatures.sType ); 9291 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageRobustnessFeatures.pNext ); 9292 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageRobustnessFeatures.robustImageAccess ); 9293 return seed; 9294 } 9295 }; 9296 9297 template <> 9298 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageSlicedViewOf3DFeaturesEXT> 9299 { operator ()std::hash9300 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageSlicedViewOf3DFeaturesEXT const & physicalDeviceImageSlicedViewOf3DFeaturesEXT ) const 9301 VULKAN_HPP_NOEXCEPT 9302 { 9303 std::size_t seed = 0; 9304 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageSlicedViewOf3DFeaturesEXT.sType ); 9305 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageSlicedViewOf3DFeaturesEXT.pNext ); 9306 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageSlicedViewOf3DFeaturesEXT.imageSlicedViewOf3D ); 9307 return seed; 9308 } 9309 }; 9310 9311 template <> 9312 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageViewImageFormatInfoEXT> 9313 { 9314 std::size_t operator ()std::hash9315 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageViewImageFormatInfoEXT const & physicalDeviceImageViewImageFormatInfoEXT ) const VULKAN_HPP_NOEXCEPT 9316 { 9317 std::size_t seed = 0; 9318 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageViewImageFormatInfoEXT.sType ); 9319 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageViewImageFormatInfoEXT.pNext ); 9320 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageViewImageFormatInfoEXT.imageViewType ); 9321 return seed; 9322 } 9323 }; 9324 9325 template <> 9326 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageViewMinLodFeaturesEXT> 9327 { 9328 std::size_t operator ()std::hash9329 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageViewMinLodFeaturesEXT const & physicalDeviceImageViewMinLodFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 9330 { 9331 std::size_t seed = 0; 9332 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageViewMinLodFeaturesEXT.sType ); 9333 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageViewMinLodFeaturesEXT.pNext ); 9334 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageViewMinLodFeaturesEXT.minLod ); 9335 return seed; 9336 } 9337 }; 9338 9339 template <> 9340 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImagelessFramebufferFeatures> 9341 { operator ()std::hash9342 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImagelessFramebufferFeatures const & physicalDeviceImagelessFramebufferFeatures ) const 9343 VULKAN_HPP_NOEXCEPT 9344 { 9345 std::size_t seed = 0; 9346 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImagelessFramebufferFeatures.sType ); 9347 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImagelessFramebufferFeatures.pNext ); 9348 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImagelessFramebufferFeatures.imagelessFramebuffer ); 9349 return seed; 9350 } 9351 }; 9352 9353 template <> 9354 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceIndexTypeUint8FeaturesKHR> 9355 { 9356 std::size_t operator ()std::hash9357 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceIndexTypeUint8FeaturesKHR const & physicalDeviceIndexTypeUint8FeaturesKHR ) const VULKAN_HPP_NOEXCEPT 9358 { 9359 std::size_t seed = 0; 9360 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIndexTypeUint8FeaturesKHR.sType ); 9361 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIndexTypeUint8FeaturesKHR.pNext ); 9362 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIndexTypeUint8FeaturesKHR.indexTypeUint8 ); 9363 return seed; 9364 } 9365 }; 9366 9367 template <> 9368 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceInheritedViewportScissorFeaturesNV> 9369 { operator ()std::hash9370 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceInheritedViewportScissorFeaturesNV const & physicalDeviceInheritedViewportScissorFeaturesNV ) 9371 const VULKAN_HPP_NOEXCEPT 9372 { 9373 std::size_t seed = 0; 9374 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInheritedViewportScissorFeaturesNV.sType ); 9375 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInheritedViewportScissorFeaturesNV.pNext ); 9376 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInheritedViewportScissorFeaturesNV.inheritedViewportScissor2D ); 9377 return seed; 9378 } 9379 }; 9380 9381 template <> 9382 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceInlineUniformBlockFeatures> 9383 { 9384 std::size_t operator ()std::hash9385 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceInlineUniformBlockFeatures const & physicalDeviceInlineUniformBlockFeatures ) const VULKAN_HPP_NOEXCEPT 9386 { 9387 std::size_t seed = 0; 9388 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockFeatures.sType ); 9389 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockFeatures.pNext ); 9390 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockFeatures.inlineUniformBlock ); 9391 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockFeatures.descriptorBindingInlineUniformBlockUpdateAfterBind ); 9392 return seed; 9393 } 9394 }; 9395 9396 template <> 9397 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceInlineUniformBlockProperties> 9398 { operator ()std::hash9399 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceInlineUniformBlockProperties const & physicalDeviceInlineUniformBlockProperties ) const 9400 VULKAN_HPP_NOEXCEPT 9401 { 9402 std::size_t seed = 0; 9403 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockProperties.sType ); 9404 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockProperties.pNext ); 9405 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockProperties.maxInlineUniformBlockSize ); 9406 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockProperties.maxPerStageDescriptorInlineUniformBlocks ); 9407 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockProperties.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks ); 9408 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockProperties.maxDescriptorSetInlineUniformBlocks ); 9409 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockProperties.maxDescriptorSetUpdateAfterBindInlineUniformBlocks ); 9410 return seed; 9411 } 9412 }; 9413 9414 template <> 9415 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceInvocationMaskFeaturesHUAWEI> 9416 { operator ()std::hash9417 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceInvocationMaskFeaturesHUAWEI const & physicalDeviceInvocationMaskFeaturesHUAWEI ) const 9418 VULKAN_HPP_NOEXCEPT 9419 { 9420 std::size_t seed = 0; 9421 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInvocationMaskFeaturesHUAWEI.sType ); 9422 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInvocationMaskFeaturesHUAWEI.pNext ); 9423 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInvocationMaskFeaturesHUAWEI.invocationMask ); 9424 return seed; 9425 } 9426 }; 9427 9428 template <> 9429 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredDriverPropertiesMSFT> 9430 { 9431 std::size_t operator ()std::hash9432 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredDriverPropertiesMSFT const & physicalDeviceLayeredDriverPropertiesMSFT ) const VULKAN_HPP_NOEXCEPT 9433 { 9434 std::size_t seed = 0; 9435 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredDriverPropertiesMSFT.sType ); 9436 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredDriverPropertiesMSFT.pNext ); 9437 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredDriverPropertiesMSFT.underlyingAPI ); 9438 return seed; 9439 } 9440 }; 9441 9442 template <> 9443 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLegacyDitheringFeaturesEXT> 9444 { 9445 std::size_t operator ()std::hash9446 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLegacyDitheringFeaturesEXT const & physicalDeviceLegacyDitheringFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 9447 { 9448 std::size_t seed = 0; 9449 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyDitheringFeaturesEXT.sType ); 9450 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyDitheringFeaturesEXT.pNext ); 9451 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyDitheringFeaturesEXT.legacyDithering ); 9452 return seed; 9453 } 9454 }; 9455 9456 template <> 9457 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLegacyVertexAttributesFeaturesEXT> 9458 { operator ()std::hash9459 std::size_t operator()( 9460 VULKAN_HPP_NAMESPACE::PhysicalDeviceLegacyVertexAttributesFeaturesEXT const & physicalDeviceLegacyVertexAttributesFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 9461 { 9462 std::size_t seed = 0; 9463 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyVertexAttributesFeaturesEXT.sType ); 9464 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyVertexAttributesFeaturesEXT.pNext ); 9465 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyVertexAttributesFeaturesEXT.legacyVertexAttributes ); 9466 return seed; 9467 } 9468 }; 9469 9470 template <> 9471 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLegacyVertexAttributesPropertiesEXT> 9472 { operator ()std::hash9473 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLegacyVertexAttributesPropertiesEXT const & physicalDeviceLegacyVertexAttributesPropertiesEXT ) 9474 const VULKAN_HPP_NOEXCEPT 9475 { 9476 std::size_t seed = 0; 9477 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyVertexAttributesPropertiesEXT.sType ); 9478 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyVertexAttributesPropertiesEXT.pNext ); 9479 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyVertexAttributesPropertiesEXT.nativeUnalignedPerformance ); 9480 return seed; 9481 } 9482 }; 9483 9484 template <> 9485 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLimits> 9486 { operator ()std::hash9487 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLimits const & physicalDeviceLimits ) const VULKAN_HPP_NOEXCEPT 9488 { 9489 std::size_t seed = 0; 9490 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxImageDimension1D ); 9491 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxImageDimension2D ); 9492 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxImageDimension3D ); 9493 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxImageDimensionCube ); 9494 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxImageArrayLayers ); 9495 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTexelBufferElements ); 9496 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxUniformBufferRange ); 9497 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxStorageBufferRange ); 9498 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxPushConstantsSize ); 9499 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxMemoryAllocationCount ); 9500 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxSamplerAllocationCount ); 9501 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.bufferImageGranularity ); 9502 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.sparseAddressSpaceSize ); 9503 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxBoundDescriptorSets ); 9504 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxPerStageDescriptorSamplers ); 9505 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxPerStageDescriptorUniformBuffers ); 9506 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxPerStageDescriptorStorageBuffers ); 9507 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxPerStageDescriptorSampledImages ); 9508 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxPerStageDescriptorStorageImages ); 9509 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxPerStageDescriptorInputAttachments ); 9510 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxPerStageResources ); 9511 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDescriptorSetSamplers ); 9512 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDescriptorSetUniformBuffers ); 9513 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDescriptorSetUniformBuffersDynamic ); 9514 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDescriptorSetStorageBuffers ); 9515 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDescriptorSetStorageBuffersDynamic ); 9516 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDescriptorSetSampledImages ); 9517 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDescriptorSetStorageImages ); 9518 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDescriptorSetInputAttachments ); 9519 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxVertexInputAttributes ); 9520 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxVertexInputBindings ); 9521 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxVertexInputAttributeOffset ); 9522 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxVertexInputBindingStride ); 9523 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxVertexOutputComponents ); 9524 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTessellationGenerationLevel ); 9525 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTessellationPatchSize ); 9526 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTessellationControlPerVertexInputComponents ); 9527 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTessellationControlPerVertexOutputComponents ); 9528 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTessellationControlPerPatchOutputComponents ); 9529 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTessellationControlTotalOutputComponents ); 9530 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTessellationEvaluationInputComponents ); 9531 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTessellationEvaluationOutputComponents ); 9532 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxGeometryShaderInvocations ); 9533 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxGeometryInputComponents ); 9534 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxGeometryOutputComponents ); 9535 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxGeometryOutputVertices ); 9536 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxGeometryTotalOutputComponents ); 9537 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxFragmentInputComponents ); 9538 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxFragmentOutputAttachments ); 9539 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxFragmentDualSrcAttachments ); 9540 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxFragmentCombinedOutputResources ); 9541 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxComputeSharedMemorySize ); 9542 for ( size_t i = 0; i < 3; ++i ) 9543 { 9544 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxComputeWorkGroupCount[i] ); 9545 } 9546 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxComputeWorkGroupInvocations ); 9547 for ( size_t i = 0; i < 3; ++i ) 9548 { 9549 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxComputeWorkGroupSize[i] ); 9550 } 9551 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.subPixelPrecisionBits ); 9552 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.subTexelPrecisionBits ); 9553 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.mipmapPrecisionBits ); 9554 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDrawIndexedIndexValue ); 9555 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDrawIndirectCount ); 9556 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxSamplerLodBias ); 9557 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxSamplerAnisotropy ); 9558 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxViewports ); 9559 for ( size_t i = 0; i < 2; ++i ) 9560 { 9561 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxViewportDimensions[i] ); 9562 } 9563 for ( size_t i = 0; i < 2; ++i ) 9564 { 9565 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.viewportBoundsRange[i] ); 9566 } 9567 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.viewportSubPixelBits ); 9568 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.minMemoryMapAlignment ); 9569 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.minTexelBufferOffsetAlignment ); 9570 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.minUniformBufferOffsetAlignment ); 9571 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.minStorageBufferOffsetAlignment ); 9572 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.minTexelOffset ); 9573 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTexelOffset ); 9574 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.minTexelGatherOffset ); 9575 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTexelGatherOffset ); 9576 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.minInterpolationOffset ); 9577 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxInterpolationOffset ); 9578 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.subPixelInterpolationOffsetBits ); 9579 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxFramebufferWidth ); 9580 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxFramebufferHeight ); 9581 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxFramebufferLayers ); 9582 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.framebufferColorSampleCounts ); 9583 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.framebufferDepthSampleCounts ); 9584 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.framebufferStencilSampleCounts ); 9585 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.framebufferNoAttachmentsSampleCounts ); 9586 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxColorAttachments ); 9587 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.sampledImageColorSampleCounts ); 9588 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.sampledImageIntegerSampleCounts ); 9589 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.sampledImageDepthSampleCounts ); 9590 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.sampledImageStencilSampleCounts ); 9591 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.storageImageSampleCounts ); 9592 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxSampleMaskWords ); 9593 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.timestampComputeAndGraphics ); 9594 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.timestampPeriod ); 9595 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxClipDistances ); 9596 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxCullDistances ); 9597 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxCombinedClipAndCullDistances ); 9598 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.discreteQueuePriorities ); 9599 for ( size_t i = 0; i < 2; ++i ) 9600 { 9601 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.pointSizeRange[i] ); 9602 } 9603 for ( size_t i = 0; i < 2; ++i ) 9604 { 9605 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.lineWidthRange[i] ); 9606 } 9607 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.pointSizeGranularity ); 9608 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.lineWidthGranularity ); 9609 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.strictLines ); 9610 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.standardSampleLocations ); 9611 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.optimalBufferCopyOffsetAlignment ); 9612 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.optimalBufferCopyRowPitchAlignment ); 9613 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.nonCoherentAtomSize ); 9614 return seed; 9615 } 9616 }; 9617 9618 template <> 9619 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationFeaturesKHR> 9620 { operator ()std::hash9621 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationFeaturesKHR const & physicalDeviceLineRasterizationFeaturesKHR ) const 9622 VULKAN_HPP_NOEXCEPT 9623 { 9624 std::size_t seed = 0; 9625 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeaturesKHR.sType ); 9626 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeaturesKHR.pNext ); 9627 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeaturesKHR.rectangularLines ); 9628 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeaturesKHR.bresenhamLines ); 9629 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeaturesKHR.smoothLines ); 9630 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeaturesKHR.stippledRectangularLines ); 9631 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeaturesKHR.stippledBresenhamLines ); 9632 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeaturesKHR.stippledSmoothLines ); 9633 return seed; 9634 } 9635 }; 9636 9637 template <> 9638 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationPropertiesKHR> 9639 { operator ()std::hash9640 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationPropertiesKHR const & physicalDeviceLineRasterizationPropertiesKHR ) const 9641 VULKAN_HPP_NOEXCEPT 9642 { 9643 std::size_t seed = 0; 9644 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationPropertiesKHR.sType ); 9645 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationPropertiesKHR.pNext ); 9646 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationPropertiesKHR.lineSubPixelPrecisionBits ); 9647 return seed; 9648 } 9649 }; 9650 9651 template <> 9652 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLinearColorAttachmentFeaturesNV> 9653 { operator ()std::hash9654 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLinearColorAttachmentFeaturesNV const & physicalDeviceLinearColorAttachmentFeaturesNV ) const 9655 VULKAN_HPP_NOEXCEPT 9656 { 9657 std::size_t seed = 0; 9658 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLinearColorAttachmentFeaturesNV.sType ); 9659 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLinearColorAttachmentFeaturesNV.pNext ); 9660 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLinearColorAttachmentFeaturesNV.linearColorAttachment ); 9661 return seed; 9662 } 9663 }; 9664 9665 template <> 9666 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance3Properties> 9667 { operator ()std::hash9668 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance3Properties const & physicalDeviceMaintenance3Properties ) const VULKAN_HPP_NOEXCEPT 9669 { 9670 std::size_t seed = 0; 9671 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance3Properties.sType ); 9672 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance3Properties.pNext ); 9673 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance3Properties.maxPerSetDescriptors ); 9674 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance3Properties.maxMemoryAllocationSize ); 9675 return seed; 9676 } 9677 }; 9678 9679 template <> 9680 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance4Features> 9681 { operator ()std::hash9682 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance4Features const & physicalDeviceMaintenance4Features ) const VULKAN_HPP_NOEXCEPT 9683 { 9684 std::size_t seed = 0; 9685 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance4Features.sType ); 9686 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance4Features.pNext ); 9687 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance4Features.maintenance4 ); 9688 return seed; 9689 } 9690 }; 9691 9692 template <> 9693 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance4Properties> 9694 { operator ()std::hash9695 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance4Properties const & physicalDeviceMaintenance4Properties ) const VULKAN_HPP_NOEXCEPT 9696 { 9697 std::size_t seed = 0; 9698 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance4Properties.sType ); 9699 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance4Properties.pNext ); 9700 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance4Properties.maxBufferSize ); 9701 return seed; 9702 } 9703 }; 9704 9705 template <> 9706 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance5FeaturesKHR> 9707 { 9708 std::size_t operator ()std::hash9709 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance5FeaturesKHR const & physicalDeviceMaintenance5FeaturesKHR ) const VULKAN_HPP_NOEXCEPT 9710 { 9711 std::size_t seed = 0; 9712 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5FeaturesKHR.sType ); 9713 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5FeaturesKHR.pNext ); 9714 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5FeaturesKHR.maintenance5 ); 9715 return seed; 9716 } 9717 }; 9718 9719 template <> 9720 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance5PropertiesKHR> 9721 { 9722 std::size_t operator ()std::hash9723 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance5PropertiesKHR const & physicalDeviceMaintenance5PropertiesKHR ) const VULKAN_HPP_NOEXCEPT 9724 { 9725 std::size_t seed = 0; 9726 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5PropertiesKHR.sType ); 9727 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5PropertiesKHR.pNext ); 9728 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5PropertiesKHR.earlyFragmentMultisampleCoverageAfterSampleCounting ); 9729 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5PropertiesKHR.earlyFragmentSampleMaskTestBeforeSampleCounting ); 9730 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5PropertiesKHR.depthStencilSwizzleOneSupport ); 9731 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5PropertiesKHR.polygonModePointSize ); 9732 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5PropertiesKHR.nonStrictSinglePixelWideLinesUseParallelogram ); 9733 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5PropertiesKHR.nonStrictWideLinesUseParallelogram ); 9734 return seed; 9735 } 9736 }; 9737 9738 template <> 9739 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance6FeaturesKHR> 9740 { 9741 std::size_t operator ()std::hash9742 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance6FeaturesKHR const & physicalDeviceMaintenance6FeaturesKHR ) const VULKAN_HPP_NOEXCEPT 9743 { 9744 std::size_t seed = 0; 9745 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance6FeaturesKHR.sType ); 9746 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance6FeaturesKHR.pNext ); 9747 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance6FeaturesKHR.maintenance6 ); 9748 return seed; 9749 } 9750 }; 9751 9752 template <> 9753 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance6PropertiesKHR> 9754 { 9755 std::size_t operator ()std::hash9756 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance6PropertiesKHR const & physicalDeviceMaintenance6PropertiesKHR ) const VULKAN_HPP_NOEXCEPT 9757 { 9758 std::size_t seed = 0; 9759 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance6PropertiesKHR.sType ); 9760 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance6PropertiesKHR.pNext ); 9761 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance6PropertiesKHR.blockTexelViewCompatibleMultipleLayers ); 9762 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance6PropertiesKHR.maxCombinedImageSamplerDescriptorCount ); 9763 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance6PropertiesKHR.fragmentShadingRateClampCombinerInputs ); 9764 return seed; 9765 } 9766 }; 9767 9768 template <> 9769 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMapMemoryPlacedFeaturesEXT> 9770 { 9771 std::size_t operator ()std::hash9772 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMapMemoryPlacedFeaturesEXT const & physicalDeviceMapMemoryPlacedFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 9773 { 9774 std::size_t seed = 0; 9775 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMapMemoryPlacedFeaturesEXT.sType ); 9776 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMapMemoryPlacedFeaturesEXT.pNext ); 9777 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMapMemoryPlacedFeaturesEXT.memoryMapPlaced ); 9778 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMapMemoryPlacedFeaturesEXT.memoryMapRangePlaced ); 9779 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMapMemoryPlacedFeaturesEXT.memoryUnmapReserve ); 9780 return seed; 9781 } 9782 }; 9783 9784 template <> 9785 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMapMemoryPlacedPropertiesEXT> 9786 { operator ()std::hash9787 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMapMemoryPlacedPropertiesEXT const & physicalDeviceMapMemoryPlacedPropertiesEXT ) const 9788 VULKAN_HPP_NOEXCEPT 9789 { 9790 std::size_t seed = 0; 9791 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMapMemoryPlacedPropertiesEXT.sType ); 9792 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMapMemoryPlacedPropertiesEXT.pNext ); 9793 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMapMemoryPlacedPropertiesEXT.minPlacedMemoryMapAlignment ); 9794 return seed; 9795 } 9796 }; 9797 9798 template <> 9799 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryBudgetPropertiesEXT> 9800 { 9801 std::size_t operator ()std::hash9802 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryBudgetPropertiesEXT const & physicalDeviceMemoryBudgetPropertiesEXT ) const VULKAN_HPP_NOEXCEPT 9803 { 9804 std::size_t seed = 0; 9805 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryBudgetPropertiesEXT.sType ); 9806 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryBudgetPropertiesEXT.pNext ); 9807 for ( size_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i ) 9808 { 9809 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryBudgetPropertiesEXT.heapBudget[i] ); 9810 } 9811 for ( size_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i ) 9812 { 9813 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryBudgetPropertiesEXT.heapUsage[i] ); 9814 } 9815 return seed; 9816 } 9817 }; 9818 9819 template <> 9820 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryDecompressionFeaturesNV> 9821 { operator ()std::hash9822 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryDecompressionFeaturesNV const & physicalDeviceMemoryDecompressionFeaturesNV ) const 9823 VULKAN_HPP_NOEXCEPT 9824 { 9825 std::size_t seed = 0; 9826 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionFeaturesNV.sType ); 9827 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionFeaturesNV.pNext ); 9828 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionFeaturesNV.memoryDecompression ); 9829 return seed; 9830 } 9831 }; 9832 9833 template <> 9834 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryDecompressionPropertiesNV> 9835 { operator ()std::hash9836 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryDecompressionPropertiesNV const & physicalDeviceMemoryDecompressionPropertiesNV ) const 9837 VULKAN_HPP_NOEXCEPT 9838 { 9839 std::size_t seed = 0; 9840 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionPropertiesNV.sType ); 9841 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionPropertiesNV.pNext ); 9842 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionPropertiesNV.decompressionMethods ); 9843 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionPropertiesNV.maxDecompressionIndirectCount ); 9844 return seed; 9845 } 9846 }; 9847 9848 template <> 9849 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryPriorityFeaturesEXT> 9850 { 9851 std::size_t operator ()std::hash9852 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryPriorityFeaturesEXT const & physicalDeviceMemoryPriorityFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 9853 { 9854 std::size_t seed = 0; 9855 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryPriorityFeaturesEXT.sType ); 9856 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryPriorityFeaturesEXT.pNext ); 9857 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryPriorityFeaturesEXT.memoryPriority ); 9858 return seed; 9859 } 9860 }; 9861 9862 template <> 9863 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties> 9864 { operator ()std::hash9865 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties const & physicalDeviceMemoryProperties ) const VULKAN_HPP_NOEXCEPT 9866 { 9867 std::size_t seed = 0; 9868 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryProperties.memoryTypeCount ); 9869 for ( size_t i = 0; i < VK_MAX_MEMORY_TYPES; ++i ) 9870 { 9871 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryProperties.memoryTypes[i] ); 9872 } 9873 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryProperties.memoryHeapCount ); 9874 for ( size_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i ) 9875 { 9876 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryProperties.memoryHeaps[i] ); 9877 } 9878 return seed; 9879 } 9880 }; 9881 9882 template <> 9883 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2> 9884 { operator ()std::hash9885 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 const & physicalDeviceMemoryProperties2 ) const VULKAN_HPP_NOEXCEPT 9886 { 9887 std::size_t seed = 0; 9888 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryProperties2.sType ); 9889 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryProperties2.pNext ); 9890 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryProperties2.memoryProperties ); 9891 return seed; 9892 } 9893 }; 9894 9895 template <> 9896 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderFeaturesEXT> 9897 { operator ()std::hash9898 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderFeaturesEXT const & physicalDeviceMeshShaderFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 9899 { 9900 std::size_t seed = 0; 9901 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesEXT.sType ); 9902 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesEXT.pNext ); 9903 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesEXT.taskShader ); 9904 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesEXT.meshShader ); 9905 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesEXT.multiviewMeshShader ); 9906 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesEXT.primitiveFragmentShadingRateMeshShader ); 9907 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesEXT.meshShaderQueries ); 9908 return seed; 9909 } 9910 }; 9911 9912 template <> 9913 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderFeaturesNV> 9914 { operator ()std::hash9915 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderFeaturesNV const & physicalDeviceMeshShaderFeaturesNV ) const VULKAN_HPP_NOEXCEPT 9916 { 9917 std::size_t seed = 0; 9918 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesNV.sType ); 9919 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesNV.pNext ); 9920 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesNV.taskShader ); 9921 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesNV.meshShader ); 9922 return seed; 9923 } 9924 }; 9925 9926 template <> 9927 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderPropertiesEXT> 9928 { 9929 std::size_t operator ()std::hash9930 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderPropertiesEXT const & physicalDeviceMeshShaderPropertiesEXT ) const VULKAN_HPP_NOEXCEPT 9931 { 9932 std::size_t seed = 0; 9933 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.sType ); 9934 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.pNext ); 9935 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxTaskWorkGroupTotalCount ); 9936 for ( size_t i = 0; i < 3; ++i ) 9937 { 9938 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxTaskWorkGroupCount[i] ); 9939 } 9940 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxTaskWorkGroupInvocations ); 9941 for ( size_t i = 0; i < 3; ++i ) 9942 { 9943 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxTaskWorkGroupSize[i] ); 9944 } 9945 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxTaskPayloadSize ); 9946 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxTaskSharedMemorySize ); 9947 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxTaskPayloadAndSharedMemorySize ); 9948 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshWorkGroupTotalCount ); 9949 for ( size_t i = 0; i < 3; ++i ) 9950 { 9951 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshWorkGroupCount[i] ); 9952 } 9953 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshWorkGroupInvocations ); 9954 for ( size_t i = 0; i < 3; ++i ) 9955 { 9956 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshWorkGroupSize[i] ); 9957 } 9958 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshSharedMemorySize ); 9959 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshPayloadAndSharedMemorySize ); 9960 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshOutputMemorySize ); 9961 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshPayloadAndOutputMemorySize ); 9962 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshOutputComponents ); 9963 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshOutputVertices ); 9964 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshOutputPrimitives ); 9965 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshOutputLayers ); 9966 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshMultiviewViewCount ); 9967 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.meshOutputPerVertexGranularity ); 9968 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.meshOutputPerPrimitiveGranularity ); 9969 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxPreferredTaskWorkGroupInvocations ); 9970 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxPreferredMeshWorkGroupInvocations ); 9971 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.prefersLocalInvocationVertexOutput ); 9972 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.prefersLocalInvocationPrimitiveOutput ); 9973 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.prefersCompactVertexOutput ); 9974 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.prefersCompactPrimitiveOutput ); 9975 return seed; 9976 } 9977 }; 9978 9979 template <> 9980 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderPropertiesNV> 9981 { operator ()std::hash9982 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderPropertiesNV const & physicalDeviceMeshShaderPropertiesNV ) const VULKAN_HPP_NOEXCEPT 9983 { 9984 std::size_t seed = 0; 9985 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.sType ); 9986 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.pNext ); 9987 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxDrawMeshTasksCount ); 9988 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxTaskWorkGroupInvocations ); 9989 for ( size_t i = 0; i < 3; ++i ) 9990 { 9991 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxTaskWorkGroupSize[i] ); 9992 } 9993 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxTaskTotalMemorySize ); 9994 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxTaskOutputCount ); 9995 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxMeshWorkGroupInvocations ); 9996 for ( size_t i = 0; i < 3; ++i ) 9997 { 9998 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxMeshWorkGroupSize[i] ); 9999 } 10000 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxMeshTotalMemorySize ); 10001 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxMeshOutputVertices ); 10002 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxMeshOutputPrimitives ); 10003 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxMeshMultiviewViewCount ); 10004 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.meshOutputPerVertexGranularity ); 10005 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.meshOutputPerPrimitiveGranularity ); 10006 return seed; 10007 } 10008 }; 10009 10010 template <> 10011 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiDrawFeaturesEXT> 10012 { operator ()std::hash10013 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiDrawFeaturesEXT const & physicalDeviceMultiDrawFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 10014 { 10015 std::size_t seed = 0; 10016 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiDrawFeaturesEXT.sType ); 10017 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiDrawFeaturesEXT.pNext ); 10018 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiDrawFeaturesEXT.multiDraw ); 10019 return seed; 10020 } 10021 }; 10022 10023 template <> 10024 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiDrawPropertiesEXT> 10025 { operator ()std::hash10026 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiDrawPropertiesEXT const & physicalDeviceMultiDrawPropertiesEXT ) const VULKAN_HPP_NOEXCEPT 10027 { 10028 std::size_t seed = 0; 10029 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiDrawPropertiesEXT.sType ); 10030 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiDrawPropertiesEXT.pNext ); 10031 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiDrawPropertiesEXT.maxMultiDrawCount ); 10032 return seed; 10033 } 10034 }; 10035 10036 template <> 10037 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT> 10038 { operator ()std::hash10039 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT const & 10040 physicalDeviceMultisampledRenderToSingleSampledFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 10041 { 10042 std::size_t seed = 0; 10043 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultisampledRenderToSingleSampledFeaturesEXT.sType ); 10044 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultisampledRenderToSingleSampledFeaturesEXT.pNext ); 10045 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultisampledRenderToSingleSampledFeaturesEXT.multisampledRenderToSingleSampled ); 10046 return seed; 10047 } 10048 }; 10049 10050 template <> 10051 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewFeatures> 10052 { operator ()std::hash10053 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewFeatures const & physicalDeviceMultiviewFeatures ) const VULKAN_HPP_NOEXCEPT 10054 { 10055 std::size_t seed = 0; 10056 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewFeatures.sType ); 10057 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewFeatures.pNext ); 10058 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewFeatures.multiview ); 10059 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewFeatures.multiviewGeometryShader ); 10060 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewFeatures.multiviewTessellationShader ); 10061 return seed; 10062 } 10063 }; 10064 10065 template <> 10066 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX> 10067 { operator ()std::hash10068 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const & 10069 physicalDeviceMultiviewPerViewAttributesPropertiesNVX ) const VULKAN_HPP_NOEXCEPT 10070 { 10071 std::size_t seed = 0; 10072 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewAttributesPropertiesNVX.sType ); 10073 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewAttributesPropertiesNVX.pNext ); 10074 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewAttributesPropertiesNVX.perViewPositionAllComponents ); 10075 return seed; 10076 } 10077 }; 10078 10079 template <> 10080 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM> 10081 { operator ()std::hash10082 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM const & 10083 physicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM ) const VULKAN_HPP_NOEXCEPT 10084 { 10085 std::size_t seed = 0; 10086 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM.sType ); 10087 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM.pNext ); 10088 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM.multiviewPerViewRenderAreas ); 10089 return seed; 10090 } 10091 }; 10092 10093 template <> 10094 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM> 10095 { 10096 std::size_t operator ()std::hash10097 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM const & physicalDeviceMultiviewPerViewViewportsFeaturesQCOM ) const 10098 VULKAN_HPP_NOEXCEPT 10099 { 10100 std::size_t seed = 0; 10101 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewViewportsFeaturesQCOM.sType ); 10102 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewViewportsFeaturesQCOM.pNext ); 10103 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewViewportsFeaturesQCOM.multiviewPerViewViewports ); 10104 return seed; 10105 } 10106 }; 10107 10108 template <> 10109 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewProperties> 10110 { operator ()std::hash10111 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewProperties const & physicalDeviceMultiviewProperties ) const VULKAN_HPP_NOEXCEPT 10112 { 10113 std::size_t seed = 0; 10114 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewProperties.sType ); 10115 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewProperties.pNext ); 10116 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewProperties.maxMultiviewViewCount ); 10117 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewProperties.maxMultiviewInstanceIndex ); 10118 return seed; 10119 } 10120 }; 10121 10122 template <> 10123 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMutableDescriptorTypeFeaturesEXT> 10124 { operator ()std::hash10125 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMutableDescriptorTypeFeaturesEXT const & physicalDeviceMutableDescriptorTypeFeaturesEXT ) const 10126 VULKAN_HPP_NOEXCEPT 10127 { 10128 std::size_t seed = 0; 10129 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMutableDescriptorTypeFeaturesEXT.sType ); 10130 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMutableDescriptorTypeFeaturesEXT.pNext ); 10131 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMutableDescriptorTypeFeaturesEXT.mutableDescriptorType ); 10132 return seed; 10133 } 10134 }; 10135 10136 template <> 10137 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceNestedCommandBufferFeaturesEXT> 10138 { operator ()std::hash10139 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceNestedCommandBufferFeaturesEXT const & physicalDeviceNestedCommandBufferFeaturesEXT ) const 10140 VULKAN_HPP_NOEXCEPT 10141 { 10142 std::size_t seed = 0; 10143 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNestedCommandBufferFeaturesEXT.sType ); 10144 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNestedCommandBufferFeaturesEXT.pNext ); 10145 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNestedCommandBufferFeaturesEXT.nestedCommandBuffer ); 10146 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNestedCommandBufferFeaturesEXT.nestedCommandBufferRendering ); 10147 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNestedCommandBufferFeaturesEXT.nestedCommandBufferSimultaneousUse ); 10148 return seed; 10149 } 10150 }; 10151 10152 template <> 10153 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceNestedCommandBufferPropertiesEXT> 10154 { operator ()std::hash10155 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceNestedCommandBufferPropertiesEXT const & physicalDeviceNestedCommandBufferPropertiesEXT ) const 10156 VULKAN_HPP_NOEXCEPT 10157 { 10158 std::size_t seed = 0; 10159 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNestedCommandBufferPropertiesEXT.sType ); 10160 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNestedCommandBufferPropertiesEXT.pNext ); 10161 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNestedCommandBufferPropertiesEXT.maxCommandBufferNestingLevel ); 10162 return seed; 10163 } 10164 }; 10165 10166 template <> 10167 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceNonSeamlessCubeMapFeaturesEXT> 10168 { operator ()std::hash10169 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceNonSeamlessCubeMapFeaturesEXT const & physicalDeviceNonSeamlessCubeMapFeaturesEXT ) const 10170 VULKAN_HPP_NOEXCEPT 10171 { 10172 std::size_t seed = 0; 10173 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNonSeamlessCubeMapFeaturesEXT.sType ); 10174 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNonSeamlessCubeMapFeaturesEXT.pNext ); 10175 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNonSeamlessCubeMapFeaturesEXT.nonSeamlessCubeMap ); 10176 return seed; 10177 } 10178 }; 10179 10180 template <> 10181 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceOpacityMicromapFeaturesEXT> 10182 { 10183 std::size_t operator ()std::hash10184 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceOpacityMicromapFeaturesEXT const & physicalDeviceOpacityMicromapFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 10185 { 10186 std::size_t seed = 0; 10187 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapFeaturesEXT.sType ); 10188 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapFeaturesEXT.pNext ); 10189 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapFeaturesEXT.micromap ); 10190 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapFeaturesEXT.micromapCaptureReplay ); 10191 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapFeaturesEXT.micromapHostCommands ); 10192 return seed; 10193 } 10194 }; 10195 10196 template <> 10197 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceOpacityMicromapPropertiesEXT> 10198 { operator ()std::hash10199 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceOpacityMicromapPropertiesEXT const & physicalDeviceOpacityMicromapPropertiesEXT ) const 10200 VULKAN_HPP_NOEXCEPT 10201 { 10202 std::size_t seed = 0; 10203 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapPropertiesEXT.sType ); 10204 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapPropertiesEXT.pNext ); 10205 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapPropertiesEXT.maxOpacity2StateSubdivisionLevel ); 10206 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapPropertiesEXT.maxOpacity4StateSubdivisionLevel ); 10207 return seed; 10208 } 10209 }; 10210 10211 template <> 10212 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceOpticalFlowFeaturesNV> 10213 { operator ()std::hash10214 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceOpticalFlowFeaturesNV const & physicalDeviceOpticalFlowFeaturesNV ) const VULKAN_HPP_NOEXCEPT 10215 { 10216 std::size_t seed = 0; 10217 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowFeaturesNV.sType ); 10218 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowFeaturesNV.pNext ); 10219 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowFeaturesNV.opticalFlow ); 10220 return seed; 10221 } 10222 }; 10223 10224 template <> 10225 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceOpticalFlowPropertiesNV> 10226 { 10227 std::size_t operator ()std::hash10228 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceOpticalFlowPropertiesNV const & physicalDeviceOpticalFlowPropertiesNV ) const VULKAN_HPP_NOEXCEPT 10229 { 10230 std::size_t seed = 0; 10231 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.sType ); 10232 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.pNext ); 10233 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.supportedOutputGridSizes ); 10234 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.supportedHintGridSizes ); 10235 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.hintSupported ); 10236 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.costSupported ); 10237 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.bidirectionalFlowSupported ); 10238 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.globalFlowSupported ); 10239 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.minWidth ); 10240 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.minHeight ); 10241 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.maxWidth ); 10242 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.maxHeight ); 10243 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.maxNumRegionsOfInterest ); 10244 return seed; 10245 } 10246 }; 10247 10248 template <> 10249 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePCIBusInfoPropertiesEXT> 10250 { 10251 std::size_t operator ()std::hash10252 operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePCIBusInfoPropertiesEXT const & physicalDevicePCIBusInfoPropertiesEXT ) const VULKAN_HPP_NOEXCEPT 10253 { 10254 std::size_t seed = 0; 10255 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePCIBusInfoPropertiesEXT.sType ); 10256 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePCIBusInfoPropertiesEXT.pNext ); 10257 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePCIBusInfoPropertiesEXT.pciDomain ); 10258 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePCIBusInfoPropertiesEXT.pciBus ); 10259 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePCIBusInfoPropertiesEXT.pciDevice ); 10260 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePCIBusInfoPropertiesEXT.pciFunction ); 10261 return seed; 10262 } 10263 }; 10264 10265 template <> 10266 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT> 10267 { 10268 std::size_t operator ()std::hash10269 operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT const & physicalDevicePageableDeviceLocalMemoryFeaturesEXT ) const 10270 VULKAN_HPP_NOEXCEPT 10271 { 10272 std::size_t seed = 0; 10273 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePageableDeviceLocalMemoryFeaturesEXT.sType ); 10274 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePageableDeviceLocalMemoryFeaturesEXT.pNext ); 10275 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePageableDeviceLocalMemoryFeaturesEXT.pageableDeviceLocalMemory ); 10276 return seed; 10277 } 10278 }; 10279 10280 template <> 10281 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePerStageDescriptorSetFeaturesNV> 10282 { operator ()std::hash10283 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePerStageDescriptorSetFeaturesNV const & physicalDevicePerStageDescriptorSetFeaturesNV ) const 10284 VULKAN_HPP_NOEXCEPT 10285 { 10286 std::size_t seed = 0; 10287 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerStageDescriptorSetFeaturesNV.sType ); 10288 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerStageDescriptorSetFeaturesNV.pNext ); 10289 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerStageDescriptorSetFeaturesNV.perStageDescriptorSet ); 10290 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerStageDescriptorSetFeaturesNV.dynamicPipelineLayout ); 10291 return seed; 10292 } 10293 }; 10294 10295 template <> 10296 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceQueryFeaturesKHR> 10297 { 10298 std::size_t operator ()std::hash10299 operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceQueryFeaturesKHR const & physicalDevicePerformanceQueryFeaturesKHR ) const VULKAN_HPP_NOEXCEPT 10300 { 10301 std::size_t seed = 0; 10302 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceQueryFeaturesKHR.sType ); 10303 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceQueryFeaturesKHR.pNext ); 10304 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceQueryFeaturesKHR.performanceCounterQueryPools ); 10305 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceQueryFeaturesKHR.performanceCounterMultipleQueryPools ); 10306 return seed; 10307 } 10308 }; 10309 10310 template <> 10311 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceQueryPropertiesKHR> 10312 { operator ()std::hash10313 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceQueryPropertiesKHR const & physicalDevicePerformanceQueryPropertiesKHR ) const 10314 VULKAN_HPP_NOEXCEPT 10315 { 10316 std::size_t seed = 0; 10317 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceQueryPropertiesKHR.sType ); 10318 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceQueryPropertiesKHR.pNext ); 10319 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceQueryPropertiesKHR.allowCommandBufferQueryCopies ); 10320 return seed; 10321 } 10322 }; 10323 10324 template <> 10325 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineCreationCacheControlFeatures> 10326 { 10327 std::size_t operator ()std::hash10328 operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineCreationCacheControlFeatures const & physicalDevicePipelineCreationCacheControlFeatures ) const 10329 VULKAN_HPP_NOEXCEPT 10330 { 10331 std::size_t seed = 0; 10332 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineCreationCacheControlFeatures.sType ); 10333 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineCreationCacheControlFeatures.pNext ); 10334 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineCreationCacheControlFeatures.pipelineCreationCacheControl ); 10335 return seed; 10336 } 10337 }; 10338 10339 template <> 10340 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR> 10341 { operator ()std::hash10342 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR const & 10343 physicalDevicePipelineExecutablePropertiesFeaturesKHR ) const VULKAN_HPP_NOEXCEPT 10344 { 10345 std::size_t seed = 0; 10346 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineExecutablePropertiesFeaturesKHR.sType ); 10347 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineExecutablePropertiesFeaturesKHR.pNext ); 10348 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineExecutablePropertiesFeaturesKHR.pipelineExecutableInfo ); 10349 return seed; 10350 } 10351 }; 10352 10353 template <> 10354 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT> 10355 { operator ()std::hash10356 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT const & 10357 physicalDevicePipelineLibraryGroupHandlesFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 10358 { 10359 std::size_t seed = 0; 10360 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineLibraryGroupHandlesFeaturesEXT.sType ); 10361 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineLibraryGroupHandlesFeaturesEXT.pNext ); 10362 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineLibraryGroupHandlesFeaturesEXT.pipelineLibraryGroupHandles ); 10363 return seed; 10364 } 10365 }; 10366 10367 template <> 10368 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelinePropertiesFeaturesEXT> 10369 { operator ()std::hash10370 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelinePropertiesFeaturesEXT const & physicalDevicePipelinePropertiesFeaturesEXT ) const 10371 VULKAN_HPP_NOEXCEPT 10372 { 10373 std::size_t seed = 0; 10374 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelinePropertiesFeaturesEXT.sType ); 10375 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelinePropertiesFeaturesEXT.pNext ); 10376 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelinePropertiesFeaturesEXT.pipelinePropertiesIdentifier ); 10377 return seed; 10378 } 10379 }; 10380 10381 template <> 10382 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineProtectedAccessFeaturesEXT> 10383 { operator ()std::hash10384 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineProtectedAccessFeaturesEXT const & physicalDevicePipelineProtectedAccessFeaturesEXT ) 10385 const VULKAN_HPP_NOEXCEPT 10386 { 10387 std::size_t seed = 0; 10388 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineProtectedAccessFeaturesEXT.sType ); 10389 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineProtectedAccessFeaturesEXT.pNext ); 10390 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineProtectedAccessFeaturesEXT.pipelineProtectedAccess ); 10391 return seed; 10392 } 10393 }; 10394 10395 template <> 10396 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineRobustnessFeaturesEXT> 10397 { operator ()std::hash10398 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineRobustnessFeaturesEXT const & physicalDevicePipelineRobustnessFeaturesEXT ) const 10399 VULKAN_HPP_NOEXCEPT 10400 { 10401 std::size_t seed = 0; 10402 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineRobustnessFeaturesEXT.sType ); 10403 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineRobustnessFeaturesEXT.pNext ); 10404 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineRobustnessFeaturesEXT.pipelineRobustness ); 10405 return seed; 10406 } 10407 }; 10408 10409 template <> 10410 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineRobustnessPropertiesEXT> 10411 { operator ()std::hash10412 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineRobustnessPropertiesEXT const & physicalDevicePipelineRobustnessPropertiesEXT ) const 10413 VULKAN_HPP_NOEXCEPT 10414 { 10415 std::size_t seed = 0; 10416 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineRobustnessPropertiesEXT.sType ); 10417 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineRobustnessPropertiesEXT.pNext ); 10418 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineRobustnessPropertiesEXT.defaultRobustnessStorageBuffers ); 10419 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineRobustnessPropertiesEXT.defaultRobustnessUniformBuffers ); 10420 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineRobustnessPropertiesEXT.defaultRobustnessVertexInputs ); 10421 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineRobustnessPropertiesEXT.defaultRobustnessImages ); 10422 return seed; 10423 } 10424 }; 10425 10426 template <> 10427 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePointClippingProperties> 10428 { 10429 std::size_t operator ()std::hash10430 operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePointClippingProperties const & physicalDevicePointClippingProperties ) const VULKAN_HPP_NOEXCEPT 10431 { 10432 std::size_t seed = 0; 10433 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePointClippingProperties.sType ); 10434 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePointClippingProperties.pNext ); 10435 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePointClippingProperties.pointClippingBehavior ); 10436 return seed; 10437 } 10438 }; 10439 10440 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 10441 template <> 10442 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePortabilitySubsetFeaturesKHR> 10443 { operator ()std::hash10444 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePortabilitySubsetFeaturesKHR const & physicalDevicePortabilitySubsetFeaturesKHR ) const 10445 VULKAN_HPP_NOEXCEPT 10446 { 10447 std::size_t seed = 0; 10448 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.sType ); 10449 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.pNext ); 10450 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.constantAlphaColorBlendFactors ); 10451 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.events ); 10452 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.imageViewFormatReinterpretation ); 10453 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.imageViewFormatSwizzle ); 10454 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.imageView2DOn3DImage ); 10455 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.multisampleArrayImage ); 10456 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.mutableComparisonSamplers ); 10457 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.pointPolygons ); 10458 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.samplerMipLodBias ); 10459 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.separateStencilMaskRef ); 10460 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.shaderSampleRateInterpolationFunctions ); 10461 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.tessellationIsolines ); 10462 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.tessellationPointMode ); 10463 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.triangleFans ); 10464 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.vertexAttributeAccessBeyondStride ); 10465 return seed; 10466 } 10467 }; 10468 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 10469 10470 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 10471 template <> 10472 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePortabilitySubsetPropertiesKHR> 10473 { operator ()std::hash10474 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePortabilitySubsetPropertiesKHR const & physicalDevicePortabilitySubsetPropertiesKHR ) const 10475 VULKAN_HPP_NOEXCEPT 10476 { 10477 std::size_t seed = 0; 10478 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetPropertiesKHR.sType ); 10479 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetPropertiesKHR.pNext ); 10480 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetPropertiesKHR.minVertexInputBindingStrideAlignment ); 10481 return seed; 10482 } 10483 }; 10484 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 10485 10486 template <> 10487 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePresentBarrierFeaturesNV> 10488 { 10489 std::size_t operator ()std::hash10490 operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePresentBarrierFeaturesNV const & physicalDevicePresentBarrierFeaturesNV ) const VULKAN_HPP_NOEXCEPT 10491 { 10492 std::size_t seed = 0; 10493 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentBarrierFeaturesNV.sType ); 10494 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentBarrierFeaturesNV.pNext ); 10495 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentBarrierFeaturesNV.presentBarrier ); 10496 return seed; 10497 } 10498 }; 10499 10500 template <> 10501 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePresentIdFeaturesKHR> 10502 { operator ()std::hash10503 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePresentIdFeaturesKHR const & physicalDevicePresentIdFeaturesKHR ) const VULKAN_HPP_NOEXCEPT 10504 { 10505 std::size_t seed = 0; 10506 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentIdFeaturesKHR.sType ); 10507 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentIdFeaturesKHR.pNext ); 10508 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentIdFeaturesKHR.presentId ); 10509 return seed; 10510 } 10511 }; 10512 10513 template <> 10514 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePresentWaitFeaturesKHR> 10515 { operator ()std::hash10516 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePresentWaitFeaturesKHR const & physicalDevicePresentWaitFeaturesKHR ) const VULKAN_HPP_NOEXCEPT 10517 { 10518 std::size_t seed = 0; 10519 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentWaitFeaturesKHR.sType ); 10520 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentWaitFeaturesKHR.pNext ); 10521 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentWaitFeaturesKHR.presentWait ); 10522 return seed; 10523 } 10524 }; 10525 10526 template <> 10527 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT> 10528 { operator ()std::hash10529 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT const & 10530 physicalDevicePrimitiveTopologyListRestartFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 10531 { 10532 std::size_t seed = 0; 10533 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrimitiveTopologyListRestartFeaturesEXT.sType ); 10534 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrimitiveTopologyListRestartFeaturesEXT.pNext ); 10535 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrimitiveTopologyListRestartFeaturesEXT.primitiveTopologyListRestart ); 10536 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrimitiveTopologyListRestartFeaturesEXT.primitiveTopologyPatchListRestart ); 10537 return seed; 10538 } 10539 }; 10540 10541 template <> 10542 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT> 10543 { operator ()std::hash10544 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT const & physicalDevicePrimitivesGeneratedQueryFeaturesEXT ) 10545 const VULKAN_HPP_NOEXCEPT 10546 { 10547 std::size_t seed = 0; 10548 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrimitivesGeneratedQueryFeaturesEXT.sType ); 10549 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrimitivesGeneratedQueryFeaturesEXT.pNext ); 10550 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrimitivesGeneratedQueryFeaturesEXT.primitivesGeneratedQuery ); 10551 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrimitivesGeneratedQueryFeaturesEXT.primitivesGeneratedQueryWithRasterizerDiscard ); 10552 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrimitivesGeneratedQueryFeaturesEXT.primitivesGeneratedQueryWithNonZeroStreams ); 10553 return seed; 10554 } 10555 }; 10556 10557 template <> 10558 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePrivateDataFeatures> 10559 { operator ()std::hash10560 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePrivateDataFeatures const & physicalDevicePrivateDataFeatures ) const VULKAN_HPP_NOEXCEPT 10561 { 10562 std::size_t seed = 0; 10563 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrivateDataFeatures.sType ); 10564 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrivateDataFeatures.pNext ); 10565 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrivateDataFeatures.privateData ); 10566 return seed; 10567 } 10568 }; 10569 10570 template <> 10571 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseProperties> 10572 { operator ()std::hash10573 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseProperties const & physicalDeviceSparseProperties ) const VULKAN_HPP_NOEXCEPT 10574 { 10575 std::size_t seed = 0; 10576 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseProperties.residencyStandard2DBlockShape ); 10577 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseProperties.residencyStandard2DMultisampleBlockShape ); 10578 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseProperties.residencyStandard3DBlockShape ); 10579 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseProperties.residencyAlignedMipSize ); 10580 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseProperties.residencyNonResidentStrict ); 10581 return seed; 10582 } 10583 }; 10584 10585 template <> 10586 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties> 10587 { operator ()std::hash10588 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties const & physicalDeviceProperties ) const VULKAN_HPP_NOEXCEPT 10589 { 10590 std::size_t seed = 0; 10591 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.apiVersion ); 10592 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.driverVersion ); 10593 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.vendorID ); 10594 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.deviceID ); 10595 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.deviceType ); 10596 for ( size_t i = 0; i < VK_MAX_PHYSICAL_DEVICE_NAME_SIZE; ++i ) 10597 { 10598 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.deviceName[i] ); 10599 } 10600 for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) 10601 { 10602 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.pipelineCacheUUID[i] ); 10603 } 10604 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.limits ); 10605 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.sparseProperties ); 10606 return seed; 10607 } 10608 }; 10609 10610 template <> 10611 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2> 10612 { operator ()std::hash10613 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 const & physicalDeviceProperties2 ) const VULKAN_HPP_NOEXCEPT 10614 { 10615 std::size_t seed = 0; 10616 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties2.sType ); 10617 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties2.pNext ); 10618 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties2.properties ); 10619 return seed; 10620 } 10621 }; 10622 10623 template <> 10624 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceProtectedMemoryFeatures> 10625 { 10626 std::size_t operator ()std::hash10627 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProtectedMemoryFeatures const & physicalDeviceProtectedMemoryFeatures ) const VULKAN_HPP_NOEXCEPT 10628 { 10629 std::size_t seed = 0; 10630 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProtectedMemoryFeatures.sType ); 10631 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProtectedMemoryFeatures.pNext ); 10632 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProtectedMemoryFeatures.protectedMemory ); 10633 return seed; 10634 } 10635 }; 10636 10637 template <> 10638 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceProtectedMemoryProperties> 10639 { 10640 std::size_t operator ()std::hash10641 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProtectedMemoryProperties const & physicalDeviceProtectedMemoryProperties ) const VULKAN_HPP_NOEXCEPT 10642 { 10643 std::size_t seed = 0; 10644 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProtectedMemoryProperties.sType ); 10645 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProtectedMemoryProperties.pNext ); 10646 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProtectedMemoryProperties.protectedNoFault ); 10647 return seed; 10648 } 10649 }; 10650 10651 template <> 10652 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceProvokingVertexFeaturesEXT> 10653 { 10654 std::size_t operator ()std::hash10655 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProvokingVertexFeaturesEXT const & physicalDeviceProvokingVertexFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 10656 { 10657 std::size_t seed = 0; 10658 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProvokingVertexFeaturesEXT.sType ); 10659 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProvokingVertexFeaturesEXT.pNext ); 10660 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProvokingVertexFeaturesEXT.provokingVertexLast ); 10661 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProvokingVertexFeaturesEXT.transformFeedbackPreservesProvokingVertex ); 10662 return seed; 10663 } 10664 }; 10665 10666 template <> 10667 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceProvokingVertexPropertiesEXT> 10668 { operator ()std::hash10669 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProvokingVertexPropertiesEXT const & physicalDeviceProvokingVertexPropertiesEXT ) const 10670 VULKAN_HPP_NOEXCEPT 10671 { 10672 std::size_t seed = 0; 10673 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProvokingVertexPropertiesEXT.sType ); 10674 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProvokingVertexPropertiesEXT.pNext ); 10675 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProvokingVertexPropertiesEXT.provokingVertexModePerPipeline ); 10676 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProvokingVertexPropertiesEXT.transformFeedbackPreservesTriangleFanProvokingVertex ); 10677 return seed; 10678 } 10679 }; 10680 10681 template <> 10682 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePushDescriptorPropertiesKHR> 10683 { 10684 std::size_t operator ()std::hash10685 operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePushDescriptorPropertiesKHR const & physicalDevicePushDescriptorPropertiesKHR ) const VULKAN_HPP_NOEXCEPT 10686 { 10687 std::size_t seed = 0; 10688 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePushDescriptorPropertiesKHR.sType ); 10689 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePushDescriptorPropertiesKHR.pNext ); 10690 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePushDescriptorPropertiesKHR.maxPushDescriptors ); 10691 return seed; 10692 } 10693 }; 10694 10695 template <> 10696 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRGBA10X6FormatsFeaturesEXT> 10697 { 10698 std::size_t operator ()std::hash10699 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRGBA10X6FormatsFeaturesEXT const & physicalDeviceRGBA10X6FormatsFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 10700 { 10701 std::size_t seed = 0; 10702 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRGBA10X6FormatsFeaturesEXT.sType ); 10703 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRGBA10X6FormatsFeaturesEXT.pNext ); 10704 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRGBA10X6FormatsFeaturesEXT.formatRgba10x6WithoutYCbCrSampler ); 10705 return seed; 10706 } 10707 }; 10708 10709 template <> 10710 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT> 10711 { operator ()std::hash10712 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT const & 10713 physicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 10714 { 10715 std::size_t seed = 0; 10716 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT.sType ); 10717 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT.pNext ); 10718 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT.rasterizationOrderColorAttachmentAccess ); 10719 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT.rasterizationOrderDepthAttachmentAccess ); 10720 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT.rasterizationOrderStencilAttachmentAccess ); 10721 return seed; 10722 } 10723 }; 10724 10725 template <> 10726 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRawAccessChainsFeaturesNV> 10727 { 10728 std::size_t operator ()std::hash10729 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRawAccessChainsFeaturesNV const & physicalDeviceRawAccessChainsFeaturesNV ) const VULKAN_HPP_NOEXCEPT 10730 { 10731 std::size_t seed = 0; 10732 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRawAccessChainsFeaturesNV.sType ); 10733 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRawAccessChainsFeaturesNV.pNext ); 10734 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRawAccessChainsFeaturesNV.shaderRawAccessChains ); 10735 return seed; 10736 } 10737 }; 10738 10739 template <> 10740 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayQueryFeaturesKHR> 10741 { operator ()std::hash10742 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayQueryFeaturesKHR const & physicalDeviceRayQueryFeaturesKHR ) const VULKAN_HPP_NOEXCEPT 10743 { 10744 std::size_t seed = 0; 10745 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayQueryFeaturesKHR.sType ); 10746 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayQueryFeaturesKHR.pNext ); 10747 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayQueryFeaturesKHR.rayQuery ); 10748 return seed; 10749 } 10750 }; 10751 10752 template <> 10753 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderFeaturesNV> 10754 { 10755 std::size_t operator ()std::hash10756 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderFeaturesNV const & physicalDeviceRayTracingInvocationReorderFeaturesNV ) const 10757 VULKAN_HPP_NOEXCEPT 10758 { 10759 std::size_t seed = 0; 10760 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderFeaturesNV.sType ); 10761 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderFeaturesNV.pNext ); 10762 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderFeaturesNV.rayTracingInvocationReorder ); 10763 return seed; 10764 } 10765 }; 10766 10767 template <> 10768 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderPropertiesNV> 10769 { operator ()std::hash10770 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderPropertiesNV const & 10771 physicalDeviceRayTracingInvocationReorderPropertiesNV ) const VULKAN_HPP_NOEXCEPT 10772 { 10773 std::size_t seed = 0; 10774 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderPropertiesNV.sType ); 10775 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderPropertiesNV.pNext ); 10776 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderPropertiesNV.rayTracingInvocationReorderReorderingHint ); 10777 return seed; 10778 } 10779 }; 10780 10781 template <> 10782 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingMaintenance1FeaturesKHR> 10783 { operator ()std::hash10784 std::size_t operator()( 10785 VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingMaintenance1FeaturesKHR const & physicalDeviceRayTracingMaintenance1FeaturesKHR ) const VULKAN_HPP_NOEXCEPT 10786 { 10787 std::size_t seed = 0; 10788 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingMaintenance1FeaturesKHR.sType ); 10789 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingMaintenance1FeaturesKHR.pNext ); 10790 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingMaintenance1FeaturesKHR.rayTracingMaintenance1 ); 10791 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingMaintenance1FeaturesKHR.rayTracingPipelineTraceRaysIndirect2 ); 10792 return seed; 10793 } 10794 }; 10795 10796 template <> 10797 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingMotionBlurFeaturesNV> 10798 { operator ()std::hash10799 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingMotionBlurFeaturesNV const & physicalDeviceRayTracingMotionBlurFeaturesNV ) const 10800 VULKAN_HPP_NOEXCEPT 10801 { 10802 std::size_t seed = 0; 10803 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingMotionBlurFeaturesNV.sType ); 10804 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingMotionBlurFeaturesNV.pNext ); 10805 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingMotionBlurFeaturesNV.rayTracingMotionBlur ); 10806 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingMotionBlurFeaturesNV.rayTracingMotionBlurPipelineTraceRaysIndirect ); 10807 return seed; 10808 } 10809 }; 10810 10811 template <> 10812 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPipelineFeaturesKHR> 10813 { operator ()std::hash10814 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPipelineFeaturesKHR const & physicalDeviceRayTracingPipelineFeaturesKHR ) const 10815 VULKAN_HPP_NOEXCEPT 10816 { 10817 std::size_t seed = 0; 10818 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelineFeaturesKHR.sType ); 10819 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelineFeaturesKHR.pNext ); 10820 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelineFeaturesKHR.rayTracingPipeline ); 10821 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelineFeaturesKHR.rayTracingPipelineShaderGroupHandleCaptureReplay ); 10822 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelineFeaturesKHR.rayTracingPipelineShaderGroupHandleCaptureReplayMixed ); 10823 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelineFeaturesKHR.rayTracingPipelineTraceRaysIndirect ); 10824 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelineFeaturesKHR.rayTraversalPrimitiveCulling ); 10825 return seed; 10826 } 10827 }; 10828 10829 template <> 10830 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPipelinePropertiesKHR> 10831 { operator ()std::hash10832 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPipelinePropertiesKHR const & physicalDeviceRayTracingPipelinePropertiesKHR ) const 10833 VULKAN_HPP_NOEXCEPT 10834 { 10835 std::size_t seed = 0; 10836 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.sType ); 10837 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.pNext ); 10838 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.shaderGroupHandleSize ); 10839 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.maxRayRecursionDepth ); 10840 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.maxShaderGroupStride ); 10841 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.shaderGroupBaseAlignment ); 10842 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.shaderGroupHandleCaptureReplaySize ); 10843 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.maxRayDispatchInvocationCount ); 10844 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.shaderGroupHandleAlignment ); 10845 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.maxRayHitAttributeSize ); 10846 return seed; 10847 } 10848 }; 10849 10850 template <> 10851 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPositionFetchFeaturesKHR> 10852 { operator ()std::hash10853 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPositionFetchFeaturesKHR const & physicalDeviceRayTracingPositionFetchFeaturesKHR ) 10854 const VULKAN_HPP_NOEXCEPT 10855 { 10856 std::size_t seed = 0; 10857 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPositionFetchFeaturesKHR.sType ); 10858 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPositionFetchFeaturesKHR.pNext ); 10859 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPositionFetchFeaturesKHR.rayTracingPositionFetch ); 10860 return seed; 10861 } 10862 }; 10863 10864 template <> 10865 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPropertiesNV> 10866 { operator ()std::hash10867 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPropertiesNV const & physicalDeviceRayTracingPropertiesNV ) const VULKAN_HPP_NOEXCEPT 10868 { 10869 std::size_t seed = 0; 10870 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.sType ); 10871 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.pNext ); 10872 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.shaderGroupHandleSize ); 10873 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.maxRecursionDepth ); 10874 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.maxShaderGroupStride ); 10875 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.shaderGroupBaseAlignment ); 10876 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.maxGeometryCount ); 10877 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.maxInstanceCount ); 10878 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.maxTriangleCount ); 10879 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.maxDescriptorSetAccelerationStructures ); 10880 return seed; 10881 } 10882 }; 10883 10884 template <> 10885 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingValidationFeaturesNV> 10886 { operator ()std::hash10887 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingValidationFeaturesNV const & physicalDeviceRayTracingValidationFeaturesNV ) const 10888 VULKAN_HPP_NOEXCEPT 10889 { 10890 std::size_t seed = 0; 10891 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingValidationFeaturesNV.sType ); 10892 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingValidationFeaturesNV.pNext ); 10893 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingValidationFeaturesNV.rayTracingValidation ); 10894 return seed; 10895 } 10896 }; 10897 10898 template <> 10899 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRelaxedLineRasterizationFeaturesIMG> 10900 { operator ()std::hash10901 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRelaxedLineRasterizationFeaturesIMG const & physicalDeviceRelaxedLineRasterizationFeaturesIMG ) 10902 const VULKAN_HPP_NOEXCEPT 10903 { 10904 std::size_t seed = 0; 10905 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRelaxedLineRasterizationFeaturesIMG.sType ); 10906 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRelaxedLineRasterizationFeaturesIMG.pNext ); 10907 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRelaxedLineRasterizationFeaturesIMG.relaxedLineRasterization ); 10908 return seed; 10909 } 10910 }; 10911 10912 template <> 10913 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRenderPassStripedFeaturesARM> 10914 { operator ()std::hash10915 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRenderPassStripedFeaturesARM const & physicalDeviceRenderPassStripedFeaturesARM ) const 10916 VULKAN_HPP_NOEXCEPT 10917 { 10918 std::size_t seed = 0; 10919 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRenderPassStripedFeaturesARM.sType ); 10920 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRenderPassStripedFeaturesARM.pNext ); 10921 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRenderPassStripedFeaturesARM.renderPassStriped ); 10922 return seed; 10923 } 10924 }; 10925 10926 template <> 10927 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRenderPassStripedPropertiesARM> 10928 { operator ()std::hash10929 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRenderPassStripedPropertiesARM const & physicalDeviceRenderPassStripedPropertiesARM ) const 10930 VULKAN_HPP_NOEXCEPT 10931 { 10932 std::size_t seed = 0; 10933 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRenderPassStripedPropertiesARM.sType ); 10934 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRenderPassStripedPropertiesARM.pNext ); 10935 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRenderPassStripedPropertiesARM.renderPassStripeGranularity ); 10936 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRenderPassStripedPropertiesARM.maxRenderPassStripes ); 10937 return seed; 10938 } 10939 }; 10940 10941 template <> 10942 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRepresentativeFragmentTestFeaturesNV> 10943 { 10944 std::size_t operator ()std::hash10945 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRepresentativeFragmentTestFeaturesNV const & physicalDeviceRepresentativeFragmentTestFeaturesNV ) const 10946 VULKAN_HPP_NOEXCEPT 10947 { 10948 std::size_t seed = 0; 10949 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRepresentativeFragmentTestFeaturesNV.sType ); 10950 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRepresentativeFragmentTestFeaturesNV.pNext ); 10951 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRepresentativeFragmentTestFeaturesNV.representativeFragmentTest ); 10952 return seed; 10953 } 10954 }; 10955 10956 template <> 10957 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2FeaturesEXT> 10958 { operator ()std::hash10959 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2FeaturesEXT const & physicalDeviceRobustness2FeaturesEXT ) const VULKAN_HPP_NOEXCEPT 10960 { 10961 std::size_t seed = 0; 10962 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2FeaturesEXT.sType ); 10963 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2FeaturesEXT.pNext ); 10964 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2FeaturesEXT.robustBufferAccess2 ); 10965 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2FeaturesEXT.robustImageAccess2 ); 10966 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2FeaturesEXT.nullDescriptor ); 10967 return seed; 10968 } 10969 }; 10970 10971 template <> 10972 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2PropertiesEXT> 10973 { 10974 std::size_t operator ()std::hash10975 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2PropertiesEXT const & physicalDeviceRobustness2PropertiesEXT ) const VULKAN_HPP_NOEXCEPT 10976 { 10977 std::size_t seed = 0; 10978 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2PropertiesEXT.sType ); 10979 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2PropertiesEXT.pNext ); 10980 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2PropertiesEXT.robustStorageBufferAccessSizeAlignment ); 10981 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2PropertiesEXT.robustUniformBufferAccessSizeAlignment ); 10982 return seed; 10983 } 10984 }; 10985 10986 template <> 10987 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSampleLocationsPropertiesEXT> 10988 { operator ()std::hash10989 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSampleLocationsPropertiesEXT const & physicalDeviceSampleLocationsPropertiesEXT ) const 10990 VULKAN_HPP_NOEXCEPT 10991 { 10992 std::size_t seed = 0; 10993 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSampleLocationsPropertiesEXT.sType ); 10994 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSampleLocationsPropertiesEXT.pNext ); 10995 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSampleLocationsPropertiesEXT.sampleLocationSampleCounts ); 10996 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSampleLocationsPropertiesEXT.maxSampleLocationGridSize ); 10997 for ( size_t i = 0; i < 2; ++i ) 10998 { 10999 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSampleLocationsPropertiesEXT.sampleLocationCoordinateRange[i] ); 11000 } 11001 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSampleLocationsPropertiesEXT.sampleLocationSubPixelBits ); 11002 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSampleLocationsPropertiesEXT.variableSampleLocations ); 11003 return seed; 11004 } 11005 }; 11006 11007 template <> 11008 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSamplerFilterMinmaxProperties> 11009 { operator ()std::hash11010 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSamplerFilterMinmaxProperties const & physicalDeviceSamplerFilterMinmaxProperties ) const 11011 VULKAN_HPP_NOEXCEPT 11012 { 11013 std::size_t seed = 0; 11014 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSamplerFilterMinmaxProperties.sType ); 11015 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSamplerFilterMinmaxProperties.pNext ); 11016 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSamplerFilterMinmaxProperties.filterMinmaxSingleComponentFormats ); 11017 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSamplerFilterMinmaxProperties.filterMinmaxImageComponentMapping ); 11018 return seed; 11019 } 11020 }; 11021 11022 template <> 11023 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSamplerYcbcrConversionFeatures> 11024 { operator ()std::hash11025 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSamplerYcbcrConversionFeatures const & physicalDeviceSamplerYcbcrConversionFeatures ) const 11026 VULKAN_HPP_NOEXCEPT 11027 { 11028 std::size_t seed = 0; 11029 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSamplerYcbcrConversionFeatures.sType ); 11030 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSamplerYcbcrConversionFeatures.pNext ); 11031 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSamplerYcbcrConversionFeatures.samplerYcbcrConversion ); 11032 return seed; 11033 } 11034 }; 11035 11036 template <> 11037 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceScalarBlockLayoutFeatures> 11038 { 11039 std::size_t operator ()std::hash11040 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceScalarBlockLayoutFeatures const & physicalDeviceScalarBlockLayoutFeatures ) const VULKAN_HPP_NOEXCEPT 11041 { 11042 std::size_t seed = 0; 11043 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceScalarBlockLayoutFeatures.sType ); 11044 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceScalarBlockLayoutFeatures.pNext ); 11045 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceScalarBlockLayoutFeatures.scalarBlockLayout ); 11046 return seed; 11047 } 11048 }; 11049 11050 template <> 11051 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSchedulingControlsFeaturesARM> 11052 { operator ()std::hash11053 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSchedulingControlsFeaturesARM const & physicalDeviceSchedulingControlsFeaturesARM ) const 11054 VULKAN_HPP_NOEXCEPT 11055 { 11056 std::size_t seed = 0; 11057 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSchedulingControlsFeaturesARM.sType ); 11058 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSchedulingControlsFeaturesARM.pNext ); 11059 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSchedulingControlsFeaturesARM.schedulingControls ); 11060 return seed; 11061 } 11062 }; 11063 11064 template <> 11065 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSchedulingControlsPropertiesARM> 11066 { operator ()std::hash11067 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSchedulingControlsPropertiesARM const & physicalDeviceSchedulingControlsPropertiesARM ) const 11068 VULKAN_HPP_NOEXCEPT 11069 { 11070 std::size_t seed = 0; 11071 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSchedulingControlsPropertiesARM.sType ); 11072 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSchedulingControlsPropertiesARM.pNext ); 11073 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSchedulingControlsPropertiesARM.schedulingControlsFlags ); 11074 return seed; 11075 } 11076 }; 11077 11078 template <> 11079 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSeparateDepthStencilLayoutsFeatures> 11080 { operator ()std::hash11081 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSeparateDepthStencilLayoutsFeatures const & physicalDeviceSeparateDepthStencilLayoutsFeatures ) 11082 const VULKAN_HPP_NOEXCEPT 11083 { 11084 std::size_t seed = 0; 11085 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSeparateDepthStencilLayoutsFeatures.sType ); 11086 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSeparateDepthStencilLayoutsFeatures.pNext ); 11087 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSeparateDepthStencilLayoutsFeatures.separateDepthStencilLayouts ); 11088 return seed; 11089 } 11090 }; 11091 11092 template <> 11093 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV> 11094 { operator ()std::hash11095 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV const & physicalDeviceShaderAtomicFloat16VectorFeaturesNV ) 11096 const VULKAN_HPP_NOEXCEPT 11097 { 11098 std::size_t seed = 0; 11099 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat16VectorFeaturesNV.sType ); 11100 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat16VectorFeaturesNV.pNext ); 11101 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat16VectorFeaturesNV.shaderFloat16VectorAtomics ); 11102 return seed; 11103 } 11104 }; 11105 11106 template <> 11107 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloat2FeaturesEXT> 11108 { operator ()std::hash11109 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloat2FeaturesEXT const & physicalDeviceShaderAtomicFloat2FeaturesEXT ) const 11110 VULKAN_HPP_NOEXCEPT 11111 { 11112 std::size_t seed = 0; 11113 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.sType ); 11114 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.pNext ); 11115 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderBufferFloat16Atomics ); 11116 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderBufferFloat16AtomicAdd ); 11117 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderBufferFloat16AtomicMinMax ); 11118 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderBufferFloat32AtomicMinMax ); 11119 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderBufferFloat64AtomicMinMax ); 11120 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderSharedFloat16Atomics ); 11121 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderSharedFloat16AtomicAdd ); 11122 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderSharedFloat16AtomicMinMax ); 11123 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderSharedFloat32AtomicMinMax ); 11124 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderSharedFloat64AtomicMinMax ); 11125 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderImageFloat32AtomicMinMax ); 11126 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.sparseImageFloat32AtomicMinMax ); 11127 return seed; 11128 } 11129 }; 11130 11131 template <> 11132 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloatFeaturesEXT> 11133 { operator ()std::hash11134 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloatFeaturesEXT const & physicalDeviceShaderAtomicFloatFeaturesEXT ) const 11135 VULKAN_HPP_NOEXCEPT 11136 { 11137 std::size_t seed = 0; 11138 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.sType ); 11139 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.pNext ); 11140 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderBufferFloat32Atomics ); 11141 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderBufferFloat32AtomicAdd ); 11142 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderBufferFloat64Atomics ); 11143 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderBufferFloat64AtomicAdd ); 11144 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderSharedFloat32Atomics ); 11145 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderSharedFloat32AtomicAdd ); 11146 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderSharedFloat64Atomics ); 11147 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderSharedFloat64AtomicAdd ); 11148 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderImageFloat32Atomics ); 11149 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderImageFloat32AtomicAdd ); 11150 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.sparseImageFloat32Atomics ); 11151 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.sparseImageFloat32AtomicAdd ); 11152 return seed; 11153 } 11154 }; 11155 11156 template <> 11157 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicInt64Features> 11158 { 11159 std::size_t operator ()std::hash11160 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicInt64Features const & physicalDeviceShaderAtomicInt64Features ) const VULKAN_HPP_NOEXCEPT 11161 { 11162 std::size_t seed = 0; 11163 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicInt64Features.sType ); 11164 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicInt64Features.pNext ); 11165 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicInt64Features.shaderBufferInt64Atomics ); 11166 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicInt64Features.shaderSharedInt64Atomics ); 11167 return seed; 11168 } 11169 }; 11170 11171 template <> 11172 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderClockFeaturesKHR> 11173 { operator ()std::hash11174 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderClockFeaturesKHR const & physicalDeviceShaderClockFeaturesKHR ) const VULKAN_HPP_NOEXCEPT 11175 { 11176 std::size_t seed = 0; 11177 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderClockFeaturesKHR.sType ); 11178 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderClockFeaturesKHR.pNext ); 11179 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderClockFeaturesKHR.shaderSubgroupClock ); 11180 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderClockFeaturesKHR.shaderDeviceClock ); 11181 return seed; 11182 } 11183 }; 11184 11185 template <> 11186 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCoreBuiltinsFeaturesARM> 11187 { operator ()std::hash11188 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCoreBuiltinsFeaturesARM const & physicalDeviceShaderCoreBuiltinsFeaturesARM ) const 11189 VULKAN_HPP_NOEXCEPT 11190 { 11191 std::size_t seed = 0; 11192 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreBuiltinsFeaturesARM.sType ); 11193 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreBuiltinsFeaturesARM.pNext ); 11194 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreBuiltinsFeaturesARM.shaderCoreBuiltins ); 11195 return seed; 11196 } 11197 }; 11198 11199 template <> 11200 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCoreBuiltinsPropertiesARM> 11201 { operator ()std::hash11202 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCoreBuiltinsPropertiesARM const & physicalDeviceShaderCoreBuiltinsPropertiesARM ) const 11203 VULKAN_HPP_NOEXCEPT 11204 { 11205 std::size_t seed = 0; 11206 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreBuiltinsPropertiesARM.sType ); 11207 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreBuiltinsPropertiesARM.pNext ); 11208 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreBuiltinsPropertiesARM.shaderCoreMask ); 11209 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreBuiltinsPropertiesARM.shaderCoreCount ); 11210 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreBuiltinsPropertiesARM.shaderWarpsPerCore ); 11211 return seed; 11212 } 11213 }; 11214 11215 template <> 11216 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCoreProperties2AMD> 11217 { 11218 std::size_t operator ()std::hash11219 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCoreProperties2AMD const & physicalDeviceShaderCoreProperties2AMD ) const VULKAN_HPP_NOEXCEPT 11220 { 11221 std::size_t seed = 0; 11222 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreProperties2AMD.sType ); 11223 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreProperties2AMD.pNext ); 11224 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreProperties2AMD.shaderCoreFeatures ); 11225 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreProperties2AMD.activeComputeUnitCount ); 11226 return seed; 11227 } 11228 }; 11229 11230 template <> 11231 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCorePropertiesAMD> 11232 { 11233 std::size_t operator ()std::hash11234 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCorePropertiesAMD const & physicalDeviceShaderCorePropertiesAMD ) const VULKAN_HPP_NOEXCEPT 11235 { 11236 std::size_t seed = 0; 11237 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.sType ); 11238 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.pNext ); 11239 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.shaderEngineCount ); 11240 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.shaderArraysPerEngineCount ); 11241 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.computeUnitsPerShaderArray ); 11242 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.simdPerComputeUnit ); 11243 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.wavefrontsPerSimd ); 11244 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.wavefrontSize ); 11245 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.sgprsPerSimd ); 11246 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.minSgprAllocation ); 11247 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.maxSgprAllocation ); 11248 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.sgprAllocationGranularity ); 11249 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.vgprsPerSimd ); 11250 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.minVgprAllocation ); 11251 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.maxVgprAllocation ); 11252 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.vgprAllocationGranularity ); 11253 return seed; 11254 } 11255 }; 11256 11257 template <> 11258 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCorePropertiesARM> 11259 { 11260 std::size_t operator ()std::hash11261 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCorePropertiesARM const & physicalDeviceShaderCorePropertiesARM ) const VULKAN_HPP_NOEXCEPT 11262 { 11263 std::size_t seed = 0; 11264 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesARM.sType ); 11265 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesARM.pNext ); 11266 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesARM.pixelRate ); 11267 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesARM.texelRate ); 11268 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesARM.fmaRate ); 11269 return seed; 11270 } 11271 }; 11272 11273 template <> 11274 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderDemoteToHelperInvocationFeatures> 11275 { operator ()std::hash11276 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderDemoteToHelperInvocationFeatures const & 11277 physicalDeviceShaderDemoteToHelperInvocationFeatures ) const VULKAN_HPP_NOEXCEPT 11278 { 11279 std::size_t seed = 0; 11280 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderDemoteToHelperInvocationFeatures.sType ); 11281 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderDemoteToHelperInvocationFeatures.pNext ); 11282 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderDemoteToHelperInvocationFeatures.shaderDemoteToHelperInvocation ); 11283 return seed; 11284 } 11285 }; 11286 11287 template <> 11288 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderDrawParametersFeatures> 11289 { operator ()std::hash11290 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderDrawParametersFeatures const & physicalDeviceShaderDrawParametersFeatures ) const 11291 VULKAN_HPP_NOEXCEPT 11292 { 11293 std::size_t seed = 0; 11294 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderDrawParametersFeatures.sType ); 11295 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderDrawParametersFeatures.pNext ); 11296 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderDrawParametersFeatures.shaderDrawParameters ); 11297 return seed; 11298 } 11299 }; 11300 11301 template <> 11302 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD> 11303 { operator ()std::hash11304 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD const & 11305 physicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD ) const VULKAN_HPP_NOEXCEPT 11306 { 11307 std::size_t seed = 0; 11308 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD.sType ); 11309 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD.pNext ); 11310 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD.shaderEarlyAndLateFragmentTests ); 11311 return seed; 11312 } 11313 }; 11314 11315 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 11316 template <> 11317 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderEnqueueFeaturesAMDX> 11318 { 11319 std::size_t operator ()std::hash11320 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderEnqueueFeaturesAMDX const & physicalDeviceShaderEnqueueFeaturesAMDX ) const VULKAN_HPP_NOEXCEPT 11321 { 11322 std::size_t seed = 0; 11323 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueueFeaturesAMDX.sType ); 11324 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueueFeaturesAMDX.pNext ); 11325 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueueFeaturesAMDX.shaderEnqueue ); 11326 return seed; 11327 } 11328 }; 11329 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 11330 11331 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 11332 template <> 11333 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderEnqueuePropertiesAMDX> 11334 { 11335 std::size_t operator ()std::hash11336 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderEnqueuePropertiesAMDX const & physicalDeviceShaderEnqueuePropertiesAMDX ) const VULKAN_HPP_NOEXCEPT 11337 { 11338 std::size_t seed = 0; 11339 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueuePropertiesAMDX.sType ); 11340 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueuePropertiesAMDX.pNext ); 11341 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueuePropertiesAMDX.maxExecutionGraphDepth ); 11342 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueuePropertiesAMDX.maxExecutionGraphShaderOutputNodes ); 11343 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueuePropertiesAMDX.maxExecutionGraphShaderPayloadSize ); 11344 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueuePropertiesAMDX.maxExecutionGraphShaderPayloadCount ); 11345 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueuePropertiesAMDX.executionGraphDispatchAddressAlignment ); 11346 return seed; 11347 } 11348 }; 11349 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 11350 11351 template <> 11352 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderExpectAssumeFeaturesKHR> 11353 { operator ()std::hash11354 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderExpectAssumeFeaturesKHR const & physicalDeviceShaderExpectAssumeFeaturesKHR ) const 11355 VULKAN_HPP_NOEXCEPT 11356 { 11357 std::size_t seed = 0; 11358 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderExpectAssumeFeaturesKHR.sType ); 11359 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderExpectAssumeFeaturesKHR.pNext ); 11360 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderExpectAssumeFeaturesKHR.shaderExpectAssume ); 11361 return seed; 11362 } 11363 }; 11364 11365 template <> 11366 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFloat16Int8Features> 11367 { 11368 std::size_t operator ()std::hash11369 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFloat16Int8Features const & physicalDeviceShaderFloat16Int8Features ) const VULKAN_HPP_NOEXCEPT 11370 { 11371 std::size_t seed = 0; 11372 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFloat16Int8Features.sType ); 11373 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFloat16Int8Features.pNext ); 11374 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFloat16Int8Features.shaderFloat16 ); 11375 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFloat16Int8Features.shaderInt8 ); 11376 return seed; 11377 } 11378 }; 11379 11380 template <> 11381 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFloatControls2FeaturesKHR> 11382 { operator ()std::hash11383 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFloatControls2FeaturesKHR const & physicalDeviceShaderFloatControls2FeaturesKHR ) const 11384 VULKAN_HPP_NOEXCEPT 11385 { 11386 std::size_t seed = 0; 11387 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFloatControls2FeaturesKHR.sType ); 11388 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFloatControls2FeaturesKHR.pNext ); 11389 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFloatControls2FeaturesKHR.shaderFloatControls2 ); 11390 return seed; 11391 } 11392 }; 11393 11394 template <> 11395 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderImageAtomicInt64FeaturesEXT> 11396 { operator ()std::hash11397 std::size_t operator()( 11398 VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderImageAtomicInt64FeaturesEXT const & physicalDeviceShaderImageAtomicInt64FeaturesEXT ) const VULKAN_HPP_NOEXCEPT 11399 { 11400 std::size_t seed = 0; 11401 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderImageAtomicInt64FeaturesEXT.sType ); 11402 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderImageAtomicInt64FeaturesEXT.pNext ); 11403 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderImageAtomicInt64FeaturesEXT.shaderImageInt64Atomics ); 11404 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderImageAtomicInt64FeaturesEXT.sparseImageInt64Atomics ); 11405 return seed; 11406 } 11407 }; 11408 11409 template <> 11410 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderImageFootprintFeaturesNV> 11411 { operator ()std::hash11412 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderImageFootprintFeaturesNV const & physicalDeviceShaderImageFootprintFeaturesNV ) const 11413 VULKAN_HPP_NOEXCEPT 11414 { 11415 std::size_t seed = 0; 11416 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderImageFootprintFeaturesNV.sType ); 11417 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderImageFootprintFeaturesNV.pNext ); 11418 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderImageFootprintFeaturesNV.imageFootprint ); 11419 return seed; 11420 } 11421 }; 11422 11423 template <> 11424 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerDotProductFeatures> 11425 { operator ()std::hash11426 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerDotProductFeatures const & physicalDeviceShaderIntegerDotProductFeatures ) const 11427 VULKAN_HPP_NOEXCEPT 11428 { 11429 std::size_t seed = 0; 11430 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductFeatures.sType ); 11431 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductFeatures.pNext ); 11432 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductFeatures.shaderIntegerDotProduct ); 11433 return seed; 11434 } 11435 }; 11436 11437 template <> 11438 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerDotProductProperties> 11439 { operator ()std::hash11440 std::size_t operator()( 11441 VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerDotProductProperties const & physicalDeviceShaderIntegerDotProductProperties ) const VULKAN_HPP_NOEXCEPT 11442 { 11443 std::size_t seed = 0; 11444 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.sType ); 11445 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.pNext ); 11446 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct8BitUnsignedAccelerated ); 11447 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct8BitSignedAccelerated ); 11448 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct8BitMixedSignednessAccelerated ); 11449 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct4x8BitPackedUnsignedAccelerated ); 11450 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct4x8BitPackedSignedAccelerated ); 11451 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct4x8BitPackedMixedSignednessAccelerated ); 11452 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct16BitUnsignedAccelerated ); 11453 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct16BitSignedAccelerated ); 11454 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct16BitMixedSignednessAccelerated ); 11455 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct32BitUnsignedAccelerated ); 11456 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct32BitSignedAccelerated ); 11457 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct32BitMixedSignednessAccelerated ); 11458 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct64BitUnsignedAccelerated ); 11459 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct64BitSignedAccelerated ); 11460 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct64BitMixedSignednessAccelerated ); 11461 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating8BitUnsignedAccelerated ); 11462 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating8BitSignedAccelerated ); 11463 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated ); 11464 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated ); 11465 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated ); 11466 VULKAN_HPP_HASH_COMBINE( seed, 11467 physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated ); 11468 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating16BitUnsignedAccelerated ); 11469 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating16BitSignedAccelerated ); 11470 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated ); 11471 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating32BitUnsignedAccelerated ); 11472 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating32BitSignedAccelerated ); 11473 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated ); 11474 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating64BitUnsignedAccelerated ); 11475 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating64BitSignedAccelerated ); 11476 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated ); 11477 return seed; 11478 } 11479 }; 11480 11481 template <> 11482 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL> 11483 { 11484 std::size_t operator ()std::hash11485 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const & physicalDeviceShaderIntegerFunctions2FeaturesINTEL ) const 11486 VULKAN_HPP_NOEXCEPT 11487 { 11488 std::size_t seed = 0; 11489 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerFunctions2FeaturesINTEL.sType ); 11490 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerFunctions2FeaturesINTEL.pNext ); 11491 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerFunctions2FeaturesINTEL.shaderIntegerFunctions2 ); 11492 return seed; 11493 } 11494 }; 11495 11496 template <> 11497 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR> 11498 { 11499 std::size_t operator ()std::hash11500 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR const & physicalDeviceShaderMaximalReconvergenceFeaturesKHR ) const 11501 VULKAN_HPP_NOEXCEPT 11502 { 11503 std::size_t seed = 0; 11504 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderMaximalReconvergenceFeaturesKHR.sType ); 11505 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderMaximalReconvergenceFeaturesKHR.pNext ); 11506 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderMaximalReconvergenceFeaturesKHR.shaderMaximalReconvergence ); 11507 return seed; 11508 } 11509 }; 11510 11511 template <> 11512 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderModuleIdentifierFeaturesEXT> 11513 { operator ()std::hash11514 std::size_t operator()( 11515 VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderModuleIdentifierFeaturesEXT const & physicalDeviceShaderModuleIdentifierFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 11516 { 11517 std::size_t seed = 0; 11518 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderModuleIdentifierFeaturesEXT.sType ); 11519 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderModuleIdentifierFeaturesEXT.pNext ); 11520 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderModuleIdentifierFeaturesEXT.shaderModuleIdentifier ); 11521 return seed; 11522 } 11523 }; 11524 11525 template <> 11526 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderModuleIdentifierPropertiesEXT> 11527 { operator ()std::hash11528 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderModuleIdentifierPropertiesEXT const & physicalDeviceShaderModuleIdentifierPropertiesEXT ) 11529 const VULKAN_HPP_NOEXCEPT 11530 { 11531 std::size_t seed = 0; 11532 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderModuleIdentifierPropertiesEXT.sType ); 11533 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderModuleIdentifierPropertiesEXT.pNext ); 11534 for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) 11535 { 11536 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderModuleIdentifierPropertiesEXT.shaderModuleIdentifierAlgorithmUUID[i] ); 11537 } 11538 return seed; 11539 } 11540 }; 11541 11542 template <> 11543 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderObjectFeaturesEXT> 11544 { 11545 std::size_t operator ()std::hash11546 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderObjectFeaturesEXT const & physicalDeviceShaderObjectFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 11547 { 11548 std::size_t seed = 0; 11549 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderObjectFeaturesEXT.sType ); 11550 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderObjectFeaturesEXT.pNext ); 11551 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderObjectFeaturesEXT.shaderObject ); 11552 return seed; 11553 } 11554 }; 11555 11556 template <> 11557 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderObjectPropertiesEXT> 11558 { 11559 std::size_t operator ()std::hash11560 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderObjectPropertiesEXT const & physicalDeviceShaderObjectPropertiesEXT ) const VULKAN_HPP_NOEXCEPT 11561 { 11562 std::size_t seed = 0; 11563 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderObjectPropertiesEXT.sType ); 11564 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderObjectPropertiesEXT.pNext ); 11565 for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) 11566 { 11567 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderObjectPropertiesEXT.shaderBinaryUUID[i] ); 11568 } 11569 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderObjectPropertiesEXT.shaderBinaryVersion ); 11570 return seed; 11571 } 11572 }; 11573 11574 template <> 11575 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderQuadControlFeaturesKHR> 11576 { operator ()std::hash11577 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderQuadControlFeaturesKHR const & physicalDeviceShaderQuadControlFeaturesKHR ) const 11578 VULKAN_HPP_NOEXCEPT 11579 { 11580 std::size_t seed = 0; 11581 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderQuadControlFeaturesKHR.sType ); 11582 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderQuadControlFeaturesKHR.pNext ); 11583 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderQuadControlFeaturesKHR.shaderQuadControl ); 11584 return seed; 11585 } 11586 }; 11587 11588 template <> 11589 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderReplicatedCompositesFeaturesEXT> 11590 { 11591 std::size_t operator ()std::hash11592 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderReplicatedCompositesFeaturesEXT const & physicalDeviceShaderReplicatedCompositesFeaturesEXT ) const 11593 VULKAN_HPP_NOEXCEPT 11594 { 11595 std::size_t seed = 0; 11596 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderReplicatedCompositesFeaturesEXT.sType ); 11597 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderReplicatedCompositesFeaturesEXT.pNext ); 11598 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderReplicatedCompositesFeaturesEXT.shaderReplicatedComposites ); 11599 return seed; 11600 } 11601 }; 11602 11603 template <> 11604 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSMBuiltinsFeaturesNV> 11605 { 11606 std::size_t operator ()std::hash11607 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSMBuiltinsFeaturesNV const & physicalDeviceShaderSMBuiltinsFeaturesNV ) const VULKAN_HPP_NOEXCEPT 11608 { 11609 std::size_t seed = 0; 11610 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSMBuiltinsFeaturesNV.sType ); 11611 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSMBuiltinsFeaturesNV.pNext ); 11612 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSMBuiltinsFeaturesNV.shaderSMBuiltins ); 11613 return seed; 11614 } 11615 }; 11616 11617 template <> 11618 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSMBuiltinsPropertiesNV> 11619 { operator ()std::hash11620 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSMBuiltinsPropertiesNV const & physicalDeviceShaderSMBuiltinsPropertiesNV ) const 11621 VULKAN_HPP_NOEXCEPT 11622 { 11623 std::size_t seed = 0; 11624 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSMBuiltinsPropertiesNV.sType ); 11625 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSMBuiltinsPropertiesNV.pNext ); 11626 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSMBuiltinsPropertiesNV.shaderSMCount ); 11627 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSMBuiltinsPropertiesNV.shaderWarpsPerSM ); 11628 return seed; 11629 } 11630 }; 11631 11632 template <> 11633 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupExtendedTypesFeatures> 11634 { operator ()std::hash11635 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupExtendedTypesFeatures const & physicalDeviceShaderSubgroupExtendedTypesFeatures ) 11636 const VULKAN_HPP_NOEXCEPT 11637 { 11638 std::size_t seed = 0; 11639 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupExtendedTypesFeatures.sType ); 11640 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupExtendedTypesFeatures.pNext ); 11641 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupExtendedTypesFeatures.shaderSubgroupExtendedTypes ); 11642 return seed; 11643 } 11644 }; 11645 11646 template <> 11647 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupRotateFeaturesKHR> 11648 { operator ()std::hash11649 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupRotateFeaturesKHR const & physicalDeviceShaderSubgroupRotateFeaturesKHR ) const 11650 VULKAN_HPP_NOEXCEPT 11651 { 11652 std::size_t seed = 0; 11653 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupRotateFeaturesKHR.sType ); 11654 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupRotateFeaturesKHR.pNext ); 11655 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupRotateFeaturesKHR.shaderSubgroupRotate ); 11656 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupRotateFeaturesKHR.shaderSubgroupRotateClustered ); 11657 return seed; 11658 } 11659 }; 11660 11661 template <> 11662 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR> 11663 { operator ()std::hash11664 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR const & 11665 physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR ) const VULKAN_HPP_NOEXCEPT 11666 { 11667 std::size_t seed = 0; 11668 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR.sType ); 11669 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR.pNext ); 11670 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR.shaderSubgroupUniformControlFlow ); 11671 return seed; 11672 } 11673 }; 11674 11675 template <> 11676 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderTerminateInvocationFeatures> 11677 { operator ()std::hash11678 std::size_t operator()( 11679 VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderTerminateInvocationFeatures const & physicalDeviceShaderTerminateInvocationFeatures ) const VULKAN_HPP_NOEXCEPT 11680 { 11681 std::size_t seed = 0; 11682 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTerminateInvocationFeatures.sType ); 11683 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTerminateInvocationFeatures.pNext ); 11684 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTerminateInvocationFeatures.shaderTerminateInvocation ); 11685 return seed; 11686 } 11687 }; 11688 11689 template <> 11690 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderTileImageFeaturesEXT> 11691 { 11692 std::size_t operator ()std::hash11693 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderTileImageFeaturesEXT const & physicalDeviceShaderTileImageFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 11694 { 11695 std::size_t seed = 0; 11696 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImageFeaturesEXT.sType ); 11697 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImageFeaturesEXT.pNext ); 11698 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImageFeaturesEXT.shaderTileImageColorReadAccess ); 11699 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImageFeaturesEXT.shaderTileImageDepthReadAccess ); 11700 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImageFeaturesEXT.shaderTileImageStencilReadAccess ); 11701 return seed; 11702 } 11703 }; 11704 11705 template <> 11706 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderTileImagePropertiesEXT> 11707 { operator ()std::hash11708 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderTileImagePropertiesEXT const & physicalDeviceShaderTileImagePropertiesEXT ) const 11709 VULKAN_HPP_NOEXCEPT 11710 { 11711 std::size_t seed = 0; 11712 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImagePropertiesEXT.sType ); 11713 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImagePropertiesEXT.pNext ); 11714 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImagePropertiesEXT.shaderTileImageCoherentReadAccelerated ); 11715 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImagePropertiesEXT.shaderTileImageReadSampleFromPixelRateInvocation ); 11716 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImagePropertiesEXT.shaderTileImageReadFromHelperInvocation ); 11717 return seed; 11718 } 11719 }; 11720 11721 template <> 11722 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShadingRateImageFeaturesNV> 11723 { 11724 std::size_t operator ()std::hash11725 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShadingRateImageFeaturesNV const & physicalDeviceShadingRateImageFeaturesNV ) const VULKAN_HPP_NOEXCEPT 11726 { 11727 std::size_t seed = 0; 11728 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShadingRateImageFeaturesNV.sType ); 11729 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShadingRateImageFeaturesNV.pNext ); 11730 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShadingRateImageFeaturesNV.shadingRateImage ); 11731 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShadingRateImageFeaturesNV.shadingRateCoarseSampleOrder ); 11732 return seed; 11733 } 11734 }; 11735 11736 template <> 11737 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShadingRateImagePropertiesNV> 11738 { operator ()std::hash11739 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShadingRateImagePropertiesNV const & physicalDeviceShadingRateImagePropertiesNV ) const 11740 VULKAN_HPP_NOEXCEPT 11741 { 11742 std::size_t seed = 0; 11743 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShadingRateImagePropertiesNV.sType ); 11744 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShadingRateImagePropertiesNV.pNext ); 11745 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShadingRateImagePropertiesNV.shadingRateTexelSize ); 11746 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShadingRateImagePropertiesNV.shadingRatePaletteSize ); 11747 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShadingRateImagePropertiesNV.shadingRateMaxCoarseSamples ); 11748 return seed; 11749 } 11750 }; 11751 11752 template <> 11753 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2> 11754 { operator ()std::hash11755 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 const & physicalDeviceSparseImageFormatInfo2 ) const VULKAN_HPP_NOEXCEPT 11756 { 11757 std::size_t seed = 0; 11758 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseImageFormatInfo2.sType ); 11759 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseImageFormatInfo2.pNext ); 11760 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseImageFormatInfo2.format ); 11761 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseImageFormatInfo2.type ); 11762 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseImageFormatInfo2.samples ); 11763 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseImageFormatInfo2.usage ); 11764 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseImageFormatInfo2.tiling ); 11765 return seed; 11766 } 11767 }; 11768 11769 template <> 11770 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupProperties> 11771 { operator ()std::hash11772 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupProperties const & physicalDeviceSubgroupProperties ) const VULKAN_HPP_NOEXCEPT 11773 { 11774 std::size_t seed = 0; 11775 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupProperties.sType ); 11776 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupProperties.pNext ); 11777 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupProperties.subgroupSize ); 11778 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupProperties.supportedStages ); 11779 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupProperties.supportedOperations ); 11780 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupProperties.quadOperationsInAllStages ); 11781 return seed; 11782 } 11783 }; 11784 11785 template <> 11786 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupSizeControlFeatures> 11787 { 11788 std::size_t operator ()std::hash11789 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupSizeControlFeatures const & physicalDeviceSubgroupSizeControlFeatures ) const VULKAN_HPP_NOEXCEPT 11790 { 11791 std::size_t seed = 0; 11792 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlFeatures.sType ); 11793 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlFeatures.pNext ); 11794 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlFeatures.subgroupSizeControl ); 11795 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlFeatures.computeFullSubgroups ); 11796 return seed; 11797 } 11798 }; 11799 11800 template <> 11801 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupSizeControlProperties> 11802 { operator ()std::hash11803 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupSizeControlProperties const & physicalDeviceSubgroupSizeControlProperties ) const 11804 VULKAN_HPP_NOEXCEPT 11805 { 11806 std::size_t seed = 0; 11807 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlProperties.sType ); 11808 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlProperties.pNext ); 11809 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlProperties.minSubgroupSize ); 11810 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlProperties.maxSubgroupSize ); 11811 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlProperties.maxComputeWorkgroupSubgroups ); 11812 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlProperties.requiredSubgroupSizeStages ); 11813 return seed; 11814 } 11815 }; 11816 11817 template <> 11818 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassMergeFeedbackFeaturesEXT> 11819 { operator ()std::hash11820 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassMergeFeedbackFeaturesEXT const & physicalDeviceSubpassMergeFeedbackFeaturesEXT ) const 11821 VULKAN_HPP_NOEXCEPT 11822 { 11823 std::size_t seed = 0; 11824 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubpassMergeFeedbackFeaturesEXT.sType ); 11825 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubpassMergeFeedbackFeaturesEXT.pNext ); 11826 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubpassMergeFeedbackFeaturesEXT.subpassMergeFeedback ); 11827 return seed; 11828 } 11829 }; 11830 11831 template <> 11832 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassShadingFeaturesHUAWEI> 11833 { operator ()std::hash11834 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassShadingFeaturesHUAWEI const & physicalDeviceSubpassShadingFeaturesHUAWEI ) const 11835 VULKAN_HPP_NOEXCEPT 11836 { 11837 std::size_t seed = 0; 11838 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubpassShadingFeaturesHUAWEI.sType ); 11839 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubpassShadingFeaturesHUAWEI.pNext ); 11840 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubpassShadingFeaturesHUAWEI.subpassShading ); 11841 return seed; 11842 } 11843 }; 11844 11845 template <> 11846 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassShadingPropertiesHUAWEI> 11847 { operator ()std::hash11848 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassShadingPropertiesHUAWEI const & physicalDeviceSubpassShadingPropertiesHUAWEI ) const 11849 VULKAN_HPP_NOEXCEPT 11850 { 11851 std::size_t seed = 0; 11852 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubpassShadingPropertiesHUAWEI.sType ); 11853 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubpassShadingPropertiesHUAWEI.pNext ); 11854 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubpassShadingPropertiesHUAWEI.maxSubpassShadingWorkgroupSizeAspectRatio ); 11855 return seed; 11856 } 11857 }; 11858 11859 template <> 11860 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR> 11861 { operator ()std::hash11862 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR const & physicalDeviceSurfaceInfo2KHR ) const VULKAN_HPP_NOEXCEPT 11863 { 11864 std::size_t seed = 0; 11865 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSurfaceInfo2KHR.sType ); 11866 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSurfaceInfo2KHR.pNext ); 11867 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSurfaceInfo2KHR.surface ); 11868 return seed; 11869 } 11870 }; 11871 11872 template <> 11873 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSwapchainMaintenance1FeaturesEXT> 11874 { operator ()std::hash11875 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSwapchainMaintenance1FeaturesEXT const & physicalDeviceSwapchainMaintenance1FeaturesEXT ) const 11876 VULKAN_HPP_NOEXCEPT 11877 { 11878 std::size_t seed = 0; 11879 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSwapchainMaintenance1FeaturesEXT.sType ); 11880 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSwapchainMaintenance1FeaturesEXT.pNext ); 11881 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSwapchainMaintenance1FeaturesEXT.swapchainMaintenance1 ); 11882 return seed; 11883 } 11884 }; 11885 11886 template <> 11887 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSynchronization2Features> 11888 { 11889 std::size_t operator ()std::hash11890 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSynchronization2Features const & physicalDeviceSynchronization2Features ) const VULKAN_HPP_NOEXCEPT 11891 { 11892 std::size_t seed = 0; 11893 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSynchronization2Features.sType ); 11894 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSynchronization2Features.pNext ); 11895 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSynchronization2Features.synchronization2 ); 11896 return seed; 11897 } 11898 }; 11899 11900 template <> 11901 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTexelBufferAlignmentFeaturesEXT> 11902 { operator ()std::hash11903 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTexelBufferAlignmentFeaturesEXT const & physicalDeviceTexelBufferAlignmentFeaturesEXT ) const 11904 VULKAN_HPP_NOEXCEPT 11905 { 11906 std::size_t seed = 0; 11907 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTexelBufferAlignmentFeaturesEXT.sType ); 11908 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTexelBufferAlignmentFeaturesEXT.pNext ); 11909 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTexelBufferAlignmentFeaturesEXT.texelBufferAlignment ); 11910 return seed; 11911 } 11912 }; 11913 11914 template <> 11915 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTexelBufferAlignmentProperties> 11916 { operator ()std::hash11917 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTexelBufferAlignmentProperties const & physicalDeviceTexelBufferAlignmentProperties ) const 11918 VULKAN_HPP_NOEXCEPT 11919 { 11920 std::size_t seed = 0; 11921 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTexelBufferAlignmentProperties.sType ); 11922 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTexelBufferAlignmentProperties.pNext ); 11923 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTexelBufferAlignmentProperties.storageTexelBufferOffsetAlignmentBytes ); 11924 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTexelBufferAlignmentProperties.storageTexelBufferOffsetSingleTexelAlignment ); 11925 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTexelBufferAlignmentProperties.uniformTexelBufferOffsetAlignmentBytes ); 11926 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTexelBufferAlignmentProperties.uniformTexelBufferOffsetSingleTexelAlignment ); 11927 return seed; 11928 } 11929 }; 11930 11931 template <> 11932 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTextureCompressionASTCHDRFeatures> 11933 { operator ()std::hash11934 std::size_t operator()( 11935 VULKAN_HPP_NAMESPACE::PhysicalDeviceTextureCompressionASTCHDRFeatures const & physicalDeviceTextureCompressionASTCHDRFeatures ) const VULKAN_HPP_NOEXCEPT 11936 { 11937 std::size_t seed = 0; 11938 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTextureCompressionASTCHDRFeatures.sType ); 11939 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTextureCompressionASTCHDRFeatures.pNext ); 11940 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTextureCompressionASTCHDRFeatures.textureCompressionASTC_HDR ); 11941 return seed; 11942 } 11943 }; 11944 11945 template <> 11946 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTilePropertiesFeaturesQCOM> 11947 { 11948 std::size_t operator ()std::hash11949 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTilePropertiesFeaturesQCOM const & physicalDeviceTilePropertiesFeaturesQCOM ) const VULKAN_HPP_NOEXCEPT 11950 { 11951 std::size_t seed = 0; 11952 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTilePropertiesFeaturesQCOM.sType ); 11953 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTilePropertiesFeaturesQCOM.pNext ); 11954 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTilePropertiesFeaturesQCOM.tileProperties ); 11955 return seed; 11956 } 11957 }; 11958 11959 template <> 11960 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTimelineSemaphoreFeatures> 11961 { 11962 std::size_t operator ()std::hash11963 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTimelineSemaphoreFeatures const & physicalDeviceTimelineSemaphoreFeatures ) const VULKAN_HPP_NOEXCEPT 11964 { 11965 std::size_t seed = 0; 11966 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTimelineSemaphoreFeatures.sType ); 11967 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTimelineSemaphoreFeatures.pNext ); 11968 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTimelineSemaphoreFeatures.timelineSemaphore ); 11969 return seed; 11970 } 11971 }; 11972 11973 template <> 11974 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTimelineSemaphoreProperties> 11975 { 11976 std::size_t operator ()std::hash11977 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTimelineSemaphoreProperties const & physicalDeviceTimelineSemaphoreProperties ) const VULKAN_HPP_NOEXCEPT 11978 { 11979 std::size_t seed = 0; 11980 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTimelineSemaphoreProperties.sType ); 11981 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTimelineSemaphoreProperties.pNext ); 11982 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTimelineSemaphoreProperties.maxTimelineSemaphoreValueDifference ); 11983 return seed; 11984 } 11985 }; 11986 11987 template <> 11988 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties> 11989 { operator ()std::hash11990 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties const & physicalDeviceToolProperties ) const VULKAN_HPP_NOEXCEPT 11991 { 11992 std::size_t seed = 0; 11993 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceToolProperties.sType ); 11994 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceToolProperties.pNext ); 11995 for ( size_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i ) 11996 { 11997 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceToolProperties.name[i] ); 11998 } 11999 for ( size_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i ) 12000 { 12001 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceToolProperties.version[i] ); 12002 } 12003 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceToolProperties.purposes ); 12004 for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) 12005 { 12006 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceToolProperties.description[i] ); 12007 } 12008 for ( size_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i ) 12009 { 12010 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceToolProperties.layer[i] ); 12011 } 12012 return seed; 12013 } 12014 }; 12015 12016 template <> 12017 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTransformFeedbackFeaturesEXT> 12018 { operator ()std::hash12019 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTransformFeedbackFeaturesEXT const & physicalDeviceTransformFeedbackFeaturesEXT ) const 12020 VULKAN_HPP_NOEXCEPT 12021 { 12022 std::size_t seed = 0; 12023 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackFeaturesEXT.sType ); 12024 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackFeaturesEXT.pNext ); 12025 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackFeaturesEXT.transformFeedback ); 12026 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackFeaturesEXT.geometryStreams ); 12027 return seed; 12028 } 12029 }; 12030 12031 template <> 12032 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTransformFeedbackPropertiesEXT> 12033 { operator ()std::hash12034 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTransformFeedbackPropertiesEXT const & physicalDeviceTransformFeedbackPropertiesEXT ) const 12035 VULKAN_HPP_NOEXCEPT 12036 { 12037 std::size_t seed = 0; 12038 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.sType ); 12039 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.pNext ); 12040 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackStreams ); 12041 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackBuffers ); 12042 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackBufferSize ); 12043 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackStreamDataSize ); 12044 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackBufferDataSize ); 12045 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackBufferDataStride ); 12046 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.transformFeedbackQueries ); 12047 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.transformFeedbackStreamsLinesTriangles ); 12048 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.transformFeedbackRasterizationStreamSelect ); 12049 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.transformFeedbackDraw ); 12050 return seed; 12051 } 12052 }; 12053 12054 template <> 12055 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceUniformBufferStandardLayoutFeatures> 12056 { operator ()std::hash12057 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceUniformBufferStandardLayoutFeatures const & physicalDeviceUniformBufferStandardLayoutFeatures ) 12058 const VULKAN_HPP_NOEXCEPT 12059 { 12060 std::size_t seed = 0; 12061 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceUniformBufferStandardLayoutFeatures.sType ); 12062 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceUniformBufferStandardLayoutFeatures.pNext ); 12063 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceUniformBufferStandardLayoutFeatures.uniformBufferStandardLayout ); 12064 return seed; 12065 } 12066 }; 12067 12068 template <> 12069 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVariablePointersFeatures> 12070 { 12071 std::size_t operator ()std::hash12072 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVariablePointersFeatures const & physicalDeviceVariablePointersFeatures ) const VULKAN_HPP_NOEXCEPT 12073 { 12074 std::size_t seed = 0; 12075 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVariablePointersFeatures.sType ); 12076 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVariablePointersFeatures.pNext ); 12077 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVariablePointersFeatures.variablePointersStorageBuffer ); 12078 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVariablePointersFeatures.variablePointers ); 12079 return seed; 12080 } 12081 }; 12082 12083 template <> 12084 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorFeaturesKHR> 12085 { operator ()std::hash12086 std::size_t operator()( 12087 VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorFeaturesKHR const & physicalDeviceVertexAttributeDivisorFeaturesKHR ) const VULKAN_HPP_NOEXCEPT 12088 { 12089 std::size_t seed = 0; 12090 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorFeaturesKHR.sType ); 12091 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorFeaturesKHR.pNext ); 12092 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorFeaturesKHR.vertexAttributeInstanceRateDivisor ); 12093 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorFeaturesKHR.vertexAttributeInstanceRateZeroDivisor ); 12094 return seed; 12095 } 12096 }; 12097 12098 template <> 12099 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorPropertiesEXT> 12100 { operator ()std::hash12101 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorPropertiesEXT const & physicalDeviceVertexAttributeDivisorPropertiesEXT ) 12102 const VULKAN_HPP_NOEXCEPT 12103 { 12104 std::size_t seed = 0; 12105 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorPropertiesEXT.sType ); 12106 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorPropertiesEXT.pNext ); 12107 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorPropertiesEXT.maxVertexAttribDivisor ); 12108 return seed; 12109 } 12110 }; 12111 12112 template <> 12113 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorPropertiesKHR> 12114 { operator ()std::hash12115 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorPropertiesKHR const & physicalDeviceVertexAttributeDivisorPropertiesKHR ) 12116 const VULKAN_HPP_NOEXCEPT 12117 { 12118 std::size_t seed = 0; 12119 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorPropertiesKHR.sType ); 12120 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorPropertiesKHR.pNext ); 12121 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorPropertiesKHR.maxVertexAttribDivisor ); 12122 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorPropertiesKHR.supportsNonZeroFirstInstance ); 12123 return seed; 12124 } 12125 }; 12126 12127 template <> 12128 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexInputDynamicStateFeaturesEXT> 12129 { operator ()std::hash12130 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexInputDynamicStateFeaturesEXT const & physicalDeviceVertexInputDynamicStateFeaturesEXT ) 12131 const VULKAN_HPP_NOEXCEPT 12132 { 12133 std::size_t seed = 0; 12134 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexInputDynamicStateFeaturesEXT.sType ); 12135 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexInputDynamicStateFeaturesEXT.pNext ); 12136 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexInputDynamicStateFeaturesEXT.vertexInputDynamicState ); 12137 return seed; 12138 } 12139 }; 12140 12141 template <> 12142 struct hash<VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR> 12143 { operator ()std::hash12144 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR const & videoProfileInfoKHR ) const VULKAN_HPP_NOEXCEPT 12145 { 12146 std::size_t seed = 0; 12147 VULKAN_HPP_HASH_COMBINE( seed, videoProfileInfoKHR.sType ); 12148 VULKAN_HPP_HASH_COMBINE( seed, videoProfileInfoKHR.pNext ); 12149 VULKAN_HPP_HASH_COMBINE( seed, videoProfileInfoKHR.videoCodecOperation ); 12150 VULKAN_HPP_HASH_COMBINE( seed, videoProfileInfoKHR.chromaSubsampling ); 12151 VULKAN_HPP_HASH_COMBINE( seed, videoProfileInfoKHR.lumaBitDepth ); 12152 VULKAN_HPP_HASH_COMBINE( seed, videoProfileInfoKHR.chromaBitDepth ); 12153 return seed; 12154 } 12155 }; 12156 12157 template <> 12158 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeQualityLevelInfoKHR> 12159 { operator ()std::hash12160 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeQualityLevelInfoKHR const & physicalDeviceVideoEncodeQualityLevelInfoKHR ) const 12161 VULKAN_HPP_NOEXCEPT 12162 { 12163 std::size_t seed = 0; 12164 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoEncodeQualityLevelInfoKHR.sType ); 12165 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoEncodeQualityLevelInfoKHR.pNext ); 12166 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoEncodeQualityLevelInfoKHR.pVideoProfile ); 12167 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoEncodeQualityLevelInfoKHR.qualityLevel ); 12168 return seed; 12169 } 12170 }; 12171 12172 template <> 12173 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR> 12174 { operator ()std::hash12175 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR const & physicalDeviceVideoFormatInfoKHR ) const VULKAN_HPP_NOEXCEPT 12176 { 12177 std::size_t seed = 0; 12178 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoFormatInfoKHR.sType ); 12179 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoFormatInfoKHR.pNext ); 12180 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoFormatInfoKHR.imageUsage ); 12181 return seed; 12182 } 12183 }; 12184 12185 template <> 12186 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoMaintenance1FeaturesKHR> 12187 { operator ()std::hash12188 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoMaintenance1FeaturesKHR const & physicalDeviceVideoMaintenance1FeaturesKHR ) const 12189 VULKAN_HPP_NOEXCEPT 12190 { 12191 std::size_t seed = 0; 12192 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoMaintenance1FeaturesKHR.sType ); 12193 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoMaintenance1FeaturesKHR.pNext ); 12194 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoMaintenance1FeaturesKHR.videoMaintenance1 ); 12195 return seed; 12196 } 12197 }; 12198 12199 template <> 12200 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan11Features> 12201 { operator ()std::hash12202 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan11Features const & physicalDeviceVulkan11Features ) const VULKAN_HPP_NOEXCEPT 12203 { 12204 std::size_t seed = 0; 12205 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.sType ); 12206 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.pNext ); 12207 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.storageBuffer16BitAccess ); 12208 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.uniformAndStorageBuffer16BitAccess ); 12209 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.storagePushConstant16 ); 12210 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.storageInputOutput16 ); 12211 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.multiview ); 12212 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.multiviewGeometryShader ); 12213 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.multiviewTessellationShader ); 12214 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.variablePointersStorageBuffer ); 12215 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.variablePointers ); 12216 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.protectedMemory ); 12217 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.samplerYcbcrConversion ); 12218 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.shaderDrawParameters ); 12219 return seed; 12220 } 12221 }; 12222 12223 template <> 12224 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan11Properties> 12225 { operator ()std::hash12226 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan11Properties const & physicalDeviceVulkan11Properties ) const VULKAN_HPP_NOEXCEPT 12227 { 12228 std::size_t seed = 0; 12229 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.sType ); 12230 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.pNext ); 12231 for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) 12232 { 12233 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.deviceUUID[i] ); 12234 } 12235 for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) 12236 { 12237 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.driverUUID[i] ); 12238 } 12239 for ( size_t i = 0; i < VK_LUID_SIZE; ++i ) 12240 { 12241 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.deviceLUID[i] ); 12242 } 12243 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.deviceNodeMask ); 12244 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.deviceLUIDValid ); 12245 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.subgroupSize ); 12246 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.subgroupSupportedStages ); 12247 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.subgroupSupportedOperations ); 12248 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.subgroupQuadOperationsInAllStages ); 12249 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.pointClippingBehavior ); 12250 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.maxMultiviewViewCount ); 12251 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.maxMultiviewInstanceIndex ); 12252 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.protectedNoFault ); 12253 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.maxPerSetDescriptors ); 12254 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.maxMemoryAllocationSize ); 12255 return seed; 12256 } 12257 }; 12258 12259 template <> 12260 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan12Features> 12261 { operator ()std::hash12262 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan12Features const & physicalDeviceVulkan12Features ) const VULKAN_HPP_NOEXCEPT 12263 { 12264 std::size_t seed = 0; 12265 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.sType ); 12266 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.pNext ); 12267 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.samplerMirrorClampToEdge ); 12268 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.drawIndirectCount ); 12269 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.storageBuffer8BitAccess ); 12270 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.uniformAndStorageBuffer8BitAccess ); 12271 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.storagePushConstant8 ); 12272 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderBufferInt64Atomics ); 12273 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderSharedInt64Atomics ); 12274 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderFloat16 ); 12275 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderInt8 ); 12276 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorIndexing ); 12277 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderInputAttachmentArrayDynamicIndexing ); 12278 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderUniformTexelBufferArrayDynamicIndexing ); 12279 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderStorageTexelBufferArrayDynamicIndexing ); 12280 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderUniformBufferArrayNonUniformIndexing ); 12281 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderSampledImageArrayNonUniformIndexing ); 12282 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderStorageBufferArrayNonUniformIndexing ); 12283 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderStorageImageArrayNonUniformIndexing ); 12284 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderInputAttachmentArrayNonUniformIndexing ); 12285 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderUniformTexelBufferArrayNonUniformIndexing ); 12286 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderStorageTexelBufferArrayNonUniformIndexing ); 12287 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorBindingUniformBufferUpdateAfterBind ); 12288 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorBindingSampledImageUpdateAfterBind ); 12289 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorBindingStorageImageUpdateAfterBind ); 12290 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorBindingStorageBufferUpdateAfterBind ); 12291 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorBindingUniformTexelBufferUpdateAfterBind ); 12292 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorBindingStorageTexelBufferUpdateAfterBind ); 12293 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorBindingUpdateUnusedWhilePending ); 12294 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorBindingPartiallyBound ); 12295 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorBindingVariableDescriptorCount ); 12296 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.runtimeDescriptorArray ); 12297 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.samplerFilterMinmax ); 12298 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.scalarBlockLayout ); 12299 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.imagelessFramebuffer ); 12300 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.uniformBufferStandardLayout ); 12301 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderSubgroupExtendedTypes ); 12302 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.separateDepthStencilLayouts ); 12303 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.hostQueryReset ); 12304 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.timelineSemaphore ); 12305 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.bufferDeviceAddress ); 12306 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.bufferDeviceAddressCaptureReplay ); 12307 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.bufferDeviceAddressMultiDevice ); 12308 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.vulkanMemoryModel ); 12309 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.vulkanMemoryModelDeviceScope ); 12310 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.vulkanMemoryModelAvailabilityVisibilityChains ); 12311 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderOutputViewportIndex ); 12312 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderOutputLayer ); 12313 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.subgroupBroadcastDynamicId ); 12314 return seed; 12315 } 12316 }; 12317 12318 template <> 12319 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan12Properties> 12320 { operator ()std::hash12321 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan12Properties const & physicalDeviceVulkan12Properties ) const VULKAN_HPP_NOEXCEPT 12322 { 12323 std::size_t seed = 0; 12324 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.sType ); 12325 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.pNext ); 12326 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.driverID ); 12327 for ( size_t i = 0; i < VK_MAX_DRIVER_NAME_SIZE; ++i ) 12328 { 12329 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.driverName[i] ); 12330 } 12331 for ( size_t i = 0; i < VK_MAX_DRIVER_INFO_SIZE; ++i ) 12332 { 12333 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.driverInfo[i] ); 12334 } 12335 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.conformanceVersion ); 12336 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.denormBehaviorIndependence ); 12337 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.roundingModeIndependence ); 12338 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderSignedZeroInfNanPreserveFloat16 ); 12339 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderSignedZeroInfNanPreserveFloat32 ); 12340 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderSignedZeroInfNanPreserveFloat64 ); 12341 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderDenormPreserveFloat16 ); 12342 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderDenormPreserveFloat32 ); 12343 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderDenormPreserveFloat64 ); 12344 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderDenormFlushToZeroFloat16 ); 12345 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderDenormFlushToZeroFloat32 ); 12346 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderDenormFlushToZeroFloat64 ); 12347 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTEFloat16 ); 12348 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTEFloat32 ); 12349 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTEFloat64 ); 12350 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTZFloat16 ); 12351 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTZFloat32 ); 12352 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTZFloat64 ); 12353 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxUpdateAfterBindDescriptorsInAllPools ); 12354 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderUniformBufferArrayNonUniformIndexingNative ); 12355 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderSampledImageArrayNonUniformIndexingNative ); 12356 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderStorageBufferArrayNonUniformIndexingNative ); 12357 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderStorageImageArrayNonUniformIndexingNative ); 12358 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderInputAttachmentArrayNonUniformIndexingNative ); 12359 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.robustBufferAccessUpdateAfterBind ); 12360 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.quadDivergentImplicitLod ); 12361 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindSamplers ); 12362 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindUniformBuffers ); 12363 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindStorageBuffers ); 12364 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindSampledImages ); 12365 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindStorageImages ); 12366 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindInputAttachments ); 12367 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxPerStageUpdateAfterBindResources ); 12368 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindSamplers ); 12369 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindUniformBuffers ); 12370 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic ); 12371 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindStorageBuffers ); 12372 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic ); 12373 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindSampledImages ); 12374 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindStorageImages ); 12375 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindInputAttachments ); 12376 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.supportedDepthResolveModes ); 12377 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.supportedStencilResolveModes ); 12378 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.independentResolveNone ); 12379 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.independentResolve ); 12380 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.filterMinmaxSingleComponentFormats ); 12381 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.filterMinmaxImageComponentMapping ); 12382 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxTimelineSemaphoreValueDifference ); 12383 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.framebufferIntegerColorSampleCounts ); 12384 return seed; 12385 } 12386 }; 12387 12388 template <> 12389 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan13Features> 12390 { operator ()std::hash12391 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan13Features const & physicalDeviceVulkan13Features ) const VULKAN_HPP_NOEXCEPT 12392 { 12393 std::size_t seed = 0; 12394 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.sType ); 12395 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.pNext ); 12396 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.robustImageAccess ); 12397 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.inlineUniformBlock ); 12398 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.descriptorBindingInlineUniformBlockUpdateAfterBind ); 12399 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.pipelineCreationCacheControl ); 12400 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.privateData ); 12401 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.shaderDemoteToHelperInvocation ); 12402 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.shaderTerminateInvocation ); 12403 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.subgroupSizeControl ); 12404 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.computeFullSubgroups ); 12405 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.synchronization2 ); 12406 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.textureCompressionASTC_HDR ); 12407 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.shaderZeroInitializeWorkgroupMemory ); 12408 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.dynamicRendering ); 12409 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.shaderIntegerDotProduct ); 12410 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.maintenance4 ); 12411 return seed; 12412 } 12413 }; 12414 12415 template <> 12416 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan13Properties> 12417 { operator ()std::hash12418 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan13Properties const & physicalDeviceVulkan13Properties ) const VULKAN_HPP_NOEXCEPT 12419 { 12420 std::size_t seed = 0; 12421 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.sType ); 12422 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.pNext ); 12423 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.minSubgroupSize ); 12424 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.maxSubgroupSize ); 12425 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.maxComputeWorkgroupSubgroups ); 12426 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.requiredSubgroupSizeStages ); 12427 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.maxInlineUniformBlockSize ); 12428 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.maxPerStageDescriptorInlineUniformBlocks ); 12429 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks ); 12430 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.maxDescriptorSetInlineUniformBlocks ); 12431 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.maxDescriptorSetUpdateAfterBindInlineUniformBlocks ); 12432 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.maxInlineUniformTotalSize ); 12433 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct8BitUnsignedAccelerated ); 12434 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct8BitSignedAccelerated ); 12435 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct8BitMixedSignednessAccelerated ); 12436 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct4x8BitPackedUnsignedAccelerated ); 12437 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct4x8BitPackedSignedAccelerated ); 12438 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct4x8BitPackedMixedSignednessAccelerated ); 12439 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct16BitUnsignedAccelerated ); 12440 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct16BitSignedAccelerated ); 12441 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct16BitMixedSignednessAccelerated ); 12442 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct32BitUnsignedAccelerated ); 12443 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct32BitSignedAccelerated ); 12444 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct32BitMixedSignednessAccelerated ); 12445 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct64BitUnsignedAccelerated ); 12446 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct64BitSignedAccelerated ); 12447 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct64BitMixedSignednessAccelerated ); 12448 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating8BitUnsignedAccelerated ); 12449 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating8BitSignedAccelerated ); 12450 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated ); 12451 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated ); 12452 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated ); 12453 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated ); 12454 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating16BitUnsignedAccelerated ); 12455 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating16BitSignedAccelerated ); 12456 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated ); 12457 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating32BitUnsignedAccelerated ); 12458 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating32BitSignedAccelerated ); 12459 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated ); 12460 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating64BitUnsignedAccelerated ); 12461 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating64BitSignedAccelerated ); 12462 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated ); 12463 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.storageTexelBufferOffsetAlignmentBytes ); 12464 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.storageTexelBufferOffsetSingleTexelAlignment ); 12465 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.uniformTexelBufferOffsetAlignmentBytes ); 12466 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.uniformTexelBufferOffsetSingleTexelAlignment ); 12467 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.maxBufferSize ); 12468 return seed; 12469 } 12470 }; 12471 12472 template <> 12473 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkanMemoryModelFeatures> 12474 { 12475 std::size_t operator ()std::hash12476 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkanMemoryModelFeatures const & physicalDeviceVulkanMemoryModelFeatures ) const VULKAN_HPP_NOEXCEPT 12477 { 12478 std::size_t seed = 0; 12479 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkanMemoryModelFeatures.sType ); 12480 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkanMemoryModelFeatures.pNext ); 12481 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkanMemoryModelFeatures.vulkanMemoryModel ); 12482 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkanMemoryModelFeatures.vulkanMemoryModelDeviceScope ); 12483 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkanMemoryModelFeatures.vulkanMemoryModelAvailabilityVisibilityChains ); 12484 return seed; 12485 } 12486 }; 12487 12488 template <> 12489 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR> 12490 { operator ()std::hash12491 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR const & 12492 physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR ) const VULKAN_HPP_NOEXCEPT 12493 { 12494 std::size_t seed = 0; 12495 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.sType ); 12496 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.pNext ); 12497 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.workgroupMemoryExplicitLayout ); 12498 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.workgroupMemoryExplicitLayoutScalarBlockLayout ); 12499 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.workgroupMemoryExplicitLayout8BitAccess ); 12500 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.workgroupMemoryExplicitLayout16BitAccess ); 12501 return seed; 12502 } 12503 }; 12504 12505 template <> 12506 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT> 12507 { operator ()std::hash12508 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT const & physicalDeviceYcbcr2Plane444FormatsFeaturesEXT ) const 12509 VULKAN_HPP_NOEXCEPT 12510 { 12511 std::size_t seed = 0; 12512 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceYcbcr2Plane444FormatsFeaturesEXT.sType ); 12513 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceYcbcr2Plane444FormatsFeaturesEXT.pNext ); 12514 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceYcbcr2Plane444FormatsFeaturesEXT.ycbcr2plane444Formats ); 12515 return seed; 12516 } 12517 }; 12518 12519 template <> 12520 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcrDegammaFeaturesQCOM> 12521 { 12522 std::size_t operator ()std::hash12523 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcrDegammaFeaturesQCOM const & physicalDeviceYcbcrDegammaFeaturesQCOM ) const VULKAN_HPP_NOEXCEPT 12524 { 12525 std::size_t seed = 0; 12526 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceYcbcrDegammaFeaturesQCOM.sType ); 12527 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceYcbcrDegammaFeaturesQCOM.pNext ); 12528 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceYcbcrDegammaFeaturesQCOM.ycbcrDegamma ); 12529 return seed; 12530 } 12531 }; 12532 12533 template <> 12534 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcrImageArraysFeaturesEXT> 12535 { 12536 std::size_t operator ()std::hash12537 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcrImageArraysFeaturesEXT const & physicalDeviceYcbcrImageArraysFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 12538 { 12539 std::size_t seed = 0; 12540 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceYcbcrImageArraysFeaturesEXT.sType ); 12541 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceYcbcrImageArraysFeaturesEXT.pNext ); 12542 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceYcbcrImageArraysFeaturesEXT.ycbcrImageArrays ); 12543 return seed; 12544 } 12545 }; 12546 12547 template <> 12548 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures> 12549 { 12550 std::size_t operator ()std::hash12551 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures const & physicalDeviceZeroInitializeWorkgroupMemoryFeatures ) const 12552 VULKAN_HPP_NOEXCEPT 12553 { 12554 std::size_t seed = 0; 12555 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceZeroInitializeWorkgroupMemoryFeatures.sType ); 12556 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceZeroInitializeWorkgroupMemoryFeatures.pNext ); 12557 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceZeroInitializeWorkgroupMemoryFeatures.shaderZeroInitializeWorkgroupMemory ); 12558 return seed; 12559 } 12560 }; 12561 12562 template <> 12563 struct hash<VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo> 12564 { operator ()std::hash12565 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo const & pipelineCacheCreateInfo ) const VULKAN_HPP_NOEXCEPT 12566 { 12567 std::size_t seed = 0; 12568 VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheCreateInfo.sType ); 12569 VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheCreateInfo.pNext ); 12570 VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheCreateInfo.flags ); 12571 VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheCreateInfo.initialDataSize ); 12572 VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheCreateInfo.pInitialData ); 12573 return seed; 12574 } 12575 }; 12576 12577 template <> 12578 struct hash<VULKAN_HPP_NAMESPACE::PipelineCacheHeaderVersionOne> 12579 { operator ()std::hash12580 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCacheHeaderVersionOne const & pipelineCacheHeaderVersionOne ) const VULKAN_HPP_NOEXCEPT 12581 { 12582 std::size_t seed = 0; 12583 VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheHeaderVersionOne.headerSize ); 12584 VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheHeaderVersionOne.headerVersion ); 12585 VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheHeaderVersionOne.vendorID ); 12586 VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheHeaderVersionOne.deviceID ); 12587 for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) 12588 { 12589 VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheHeaderVersionOne.pipelineCacheUUID[i] ); 12590 } 12591 return seed; 12592 } 12593 }; 12594 12595 template <> 12596 struct hash<VULKAN_HPP_NAMESPACE::PipelineColorBlendAdvancedStateCreateInfoEXT> 12597 { operator ()std::hash12598 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineColorBlendAdvancedStateCreateInfoEXT const & pipelineColorBlendAdvancedStateCreateInfoEXT ) const 12599 VULKAN_HPP_NOEXCEPT 12600 { 12601 std::size_t seed = 0; 12602 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAdvancedStateCreateInfoEXT.sType ); 12603 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAdvancedStateCreateInfoEXT.pNext ); 12604 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAdvancedStateCreateInfoEXT.srcPremultiplied ); 12605 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAdvancedStateCreateInfoEXT.dstPremultiplied ); 12606 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAdvancedStateCreateInfoEXT.blendOverlap ); 12607 return seed; 12608 } 12609 }; 12610 12611 template <> 12612 struct hash<VULKAN_HPP_NAMESPACE::PipelineColorWriteCreateInfoEXT> 12613 { operator ()std::hash12614 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineColorWriteCreateInfoEXT const & pipelineColorWriteCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 12615 { 12616 std::size_t seed = 0; 12617 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorWriteCreateInfoEXT.sType ); 12618 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorWriteCreateInfoEXT.pNext ); 12619 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorWriteCreateInfoEXT.attachmentCount ); 12620 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorWriteCreateInfoEXT.pColorWriteEnables ); 12621 return seed; 12622 } 12623 }; 12624 12625 template <> 12626 struct hash<VULKAN_HPP_NAMESPACE::PipelineCompilerControlCreateInfoAMD> 12627 { operator ()std::hash12628 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCompilerControlCreateInfoAMD const & pipelineCompilerControlCreateInfoAMD ) const VULKAN_HPP_NOEXCEPT 12629 { 12630 std::size_t seed = 0; 12631 VULKAN_HPP_HASH_COMBINE( seed, pipelineCompilerControlCreateInfoAMD.sType ); 12632 VULKAN_HPP_HASH_COMBINE( seed, pipelineCompilerControlCreateInfoAMD.pNext ); 12633 VULKAN_HPP_HASH_COMBINE( seed, pipelineCompilerControlCreateInfoAMD.compilerControlFlags ); 12634 return seed; 12635 } 12636 }; 12637 12638 template <> 12639 struct hash<VULKAN_HPP_NAMESPACE::PipelineCoverageModulationStateCreateInfoNV> 12640 { operator ()std::hash12641 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCoverageModulationStateCreateInfoNV const & pipelineCoverageModulationStateCreateInfoNV ) const 12642 VULKAN_HPP_NOEXCEPT 12643 { 12644 std::size_t seed = 0; 12645 VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageModulationStateCreateInfoNV.sType ); 12646 VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageModulationStateCreateInfoNV.pNext ); 12647 VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageModulationStateCreateInfoNV.flags ); 12648 VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageModulationStateCreateInfoNV.coverageModulationMode ); 12649 VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageModulationStateCreateInfoNV.coverageModulationTableEnable ); 12650 VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageModulationStateCreateInfoNV.coverageModulationTableCount ); 12651 VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageModulationStateCreateInfoNV.pCoverageModulationTable ); 12652 return seed; 12653 } 12654 }; 12655 12656 template <> 12657 struct hash<VULKAN_HPP_NAMESPACE::PipelineCoverageReductionStateCreateInfoNV> 12658 { operator ()std::hash12659 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCoverageReductionStateCreateInfoNV const & pipelineCoverageReductionStateCreateInfoNV ) const 12660 VULKAN_HPP_NOEXCEPT 12661 { 12662 std::size_t seed = 0; 12663 VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageReductionStateCreateInfoNV.sType ); 12664 VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageReductionStateCreateInfoNV.pNext ); 12665 VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageReductionStateCreateInfoNV.flags ); 12666 VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageReductionStateCreateInfoNV.coverageReductionMode ); 12667 return seed; 12668 } 12669 }; 12670 12671 template <> 12672 struct hash<VULKAN_HPP_NAMESPACE::PipelineCoverageToColorStateCreateInfoNV> 12673 { 12674 std::size_t operator ()std::hash12675 operator()( VULKAN_HPP_NAMESPACE::PipelineCoverageToColorStateCreateInfoNV const & pipelineCoverageToColorStateCreateInfoNV ) const VULKAN_HPP_NOEXCEPT 12676 { 12677 std::size_t seed = 0; 12678 VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageToColorStateCreateInfoNV.sType ); 12679 VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageToColorStateCreateInfoNV.pNext ); 12680 VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageToColorStateCreateInfoNV.flags ); 12681 VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageToColorStateCreateInfoNV.coverageToColorEnable ); 12682 VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageToColorStateCreateInfoNV.coverageToColorLocation ); 12683 return seed; 12684 } 12685 }; 12686 12687 template <> 12688 struct hash<VULKAN_HPP_NAMESPACE::PipelineCreateFlags2CreateInfoKHR> 12689 { operator ()std::hash12690 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCreateFlags2CreateInfoKHR const & pipelineCreateFlags2CreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 12691 { 12692 std::size_t seed = 0; 12693 VULKAN_HPP_HASH_COMBINE( seed, pipelineCreateFlags2CreateInfoKHR.sType ); 12694 VULKAN_HPP_HASH_COMBINE( seed, pipelineCreateFlags2CreateInfoKHR.pNext ); 12695 VULKAN_HPP_HASH_COMBINE( seed, pipelineCreateFlags2CreateInfoKHR.flags ); 12696 return seed; 12697 } 12698 }; 12699 12700 template <> 12701 struct hash<VULKAN_HPP_NAMESPACE::PipelineCreationFeedback> 12702 { operator ()std::hash12703 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCreationFeedback const & pipelineCreationFeedback ) const VULKAN_HPP_NOEXCEPT 12704 { 12705 std::size_t seed = 0; 12706 VULKAN_HPP_HASH_COMBINE( seed, pipelineCreationFeedback.flags ); 12707 VULKAN_HPP_HASH_COMBINE( seed, pipelineCreationFeedback.duration ); 12708 return seed; 12709 } 12710 }; 12711 12712 template <> 12713 struct hash<VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackCreateInfo> 12714 { operator ()std::hash12715 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackCreateInfo const & pipelineCreationFeedbackCreateInfo ) const VULKAN_HPP_NOEXCEPT 12716 { 12717 std::size_t seed = 0; 12718 VULKAN_HPP_HASH_COMBINE( seed, pipelineCreationFeedbackCreateInfo.sType ); 12719 VULKAN_HPP_HASH_COMBINE( seed, pipelineCreationFeedbackCreateInfo.pNext ); 12720 VULKAN_HPP_HASH_COMBINE( seed, pipelineCreationFeedbackCreateInfo.pPipelineCreationFeedback ); 12721 VULKAN_HPP_HASH_COMBINE( seed, pipelineCreationFeedbackCreateInfo.pipelineStageCreationFeedbackCount ); 12722 VULKAN_HPP_HASH_COMBINE( seed, pipelineCreationFeedbackCreateInfo.pPipelineStageCreationFeedbacks ); 12723 return seed; 12724 } 12725 }; 12726 12727 template <> 12728 struct hash<VULKAN_HPP_NAMESPACE::PipelineDiscardRectangleStateCreateInfoEXT> 12729 { operator ()std::hash12730 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineDiscardRectangleStateCreateInfoEXT const & pipelineDiscardRectangleStateCreateInfoEXT ) const 12731 VULKAN_HPP_NOEXCEPT 12732 { 12733 std::size_t seed = 0; 12734 VULKAN_HPP_HASH_COMBINE( seed, pipelineDiscardRectangleStateCreateInfoEXT.sType ); 12735 VULKAN_HPP_HASH_COMBINE( seed, pipelineDiscardRectangleStateCreateInfoEXT.pNext ); 12736 VULKAN_HPP_HASH_COMBINE( seed, pipelineDiscardRectangleStateCreateInfoEXT.flags ); 12737 VULKAN_HPP_HASH_COMBINE( seed, pipelineDiscardRectangleStateCreateInfoEXT.discardRectangleMode ); 12738 VULKAN_HPP_HASH_COMBINE( seed, pipelineDiscardRectangleStateCreateInfoEXT.discardRectangleCount ); 12739 VULKAN_HPP_HASH_COMBINE( seed, pipelineDiscardRectangleStateCreateInfoEXT.pDiscardRectangles ); 12740 return seed; 12741 } 12742 }; 12743 12744 template <> 12745 struct hash<VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR> 12746 { operator ()std::hash12747 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR const & pipelineExecutableInfoKHR ) const VULKAN_HPP_NOEXCEPT 12748 { 12749 std::size_t seed = 0; 12750 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInfoKHR.sType ); 12751 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInfoKHR.pNext ); 12752 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInfoKHR.pipeline ); 12753 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInfoKHR.executableIndex ); 12754 return seed; 12755 } 12756 }; 12757 12758 template <> 12759 struct hash<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR> 12760 { operator ()std::hash12761 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR const & pipelineExecutableInternalRepresentationKHR ) const 12762 VULKAN_HPP_NOEXCEPT 12763 { 12764 std::size_t seed = 0; 12765 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInternalRepresentationKHR.sType ); 12766 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInternalRepresentationKHR.pNext ); 12767 for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) 12768 { 12769 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInternalRepresentationKHR.name[i] ); 12770 } 12771 for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) 12772 { 12773 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInternalRepresentationKHR.description[i] ); 12774 } 12775 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInternalRepresentationKHR.isText ); 12776 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInternalRepresentationKHR.dataSize ); 12777 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInternalRepresentationKHR.pData ); 12778 return seed; 12779 } 12780 }; 12781 12782 template <> 12783 struct hash<VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR> 12784 { operator ()std::hash12785 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR const & pipelineExecutablePropertiesKHR ) const VULKAN_HPP_NOEXCEPT 12786 { 12787 std::size_t seed = 0; 12788 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutablePropertiesKHR.sType ); 12789 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutablePropertiesKHR.pNext ); 12790 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutablePropertiesKHR.stages ); 12791 for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) 12792 { 12793 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutablePropertiesKHR.name[i] ); 12794 } 12795 for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) 12796 { 12797 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutablePropertiesKHR.description[i] ); 12798 } 12799 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutablePropertiesKHR.subgroupSize ); 12800 return seed; 12801 } 12802 }; 12803 12804 template <> 12805 struct hash<VULKAN_HPP_NAMESPACE::PipelineFragmentShadingRateEnumStateCreateInfoNV> 12806 { operator ()std::hash12807 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineFragmentShadingRateEnumStateCreateInfoNV const & pipelineFragmentShadingRateEnumStateCreateInfoNV ) 12808 const VULKAN_HPP_NOEXCEPT 12809 { 12810 std::size_t seed = 0; 12811 VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentShadingRateEnumStateCreateInfoNV.sType ); 12812 VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentShadingRateEnumStateCreateInfoNV.pNext ); 12813 VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentShadingRateEnumStateCreateInfoNV.shadingRateType ); 12814 VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentShadingRateEnumStateCreateInfoNV.shadingRate ); 12815 for ( size_t i = 0; i < 2; ++i ) 12816 { 12817 VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentShadingRateEnumStateCreateInfoNV.combinerOps[i] ); 12818 } 12819 return seed; 12820 } 12821 }; 12822 12823 template <> 12824 struct hash<VULKAN_HPP_NAMESPACE::PipelineFragmentShadingRateStateCreateInfoKHR> 12825 { operator ()std::hash12826 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineFragmentShadingRateStateCreateInfoKHR const & pipelineFragmentShadingRateStateCreateInfoKHR ) const 12827 VULKAN_HPP_NOEXCEPT 12828 { 12829 std::size_t seed = 0; 12830 VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentShadingRateStateCreateInfoKHR.sType ); 12831 VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentShadingRateStateCreateInfoKHR.pNext ); 12832 VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentShadingRateStateCreateInfoKHR.fragmentSize ); 12833 for ( size_t i = 0; i < 2; ++i ) 12834 { 12835 VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentShadingRateStateCreateInfoKHR.combinerOps[i] ); 12836 } 12837 return seed; 12838 } 12839 }; 12840 12841 template <> 12842 struct hash<VULKAN_HPP_NAMESPACE::PipelineIndirectDeviceAddressInfoNV> 12843 { operator ()std::hash12844 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineIndirectDeviceAddressInfoNV const & pipelineIndirectDeviceAddressInfoNV ) const VULKAN_HPP_NOEXCEPT 12845 { 12846 std::size_t seed = 0; 12847 VULKAN_HPP_HASH_COMBINE( seed, pipelineIndirectDeviceAddressInfoNV.sType ); 12848 VULKAN_HPP_HASH_COMBINE( seed, pipelineIndirectDeviceAddressInfoNV.pNext ); 12849 VULKAN_HPP_HASH_COMBINE( seed, pipelineIndirectDeviceAddressInfoNV.pipelineBindPoint ); 12850 VULKAN_HPP_HASH_COMBINE( seed, pipelineIndirectDeviceAddressInfoNV.pipeline ); 12851 return seed; 12852 } 12853 }; 12854 12855 template <> 12856 struct hash<VULKAN_HPP_NAMESPACE::PipelineInfoKHR> 12857 { operator ()std::hash12858 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineInfoKHR const & pipelineInfoKHR ) const VULKAN_HPP_NOEXCEPT 12859 { 12860 std::size_t seed = 0; 12861 VULKAN_HPP_HASH_COMBINE( seed, pipelineInfoKHR.sType ); 12862 VULKAN_HPP_HASH_COMBINE( seed, pipelineInfoKHR.pNext ); 12863 VULKAN_HPP_HASH_COMBINE( seed, pipelineInfoKHR.pipeline ); 12864 return seed; 12865 } 12866 }; 12867 12868 template <> 12869 struct hash<VULKAN_HPP_NAMESPACE::PushConstantRange> 12870 { operator ()std::hash12871 std::size_t operator()( VULKAN_HPP_NAMESPACE::PushConstantRange const & pushConstantRange ) const VULKAN_HPP_NOEXCEPT 12872 { 12873 std::size_t seed = 0; 12874 VULKAN_HPP_HASH_COMBINE( seed, pushConstantRange.stageFlags ); 12875 VULKAN_HPP_HASH_COMBINE( seed, pushConstantRange.offset ); 12876 VULKAN_HPP_HASH_COMBINE( seed, pushConstantRange.size ); 12877 return seed; 12878 } 12879 }; 12880 12881 template <> 12882 struct hash<VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo> 12883 { operator ()std::hash12884 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo const & pipelineLayoutCreateInfo ) const VULKAN_HPP_NOEXCEPT 12885 { 12886 std::size_t seed = 0; 12887 VULKAN_HPP_HASH_COMBINE( seed, pipelineLayoutCreateInfo.sType ); 12888 VULKAN_HPP_HASH_COMBINE( seed, pipelineLayoutCreateInfo.pNext ); 12889 VULKAN_HPP_HASH_COMBINE( seed, pipelineLayoutCreateInfo.flags ); 12890 VULKAN_HPP_HASH_COMBINE( seed, pipelineLayoutCreateInfo.setLayoutCount ); 12891 VULKAN_HPP_HASH_COMBINE( seed, pipelineLayoutCreateInfo.pSetLayouts ); 12892 VULKAN_HPP_HASH_COMBINE( seed, pipelineLayoutCreateInfo.pushConstantRangeCount ); 12893 VULKAN_HPP_HASH_COMBINE( seed, pipelineLayoutCreateInfo.pPushConstantRanges ); 12894 return seed; 12895 } 12896 }; 12897 12898 template <> 12899 struct hash<VULKAN_HPP_NAMESPACE::PipelinePropertiesIdentifierEXT> 12900 { operator ()std::hash12901 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelinePropertiesIdentifierEXT const & pipelinePropertiesIdentifierEXT ) const VULKAN_HPP_NOEXCEPT 12902 { 12903 std::size_t seed = 0; 12904 VULKAN_HPP_HASH_COMBINE( seed, pipelinePropertiesIdentifierEXT.sType ); 12905 VULKAN_HPP_HASH_COMBINE( seed, pipelinePropertiesIdentifierEXT.pNext ); 12906 for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) 12907 { 12908 VULKAN_HPP_HASH_COMBINE( seed, pipelinePropertiesIdentifierEXT.pipelineIdentifier[i] ); 12909 } 12910 return seed; 12911 } 12912 }; 12913 12914 template <> 12915 struct hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationConservativeStateCreateInfoEXT> 12916 { 12917 std::size_t operator ()std::hash12918 operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationConservativeStateCreateInfoEXT const & pipelineRasterizationConservativeStateCreateInfoEXT ) const 12919 VULKAN_HPP_NOEXCEPT 12920 { 12921 std::size_t seed = 0; 12922 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationConservativeStateCreateInfoEXT.sType ); 12923 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationConservativeStateCreateInfoEXT.pNext ); 12924 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationConservativeStateCreateInfoEXT.flags ); 12925 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationConservativeStateCreateInfoEXT.conservativeRasterizationMode ); 12926 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationConservativeStateCreateInfoEXT.extraPrimitiveOverestimationSize ); 12927 return seed; 12928 } 12929 }; 12930 12931 template <> 12932 struct hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationDepthClipStateCreateInfoEXT> 12933 { operator ()std::hash12934 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationDepthClipStateCreateInfoEXT const & pipelineRasterizationDepthClipStateCreateInfoEXT ) 12935 const VULKAN_HPP_NOEXCEPT 12936 { 12937 std::size_t seed = 0; 12938 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationDepthClipStateCreateInfoEXT.sType ); 12939 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationDepthClipStateCreateInfoEXT.pNext ); 12940 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationDepthClipStateCreateInfoEXT.flags ); 12941 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationDepthClipStateCreateInfoEXT.depthClipEnable ); 12942 return seed; 12943 } 12944 }; 12945 12946 template <> 12947 struct hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationLineStateCreateInfoKHR> 12948 { operator ()std::hash12949 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationLineStateCreateInfoKHR const & pipelineRasterizationLineStateCreateInfoKHR ) const 12950 VULKAN_HPP_NOEXCEPT 12951 { 12952 std::size_t seed = 0; 12953 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfoKHR.sType ); 12954 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfoKHR.pNext ); 12955 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfoKHR.lineRasterizationMode ); 12956 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfoKHR.stippledLineEnable ); 12957 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfoKHR.lineStippleFactor ); 12958 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfoKHR.lineStipplePattern ); 12959 return seed; 12960 } 12961 }; 12962 12963 template <> 12964 struct hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationProvokingVertexStateCreateInfoEXT> 12965 { operator ()std::hash12966 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationProvokingVertexStateCreateInfoEXT const & 12967 pipelineRasterizationProvokingVertexStateCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 12968 { 12969 std::size_t seed = 0; 12970 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationProvokingVertexStateCreateInfoEXT.sType ); 12971 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationProvokingVertexStateCreateInfoEXT.pNext ); 12972 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationProvokingVertexStateCreateInfoEXT.provokingVertexMode ); 12973 return seed; 12974 } 12975 }; 12976 12977 template <> 12978 struct hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationStateRasterizationOrderAMD> 12979 { operator ()std::hash12980 std::size_t operator()( 12981 VULKAN_HPP_NAMESPACE::PipelineRasterizationStateRasterizationOrderAMD const & pipelineRasterizationStateRasterizationOrderAMD ) const VULKAN_HPP_NOEXCEPT 12982 { 12983 std::size_t seed = 0; 12984 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateRasterizationOrderAMD.sType ); 12985 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateRasterizationOrderAMD.pNext ); 12986 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateRasterizationOrderAMD.rasterizationOrder ); 12987 return seed; 12988 } 12989 }; 12990 12991 template <> 12992 struct hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationStateStreamCreateInfoEXT> 12993 { operator ()std::hash12994 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationStateStreamCreateInfoEXT const & pipelineRasterizationStateStreamCreateInfoEXT ) const 12995 VULKAN_HPP_NOEXCEPT 12996 { 12997 std::size_t seed = 0; 12998 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateStreamCreateInfoEXT.sType ); 12999 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateStreamCreateInfoEXT.pNext ); 13000 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateStreamCreateInfoEXT.flags ); 13001 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateStreamCreateInfoEXT.rasterizationStream ); 13002 return seed; 13003 } 13004 }; 13005 13006 template <> 13007 struct hash<VULKAN_HPP_NAMESPACE::PipelineRenderingCreateInfo> 13008 { operator ()std::hash13009 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRenderingCreateInfo const & pipelineRenderingCreateInfo ) const VULKAN_HPP_NOEXCEPT 13010 { 13011 std::size_t seed = 0; 13012 VULKAN_HPP_HASH_COMBINE( seed, pipelineRenderingCreateInfo.sType ); 13013 VULKAN_HPP_HASH_COMBINE( seed, pipelineRenderingCreateInfo.pNext ); 13014 VULKAN_HPP_HASH_COMBINE( seed, pipelineRenderingCreateInfo.viewMask ); 13015 VULKAN_HPP_HASH_COMBINE( seed, pipelineRenderingCreateInfo.colorAttachmentCount ); 13016 VULKAN_HPP_HASH_COMBINE( seed, pipelineRenderingCreateInfo.pColorAttachmentFormats ); 13017 VULKAN_HPP_HASH_COMBINE( seed, pipelineRenderingCreateInfo.depthAttachmentFormat ); 13018 VULKAN_HPP_HASH_COMBINE( seed, pipelineRenderingCreateInfo.stencilAttachmentFormat ); 13019 return seed; 13020 } 13021 }; 13022 13023 template <> 13024 struct hash<VULKAN_HPP_NAMESPACE::PipelineRepresentativeFragmentTestStateCreateInfoNV> 13025 { 13026 std::size_t operator ()std::hash13027 operator()( VULKAN_HPP_NAMESPACE::PipelineRepresentativeFragmentTestStateCreateInfoNV const & pipelineRepresentativeFragmentTestStateCreateInfoNV ) const 13028 VULKAN_HPP_NOEXCEPT 13029 { 13030 std::size_t seed = 0; 13031 VULKAN_HPP_HASH_COMBINE( seed, pipelineRepresentativeFragmentTestStateCreateInfoNV.sType ); 13032 VULKAN_HPP_HASH_COMBINE( seed, pipelineRepresentativeFragmentTestStateCreateInfoNV.pNext ); 13033 VULKAN_HPP_HASH_COMBINE( seed, pipelineRepresentativeFragmentTestStateCreateInfoNV.representativeFragmentTestEnable ); 13034 return seed; 13035 } 13036 }; 13037 13038 template <> 13039 struct hash<VULKAN_HPP_NAMESPACE::PipelineRobustnessCreateInfoEXT> 13040 { operator ()std::hash13041 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRobustnessCreateInfoEXT const & pipelineRobustnessCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 13042 { 13043 std::size_t seed = 0; 13044 VULKAN_HPP_HASH_COMBINE( seed, pipelineRobustnessCreateInfoEXT.sType ); 13045 VULKAN_HPP_HASH_COMBINE( seed, pipelineRobustnessCreateInfoEXT.pNext ); 13046 VULKAN_HPP_HASH_COMBINE( seed, pipelineRobustnessCreateInfoEXT.storageBuffers ); 13047 VULKAN_HPP_HASH_COMBINE( seed, pipelineRobustnessCreateInfoEXT.uniformBuffers ); 13048 VULKAN_HPP_HASH_COMBINE( seed, pipelineRobustnessCreateInfoEXT.vertexInputs ); 13049 VULKAN_HPP_HASH_COMBINE( seed, pipelineRobustnessCreateInfoEXT.images ); 13050 return seed; 13051 } 13052 }; 13053 13054 template <> 13055 struct hash<VULKAN_HPP_NAMESPACE::PipelineSampleLocationsStateCreateInfoEXT> 13056 { 13057 std::size_t operator ()std::hash13058 operator()( VULKAN_HPP_NAMESPACE::PipelineSampleLocationsStateCreateInfoEXT const & pipelineSampleLocationsStateCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 13059 { 13060 std::size_t seed = 0; 13061 VULKAN_HPP_HASH_COMBINE( seed, pipelineSampleLocationsStateCreateInfoEXT.sType ); 13062 VULKAN_HPP_HASH_COMBINE( seed, pipelineSampleLocationsStateCreateInfoEXT.pNext ); 13063 VULKAN_HPP_HASH_COMBINE( seed, pipelineSampleLocationsStateCreateInfoEXT.sampleLocationsEnable ); 13064 VULKAN_HPP_HASH_COMBINE( seed, pipelineSampleLocationsStateCreateInfoEXT.sampleLocationsInfo ); 13065 return seed; 13066 } 13067 }; 13068 13069 template <> 13070 struct hash<VULKAN_HPP_NAMESPACE::PipelineShaderStageModuleIdentifierCreateInfoEXT> 13071 { operator ()std::hash13072 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineShaderStageModuleIdentifierCreateInfoEXT const & pipelineShaderStageModuleIdentifierCreateInfoEXT ) 13073 const VULKAN_HPP_NOEXCEPT 13074 { 13075 std::size_t seed = 0; 13076 VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageModuleIdentifierCreateInfoEXT.sType ); 13077 VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageModuleIdentifierCreateInfoEXT.pNext ); 13078 VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageModuleIdentifierCreateInfoEXT.identifierSize ); 13079 VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageModuleIdentifierCreateInfoEXT.pIdentifier ); 13080 return seed; 13081 } 13082 }; 13083 13084 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 13085 template <> 13086 struct hash<VULKAN_HPP_NAMESPACE::PipelineShaderStageNodeCreateInfoAMDX> 13087 { 13088 std::size_t operator ()std::hash13089 operator()( VULKAN_HPP_NAMESPACE::PipelineShaderStageNodeCreateInfoAMDX const & pipelineShaderStageNodeCreateInfoAMDX ) const VULKAN_HPP_NOEXCEPT 13090 { 13091 std::size_t seed = 0; 13092 VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageNodeCreateInfoAMDX.sType ); 13093 VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageNodeCreateInfoAMDX.pNext ); 13094 for ( const char * p = pipelineShaderStageNodeCreateInfoAMDX.pName; *p != '\0'; ++p ) 13095 { 13096 VULKAN_HPP_HASH_COMBINE( seed, *p ); 13097 } 13098 VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageNodeCreateInfoAMDX.index ); 13099 return seed; 13100 } 13101 }; 13102 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 13103 13104 template <> 13105 struct hash<VULKAN_HPP_NAMESPACE::PipelineShaderStageRequiredSubgroupSizeCreateInfo> 13106 { operator ()std::hash13107 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineShaderStageRequiredSubgroupSizeCreateInfo const & pipelineShaderStageRequiredSubgroupSizeCreateInfo ) 13108 const VULKAN_HPP_NOEXCEPT 13109 { 13110 std::size_t seed = 0; 13111 VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageRequiredSubgroupSizeCreateInfo.sType ); 13112 VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageRequiredSubgroupSizeCreateInfo.pNext ); 13113 VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageRequiredSubgroupSizeCreateInfo.requiredSubgroupSize ); 13114 return seed; 13115 } 13116 }; 13117 13118 template <> 13119 struct hash<VULKAN_HPP_NAMESPACE::PipelineTessellationDomainOriginStateCreateInfo> 13120 { operator ()std::hash13121 std::size_t operator()( 13122 VULKAN_HPP_NAMESPACE::PipelineTessellationDomainOriginStateCreateInfo const & pipelineTessellationDomainOriginStateCreateInfo ) const VULKAN_HPP_NOEXCEPT 13123 { 13124 std::size_t seed = 0; 13125 VULKAN_HPP_HASH_COMBINE( seed, pipelineTessellationDomainOriginStateCreateInfo.sType ); 13126 VULKAN_HPP_HASH_COMBINE( seed, pipelineTessellationDomainOriginStateCreateInfo.pNext ); 13127 VULKAN_HPP_HASH_COMBINE( seed, pipelineTessellationDomainOriginStateCreateInfo.domainOrigin ); 13128 return seed; 13129 } 13130 }; 13131 13132 template <> 13133 struct hash<VULKAN_HPP_NAMESPACE::VertexInputBindingDivisorDescriptionKHR> 13134 { 13135 std::size_t operator ()std::hash13136 operator()( VULKAN_HPP_NAMESPACE::VertexInputBindingDivisorDescriptionKHR const & vertexInputBindingDivisorDescriptionKHR ) const VULKAN_HPP_NOEXCEPT 13137 { 13138 std::size_t seed = 0; 13139 VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDivisorDescriptionKHR.binding ); 13140 VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDivisorDescriptionKHR.divisor ); 13141 return seed; 13142 } 13143 }; 13144 13145 template <> 13146 struct hash<VULKAN_HPP_NAMESPACE::PipelineVertexInputDivisorStateCreateInfoKHR> 13147 { operator ()std::hash13148 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineVertexInputDivisorStateCreateInfoKHR const & pipelineVertexInputDivisorStateCreateInfoKHR ) const 13149 VULKAN_HPP_NOEXCEPT 13150 { 13151 std::size_t seed = 0; 13152 VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputDivisorStateCreateInfoKHR.sType ); 13153 VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputDivisorStateCreateInfoKHR.pNext ); 13154 VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputDivisorStateCreateInfoKHR.vertexBindingDivisorCount ); 13155 VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputDivisorStateCreateInfoKHR.pVertexBindingDivisors ); 13156 return seed; 13157 } 13158 }; 13159 13160 template <> 13161 struct hash<VULKAN_HPP_NAMESPACE::PipelineViewportCoarseSampleOrderStateCreateInfoNV> 13162 { 13163 std::size_t operator ()std::hash13164 operator()( VULKAN_HPP_NAMESPACE::PipelineViewportCoarseSampleOrderStateCreateInfoNV const & pipelineViewportCoarseSampleOrderStateCreateInfoNV ) const 13165 VULKAN_HPP_NOEXCEPT 13166 { 13167 std::size_t seed = 0; 13168 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportCoarseSampleOrderStateCreateInfoNV.sType ); 13169 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportCoarseSampleOrderStateCreateInfoNV.pNext ); 13170 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportCoarseSampleOrderStateCreateInfoNV.sampleOrderType ); 13171 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportCoarseSampleOrderStateCreateInfoNV.customSampleOrderCount ); 13172 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportCoarseSampleOrderStateCreateInfoNV.pCustomSampleOrders ); 13173 return seed; 13174 } 13175 }; 13176 13177 template <> 13178 struct hash<VULKAN_HPP_NAMESPACE::PipelineViewportDepthClipControlCreateInfoEXT> 13179 { operator ()std::hash13180 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineViewportDepthClipControlCreateInfoEXT const & pipelineViewportDepthClipControlCreateInfoEXT ) const 13181 VULKAN_HPP_NOEXCEPT 13182 { 13183 std::size_t seed = 0; 13184 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportDepthClipControlCreateInfoEXT.sType ); 13185 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportDepthClipControlCreateInfoEXT.pNext ); 13186 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportDepthClipControlCreateInfoEXT.negativeOneToOne ); 13187 return seed; 13188 } 13189 }; 13190 13191 template <> 13192 struct hash<VULKAN_HPP_NAMESPACE::PipelineViewportExclusiveScissorStateCreateInfoNV> 13193 { operator ()std::hash13194 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineViewportExclusiveScissorStateCreateInfoNV const & pipelineViewportExclusiveScissorStateCreateInfoNV ) 13195 const VULKAN_HPP_NOEXCEPT 13196 { 13197 std::size_t seed = 0; 13198 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportExclusiveScissorStateCreateInfoNV.sType ); 13199 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportExclusiveScissorStateCreateInfoNV.pNext ); 13200 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportExclusiveScissorStateCreateInfoNV.exclusiveScissorCount ); 13201 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportExclusiveScissorStateCreateInfoNV.pExclusiveScissors ); 13202 return seed; 13203 } 13204 }; 13205 13206 template <> 13207 struct hash<VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV> 13208 { operator ()std::hash13209 std::size_t operator()( VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV const & shadingRatePaletteNV ) const VULKAN_HPP_NOEXCEPT 13210 { 13211 std::size_t seed = 0; 13212 VULKAN_HPP_HASH_COMBINE( seed, shadingRatePaletteNV.shadingRatePaletteEntryCount ); 13213 VULKAN_HPP_HASH_COMBINE( seed, shadingRatePaletteNV.pShadingRatePaletteEntries ); 13214 return seed; 13215 } 13216 }; 13217 13218 template <> 13219 struct hash<VULKAN_HPP_NAMESPACE::PipelineViewportShadingRateImageStateCreateInfoNV> 13220 { operator ()std::hash13221 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineViewportShadingRateImageStateCreateInfoNV const & pipelineViewportShadingRateImageStateCreateInfoNV ) 13222 const VULKAN_HPP_NOEXCEPT 13223 { 13224 std::size_t seed = 0; 13225 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportShadingRateImageStateCreateInfoNV.sType ); 13226 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportShadingRateImageStateCreateInfoNV.pNext ); 13227 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportShadingRateImageStateCreateInfoNV.shadingRateImageEnable ); 13228 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportShadingRateImageStateCreateInfoNV.viewportCount ); 13229 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportShadingRateImageStateCreateInfoNV.pShadingRatePalettes ); 13230 return seed; 13231 } 13232 }; 13233 13234 template <> 13235 struct hash<VULKAN_HPP_NAMESPACE::ViewportSwizzleNV> 13236 { operator ()std::hash13237 std::size_t operator()( VULKAN_HPP_NAMESPACE::ViewportSwizzleNV const & viewportSwizzleNV ) const VULKAN_HPP_NOEXCEPT 13238 { 13239 std::size_t seed = 0; 13240 VULKAN_HPP_HASH_COMBINE( seed, viewportSwizzleNV.x ); 13241 VULKAN_HPP_HASH_COMBINE( seed, viewportSwizzleNV.y ); 13242 VULKAN_HPP_HASH_COMBINE( seed, viewportSwizzleNV.z ); 13243 VULKAN_HPP_HASH_COMBINE( seed, viewportSwizzleNV.w ); 13244 return seed; 13245 } 13246 }; 13247 13248 template <> 13249 struct hash<VULKAN_HPP_NAMESPACE::PipelineViewportSwizzleStateCreateInfoNV> 13250 { 13251 std::size_t operator ()std::hash13252 operator()( VULKAN_HPP_NAMESPACE::PipelineViewportSwizzleStateCreateInfoNV const & pipelineViewportSwizzleStateCreateInfoNV ) const VULKAN_HPP_NOEXCEPT 13253 { 13254 std::size_t seed = 0; 13255 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportSwizzleStateCreateInfoNV.sType ); 13256 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportSwizzleStateCreateInfoNV.pNext ); 13257 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportSwizzleStateCreateInfoNV.flags ); 13258 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportSwizzleStateCreateInfoNV.viewportCount ); 13259 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportSwizzleStateCreateInfoNV.pViewportSwizzles ); 13260 return seed; 13261 } 13262 }; 13263 13264 template <> 13265 struct hash<VULKAN_HPP_NAMESPACE::ViewportWScalingNV> 13266 { operator ()std::hash13267 std::size_t operator()( VULKAN_HPP_NAMESPACE::ViewportWScalingNV const & viewportWScalingNV ) const VULKAN_HPP_NOEXCEPT 13268 { 13269 std::size_t seed = 0; 13270 VULKAN_HPP_HASH_COMBINE( seed, viewportWScalingNV.xcoeff ); 13271 VULKAN_HPP_HASH_COMBINE( seed, viewportWScalingNV.ycoeff ); 13272 return seed; 13273 } 13274 }; 13275 13276 template <> 13277 struct hash<VULKAN_HPP_NAMESPACE::PipelineViewportWScalingStateCreateInfoNV> 13278 { 13279 std::size_t operator ()std::hash13280 operator()( VULKAN_HPP_NAMESPACE::PipelineViewportWScalingStateCreateInfoNV const & pipelineViewportWScalingStateCreateInfoNV ) const VULKAN_HPP_NOEXCEPT 13281 { 13282 std::size_t seed = 0; 13283 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportWScalingStateCreateInfoNV.sType ); 13284 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportWScalingStateCreateInfoNV.pNext ); 13285 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportWScalingStateCreateInfoNV.viewportWScalingEnable ); 13286 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportWScalingStateCreateInfoNV.viewportCount ); 13287 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportWScalingStateCreateInfoNV.pViewportWScalings ); 13288 return seed; 13289 } 13290 }; 13291 13292 # if defined( VK_USE_PLATFORM_GGP ) 13293 template <> 13294 struct hash<VULKAN_HPP_NAMESPACE::PresentFrameTokenGGP> 13295 { operator ()std::hash13296 std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentFrameTokenGGP const & presentFrameTokenGGP ) const VULKAN_HPP_NOEXCEPT 13297 { 13298 std::size_t seed = 0; 13299 VULKAN_HPP_HASH_COMBINE( seed, presentFrameTokenGGP.sType ); 13300 VULKAN_HPP_HASH_COMBINE( seed, presentFrameTokenGGP.pNext ); 13301 VULKAN_HPP_HASH_COMBINE( seed, presentFrameTokenGGP.frameToken ); 13302 return seed; 13303 } 13304 }; 13305 # endif /*VK_USE_PLATFORM_GGP*/ 13306 13307 template <> 13308 struct hash<VULKAN_HPP_NAMESPACE::PresentIdKHR> 13309 { operator ()std::hash13310 std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentIdKHR const & presentIdKHR ) const VULKAN_HPP_NOEXCEPT 13311 { 13312 std::size_t seed = 0; 13313 VULKAN_HPP_HASH_COMBINE( seed, presentIdKHR.sType ); 13314 VULKAN_HPP_HASH_COMBINE( seed, presentIdKHR.pNext ); 13315 VULKAN_HPP_HASH_COMBINE( seed, presentIdKHR.swapchainCount ); 13316 VULKAN_HPP_HASH_COMBINE( seed, presentIdKHR.pPresentIds ); 13317 return seed; 13318 } 13319 }; 13320 13321 template <> 13322 struct hash<VULKAN_HPP_NAMESPACE::PresentInfoKHR> 13323 { operator ()std::hash13324 std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentInfoKHR const & presentInfoKHR ) const VULKAN_HPP_NOEXCEPT 13325 { 13326 std::size_t seed = 0; 13327 VULKAN_HPP_HASH_COMBINE( seed, presentInfoKHR.sType ); 13328 VULKAN_HPP_HASH_COMBINE( seed, presentInfoKHR.pNext ); 13329 VULKAN_HPP_HASH_COMBINE( seed, presentInfoKHR.waitSemaphoreCount ); 13330 VULKAN_HPP_HASH_COMBINE( seed, presentInfoKHR.pWaitSemaphores ); 13331 VULKAN_HPP_HASH_COMBINE( seed, presentInfoKHR.swapchainCount ); 13332 VULKAN_HPP_HASH_COMBINE( seed, presentInfoKHR.pSwapchains ); 13333 VULKAN_HPP_HASH_COMBINE( seed, presentInfoKHR.pImageIndices ); 13334 VULKAN_HPP_HASH_COMBINE( seed, presentInfoKHR.pResults ); 13335 return seed; 13336 } 13337 }; 13338 13339 template <> 13340 struct hash<VULKAN_HPP_NAMESPACE::RectLayerKHR> 13341 { operator ()std::hash13342 std::size_t operator()( VULKAN_HPP_NAMESPACE::RectLayerKHR const & rectLayerKHR ) const VULKAN_HPP_NOEXCEPT 13343 { 13344 std::size_t seed = 0; 13345 VULKAN_HPP_HASH_COMBINE( seed, rectLayerKHR.offset ); 13346 VULKAN_HPP_HASH_COMBINE( seed, rectLayerKHR.extent ); 13347 VULKAN_HPP_HASH_COMBINE( seed, rectLayerKHR.layer ); 13348 return seed; 13349 } 13350 }; 13351 13352 template <> 13353 struct hash<VULKAN_HPP_NAMESPACE::PresentRegionKHR> 13354 { operator ()std::hash13355 std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentRegionKHR const & presentRegionKHR ) const VULKAN_HPP_NOEXCEPT 13356 { 13357 std::size_t seed = 0; 13358 VULKAN_HPP_HASH_COMBINE( seed, presentRegionKHR.rectangleCount ); 13359 VULKAN_HPP_HASH_COMBINE( seed, presentRegionKHR.pRectangles ); 13360 return seed; 13361 } 13362 }; 13363 13364 template <> 13365 struct hash<VULKAN_HPP_NAMESPACE::PresentRegionsKHR> 13366 { operator ()std::hash13367 std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentRegionsKHR const & presentRegionsKHR ) const VULKAN_HPP_NOEXCEPT 13368 { 13369 std::size_t seed = 0; 13370 VULKAN_HPP_HASH_COMBINE( seed, presentRegionsKHR.sType ); 13371 VULKAN_HPP_HASH_COMBINE( seed, presentRegionsKHR.pNext ); 13372 VULKAN_HPP_HASH_COMBINE( seed, presentRegionsKHR.swapchainCount ); 13373 VULKAN_HPP_HASH_COMBINE( seed, presentRegionsKHR.pRegions ); 13374 return seed; 13375 } 13376 }; 13377 13378 template <> 13379 struct hash<VULKAN_HPP_NAMESPACE::PresentTimeGOOGLE> 13380 { operator ()std::hash13381 std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentTimeGOOGLE const & presentTimeGOOGLE ) const VULKAN_HPP_NOEXCEPT 13382 { 13383 std::size_t seed = 0; 13384 VULKAN_HPP_HASH_COMBINE( seed, presentTimeGOOGLE.presentID ); 13385 VULKAN_HPP_HASH_COMBINE( seed, presentTimeGOOGLE.desiredPresentTime ); 13386 return seed; 13387 } 13388 }; 13389 13390 template <> 13391 struct hash<VULKAN_HPP_NAMESPACE::PresentTimesInfoGOOGLE> 13392 { operator ()std::hash13393 std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentTimesInfoGOOGLE const & presentTimesInfoGOOGLE ) const VULKAN_HPP_NOEXCEPT 13394 { 13395 std::size_t seed = 0; 13396 VULKAN_HPP_HASH_COMBINE( seed, presentTimesInfoGOOGLE.sType ); 13397 VULKAN_HPP_HASH_COMBINE( seed, presentTimesInfoGOOGLE.pNext ); 13398 VULKAN_HPP_HASH_COMBINE( seed, presentTimesInfoGOOGLE.swapchainCount ); 13399 VULKAN_HPP_HASH_COMBINE( seed, presentTimesInfoGOOGLE.pTimes ); 13400 return seed; 13401 } 13402 }; 13403 13404 template <> 13405 struct hash<VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo> 13406 { operator ()std::hash13407 std::size_t operator()( VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo const & privateDataSlotCreateInfo ) const VULKAN_HPP_NOEXCEPT 13408 { 13409 std::size_t seed = 0; 13410 VULKAN_HPP_HASH_COMBINE( seed, privateDataSlotCreateInfo.sType ); 13411 VULKAN_HPP_HASH_COMBINE( seed, privateDataSlotCreateInfo.pNext ); 13412 VULKAN_HPP_HASH_COMBINE( seed, privateDataSlotCreateInfo.flags ); 13413 return seed; 13414 } 13415 }; 13416 13417 template <> 13418 struct hash<VULKAN_HPP_NAMESPACE::ProtectedSubmitInfo> 13419 { operator ()std::hash13420 std::size_t operator()( VULKAN_HPP_NAMESPACE::ProtectedSubmitInfo const & protectedSubmitInfo ) const VULKAN_HPP_NOEXCEPT 13421 { 13422 std::size_t seed = 0; 13423 VULKAN_HPP_HASH_COMBINE( seed, protectedSubmitInfo.sType ); 13424 VULKAN_HPP_HASH_COMBINE( seed, protectedSubmitInfo.pNext ); 13425 VULKAN_HPP_HASH_COMBINE( seed, protectedSubmitInfo.protectedSubmit ); 13426 return seed; 13427 } 13428 }; 13429 13430 template <> 13431 struct hash<VULKAN_HPP_NAMESPACE::PushConstantsInfoKHR> 13432 { operator ()std::hash13433 std::size_t operator()( VULKAN_HPP_NAMESPACE::PushConstantsInfoKHR const & pushConstantsInfoKHR ) const VULKAN_HPP_NOEXCEPT 13434 { 13435 std::size_t seed = 0; 13436 VULKAN_HPP_HASH_COMBINE( seed, pushConstantsInfoKHR.sType ); 13437 VULKAN_HPP_HASH_COMBINE( seed, pushConstantsInfoKHR.pNext ); 13438 VULKAN_HPP_HASH_COMBINE( seed, pushConstantsInfoKHR.layout ); 13439 VULKAN_HPP_HASH_COMBINE( seed, pushConstantsInfoKHR.stageFlags ); 13440 VULKAN_HPP_HASH_COMBINE( seed, pushConstantsInfoKHR.offset ); 13441 VULKAN_HPP_HASH_COMBINE( seed, pushConstantsInfoKHR.size ); 13442 VULKAN_HPP_HASH_COMBINE( seed, pushConstantsInfoKHR.pValues ); 13443 return seed; 13444 } 13445 }; 13446 13447 template <> 13448 struct hash<VULKAN_HPP_NAMESPACE::WriteDescriptorSet> 13449 { operator ()std::hash13450 std::size_t operator()( VULKAN_HPP_NAMESPACE::WriteDescriptorSet const & writeDescriptorSet ) const VULKAN_HPP_NOEXCEPT 13451 { 13452 std::size_t seed = 0; 13453 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.sType ); 13454 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.pNext ); 13455 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.dstSet ); 13456 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.dstBinding ); 13457 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.dstArrayElement ); 13458 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.descriptorCount ); 13459 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.descriptorType ); 13460 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.pImageInfo ); 13461 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.pBufferInfo ); 13462 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.pTexelBufferView ); 13463 return seed; 13464 } 13465 }; 13466 13467 template <> 13468 struct hash<VULKAN_HPP_NAMESPACE::PushDescriptorSetInfoKHR> 13469 { operator ()std::hash13470 std::size_t operator()( VULKAN_HPP_NAMESPACE::PushDescriptorSetInfoKHR const & pushDescriptorSetInfoKHR ) const VULKAN_HPP_NOEXCEPT 13471 { 13472 std::size_t seed = 0; 13473 VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetInfoKHR.sType ); 13474 VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetInfoKHR.pNext ); 13475 VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetInfoKHR.stageFlags ); 13476 VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetInfoKHR.layout ); 13477 VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetInfoKHR.set ); 13478 VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetInfoKHR.descriptorWriteCount ); 13479 VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetInfoKHR.pDescriptorWrites ); 13480 return seed; 13481 } 13482 }; 13483 13484 template <> 13485 struct hash<VULKAN_HPP_NAMESPACE::PushDescriptorSetWithTemplateInfoKHR> 13486 { operator ()std::hash13487 std::size_t operator()( VULKAN_HPP_NAMESPACE::PushDescriptorSetWithTemplateInfoKHR const & pushDescriptorSetWithTemplateInfoKHR ) const VULKAN_HPP_NOEXCEPT 13488 { 13489 std::size_t seed = 0; 13490 VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetWithTemplateInfoKHR.sType ); 13491 VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetWithTemplateInfoKHR.pNext ); 13492 VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetWithTemplateInfoKHR.descriptorUpdateTemplate ); 13493 VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetWithTemplateInfoKHR.layout ); 13494 VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetWithTemplateInfoKHR.set ); 13495 VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetWithTemplateInfoKHR.pData ); 13496 return seed; 13497 } 13498 }; 13499 13500 template <> 13501 struct hash<VULKAN_HPP_NAMESPACE::QueryLowLatencySupportNV> 13502 { operator ()std::hash13503 std::size_t operator()( VULKAN_HPP_NAMESPACE::QueryLowLatencySupportNV const & queryLowLatencySupportNV ) const VULKAN_HPP_NOEXCEPT 13504 { 13505 std::size_t seed = 0; 13506 VULKAN_HPP_HASH_COMBINE( seed, queryLowLatencySupportNV.sType ); 13507 VULKAN_HPP_HASH_COMBINE( seed, queryLowLatencySupportNV.pNext ); 13508 VULKAN_HPP_HASH_COMBINE( seed, queryLowLatencySupportNV.pQueriedLowLatencyData ); 13509 return seed; 13510 } 13511 }; 13512 13513 template <> 13514 struct hash<VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo> 13515 { operator ()std::hash13516 std::size_t operator()( VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo const & queryPoolCreateInfo ) const VULKAN_HPP_NOEXCEPT 13517 { 13518 std::size_t seed = 0; 13519 VULKAN_HPP_HASH_COMBINE( seed, queryPoolCreateInfo.sType ); 13520 VULKAN_HPP_HASH_COMBINE( seed, queryPoolCreateInfo.pNext ); 13521 VULKAN_HPP_HASH_COMBINE( seed, queryPoolCreateInfo.flags ); 13522 VULKAN_HPP_HASH_COMBINE( seed, queryPoolCreateInfo.queryType ); 13523 VULKAN_HPP_HASH_COMBINE( seed, queryPoolCreateInfo.queryCount ); 13524 VULKAN_HPP_HASH_COMBINE( seed, queryPoolCreateInfo.pipelineStatistics ); 13525 return seed; 13526 } 13527 }; 13528 13529 template <> 13530 struct hash<VULKAN_HPP_NAMESPACE::QueryPoolPerformanceCreateInfoKHR> 13531 { operator ()std::hash13532 std::size_t operator()( VULKAN_HPP_NAMESPACE::QueryPoolPerformanceCreateInfoKHR const & queryPoolPerformanceCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 13533 { 13534 std::size_t seed = 0; 13535 VULKAN_HPP_HASH_COMBINE( seed, queryPoolPerformanceCreateInfoKHR.sType ); 13536 VULKAN_HPP_HASH_COMBINE( seed, queryPoolPerformanceCreateInfoKHR.pNext ); 13537 VULKAN_HPP_HASH_COMBINE( seed, queryPoolPerformanceCreateInfoKHR.queueFamilyIndex ); 13538 VULKAN_HPP_HASH_COMBINE( seed, queryPoolPerformanceCreateInfoKHR.counterIndexCount ); 13539 VULKAN_HPP_HASH_COMBINE( seed, queryPoolPerformanceCreateInfoKHR.pCounterIndices ); 13540 return seed; 13541 } 13542 }; 13543 13544 template <> 13545 struct hash<VULKAN_HPP_NAMESPACE::QueryPoolPerformanceQueryCreateInfoINTEL> 13546 { 13547 std::size_t operator ()std::hash13548 operator()( VULKAN_HPP_NAMESPACE::QueryPoolPerformanceQueryCreateInfoINTEL const & queryPoolPerformanceQueryCreateInfoINTEL ) const VULKAN_HPP_NOEXCEPT 13549 { 13550 std::size_t seed = 0; 13551 VULKAN_HPP_HASH_COMBINE( seed, queryPoolPerformanceQueryCreateInfoINTEL.sType ); 13552 VULKAN_HPP_HASH_COMBINE( seed, queryPoolPerformanceQueryCreateInfoINTEL.pNext ); 13553 VULKAN_HPP_HASH_COMBINE( seed, queryPoolPerformanceQueryCreateInfoINTEL.performanceCountersSampling ); 13554 return seed; 13555 } 13556 }; 13557 13558 template <> 13559 struct hash<VULKAN_HPP_NAMESPACE::QueryPoolVideoEncodeFeedbackCreateInfoKHR> 13560 { 13561 std::size_t operator ()std::hash13562 operator()( VULKAN_HPP_NAMESPACE::QueryPoolVideoEncodeFeedbackCreateInfoKHR const & queryPoolVideoEncodeFeedbackCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 13563 { 13564 std::size_t seed = 0; 13565 VULKAN_HPP_HASH_COMBINE( seed, queryPoolVideoEncodeFeedbackCreateInfoKHR.sType ); 13566 VULKAN_HPP_HASH_COMBINE( seed, queryPoolVideoEncodeFeedbackCreateInfoKHR.pNext ); 13567 VULKAN_HPP_HASH_COMBINE( seed, queryPoolVideoEncodeFeedbackCreateInfoKHR.encodeFeedbackFlags ); 13568 return seed; 13569 } 13570 }; 13571 13572 template <> 13573 struct hash<VULKAN_HPP_NAMESPACE::QueueFamilyCheckpointProperties2NV> 13574 { operator ()std::hash13575 std::size_t operator()( VULKAN_HPP_NAMESPACE::QueueFamilyCheckpointProperties2NV const & queueFamilyCheckpointProperties2NV ) const VULKAN_HPP_NOEXCEPT 13576 { 13577 std::size_t seed = 0; 13578 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyCheckpointProperties2NV.sType ); 13579 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyCheckpointProperties2NV.pNext ); 13580 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyCheckpointProperties2NV.checkpointExecutionStageMask ); 13581 return seed; 13582 } 13583 }; 13584 13585 template <> 13586 struct hash<VULKAN_HPP_NAMESPACE::QueueFamilyCheckpointPropertiesNV> 13587 { operator ()std::hash13588 std::size_t operator()( VULKAN_HPP_NAMESPACE::QueueFamilyCheckpointPropertiesNV const & queueFamilyCheckpointPropertiesNV ) const VULKAN_HPP_NOEXCEPT 13589 { 13590 std::size_t seed = 0; 13591 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyCheckpointPropertiesNV.sType ); 13592 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyCheckpointPropertiesNV.pNext ); 13593 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyCheckpointPropertiesNV.checkpointExecutionStageMask ); 13594 return seed; 13595 } 13596 }; 13597 13598 template <> 13599 struct hash<VULKAN_HPP_NAMESPACE::QueueFamilyGlobalPriorityPropertiesKHR> 13600 { 13601 std::size_t operator ()std::hash13602 operator()( VULKAN_HPP_NAMESPACE::QueueFamilyGlobalPriorityPropertiesKHR const & queueFamilyGlobalPriorityPropertiesKHR ) const VULKAN_HPP_NOEXCEPT 13603 { 13604 std::size_t seed = 0; 13605 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyGlobalPriorityPropertiesKHR.sType ); 13606 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyGlobalPriorityPropertiesKHR.pNext ); 13607 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyGlobalPriorityPropertiesKHR.priorityCount ); 13608 for ( size_t i = 0; i < VK_MAX_GLOBAL_PRIORITY_SIZE_KHR; ++i ) 13609 { 13610 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyGlobalPriorityPropertiesKHR.priorities[i] ); 13611 } 13612 return seed; 13613 } 13614 }; 13615 13616 template <> 13617 struct hash<VULKAN_HPP_NAMESPACE::QueueFamilyProperties> 13618 { operator ()std::hash13619 std::size_t operator()( VULKAN_HPP_NAMESPACE::QueueFamilyProperties const & queueFamilyProperties ) const VULKAN_HPP_NOEXCEPT 13620 { 13621 std::size_t seed = 0; 13622 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyProperties.queueFlags ); 13623 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyProperties.queueCount ); 13624 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyProperties.timestampValidBits ); 13625 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyProperties.minImageTransferGranularity ); 13626 return seed; 13627 } 13628 }; 13629 13630 template <> 13631 struct hash<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2> 13632 { operator ()std::hash13633 std::size_t operator()( VULKAN_HPP_NAMESPACE::QueueFamilyProperties2 const & queueFamilyProperties2 ) const VULKAN_HPP_NOEXCEPT 13634 { 13635 std::size_t seed = 0; 13636 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyProperties2.sType ); 13637 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyProperties2.pNext ); 13638 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyProperties2.queueFamilyProperties ); 13639 return seed; 13640 } 13641 }; 13642 13643 template <> 13644 struct hash<VULKAN_HPP_NAMESPACE::QueueFamilyQueryResultStatusPropertiesKHR> 13645 { 13646 std::size_t operator ()std::hash13647 operator()( VULKAN_HPP_NAMESPACE::QueueFamilyQueryResultStatusPropertiesKHR const & queueFamilyQueryResultStatusPropertiesKHR ) const VULKAN_HPP_NOEXCEPT 13648 { 13649 std::size_t seed = 0; 13650 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyQueryResultStatusPropertiesKHR.sType ); 13651 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyQueryResultStatusPropertiesKHR.pNext ); 13652 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyQueryResultStatusPropertiesKHR.queryResultStatusSupport ); 13653 return seed; 13654 } 13655 }; 13656 13657 template <> 13658 struct hash<VULKAN_HPP_NAMESPACE::QueueFamilyVideoPropertiesKHR> 13659 { operator ()std::hash13660 std::size_t operator()( VULKAN_HPP_NAMESPACE::QueueFamilyVideoPropertiesKHR const & queueFamilyVideoPropertiesKHR ) const VULKAN_HPP_NOEXCEPT 13661 { 13662 std::size_t seed = 0; 13663 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyVideoPropertiesKHR.sType ); 13664 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyVideoPropertiesKHR.pNext ); 13665 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyVideoPropertiesKHR.videoCodecOperations ); 13666 return seed; 13667 } 13668 }; 13669 13670 template <> 13671 struct hash<VULKAN_HPP_NAMESPACE::RayTracingShaderGroupCreateInfoKHR> 13672 { operator ()std::hash13673 std::size_t operator()( VULKAN_HPP_NAMESPACE::RayTracingShaderGroupCreateInfoKHR const & rayTracingShaderGroupCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 13674 { 13675 std::size_t seed = 0; 13676 VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoKHR.sType ); 13677 VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoKHR.pNext ); 13678 VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoKHR.type ); 13679 VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoKHR.generalShader ); 13680 VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoKHR.closestHitShader ); 13681 VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoKHR.anyHitShader ); 13682 VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoKHR.intersectionShader ); 13683 VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoKHR.pShaderGroupCaptureReplayHandle ); 13684 return seed; 13685 } 13686 }; 13687 13688 template <> 13689 struct hash<VULKAN_HPP_NAMESPACE::RayTracingPipelineInterfaceCreateInfoKHR> 13690 { 13691 std::size_t operator ()std::hash13692 operator()( VULKAN_HPP_NAMESPACE::RayTracingPipelineInterfaceCreateInfoKHR const & rayTracingPipelineInterfaceCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 13693 { 13694 std::size_t seed = 0; 13695 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineInterfaceCreateInfoKHR.sType ); 13696 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineInterfaceCreateInfoKHR.pNext ); 13697 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineInterfaceCreateInfoKHR.maxPipelineRayPayloadSize ); 13698 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineInterfaceCreateInfoKHR.maxPipelineRayHitAttributeSize ); 13699 return seed; 13700 } 13701 }; 13702 13703 template <> 13704 struct hash<VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> 13705 { operator ()std::hash13706 std::size_t operator()( VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR const & rayTracingPipelineCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 13707 { 13708 std::size_t seed = 0; 13709 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.sType ); 13710 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.pNext ); 13711 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.flags ); 13712 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.stageCount ); 13713 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.pStages ); 13714 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.groupCount ); 13715 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.pGroups ); 13716 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.maxPipelineRayRecursionDepth ); 13717 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.pLibraryInfo ); 13718 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.pLibraryInterface ); 13719 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.pDynamicState ); 13720 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.layout ); 13721 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.basePipelineHandle ); 13722 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.basePipelineIndex ); 13723 return seed; 13724 } 13725 }; 13726 13727 template <> 13728 struct hash<VULKAN_HPP_NAMESPACE::RayTracingShaderGroupCreateInfoNV> 13729 { operator ()std::hash13730 std::size_t operator()( VULKAN_HPP_NAMESPACE::RayTracingShaderGroupCreateInfoNV const & rayTracingShaderGroupCreateInfoNV ) const VULKAN_HPP_NOEXCEPT 13731 { 13732 std::size_t seed = 0; 13733 VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoNV.sType ); 13734 VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoNV.pNext ); 13735 VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoNV.type ); 13736 VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoNV.generalShader ); 13737 VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoNV.closestHitShader ); 13738 VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoNV.anyHitShader ); 13739 VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoNV.intersectionShader ); 13740 return seed; 13741 } 13742 }; 13743 13744 template <> 13745 struct hash<VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> 13746 { operator ()std::hash13747 std::size_t operator()( VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV const & rayTracingPipelineCreateInfoNV ) const VULKAN_HPP_NOEXCEPT 13748 { 13749 std::size_t seed = 0; 13750 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.sType ); 13751 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.pNext ); 13752 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.flags ); 13753 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.stageCount ); 13754 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.pStages ); 13755 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.groupCount ); 13756 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.pGroups ); 13757 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.maxRecursionDepth ); 13758 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.layout ); 13759 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.basePipelineHandle ); 13760 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.basePipelineIndex ); 13761 return seed; 13762 } 13763 }; 13764 13765 template <> 13766 struct hash<VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE> 13767 { operator ()std::hash13768 std::size_t operator()( VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE const & refreshCycleDurationGOOGLE ) const VULKAN_HPP_NOEXCEPT 13769 { 13770 std::size_t seed = 0; 13771 VULKAN_HPP_HASH_COMBINE( seed, refreshCycleDurationGOOGLE.refreshDuration ); 13772 return seed; 13773 } 13774 }; 13775 13776 template <> 13777 struct hash<VULKAN_HPP_NAMESPACE::ReleaseSwapchainImagesInfoEXT> 13778 { operator ()std::hash13779 std::size_t operator()( VULKAN_HPP_NAMESPACE::ReleaseSwapchainImagesInfoEXT const & releaseSwapchainImagesInfoEXT ) const VULKAN_HPP_NOEXCEPT 13780 { 13781 std::size_t seed = 0; 13782 VULKAN_HPP_HASH_COMBINE( seed, releaseSwapchainImagesInfoEXT.sType ); 13783 VULKAN_HPP_HASH_COMBINE( seed, releaseSwapchainImagesInfoEXT.pNext ); 13784 VULKAN_HPP_HASH_COMBINE( seed, releaseSwapchainImagesInfoEXT.swapchain ); 13785 VULKAN_HPP_HASH_COMBINE( seed, releaseSwapchainImagesInfoEXT.imageIndexCount ); 13786 VULKAN_HPP_HASH_COMBINE( seed, releaseSwapchainImagesInfoEXT.pImageIndices ); 13787 return seed; 13788 } 13789 }; 13790 13791 template <> 13792 struct hash<VULKAN_HPP_NAMESPACE::RenderPassAttachmentBeginInfo> 13793 { operator ()std::hash13794 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassAttachmentBeginInfo const & renderPassAttachmentBeginInfo ) const VULKAN_HPP_NOEXCEPT 13795 { 13796 std::size_t seed = 0; 13797 VULKAN_HPP_HASH_COMBINE( seed, renderPassAttachmentBeginInfo.sType ); 13798 VULKAN_HPP_HASH_COMBINE( seed, renderPassAttachmentBeginInfo.pNext ); 13799 VULKAN_HPP_HASH_COMBINE( seed, renderPassAttachmentBeginInfo.attachmentCount ); 13800 VULKAN_HPP_HASH_COMBINE( seed, renderPassAttachmentBeginInfo.pAttachments ); 13801 return seed; 13802 } 13803 }; 13804 13805 template <> 13806 struct hash<VULKAN_HPP_NAMESPACE::RenderPassBeginInfo> 13807 { operator ()std::hash13808 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassBeginInfo const & renderPassBeginInfo ) const VULKAN_HPP_NOEXCEPT 13809 { 13810 std::size_t seed = 0; 13811 VULKAN_HPP_HASH_COMBINE( seed, renderPassBeginInfo.sType ); 13812 VULKAN_HPP_HASH_COMBINE( seed, renderPassBeginInfo.pNext ); 13813 VULKAN_HPP_HASH_COMBINE( seed, renderPassBeginInfo.renderPass ); 13814 VULKAN_HPP_HASH_COMBINE( seed, renderPassBeginInfo.framebuffer ); 13815 VULKAN_HPP_HASH_COMBINE( seed, renderPassBeginInfo.renderArea ); 13816 VULKAN_HPP_HASH_COMBINE( seed, renderPassBeginInfo.clearValueCount ); 13817 VULKAN_HPP_HASH_COMBINE( seed, renderPassBeginInfo.pClearValues ); 13818 return seed; 13819 } 13820 }; 13821 13822 template <> 13823 struct hash<VULKAN_HPP_NAMESPACE::SubpassDescription> 13824 { operator ()std::hash13825 std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassDescription const & subpassDescription ) const VULKAN_HPP_NOEXCEPT 13826 { 13827 std::size_t seed = 0; 13828 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.flags ); 13829 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.pipelineBindPoint ); 13830 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.inputAttachmentCount ); 13831 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.pInputAttachments ); 13832 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.colorAttachmentCount ); 13833 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.pColorAttachments ); 13834 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.pResolveAttachments ); 13835 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.pDepthStencilAttachment ); 13836 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.preserveAttachmentCount ); 13837 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.pPreserveAttachments ); 13838 return seed; 13839 } 13840 }; 13841 13842 template <> 13843 struct hash<VULKAN_HPP_NAMESPACE::SubpassDependency> 13844 { operator ()std::hash13845 std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassDependency const & subpassDependency ) const VULKAN_HPP_NOEXCEPT 13846 { 13847 std::size_t seed = 0; 13848 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency.srcSubpass ); 13849 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency.dstSubpass ); 13850 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency.srcStageMask ); 13851 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency.dstStageMask ); 13852 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency.srcAccessMask ); 13853 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency.dstAccessMask ); 13854 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency.dependencyFlags ); 13855 return seed; 13856 } 13857 }; 13858 13859 template <> 13860 struct hash<VULKAN_HPP_NAMESPACE::RenderPassCreateInfo> 13861 { operator ()std::hash13862 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassCreateInfo const & renderPassCreateInfo ) const VULKAN_HPP_NOEXCEPT 13863 { 13864 std::size_t seed = 0; 13865 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo.sType ); 13866 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo.pNext ); 13867 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo.flags ); 13868 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo.attachmentCount ); 13869 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo.pAttachments ); 13870 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo.subpassCount ); 13871 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo.pSubpasses ); 13872 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo.dependencyCount ); 13873 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo.pDependencies ); 13874 return seed; 13875 } 13876 }; 13877 13878 template <> 13879 struct hash<VULKAN_HPP_NAMESPACE::SubpassDescription2> 13880 { operator ()std::hash13881 std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassDescription2 const & subpassDescription2 ) const VULKAN_HPP_NOEXCEPT 13882 { 13883 std::size_t seed = 0; 13884 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.sType ); 13885 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.pNext ); 13886 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.flags ); 13887 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.pipelineBindPoint ); 13888 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.viewMask ); 13889 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.inputAttachmentCount ); 13890 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.pInputAttachments ); 13891 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.colorAttachmentCount ); 13892 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.pColorAttachments ); 13893 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.pResolveAttachments ); 13894 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.pDepthStencilAttachment ); 13895 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.preserveAttachmentCount ); 13896 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.pPreserveAttachments ); 13897 return seed; 13898 } 13899 }; 13900 13901 template <> 13902 struct hash<VULKAN_HPP_NAMESPACE::SubpassDependency2> 13903 { operator ()std::hash13904 std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassDependency2 const & subpassDependency2 ) const VULKAN_HPP_NOEXCEPT 13905 { 13906 std::size_t seed = 0; 13907 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.sType ); 13908 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.pNext ); 13909 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.srcSubpass ); 13910 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.dstSubpass ); 13911 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.srcStageMask ); 13912 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.dstStageMask ); 13913 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.srcAccessMask ); 13914 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.dstAccessMask ); 13915 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.dependencyFlags ); 13916 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.viewOffset ); 13917 return seed; 13918 } 13919 }; 13920 13921 template <> 13922 struct hash<VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2> 13923 { operator ()std::hash13924 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 const & renderPassCreateInfo2 ) const VULKAN_HPP_NOEXCEPT 13925 { 13926 std::size_t seed = 0; 13927 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.sType ); 13928 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.pNext ); 13929 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.flags ); 13930 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.attachmentCount ); 13931 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.pAttachments ); 13932 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.subpassCount ); 13933 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.pSubpasses ); 13934 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.dependencyCount ); 13935 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.pDependencies ); 13936 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.correlatedViewMaskCount ); 13937 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.pCorrelatedViewMasks ); 13938 return seed; 13939 } 13940 }; 13941 13942 template <> 13943 struct hash<VULKAN_HPP_NAMESPACE::RenderPassCreationControlEXT> 13944 { operator ()std::hash13945 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassCreationControlEXT const & renderPassCreationControlEXT ) const VULKAN_HPP_NOEXCEPT 13946 { 13947 std::size_t seed = 0; 13948 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreationControlEXT.sType ); 13949 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreationControlEXT.pNext ); 13950 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreationControlEXT.disallowMerging ); 13951 return seed; 13952 } 13953 }; 13954 13955 template <> 13956 struct hash<VULKAN_HPP_NAMESPACE::RenderPassCreationFeedbackInfoEXT> 13957 { operator ()std::hash13958 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassCreationFeedbackInfoEXT const & renderPassCreationFeedbackInfoEXT ) const VULKAN_HPP_NOEXCEPT 13959 { 13960 std::size_t seed = 0; 13961 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreationFeedbackInfoEXT.postMergeSubpassCount ); 13962 return seed; 13963 } 13964 }; 13965 13966 template <> 13967 struct hash<VULKAN_HPP_NAMESPACE::RenderPassCreationFeedbackCreateInfoEXT> 13968 { 13969 std::size_t operator ()std::hash13970 operator()( VULKAN_HPP_NAMESPACE::RenderPassCreationFeedbackCreateInfoEXT const & renderPassCreationFeedbackCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 13971 { 13972 std::size_t seed = 0; 13973 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreationFeedbackCreateInfoEXT.sType ); 13974 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreationFeedbackCreateInfoEXT.pNext ); 13975 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreationFeedbackCreateInfoEXT.pRenderPassFeedback ); 13976 return seed; 13977 } 13978 }; 13979 13980 template <> 13981 struct hash<VULKAN_HPP_NAMESPACE::RenderPassFragmentDensityMapCreateInfoEXT> 13982 { 13983 std::size_t operator ()std::hash13984 operator()( VULKAN_HPP_NAMESPACE::RenderPassFragmentDensityMapCreateInfoEXT const & renderPassFragmentDensityMapCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 13985 { 13986 std::size_t seed = 0; 13987 VULKAN_HPP_HASH_COMBINE( seed, renderPassFragmentDensityMapCreateInfoEXT.sType ); 13988 VULKAN_HPP_HASH_COMBINE( seed, renderPassFragmentDensityMapCreateInfoEXT.pNext ); 13989 VULKAN_HPP_HASH_COMBINE( seed, renderPassFragmentDensityMapCreateInfoEXT.fragmentDensityMapAttachment ); 13990 return seed; 13991 } 13992 }; 13993 13994 template <> 13995 struct hash<VULKAN_HPP_NAMESPACE::RenderPassInputAttachmentAspectCreateInfo> 13996 { 13997 std::size_t operator ()std::hash13998 operator()( VULKAN_HPP_NAMESPACE::RenderPassInputAttachmentAspectCreateInfo const & renderPassInputAttachmentAspectCreateInfo ) const VULKAN_HPP_NOEXCEPT 13999 { 14000 std::size_t seed = 0; 14001 VULKAN_HPP_HASH_COMBINE( seed, renderPassInputAttachmentAspectCreateInfo.sType ); 14002 VULKAN_HPP_HASH_COMBINE( seed, renderPassInputAttachmentAspectCreateInfo.pNext ); 14003 VULKAN_HPP_HASH_COMBINE( seed, renderPassInputAttachmentAspectCreateInfo.aspectReferenceCount ); 14004 VULKAN_HPP_HASH_COMBINE( seed, renderPassInputAttachmentAspectCreateInfo.pAspectReferences ); 14005 return seed; 14006 } 14007 }; 14008 14009 template <> 14010 struct hash<VULKAN_HPP_NAMESPACE::RenderPassMultiviewCreateInfo> 14011 { operator ()std::hash14012 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassMultiviewCreateInfo const & renderPassMultiviewCreateInfo ) const VULKAN_HPP_NOEXCEPT 14013 { 14014 std::size_t seed = 0; 14015 VULKAN_HPP_HASH_COMBINE( seed, renderPassMultiviewCreateInfo.sType ); 14016 VULKAN_HPP_HASH_COMBINE( seed, renderPassMultiviewCreateInfo.pNext ); 14017 VULKAN_HPP_HASH_COMBINE( seed, renderPassMultiviewCreateInfo.subpassCount ); 14018 VULKAN_HPP_HASH_COMBINE( seed, renderPassMultiviewCreateInfo.pViewMasks ); 14019 VULKAN_HPP_HASH_COMBINE( seed, renderPassMultiviewCreateInfo.dependencyCount ); 14020 VULKAN_HPP_HASH_COMBINE( seed, renderPassMultiviewCreateInfo.pViewOffsets ); 14021 VULKAN_HPP_HASH_COMBINE( seed, renderPassMultiviewCreateInfo.correlationMaskCount ); 14022 VULKAN_HPP_HASH_COMBINE( seed, renderPassMultiviewCreateInfo.pCorrelationMasks ); 14023 return seed; 14024 } 14025 }; 14026 14027 template <> 14028 struct hash<VULKAN_HPP_NAMESPACE::SubpassSampleLocationsEXT> 14029 { operator ()std::hash14030 std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassSampleLocationsEXT const & subpassSampleLocationsEXT ) const VULKAN_HPP_NOEXCEPT 14031 { 14032 std::size_t seed = 0; 14033 VULKAN_HPP_HASH_COMBINE( seed, subpassSampleLocationsEXT.subpassIndex ); 14034 VULKAN_HPP_HASH_COMBINE( seed, subpassSampleLocationsEXT.sampleLocationsInfo ); 14035 return seed; 14036 } 14037 }; 14038 14039 template <> 14040 struct hash<VULKAN_HPP_NAMESPACE::RenderPassSampleLocationsBeginInfoEXT> 14041 { 14042 std::size_t operator ()std::hash14043 operator()( VULKAN_HPP_NAMESPACE::RenderPassSampleLocationsBeginInfoEXT const & renderPassSampleLocationsBeginInfoEXT ) const VULKAN_HPP_NOEXCEPT 14044 { 14045 std::size_t seed = 0; 14046 VULKAN_HPP_HASH_COMBINE( seed, renderPassSampleLocationsBeginInfoEXT.sType ); 14047 VULKAN_HPP_HASH_COMBINE( seed, renderPassSampleLocationsBeginInfoEXT.pNext ); 14048 VULKAN_HPP_HASH_COMBINE( seed, renderPassSampleLocationsBeginInfoEXT.attachmentInitialSampleLocationsCount ); 14049 VULKAN_HPP_HASH_COMBINE( seed, renderPassSampleLocationsBeginInfoEXT.pAttachmentInitialSampleLocations ); 14050 VULKAN_HPP_HASH_COMBINE( seed, renderPassSampleLocationsBeginInfoEXT.postSubpassSampleLocationsCount ); 14051 VULKAN_HPP_HASH_COMBINE( seed, renderPassSampleLocationsBeginInfoEXT.pPostSubpassSampleLocations ); 14052 return seed; 14053 } 14054 }; 14055 14056 template <> 14057 struct hash<VULKAN_HPP_NAMESPACE::RenderPassStripeInfoARM> 14058 { operator ()std::hash14059 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassStripeInfoARM const & renderPassStripeInfoARM ) const VULKAN_HPP_NOEXCEPT 14060 { 14061 std::size_t seed = 0; 14062 VULKAN_HPP_HASH_COMBINE( seed, renderPassStripeInfoARM.sType ); 14063 VULKAN_HPP_HASH_COMBINE( seed, renderPassStripeInfoARM.pNext ); 14064 VULKAN_HPP_HASH_COMBINE( seed, renderPassStripeInfoARM.stripeArea ); 14065 return seed; 14066 } 14067 }; 14068 14069 template <> 14070 struct hash<VULKAN_HPP_NAMESPACE::RenderPassStripeBeginInfoARM> 14071 { operator ()std::hash14072 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassStripeBeginInfoARM const & renderPassStripeBeginInfoARM ) const VULKAN_HPP_NOEXCEPT 14073 { 14074 std::size_t seed = 0; 14075 VULKAN_HPP_HASH_COMBINE( seed, renderPassStripeBeginInfoARM.sType ); 14076 VULKAN_HPP_HASH_COMBINE( seed, renderPassStripeBeginInfoARM.pNext ); 14077 VULKAN_HPP_HASH_COMBINE( seed, renderPassStripeBeginInfoARM.stripeInfoCount ); 14078 VULKAN_HPP_HASH_COMBINE( seed, renderPassStripeBeginInfoARM.pStripeInfos ); 14079 return seed; 14080 } 14081 }; 14082 14083 template <> 14084 struct hash<VULKAN_HPP_NAMESPACE::SemaphoreSubmitInfo> 14085 { operator ()std::hash14086 std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreSubmitInfo const & semaphoreSubmitInfo ) const VULKAN_HPP_NOEXCEPT 14087 { 14088 std::size_t seed = 0; 14089 VULKAN_HPP_HASH_COMBINE( seed, semaphoreSubmitInfo.sType ); 14090 VULKAN_HPP_HASH_COMBINE( seed, semaphoreSubmitInfo.pNext ); 14091 VULKAN_HPP_HASH_COMBINE( seed, semaphoreSubmitInfo.semaphore ); 14092 VULKAN_HPP_HASH_COMBINE( seed, semaphoreSubmitInfo.value ); 14093 VULKAN_HPP_HASH_COMBINE( seed, semaphoreSubmitInfo.stageMask ); 14094 VULKAN_HPP_HASH_COMBINE( seed, semaphoreSubmitInfo.deviceIndex ); 14095 return seed; 14096 } 14097 }; 14098 14099 template <> 14100 struct hash<VULKAN_HPP_NAMESPACE::RenderPassStripeSubmitInfoARM> 14101 { operator ()std::hash14102 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassStripeSubmitInfoARM const & renderPassStripeSubmitInfoARM ) const VULKAN_HPP_NOEXCEPT 14103 { 14104 std::size_t seed = 0; 14105 VULKAN_HPP_HASH_COMBINE( seed, renderPassStripeSubmitInfoARM.sType ); 14106 VULKAN_HPP_HASH_COMBINE( seed, renderPassStripeSubmitInfoARM.pNext ); 14107 VULKAN_HPP_HASH_COMBINE( seed, renderPassStripeSubmitInfoARM.stripeSemaphoreInfoCount ); 14108 VULKAN_HPP_HASH_COMBINE( seed, renderPassStripeSubmitInfoARM.pStripeSemaphoreInfos ); 14109 return seed; 14110 } 14111 }; 14112 14113 template <> 14114 struct hash<VULKAN_HPP_NAMESPACE::RenderPassSubpassFeedbackInfoEXT> 14115 { operator ()std::hash14116 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassSubpassFeedbackInfoEXT const & renderPassSubpassFeedbackInfoEXT ) const VULKAN_HPP_NOEXCEPT 14117 { 14118 std::size_t seed = 0; 14119 VULKAN_HPP_HASH_COMBINE( seed, renderPassSubpassFeedbackInfoEXT.subpassMergeStatus ); 14120 for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) 14121 { 14122 VULKAN_HPP_HASH_COMBINE( seed, renderPassSubpassFeedbackInfoEXT.description[i] ); 14123 } 14124 VULKAN_HPP_HASH_COMBINE( seed, renderPassSubpassFeedbackInfoEXT.postMergeIndex ); 14125 return seed; 14126 } 14127 }; 14128 14129 template <> 14130 struct hash<VULKAN_HPP_NAMESPACE::RenderPassSubpassFeedbackCreateInfoEXT> 14131 { 14132 std::size_t operator ()std::hash14133 operator()( VULKAN_HPP_NAMESPACE::RenderPassSubpassFeedbackCreateInfoEXT const & renderPassSubpassFeedbackCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 14134 { 14135 std::size_t seed = 0; 14136 VULKAN_HPP_HASH_COMBINE( seed, renderPassSubpassFeedbackCreateInfoEXT.sType ); 14137 VULKAN_HPP_HASH_COMBINE( seed, renderPassSubpassFeedbackCreateInfoEXT.pNext ); 14138 VULKAN_HPP_HASH_COMBINE( seed, renderPassSubpassFeedbackCreateInfoEXT.pSubpassFeedback ); 14139 return seed; 14140 } 14141 }; 14142 14143 template <> 14144 struct hash<VULKAN_HPP_NAMESPACE::RenderPassTransformBeginInfoQCOM> 14145 { operator ()std::hash14146 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassTransformBeginInfoQCOM const & renderPassTransformBeginInfoQCOM ) const VULKAN_HPP_NOEXCEPT 14147 { 14148 std::size_t seed = 0; 14149 VULKAN_HPP_HASH_COMBINE( seed, renderPassTransformBeginInfoQCOM.sType ); 14150 VULKAN_HPP_HASH_COMBINE( seed, renderPassTransformBeginInfoQCOM.pNext ); 14151 VULKAN_HPP_HASH_COMBINE( seed, renderPassTransformBeginInfoQCOM.transform ); 14152 return seed; 14153 } 14154 }; 14155 14156 template <> 14157 struct hash<VULKAN_HPP_NAMESPACE::RenderingAreaInfoKHR> 14158 { operator ()std::hash14159 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderingAreaInfoKHR const & renderingAreaInfoKHR ) const VULKAN_HPP_NOEXCEPT 14160 { 14161 std::size_t seed = 0; 14162 VULKAN_HPP_HASH_COMBINE( seed, renderingAreaInfoKHR.sType ); 14163 VULKAN_HPP_HASH_COMBINE( seed, renderingAreaInfoKHR.pNext ); 14164 VULKAN_HPP_HASH_COMBINE( seed, renderingAreaInfoKHR.viewMask ); 14165 VULKAN_HPP_HASH_COMBINE( seed, renderingAreaInfoKHR.colorAttachmentCount ); 14166 VULKAN_HPP_HASH_COMBINE( seed, renderingAreaInfoKHR.pColorAttachmentFormats ); 14167 VULKAN_HPP_HASH_COMBINE( seed, renderingAreaInfoKHR.depthAttachmentFormat ); 14168 VULKAN_HPP_HASH_COMBINE( seed, renderingAreaInfoKHR.stencilAttachmentFormat ); 14169 return seed; 14170 } 14171 }; 14172 14173 template <> 14174 struct hash<VULKAN_HPP_NAMESPACE::RenderingAttachmentLocationInfoKHR> 14175 { operator ()std::hash14176 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderingAttachmentLocationInfoKHR const & renderingAttachmentLocationInfoKHR ) const VULKAN_HPP_NOEXCEPT 14177 { 14178 std::size_t seed = 0; 14179 VULKAN_HPP_HASH_COMBINE( seed, renderingAttachmentLocationInfoKHR.sType ); 14180 VULKAN_HPP_HASH_COMBINE( seed, renderingAttachmentLocationInfoKHR.pNext ); 14181 VULKAN_HPP_HASH_COMBINE( seed, renderingAttachmentLocationInfoKHR.colorAttachmentCount ); 14182 VULKAN_HPP_HASH_COMBINE( seed, renderingAttachmentLocationInfoKHR.pColorAttachmentLocations ); 14183 return seed; 14184 } 14185 }; 14186 14187 template <> 14188 struct hash<VULKAN_HPP_NAMESPACE::RenderingFragmentDensityMapAttachmentInfoEXT> 14189 { operator ()std::hash14190 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderingFragmentDensityMapAttachmentInfoEXT const & renderingFragmentDensityMapAttachmentInfoEXT ) const 14191 VULKAN_HPP_NOEXCEPT 14192 { 14193 std::size_t seed = 0; 14194 VULKAN_HPP_HASH_COMBINE( seed, renderingFragmentDensityMapAttachmentInfoEXT.sType ); 14195 VULKAN_HPP_HASH_COMBINE( seed, renderingFragmentDensityMapAttachmentInfoEXT.pNext ); 14196 VULKAN_HPP_HASH_COMBINE( seed, renderingFragmentDensityMapAttachmentInfoEXT.imageView ); 14197 VULKAN_HPP_HASH_COMBINE( seed, renderingFragmentDensityMapAttachmentInfoEXT.imageLayout ); 14198 return seed; 14199 } 14200 }; 14201 14202 template <> 14203 struct hash<VULKAN_HPP_NAMESPACE::RenderingFragmentShadingRateAttachmentInfoKHR> 14204 { operator ()std::hash14205 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderingFragmentShadingRateAttachmentInfoKHR const & renderingFragmentShadingRateAttachmentInfoKHR ) const 14206 VULKAN_HPP_NOEXCEPT 14207 { 14208 std::size_t seed = 0; 14209 VULKAN_HPP_HASH_COMBINE( seed, renderingFragmentShadingRateAttachmentInfoKHR.sType ); 14210 VULKAN_HPP_HASH_COMBINE( seed, renderingFragmentShadingRateAttachmentInfoKHR.pNext ); 14211 VULKAN_HPP_HASH_COMBINE( seed, renderingFragmentShadingRateAttachmentInfoKHR.imageView ); 14212 VULKAN_HPP_HASH_COMBINE( seed, renderingFragmentShadingRateAttachmentInfoKHR.imageLayout ); 14213 VULKAN_HPP_HASH_COMBINE( seed, renderingFragmentShadingRateAttachmentInfoKHR.shadingRateAttachmentTexelSize ); 14214 return seed; 14215 } 14216 }; 14217 14218 template <> 14219 struct hash<VULKAN_HPP_NAMESPACE::RenderingInfo> 14220 { operator ()std::hash14221 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderingInfo const & renderingInfo ) const VULKAN_HPP_NOEXCEPT 14222 { 14223 std::size_t seed = 0; 14224 VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.sType ); 14225 VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.pNext ); 14226 VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.flags ); 14227 VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.renderArea ); 14228 VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.layerCount ); 14229 VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.viewMask ); 14230 VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.colorAttachmentCount ); 14231 VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.pColorAttachments ); 14232 VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.pDepthAttachment ); 14233 VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.pStencilAttachment ); 14234 return seed; 14235 } 14236 }; 14237 14238 template <> 14239 struct hash<VULKAN_HPP_NAMESPACE::RenderingInputAttachmentIndexInfoKHR> 14240 { operator ()std::hash14241 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderingInputAttachmentIndexInfoKHR const & renderingInputAttachmentIndexInfoKHR ) const VULKAN_HPP_NOEXCEPT 14242 { 14243 std::size_t seed = 0; 14244 VULKAN_HPP_HASH_COMBINE( seed, renderingInputAttachmentIndexInfoKHR.sType ); 14245 VULKAN_HPP_HASH_COMBINE( seed, renderingInputAttachmentIndexInfoKHR.pNext ); 14246 VULKAN_HPP_HASH_COMBINE( seed, renderingInputAttachmentIndexInfoKHR.colorAttachmentCount ); 14247 VULKAN_HPP_HASH_COMBINE( seed, renderingInputAttachmentIndexInfoKHR.pColorAttachmentInputIndices ); 14248 VULKAN_HPP_HASH_COMBINE( seed, renderingInputAttachmentIndexInfoKHR.pDepthInputAttachmentIndex ); 14249 VULKAN_HPP_HASH_COMBINE( seed, renderingInputAttachmentIndexInfoKHR.pStencilInputAttachmentIndex ); 14250 return seed; 14251 } 14252 }; 14253 14254 template <> 14255 struct hash<VULKAN_HPP_NAMESPACE::ResolveImageInfo2> 14256 { operator ()std::hash14257 std::size_t operator()( VULKAN_HPP_NAMESPACE::ResolveImageInfo2 const & resolveImageInfo2 ) const VULKAN_HPP_NOEXCEPT 14258 { 14259 std::size_t seed = 0; 14260 VULKAN_HPP_HASH_COMBINE( seed, resolveImageInfo2.sType ); 14261 VULKAN_HPP_HASH_COMBINE( seed, resolveImageInfo2.pNext ); 14262 VULKAN_HPP_HASH_COMBINE( seed, resolveImageInfo2.srcImage ); 14263 VULKAN_HPP_HASH_COMBINE( seed, resolveImageInfo2.srcImageLayout ); 14264 VULKAN_HPP_HASH_COMBINE( seed, resolveImageInfo2.dstImage ); 14265 VULKAN_HPP_HASH_COMBINE( seed, resolveImageInfo2.dstImageLayout ); 14266 VULKAN_HPP_HASH_COMBINE( seed, resolveImageInfo2.regionCount ); 14267 VULKAN_HPP_HASH_COMBINE( seed, resolveImageInfo2.pRegions ); 14268 return seed; 14269 } 14270 }; 14271 14272 template <> 14273 struct hash<VULKAN_HPP_NAMESPACE::SamplerBlockMatchWindowCreateInfoQCOM> 14274 { 14275 std::size_t operator ()std::hash14276 operator()( VULKAN_HPP_NAMESPACE::SamplerBlockMatchWindowCreateInfoQCOM const & samplerBlockMatchWindowCreateInfoQCOM ) const VULKAN_HPP_NOEXCEPT 14277 { 14278 std::size_t seed = 0; 14279 VULKAN_HPP_HASH_COMBINE( seed, samplerBlockMatchWindowCreateInfoQCOM.sType ); 14280 VULKAN_HPP_HASH_COMBINE( seed, samplerBlockMatchWindowCreateInfoQCOM.pNext ); 14281 VULKAN_HPP_HASH_COMBINE( seed, samplerBlockMatchWindowCreateInfoQCOM.windowExtent ); 14282 VULKAN_HPP_HASH_COMBINE( seed, samplerBlockMatchWindowCreateInfoQCOM.windowCompareMode ); 14283 return seed; 14284 } 14285 }; 14286 14287 template <> 14288 struct hash<VULKAN_HPP_NAMESPACE::SamplerBorderColorComponentMappingCreateInfoEXT> 14289 { operator ()std::hash14290 std::size_t operator()( 14291 VULKAN_HPP_NAMESPACE::SamplerBorderColorComponentMappingCreateInfoEXT const & samplerBorderColorComponentMappingCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 14292 { 14293 std::size_t seed = 0; 14294 VULKAN_HPP_HASH_COMBINE( seed, samplerBorderColorComponentMappingCreateInfoEXT.sType ); 14295 VULKAN_HPP_HASH_COMBINE( seed, samplerBorderColorComponentMappingCreateInfoEXT.pNext ); 14296 VULKAN_HPP_HASH_COMBINE( seed, samplerBorderColorComponentMappingCreateInfoEXT.components ); 14297 VULKAN_HPP_HASH_COMBINE( seed, samplerBorderColorComponentMappingCreateInfoEXT.srgb ); 14298 return seed; 14299 } 14300 }; 14301 14302 template <> 14303 struct hash<VULKAN_HPP_NAMESPACE::SamplerCaptureDescriptorDataInfoEXT> 14304 { operator ()std::hash14305 std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerCaptureDescriptorDataInfoEXT const & samplerCaptureDescriptorDataInfoEXT ) const VULKAN_HPP_NOEXCEPT 14306 { 14307 std::size_t seed = 0; 14308 VULKAN_HPP_HASH_COMBINE( seed, samplerCaptureDescriptorDataInfoEXT.sType ); 14309 VULKAN_HPP_HASH_COMBINE( seed, samplerCaptureDescriptorDataInfoEXT.pNext ); 14310 VULKAN_HPP_HASH_COMBINE( seed, samplerCaptureDescriptorDataInfoEXT.sampler ); 14311 return seed; 14312 } 14313 }; 14314 14315 template <> 14316 struct hash<VULKAN_HPP_NAMESPACE::SamplerCreateInfo> 14317 { operator ()std::hash14318 std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerCreateInfo const & samplerCreateInfo ) const VULKAN_HPP_NOEXCEPT 14319 { 14320 std::size_t seed = 0; 14321 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.sType ); 14322 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.pNext ); 14323 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.flags ); 14324 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.magFilter ); 14325 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.minFilter ); 14326 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.mipmapMode ); 14327 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.addressModeU ); 14328 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.addressModeV ); 14329 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.addressModeW ); 14330 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.mipLodBias ); 14331 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.anisotropyEnable ); 14332 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.maxAnisotropy ); 14333 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.compareEnable ); 14334 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.compareOp ); 14335 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.minLod ); 14336 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.maxLod ); 14337 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.borderColor ); 14338 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.unnormalizedCoordinates ); 14339 return seed; 14340 } 14341 }; 14342 14343 template <> 14344 struct hash<VULKAN_HPP_NAMESPACE::SamplerCubicWeightsCreateInfoQCOM> 14345 { operator ()std::hash14346 std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerCubicWeightsCreateInfoQCOM const & samplerCubicWeightsCreateInfoQCOM ) const VULKAN_HPP_NOEXCEPT 14347 { 14348 std::size_t seed = 0; 14349 VULKAN_HPP_HASH_COMBINE( seed, samplerCubicWeightsCreateInfoQCOM.sType ); 14350 VULKAN_HPP_HASH_COMBINE( seed, samplerCubicWeightsCreateInfoQCOM.pNext ); 14351 VULKAN_HPP_HASH_COMBINE( seed, samplerCubicWeightsCreateInfoQCOM.cubicWeights ); 14352 return seed; 14353 } 14354 }; 14355 14356 template <> 14357 struct hash<VULKAN_HPP_NAMESPACE::SamplerReductionModeCreateInfo> 14358 { operator ()std::hash14359 std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerReductionModeCreateInfo const & samplerReductionModeCreateInfo ) const VULKAN_HPP_NOEXCEPT 14360 { 14361 std::size_t seed = 0; 14362 VULKAN_HPP_HASH_COMBINE( seed, samplerReductionModeCreateInfo.sType ); 14363 VULKAN_HPP_HASH_COMBINE( seed, samplerReductionModeCreateInfo.pNext ); 14364 VULKAN_HPP_HASH_COMBINE( seed, samplerReductionModeCreateInfo.reductionMode ); 14365 return seed; 14366 } 14367 }; 14368 14369 template <> 14370 struct hash<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo> 14371 { operator ()std::hash14372 std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo const & samplerYcbcrConversionCreateInfo ) const VULKAN_HPP_NOEXCEPT 14373 { 14374 std::size_t seed = 0; 14375 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.sType ); 14376 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.pNext ); 14377 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.format ); 14378 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.ycbcrModel ); 14379 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.ycbcrRange ); 14380 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.components ); 14381 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.xChromaOffset ); 14382 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.yChromaOffset ); 14383 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.chromaFilter ); 14384 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.forceExplicitReconstruction ); 14385 return seed; 14386 } 14387 }; 14388 14389 template <> 14390 struct hash<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionImageFormatProperties> 14391 { operator ()std::hash14392 std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionImageFormatProperties const & samplerYcbcrConversionImageFormatProperties ) const 14393 VULKAN_HPP_NOEXCEPT 14394 { 14395 std::size_t seed = 0; 14396 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionImageFormatProperties.sType ); 14397 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionImageFormatProperties.pNext ); 14398 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionImageFormatProperties.combinedImageSamplerDescriptorCount ); 14399 return seed; 14400 } 14401 }; 14402 14403 template <> 14404 struct hash<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionInfo> 14405 { operator ()std::hash14406 std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionInfo const & samplerYcbcrConversionInfo ) const VULKAN_HPP_NOEXCEPT 14407 { 14408 std::size_t seed = 0; 14409 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionInfo.sType ); 14410 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionInfo.pNext ); 14411 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionInfo.conversion ); 14412 return seed; 14413 } 14414 }; 14415 14416 template <> 14417 struct hash<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM> 14418 { operator ()std::hash14419 std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM const & samplerYcbcrConversionYcbcrDegammaCreateInfoQCOM ) 14420 const VULKAN_HPP_NOEXCEPT 14421 { 14422 std::size_t seed = 0; 14423 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionYcbcrDegammaCreateInfoQCOM.sType ); 14424 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionYcbcrDegammaCreateInfoQCOM.pNext ); 14425 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionYcbcrDegammaCreateInfoQCOM.enableYDegamma ); 14426 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionYcbcrDegammaCreateInfoQCOM.enableCbCrDegamma ); 14427 return seed; 14428 } 14429 }; 14430 14431 # if defined( VK_USE_PLATFORM_SCREEN_QNX ) 14432 template <> 14433 struct hash<VULKAN_HPP_NAMESPACE::ScreenBufferFormatPropertiesQNX> 14434 { operator ()std::hash14435 std::size_t operator()( VULKAN_HPP_NAMESPACE::ScreenBufferFormatPropertiesQNX const & screenBufferFormatPropertiesQNX ) const VULKAN_HPP_NOEXCEPT 14436 { 14437 std::size_t seed = 0; 14438 VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.sType ); 14439 VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.pNext ); 14440 VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.format ); 14441 VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.externalFormat ); 14442 VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.screenUsage ); 14443 VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.formatFeatures ); 14444 VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.samplerYcbcrConversionComponents ); 14445 VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.suggestedYcbcrModel ); 14446 VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.suggestedYcbcrRange ); 14447 VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.suggestedXChromaOffset ); 14448 VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.suggestedYChromaOffset ); 14449 return seed; 14450 } 14451 }; 14452 # endif /*VK_USE_PLATFORM_SCREEN_QNX*/ 14453 14454 # if defined( VK_USE_PLATFORM_SCREEN_QNX ) 14455 template <> 14456 struct hash<VULKAN_HPP_NAMESPACE::ScreenBufferPropertiesQNX> 14457 { operator ()std::hash14458 std::size_t operator()( VULKAN_HPP_NAMESPACE::ScreenBufferPropertiesQNX const & screenBufferPropertiesQNX ) const VULKAN_HPP_NOEXCEPT 14459 { 14460 std::size_t seed = 0; 14461 VULKAN_HPP_HASH_COMBINE( seed, screenBufferPropertiesQNX.sType ); 14462 VULKAN_HPP_HASH_COMBINE( seed, screenBufferPropertiesQNX.pNext ); 14463 VULKAN_HPP_HASH_COMBINE( seed, screenBufferPropertiesQNX.allocationSize ); 14464 VULKAN_HPP_HASH_COMBINE( seed, screenBufferPropertiesQNX.memoryTypeBits ); 14465 return seed; 14466 } 14467 }; 14468 # endif /*VK_USE_PLATFORM_SCREEN_QNX*/ 14469 14470 # if defined( VK_USE_PLATFORM_SCREEN_QNX ) 14471 template <> 14472 struct hash<VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX> 14473 { operator ()std::hash14474 std::size_t operator()( VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX const & screenSurfaceCreateInfoQNX ) const VULKAN_HPP_NOEXCEPT 14475 { 14476 std::size_t seed = 0; 14477 VULKAN_HPP_HASH_COMBINE( seed, screenSurfaceCreateInfoQNX.sType ); 14478 VULKAN_HPP_HASH_COMBINE( seed, screenSurfaceCreateInfoQNX.pNext ); 14479 VULKAN_HPP_HASH_COMBINE( seed, screenSurfaceCreateInfoQNX.flags ); 14480 VULKAN_HPP_HASH_COMBINE( seed, screenSurfaceCreateInfoQNX.context ); 14481 VULKAN_HPP_HASH_COMBINE( seed, screenSurfaceCreateInfoQNX.window ); 14482 return seed; 14483 } 14484 }; 14485 # endif /*VK_USE_PLATFORM_SCREEN_QNX*/ 14486 14487 template <> 14488 struct hash<VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo> 14489 { operator ()std::hash14490 std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo const & semaphoreCreateInfo ) const VULKAN_HPP_NOEXCEPT 14491 { 14492 std::size_t seed = 0; 14493 VULKAN_HPP_HASH_COMBINE( seed, semaphoreCreateInfo.sType ); 14494 VULKAN_HPP_HASH_COMBINE( seed, semaphoreCreateInfo.pNext ); 14495 VULKAN_HPP_HASH_COMBINE( seed, semaphoreCreateInfo.flags ); 14496 return seed; 14497 } 14498 }; 14499 14500 template <> 14501 struct hash<VULKAN_HPP_NAMESPACE::SemaphoreGetFdInfoKHR> 14502 { operator ()std::hash14503 std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreGetFdInfoKHR const & semaphoreGetFdInfoKHR ) const VULKAN_HPP_NOEXCEPT 14504 { 14505 std::size_t seed = 0; 14506 VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetFdInfoKHR.sType ); 14507 VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetFdInfoKHR.pNext ); 14508 VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetFdInfoKHR.semaphore ); 14509 VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetFdInfoKHR.handleType ); 14510 return seed; 14511 } 14512 }; 14513 14514 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 14515 template <> 14516 struct hash<VULKAN_HPP_NAMESPACE::SemaphoreGetWin32HandleInfoKHR> 14517 { operator ()std::hash14518 std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreGetWin32HandleInfoKHR const & semaphoreGetWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT 14519 { 14520 std::size_t seed = 0; 14521 VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetWin32HandleInfoKHR.sType ); 14522 VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetWin32HandleInfoKHR.pNext ); 14523 VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetWin32HandleInfoKHR.semaphore ); 14524 VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetWin32HandleInfoKHR.handleType ); 14525 return seed; 14526 } 14527 }; 14528 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 14529 14530 # if defined( VK_USE_PLATFORM_FUCHSIA ) 14531 template <> 14532 struct hash<VULKAN_HPP_NAMESPACE::SemaphoreGetZirconHandleInfoFUCHSIA> 14533 { operator ()std::hash14534 std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreGetZirconHandleInfoFUCHSIA const & semaphoreGetZirconHandleInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT 14535 { 14536 std::size_t seed = 0; 14537 VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetZirconHandleInfoFUCHSIA.sType ); 14538 VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetZirconHandleInfoFUCHSIA.pNext ); 14539 VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetZirconHandleInfoFUCHSIA.semaphore ); 14540 VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetZirconHandleInfoFUCHSIA.handleType ); 14541 return seed; 14542 } 14543 }; 14544 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 14545 14546 template <> 14547 struct hash<VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo> 14548 { operator ()std::hash14549 std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo const & semaphoreSignalInfo ) const VULKAN_HPP_NOEXCEPT 14550 { 14551 std::size_t seed = 0; 14552 VULKAN_HPP_HASH_COMBINE( seed, semaphoreSignalInfo.sType ); 14553 VULKAN_HPP_HASH_COMBINE( seed, semaphoreSignalInfo.pNext ); 14554 VULKAN_HPP_HASH_COMBINE( seed, semaphoreSignalInfo.semaphore ); 14555 VULKAN_HPP_HASH_COMBINE( seed, semaphoreSignalInfo.value ); 14556 return seed; 14557 } 14558 }; 14559 14560 template <> 14561 struct hash<VULKAN_HPP_NAMESPACE::SemaphoreTypeCreateInfo> 14562 { operator ()std::hash14563 std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreTypeCreateInfo const & semaphoreTypeCreateInfo ) const VULKAN_HPP_NOEXCEPT 14564 { 14565 std::size_t seed = 0; 14566 VULKAN_HPP_HASH_COMBINE( seed, semaphoreTypeCreateInfo.sType ); 14567 VULKAN_HPP_HASH_COMBINE( seed, semaphoreTypeCreateInfo.pNext ); 14568 VULKAN_HPP_HASH_COMBINE( seed, semaphoreTypeCreateInfo.semaphoreType ); 14569 VULKAN_HPP_HASH_COMBINE( seed, semaphoreTypeCreateInfo.initialValue ); 14570 return seed; 14571 } 14572 }; 14573 14574 template <> 14575 struct hash<VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo> 14576 { operator ()std::hash14577 std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo const & semaphoreWaitInfo ) const VULKAN_HPP_NOEXCEPT 14578 { 14579 std::size_t seed = 0; 14580 VULKAN_HPP_HASH_COMBINE( seed, semaphoreWaitInfo.sType ); 14581 VULKAN_HPP_HASH_COMBINE( seed, semaphoreWaitInfo.pNext ); 14582 VULKAN_HPP_HASH_COMBINE( seed, semaphoreWaitInfo.flags ); 14583 VULKAN_HPP_HASH_COMBINE( seed, semaphoreWaitInfo.semaphoreCount ); 14584 VULKAN_HPP_HASH_COMBINE( seed, semaphoreWaitInfo.pSemaphores ); 14585 VULKAN_HPP_HASH_COMBINE( seed, semaphoreWaitInfo.pValues ); 14586 return seed; 14587 } 14588 }; 14589 14590 template <> 14591 struct hash<VULKAN_HPP_NAMESPACE::SetDescriptorBufferOffsetsInfoEXT> 14592 { operator ()std::hash14593 std::size_t operator()( VULKAN_HPP_NAMESPACE::SetDescriptorBufferOffsetsInfoEXT const & setDescriptorBufferOffsetsInfoEXT ) const VULKAN_HPP_NOEXCEPT 14594 { 14595 std::size_t seed = 0; 14596 VULKAN_HPP_HASH_COMBINE( seed, setDescriptorBufferOffsetsInfoEXT.sType ); 14597 VULKAN_HPP_HASH_COMBINE( seed, setDescriptorBufferOffsetsInfoEXT.pNext ); 14598 VULKAN_HPP_HASH_COMBINE( seed, setDescriptorBufferOffsetsInfoEXT.stageFlags ); 14599 VULKAN_HPP_HASH_COMBINE( seed, setDescriptorBufferOffsetsInfoEXT.layout ); 14600 VULKAN_HPP_HASH_COMBINE( seed, setDescriptorBufferOffsetsInfoEXT.firstSet ); 14601 VULKAN_HPP_HASH_COMBINE( seed, setDescriptorBufferOffsetsInfoEXT.setCount ); 14602 VULKAN_HPP_HASH_COMBINE( seed, setDescriptorBufferOffsetsInfoEXT.pBufferIndices ); 14603 VULKAN_HPP_HASH_COMBINE( seed, setDescriptorBufferOffsetsInfoEXT.pOffsets ); 14604 return seed; 14605 } 14606 }; 14607 14608 template <> 14609 struct hash<VULKAN_HPP_NAMESPACE::SetLatencyMarkerInfoNV> 14610 { operator ()std::hash14611 std::size_t operator()( VULKAN_HPP_NAMESPACE::SetLatencyMarkerInfoNV const & setLatencyMarkerInfoNV ) const VULKAN_HPP_NOEXCEPT 14612 { 14613 std::size_t seed = 0; 14614 VULKAN_HPP_HASH_COMBINE( seed, setLatencyMarkerInfoNV.sType ); 14615 VULKAN_HPP_HASH_COMBINE( seed, setLatencyMarkerInfoNV.pNext ); 14616 VULKAN_HPP_HASH_COMBINE( seed, setLatencyMarkerInfoNV.presentID ); 14617 VULKAN_HPP_HASH_COMBINE( seed, setLatencyMarkerInfoNV.marker ); 14618 return seed; 14619 } 14620 }; 14621 14622 template <> 14623 struct hash<VULKAN_HPP_NAMESPACE::SetStateFlagsIndirectCommandNV> 14624 { operator ()std::hash14625 std::size_t operator()( VULKAN_HPP_NAMESPACE::SetStateFlagsIndirectCommandNV const & setStateFlagsIndirectCommandNV ) const VULKAN_HPP_NOEXCEPT 14626 { 14627 std::size_t seed = 0; 14628 VULKAN_HPP_HASH_COMBINE( seed, setStateFlagsIndirectCommandNV.data ); 14629 return seed; 14630 } 14631 }; 14632 14633 template <> 14634 struct hash<VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT> 14635 { operator ()std::hash14636 std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT const & shaderCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 14637 { 14638 std::size_t seed = 0; 14639 VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.sType ); 14640 VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.pNext ); 14641 VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.flags ); 14642 VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.stage ); 14643 VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.nextStage ); 14644 VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.codeType ); 14645 VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.codeSize ); 14646 VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.pCode ); 14647 for ( const char * p = shaderCreateInfoEXT.pName; *p != '\0'; ++p ) 14648 { 14649 VULKAN_HPP_HASH_COMBINE( seed, *p ); 14650 } 14651 VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.setLayoutCount ); 14652 VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.pSetLayouts ); 14653 VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.pushConstantRangeCount ); 14654 VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.pPushConstantRanges ); 14655 VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.pSpecializationInfo ); 14656 return seed; 14657 } 14658 }; 14659 14660 template <> 14661 struct hash<VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo> 14662 { operator ()std::hash14663 std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo const & shaderModuleCreateInfo ) const VULKAN_HPP_NOEXCEPT 14664 { 14665 std::size_t seed = 0; 14666 VULKAN_HPP_HASH_COMBINE( seed, shaderModuleCreateInfo.sType ); 14667 VULKAN_HPP_HASH_COMBINE( seed, shaderModuleCreateInfo.pNext ); 14668 VULKAN_HPP_HASH_COMBINE( seed, shaderModuleCreateInfo.flags ); 14669 VULKAN_HPP_HASH_COMBINE( seed, shaderModuleCreateInfo.codeSize ); 14670 VULKAN_HPP_HASH_COMBINE( seed, shaderModuleCreateInfo.pCode ); 14671 return seed; 14672 } 14673 }; 14674 14675 template <> 14676 struct hash<VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT> 14677 { operator ()std::hash14678 std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT const & shaderModuleIdentifierEXT ) const VULKAN_HPP_NOEXCEPT 14679 { 14680 std::size_t seed = 0; 14681 VULKAN_HPP_HASH_COMBINE( seed, shaderModuleIdentifierEXT.sType ); 14682 VULKAN_HPP_HASH_COMBINE( seed, shaderModuleIdentifierEXT.pNext ); 14683 VULKAN_HPP_HASH_COMBINE( seed, shaderModuleIdentifierEXT.identifierSize ); 14684 for ( size_t i = 0; i < VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT; ++i ) 14685 { 14686 VULKAN_HPP_HASH_COMBINE( seed, shaderModuleIdentifierEXT.identifier[i] ); 14687 } 14688 return seed; 14689 } 14690 }; 14691 14692 template <> 14693 struct hash<VULKAN_HPP_NAMESPACE::ShaderModuleValidationCacheCreateInfoEXT> 14694 { 14695 std::size_t operator ()std::hash14696 operator()( VULKAN_HPP_NAMESPACE::ShaderModuleValidationCacheCreateInfoEXT const & shaderModuleValidationCacheCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 14697 { 14698 std::size_t seed = 0; 14699 VULKAN_HPP_HASH_COMBINE( seed, shaderModuleValidationCacheCreateInfoEXT.sType ); 14700 VULKAN_HPP_HASH_COMBINE( seed, shaderModuleValidationCacheCreateInfoEXT.pNext ); 14701 VULKAN_HPP_HASH_COMBINE( seed, shaderModuleValidationCacheCreateInfoEXT.validationCache ); 14702 return seed; 14703 } 14704 }; 14705 14706 template <> 14707 struct hash<VULKAN_HPP_NAMESPACE::ShaderResourceUsageAMD> 14708 { operator ()std::hash14709 std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderResourceUsageAMD const & shaderResourceUsageAMD ) const VULKAN_HPP_NOEXCEPT 14710 { 14711 std::size_t seed = 0; 14712 VULKAN_HPP_HASH_COMBINE( seed, shaderResourceUsageAMD.numUsedVgprs ); 14713 VULKAN_HPP_HASH_COMBINE( seed, shaderResourceUsageAMD.numUsedSgprs ); 14714 VULKAN_HPP_HASH_COMBINE( seed, shaderResourceUsageAMD.ldsSizePerLocalWorkGroup ); 14715 VULKAN_HPP_HASH_COMBINE( seed, shaderResourceUsageAMD.ldsUsageSizeInBytes ); 14716 VULKAN_HPP_HASH_COMBINE( seed, shaderResourceUsageAMD.scratchMemUsageInBytes ); 14717 return seed; 14718 } 14719 }; 14720 14721 template <> 14722 struct hash<VULKAN_HPP_NAMESPACE::ShaderStatisticsInfoAMD> 14723 { operator ()std::hash14724 std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderStatisticsInfoAMD const & shaderStatisticsInfoAMD ) const VULKAN_HPP_NOEXCEPT 14725 { 14726 std::size_t seed = 0; 14727 VULKAN_HPP_HASH_COMBINE( seed, shaderStatisticsInfoAMD.shaderStageMask ); 14728 VULKAN_HPP_HASH_COMBINE( seed, shaderStatisticsInfoAMD.resourceUsage ); 14729 VULKAN_HPP_HASH_COMBINE( seed, shaderStatisticsInfoAMD.numPhysicalVgprs ); 14730 VULKAN_HPP_HASH_COMBINE( seed, shaderStatisticsInfoAMD.numPhysicalSgprs ); 14731 VULKAN_HPP_HASH_COMBINE( seed, shaderStatisticsInfoAMD.numAvailableVgprs ); 14732 VULKAN_HPP_HASH_COMBINE( seed, shaderStatisticsInfoAMD.numAvailableSgprs ); 14733 for ( size_t i = 0; i < 3; ++i ) 14734 { 14735 VULKAN_HPP_HASH_COMBINE( seed, shaderStatisticsInfoAMD.computeWorkGroupSize[i] ); 14736 } 14737 return seed; 14738 } 14739 }; 14740 14741 template <> 14742 struct hash<VULKAN_HPP_NAMESPACE::SharedPresentSurfaceCapabilitiesKHR> 14743 { operator ()std::hash14744 std::size_t operator()( VULKAN_HPP_NAMESPACE::SharedPresentSurfaceCapabilitiesKHR const & sharedPresentSurfaceCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT 14745 { 14746 std::size_t seed = 0; 14747 VULKAN_HPP_HASH_COMBINE( seed, sharedPresentSurfaceCapabilitiesKHR.sType ); 14748 VULKAN_HPP_HASH_COMBINE( seed, sharedPresentSurfaceCapabilitiesKHR.pNext ); 14749 VULKAN_HPP_HASH_COMBINE( seed, sharedPresentSurfaceCapabilitiesKHR.sharedPresentSupportedUsageFlags ); 14750 return seed; 14751 } 14752 }; 14753 14754 template <> 14755 struct hash<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties> 14756 { operator ()std::hash14757 std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageFormatProperties const & sparseImageFormatProperties ) const VULKAN_HPP_NOEXCEPT 14758 { 14759 std::size_t seed = 0; 14760 VULKAN_HPP_HASH_COMBINE( seed, sparseImageFormatProperties.aspectMask ); 14761 VULKAN_HPP_HASH_COMBINE( seed, sparseImageFormatProperties.imageGranularity ); 14762 VULKAN_HPP_HASH_COMBINE( seed, sparseImageFormatProperties.flags ); 14763 return seed; 14764 } 14765 }; 14766 14767 template <> 14768 struct hash<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2> 14769 { operator ()std::hash14770 std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2 const & sparseImageFormatProperties2 ) const VULKAN_HPP_NOEXCEPT 14771 { 14772 std::size_t seed = 0; 14773 VULKAN_HPP_HASH_COMBINE( seed, sparseImageFormatProperties2.sType ); 14774 VULKAN_HPP_HASH_COMBINE( seed, sparseImageFormatProperties2.pNext ); 14775 VULKAN_HPP_HASH_COMBINE( seed, sparseImageFormatProperties2.properties ); 14776 return seed; 14777 } 14778 }; 14779 14780 template <> 14781 struct hash<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements> 14782 { operator ()std::hash14783 std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements const & sparseImageMemoryRequirements ) const VULKAN_HPP_NOEXCEPT 14784 { 14785 std::size_t seed = 0; 14786 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryRequirements.formatProperties ); 14787 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryRequirements.imageMipTailFirstLod ); 14788 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryRequirements.imageMipTailSize ); 14789 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryRequirements.imageMipTailOffset ); 14790 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryRequirements.imageMipTailStride ); 14791 return seed; 14792 } 14793 }; 14794 14795 template <> 14796 struct hash<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2> 14797 { operator ()std::hash14798 std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 const & sparseImageMemoryRequirements2 ) const VULKAN_HPP_NOEXCEPT 14799 { 14800 std::size_t seed = 0; 14801 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryRequirements2.sType ); 14802 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryRequirements2.pNext ); 14803 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryRequirements2.memoryRequirements ); 14804 return seed; 14805 } 14806 }; 14807 14808 # if defined( VK_USE_PLATFORM_GGP ) 14809 template <> 14810 struct hash<VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP> 14811 { operator ()std::hash14812 std::size_t operator()( VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP const & streamDescriptorSurfaceCreateInfoGGP ) const VULKAN_HPP_NOEXCEPT 14813 { 14814 std::size_t seed = 0; 14815 VULKAN_HPP_HASH_COMBINE( seed, streamDescriptorSurfaceCreateInfoGGP.sType ); 14816 VULKAN_HPP_HASH_COMBINE( seed, streamDescriptorSurfaceCreateInfoGGP.pNext ); 14817 VULKAN_HPP_HASH_COMBINE( seed, streamDescriptorSurfaceCreateInfoGGP.flags ); 14818 VULKAN_HPP_HASH_COMBINE( seed, streamDescriptorSurfaceCreateInfoGGP.streamDescriptor ); 14819 return seed; 14820 } 14821 }; 14822 # endif /*VK_USE_PLATFORM_GGP*/ 14823 14824 template <> 14825 struct hash<VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR> 14826 { operator ()std::hash14827 std::size_t operator()( VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR const & stridedDeviceAddressRegionKHR ) const VULKAN_HPP_NOEXCEPT 14828 { 14829 std::size_t seed = 0; 14830 VULKAN_HPP_HASH_COMBINE( seed, stridedDeviceAddressRegionKHR.deviceAddress ); 14831 VULKAN_HPP_HASH_COMBINE( seed, stridedDeviceAddressRegionKHR.stride ); 14832 VULKAN_HPP_HASH_COMBINE( seed, stridedDeviceAddressRegionKHR.size ); 14833 return seed; 14834 } 14835 }; 14836 14837 template <> 14838 struct hash<VULKAN_HPP_NAMESPACE::SubmitInfo> 14839 { operator ()std::hash14840 std::size_t operator()( VULKAN_HPP_NAMESPACE::SubmitInfo const & submitInfo ) const VULKAN_HPP_NOEXCEPT 14841 { 14842 std::size_t seed = 0; 14843 VULKAN_HPP_HASH_COMBINE( seed, submitInfo.sType ); 14844 VULKAN_HPP_HASH_COMBINE( seed, submitInfo.pNext ); 14845 VULKAN_HPP_HASH_COMBINE( seed, submitInfo.waitSemaphoreCount ); 14846 VULKAN_HPP_HASH_COMBINE( seed, submitInfo.pWaitSemaphores ); 14847 VULKAN_HPP_HASH_COMBINE( seed, submitInfo.pWaitDstStageMask ); 14848 VULKAN_HPP_HASH_COMBINE( seed, submitInfo.commandBufferCount ); 14849 VULKAN_HPP_HASH_COMBINE( seed, submitInfo.pCommandBuffers ); 14850 VULKAN_HPP_HASH_COMBINE( seed, submitInfo.signalSemaphoreCount ); 14851 VULKAN_HPP_HASH_COMBINE( seed, submitInfo.pSignalSemaphores ); 14852 return seed; 14853 } 14854 }; 14855 14856 template <> 14857 struct hash<VULKAN_HPP_NAMESPACE::SubmitInfo2> 14858 { operator ()std::hash14859 std::size_t operator()( VULKAN_HPP_NAMESPACE::SubmitInfo2 const & submitInfo2 ) const VULKAN_HPP_NOEXCEPT 14860 { 14861 std::size_t seed = 0; 14862 VULKAN_HPP_HASH_COMBINE( seed, submitInfo2.sType ); 14863 VULKAN_HPP_HASH_COMBINE( seed, submitInfo2.pNext ); 14864 VULKAN_HPP_HASH_COMBINE( seed, submitInfo2.flags ); 14865 VULKAN_HPP_HASH_COMBINE( seed, submitInfo2.waitSemaphoreInfoCount ); 14866 VULKAN_HPP_HASH_COMBINE( seed, submitInfo2.pWaitSemaphoreInfos ); 14867 VULKAN_HPP_HASH_COMBINE( seed, submitInfo2.commandBufferInfoCount ); 14868 VULKAN_HPP_HASH_COMBINE( seed, submitInfo2.pCommandBufferInfos ); 14869 VULKAN_HPP_HASH_COMBINE( seed, submitInfo2.signalSemaphoreInfoCount ); 14870 VULKAN_HPP_HASH_COMBINE( seed, submitInfo2.pSignalSemaphoreInfos ); 14871 return seed; 14872 } 14873 }; 14874 14875 template <> 14876 struct hash<VULKAN_HPP_NAMESPACE::SubpassBeginInfo> 14877 { operator ()std::hash14878 std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassBeginInfo const & subpassBeginInfo ) const VULKAN_HPP_NOEXCEPT 14879 { 14880 std::size_t seed = 0; 14881 VULKAN_HPP_HASH_COMBINE( seed, subpassBeginInfo.sType ); 14882 VULKAN_HPP_HASH_COMBINE( seed, subpassBeginInfo.pNext ); 14883 VULKAN_HPP_HASH_COMBINE( seed, subpassBeginInfo.contents ); 14884 return seed; 14885 } 14886 }; 14887 14888 template <> 14889 struct hash<VULKAN_HPP_NAMESPACE::SubpassDescriptionDepthStencilResolve> 14890 { 14891 std::size_t operator ()std::hash14892 operator()( VULKAN_HPP_NAMESPACE::SubpassDescriptionDepthStencilResolve const & subpassDescriptionDepthStencilResolve ) const VULKAN_HPP_NOEXCEPT 14893 { 14894 std::size_t seed = 0; 14895 VULKAN_HPP_HASH_COMBINE( seed, subpassDescriptionDepthStencilResolve.sType ); 14896 VULKAN_HPP_HASH_COMBINE( seed, subpassDescriptionDepthStencilResolve.pNext ); 14897 VULKAN_HPP_HASH_COMBINE( seed, subpassDescriptionDepthStencilResolve.depthResolveMode ); 14898 VULKAN_HPP_HASH_COMBINE( seed, subpassDescriptionDepthStencilResolve.stencilResolveMode ); 14899 VULKAN_HPP_HASH_COMBINE( seed, subpassDescriptionDepthStencilResolve.pDepthStencilResolveAttachment ); 14900 return seed; 14901 } 14902 }; 14903 14904 template <> 14905 struct hash<VULKAN_HPP_NAMESPACE::SubpassEndInfo> 14906 { operator ()std::hash14907 std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassEndInfo const & subpassEndInfo ) const VULKAN_HPP_NOEXCEPT 14908 { 14909 std::size_t seed = 0; 14910 VULKAN_HPP_HASH_COMBINE( seed, subpassEndInfo.sType ); 14911 VULKAN_HPP_HASH_COMBINE( seed, subpassEndInfo.pNext ); 14912 return seed; 14913 } 14914 }; 14915 14916 template <> 14917 struct hash<VULKAN_HPP_NAMESPACE::SubpassFragmentDensityMapOffsetEndInfoQCOM> 14918 { operator ()std::hash14919 std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassFragmentDensityMapOffsetEndInfoQCOM const & subpassFragmentDensityMapOffsetEndInfoQCOM ) const 14920 VULKAN_HPP_NOEXCEPT 14921 { 14922 std::size_t seed = 0; 14923 VULKAN_HPP_HASH_COMBINE( seed, subpassFragmentDensityMapOffsetEndInfoQCOM.sType ); 14924 VULKAN_HPP_HASH_COMBINE( seed, subpassFragmentDensityMapOffsetEndInfoQCOM.pNext ); 14925 VULKAN_HPP_HASH_COMBINE( seed, subpassFragmentDensityMapOffsetEndInfoQCOM.fragmentDensityOffsetCount ); 14926 VULKAN_HPP_HASH_COMBINE( seed, subpassFragmentDensityMapOffsetEndInfoQCOM.pFragmentDensityOffsets ); 14927 return seed; 14928 } 14929 }; 14930 14931 template <> 14932 struct hash<VULKAN_HPP_NAMESPACE::SubpassResolvePerformanceQueryEXT> 14933 { operator ()std::hash14934 std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassResolvePerformanceQueryEXT const & subpassResolvePerformanceQueryEXT ) const VULKAN_HPP_NOEXCEPT 14935 { 14936 std::size_t seed = 0; 14937 VULKAN_HPP_HASH_COMBINE( seed, subpassResolvePerformanceQueryEXT.sType ); 14938 VULKAN_HPP_HASH_COMBINE( seed, subpassResolvePerformanceQueryEXT.pNext ); 14939 VULKAN_HPP_HASH_COMBINE( seed, subpassResolvePerformanceQueryEXT.optimal ); 14940 return seed; 14941 } 14942 }; 14943 14944 template <> 14945 struct hash<VULKAN_HPP_NAMESPACE::SubpassShadingPipelineCreateInfoHUAWEI> 14946 { 14947 std::size_t operator ()std::hash14948 operator()( VULKAN_HPP_NAMESPACE::SubpassShadingPipelineCreateInfoHUAWEI const & subpassShadingPipelineCreateInfoHUAWEI ) const VULKAN_HPP_NOEXCEPT 14949 { 14950 std::size_t seed = 0; 14951 VULKAN_HPP_HASH_COMBINE( seed, subpassShadingPipelineCreateInfoHUAWEI.sType ); 14952 VULKAN_HPP_HASH_COMBINE( seed, subpassShadingPipelineCreateInfoHUAWEI.pNext ); 14953 VULKAN_HPP_HASH_COMBINE( seed, subpassShadingPipelineCreateInfoHUAWEI.renderPass ); 14954 VULKAN_HPP_HASH_COMBINE( seed, subpassShadingPipelineCreateInfoHUAWEI.subpass ); 14955 return seed; 14956 } 14957 }; 14958 14959 template <> 14960 struct hash<VULKAN_HPP_NAMESPACE::SubresourceHostMemcpySizeEXT> 14961 { operator ()std::hash14962 std::size_t operator()( VULKAN_HPP_NAMESPACE::SubresourceHostMemcpySizeEXT const & subresourceHostMemcpySizeEXT ) const VULKAN_HPP_NOEXCEPT 14963 { 14964 std::size_t seed = 0; 14965 VULKAN_HPP_HASH_COMBINE( seed, subresourceHostMemcpySizeEXT.sType ); 14966 VULKAN_HPP_HASH_COMBINE( seed, subresourceHostMemcpySizeEXT.pNext ); 14967 VULKAN_HPP_HASH_COMBINE( seed, subresourceHostMemcpySizeEXT.size ); 14968 return seed; 14969 } 14970 }; 14971 14972 template <> 14973 struct hash<VULKAN_HPP_NAMESPACE::SubresourceLayout2KHR> 14974 { operator ()std::hash14975 std::size_t operator()( VULKAN_HPP_NAMESPACE::SubresourceLayout2KHR const & subresourceLayout2KHR ) const VULKAN_HPP_NOEXCEPT 14976 { 14977 std::size_t seed = 0; 14978 VULKAN_HPP_HASH_COMBINE( seed, subresourceLayout2KHR.sType ); 14979 VULKAN_HPP_HASH_COMBINE( seed, subresourceLayout2KHR.pNext ); 14980 VULKAN_HPP_HASH_COMBINE( seed, subresourceLayout2KHR.subresourceLayout ); 14981 return seed; 14982 } 14983 }; 14984 14985 template <> 14986 struct hash<VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT> 14987 { operator ()std::hash14988 std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT const & surfaceCapabilities2EXT ) const VULKAN_HPP_NOEXCEPT 14989 { 14990 std::size_t seed = 0; 14991 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.sType ); 14992 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.pNext ); 14993 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.minImageCount ); 14994 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.maxImageCount ); 14995 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.currentExtent ); 14996 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.minImageExtent ); 14997 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.maxImageExtent ); 14998 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.maxImageArrayLayers ); 14999 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.supportedTransforms ); 15000 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.currentTransform ); 15001 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.supportedCompositeAlpha ); 15002 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.supportedUsageFlags ); 15003 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.supportedSurfaceCounters ); 15004 return seed; 15005 } 15006 }; 15007 15008 template <> 15009 struct hash<VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR> 15010 { operator ()std::hash15011 std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR const & surfaceCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT 15012 { 15013 std::size_t seed = 0; 15014 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.minImageCount ); 15015 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.maxImageCount ); 15016 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.currentExtent ); 15017 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.minImageExtent ); 15018 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.maxImageExtent ); 15019 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.maxImageArrayLayers ); 15020 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.supportedTransforms ); 15021 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.currentTransform ); 15022 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.supportedCompositeAlpha ); 15023 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.supportedUsageFlags ); 15024 return seed; 15025 } 15026 }; 15027 15028 template <> 15029 struct hash<VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR> 15030 { operator ()std::hash15031 std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR const & surfaceCapabilities2KHR ) const VULKAN_HPP_NOEXCEPT 15032 { 15033 std::size_t seed = 0; 15034 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2KHR.sType ); 15035 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2KHR.pNext ); 15036 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2KHR.surfaceCapabilities ); 15037 return seed; 15038 } 15039 }; 15040 15041 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 15042 template <> 15043 struct hash<VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesFullScreenExclusiveEXT> 15044 { 15045 std::size_t operator ()std::hash15046 operator()( VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesFullScreenExclusiveEXT const & surfaceCapabilitiesFullScreenExclusiveEXT ) const VULKAN_HPP_NOEXCEPT 15047 { 15048 std::size_t seed = 0; 15049 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesFullScreenExclusiveEXT.sType ); 15050 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesFullScreenExclusiveEXT.pNext ); 15051 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesFullScreenExclusiveEXT.fullScreenExclusiveSupported ); 15052 return seed; 15053 } 15054 }; 15055 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 15056 15057 template <> 15058 struct hash<VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesPresentBarrierNV> 15059 { operator ()std::hash15060 std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesPresentBarrierNV const & surfaceCapabilitiesPresentBarrierNV ) const VULKAN_HPP_NOEXCEPT 15061 { 15062 std::size_t seed = 0; 15063 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesPresentBarrierNV.sType ); 15064 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesPresentBarrierNV.pNext ); 15065 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesPresentBarrierNV.presentBarrierSupported ); 15066 return seed; 15067 } 15068 }; 15069 15070 template <> 15071 struct hash<VULKAN_HPP_NAMESPACE::SurfaceFormatKHR> 15072 { operator ()std::hash15073 std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceFormatKHR const & surfaceFormatKHR ) const VULKAN_HPP_NOEXCEPT 15074 { 15075 std::size_t seed = 0; 15076 VULKAN_HPP_HASH_COMBINE( seed, surfaceFormatKHR.format ); 15077 VULKAN_HPP_HASH_COMBINE( seed, surfaceFormatKHR.colorSpace ); 15078 return seed; 15079 } 15080 }; 15081 15082 template <> 15083 struct hash<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR> 15084 { operator ()std::hash15085 std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR const & surfaceFormat2KHR ) const VULKAN_HPP_NOEXCEPT 15086 { 15087 std::size_t seed = 0; 15088 VULKAN_HPP_HASH_COMBINE( seed, surfaceFormat2KHR.sType ); 15089 VULKAN_HPP_HASH_COMBINE( seed, surfaceFormat2KHR.pNext ); 15090 VULKAN_HPP_HASH_COMBINE( seed, surfaceFormat2KHR.surfaceFormat ); 15091 return seed; 15092 } 15093 }; 15094 15095 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 15096 template <> 15097 struct hash<VULKAN_HPP_NAMESPACE::SurfaceFullScreenExclusiveInfoEXT> 15098 { operator ()std::hash15099 std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceFullScreenExclusiveInfoEXT const & surfaceFullScreenExclusiveInfoEXT ) const VULKAN_HPP_NOEXCEPT 15100 { 15101 std::size_t seed = 0; 15102 VULKAN_HPP_HASH_COMBINE( seed, surfaceFullScreenExclusiveInfoEXT.sType ); 15103 VULKAN_HPP_HASH_COMBINE( seed, surfaceFullScreenExclusiveInfoEXT.pNext ); 15104 VULKAN_HPP_HASH_COMBINE( seed, surfaceFullScreenExclusiveInfoEXT.fullScreenExclusive ); 15105 return seed; 15106 } 15107 }; 15108 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 15109 15110 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 15111 template <> 15112 struct hash<VULKAN_HPP_NAMESPACE::SurfaceFullScreenExclusiveWin32InfoEXT> 15113 { 15114 std::size_t operator ()std::hash15115 operator()( VULKAN_HPP_NAMESPACE::SurfaceFullScreenExclusiveWin32InfoEXT const & surfaceFullScreenExclusiveWin32InfoEXT ) const VULKAN_HPP_NOEXCEPT 15116 { 15117 std::size_t seed = 0; 15118 VULKAN_HPP_HASH_COMBINE( seed, surfaceFullScreenExclusiveWin32InfoEXT.sType ); 15119 VULKAN_HPP_HASH_COMBINE( seed, surfaceFullScreenExclusiveWin32InfoEXT.pNext ); 15120 VULKAN_HPP_HASH_COMBINE( seed, surfaceFullScreenExclusiveWin32InfoEXT.hmonitor ); 15121 return seed; 15122 } 15123 }; 15124 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 15125 15126 template <> 15127 struct hash<VULKAN_HPP_NAMESPACE::SurfacePresentModeCompatibilityEXT> 15128 { operator ()std::hash15129 std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfacePresentModeCompatibilityEXT const & surfacePresentModeCompatibilityEXT ) const VULKAN_HPP_NOEXCEPT 15130 { 15131 std::size_t seed = 0; 15132 VULKAN_HPP_HASH_COMBINE( seed, surfacePresentModeCompatibilityEXT.sType ); 15133 VULKAN_HPP_HASH_COMBINE( seed, surfacePresentModeCompatibilityEXT.pNext ); 15134 VULKAN_HPP_HASH_COMBINE( seed, surfacePresentModeCompatibilityEXT.presentModeCount ); 15135 VULKAN_HPP_HASH_COMBINE( seed, surfacePresentModeCompatibilityEXT.pPresentModes ); 15136 return seed; 15137 } 15138 }; 15139 15140 template <> 15141 struct hash<VULKAN_HPP_NAMESPACE::SurfacePresentModeEXT> 15142 { operator ()std::hash15143 std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfacePresentModeEXT const & surfacePresentModeEXT ) const VULKAN_HPP_NOEXCEPT 15144 { 15145 std::size_t seed = 0; 15146 VULKAN_HPP_HASH_COMBINE( seed, surfacePresentModeEXT.sType ); 15147 VULKAN_HPP_HASH_COMBINE( seed, surfacePresentModeEXT.pNext ); 15148 VULKAN_HPP_HASH_COMBINE( seed, surfacePresentModeEXT.presentMode ); 15149 return seed; 15150 } 15151 }; 15152 15153 template <> 15154 struct hash<VULKAN_HPP_NAMESPACE::SurfacePresentScalingCapabilitiesEXT> 15155 { operator ()std::hash15156 std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfacePresentScalingCapabilitiesEXT const & surfacePresentScalingCapabilitiesEXT ) const VULKAN_HPP_NOEXCEPT 15157 { 15158 std::size_t seed = 0; 15159 VULKAN_HPP_HASH_COMBINE( seed, surfacePresentScalingCapabilitiesEXT.sType ); 15160 VULKAN_HPP_HASH_COMBINE( seed, surfacePresentScalingCapabilitiesEXT.pNext ); 15161 VULKAN_HPP_HASH_COMBINE( seed, surfacePresentScalingCapabilitiesEXT.supportedPresentScaling ); 15162 VULKAN_HPP_HASH_COMBINE( seed, surfacePresentScalingCapabilitiesEXT.supportedPresentGravityX ); 15163 VULKAN_HPP_HASH_COMBINE( seed, surfacePresentScalingCapabilitiesEXT.supportedPresentGravityY ); 15164 VULKAN_HPP_HASH_COMBINE( seed, surfacePresentScalingCapabilitiesEXT.minScaledImageExtent ); 15165 VULKAN_HPP_HASH_COMBINE( seed, surfacePresentScalingCapabilitiesEXT.maxScaledImageExtent ); 15166 return seed; 15167 } 15168 }; 15169 15170 template <> 15171 struct hash<VULKAN_HPP_NAMESPACE::SurfaceProtectedCapabilitiesKHR> 15172 { operator ()std::hash15173 std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceProtectedCapabilitiesKHR const & surfaceProtectedCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT 15174 { 15175 std::size_t seed = 0; 15176 VULKAN_HPP_HASH_COMBINE( seed, surfaceProtectedCapabilitiesKHR.sType ); 15177 VULKAN_HPP_HASH_COMBINE( seed, surfaceProtectedCapabilitiesKHR.pNext ); 15178 VULKAN_HPP_HASH_COMBINE( seed, surfaceProtectedCapabilitiesKHR.supportsProtected ); 15179 return seed; 15180 } 15181 }; 15182 15183 template <> 15184 struct hash<VULKAN_HPP_NAMESPACE::SwapchainCounterCreateInfoEXT> 15185 { operator ()std::hash15186 std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainCounterCreateInfoEXT const & swapchainCounterCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 15187 { 15188 std::size_t seed = 0; 15189 VULKAN_HPP_HASH_COMBINE( seed, swapchainCounterCreateInfoEXT.sType ); 15190 VULKAN_HPP_HASH_COMBINE( seed, swapchainCounterCreateInfoEXT.pNext ); 15191 VULKAN_HPP_HASH_COMBINE( seed, swapchainCounterCreateInfoEXT.surfaceCounters ); 15192 return seed; 15193 } 15194 }; 15195 15196 template <> 15197 struct hash<VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> 15198 { operator ()std::hash15199 std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR const & swapchainCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 15200 { 15201 std::size_t seed = 0; 15202 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.sType ); 15203 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.pNext ); 15204 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.flags ); 15205 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.surface ); 15206 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.minImageCount ); 15207 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.imageFormat ); 15208 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.imageColorSpace ); 15209 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.imageExtent ); 15210 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.imageArrayLayers ); 15211 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.imageUsage ); 15212 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.imageSharingMode ); 15213 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.queueFamilyIndexCount ); 15214 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.pQueueFamilyIndices ); 15215 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.preTransform ); 15216 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.compositeAlpha ); 15217 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.presentMode ); 15218 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.clipped ); 15219 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.oldSwapchain ); 15220 return seed; 15221 } 15222 }; 15223 15224 template <> 15225 struct hash<VULKAN_HPP_NAMESPACE::SwapchainDisplayNativeHdrCreateInfoAMD> 15226 { 15227 std::size_t operator ()std::hash15228 operator()( VULKAN_HPP_NAMESPACE::SwapchainDisplayNativeHdrCreateInfoAMD const & swapchainDisplayNativeHdrCreateInfoAMD ) const VULKAN_HPP_NOEXCEPT 15229 { 15230 std::size_t seed = 0; 15231 VULKAN_HPP_HASH_COMBINE( seed, swapchainDisplayNativeHdrCreateInfoAMD.sType ); 15232 VULKAN_HPP_HASH_COMBINE( seed, swapchainDisplayNativeHdrCreateInfoAMD.pNext ); 15233 VULKAN_HPP_HASH_COMBINE( seed, swapchainDisplayNativeHdrCreateInfoAMD.localDimmingEnable ); 15234 return seed; 15235 } 15236 }; 15237 15238 template <> 15239 struct hash<VULKAN_HPP_NAMESPACE::SwapchainLatencyCreateInfoNV> 15240 { operator ()std::hash15241 std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainLatencyCreateInfoNV const & swapchainLatencyCreateInfoNV ) const VULKAN_HPP_NOEXCEPT 15242 { 15243 std::size_t seed = 0; 15244 VULKAN_HPP_HASH_COMBINE( seed, swapchainLatencyCreateInfoNV.sType ); 15245 VULKAN_HPP_HASH_COMBINE( seed, swapchainLatencyCreateInfoNV.pNext ); 15246 VULKAN_HPP_HASH_COMBINE( seed, swapchainLatencyCreateInfoNV.latencyModeEnable ); 15247 return seed; 15248 } 15249 }; 15250 15251 template <> 15252 struct hash<VULKAN_HPP_NAMESPACE::SwapchainPresentBarrierCreateInfoNV> 15253 { operator ()std::hash15254 std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainPresentBarrierCreateInfoNV const & swapchainPresentBarrierCreateInfoNV ) const VULKAN_HPP_NOEXCEPT 15255 { 15256 std::size_t seed = 0; 15257 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentBarrierCreateInfoNV.sType ); 15258 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentBarrierCreateInfoNV.pNext ); 15259 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentBarrierCreateInfoNV.presentBarrierEnable ); 15260 return seed; 15261 } 15262 }; 15263 15264 template <> 15265 struct hash<VULKAN_HPP_NAMESPACE::SwapchainPresentFenceInfoEXT> 15266 { operator ()std::hash15267 std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainPresentFenceInfoEXT const & swapchainPresentFenceInfoEXT ) const VULKAN_HPP_NOEXCEPT 15268 { 15269 std::size_t seed = 0; 15270 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentFenceInfoEXT.sType ); 15271 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentFenceInfoEXT.pNext ); 15272 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentFenceInfoEXT.swapchainCount ); 15273 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentFenceInfoEXT.pFences ); 15274 return seed; 15275 } 15276 }; 15277 15278 template <> 15279 struct hash<VULKAN_HPP_NAMESPACE::SwapchainPresentModeInfoEXT> 15280 { operator ()std::hash15281 std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainPresentModeInfoEXT const & swapchainPresentModeInfoEXT ) const VULKAN_HPP_NOEXCEPT 15282 { 15283 std::size_t seed = 0; 15284 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentModeInfoEXT.sType ); 15285 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentModeInfoEXT.pNext ); 15286 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentModeInfoEXT.swapchainCount ); 15287 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentModeInfoEXT.pPresentModes ); 15288 return seed; 15289 } 15290 }; 15291 15292 template <> 15293 struct hash<VULKAN_HPP_NAMESPACE::SwapchainPresentModesCreateInfoEXT> 15294 { operator ()std::hash15295 std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainPresentModesCreateInfoEXT const & swapchainPresentModesCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 15296 { 15297 std::size_t seed = 0; 15298 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentModesCreateInfoEXT.sType ); 15299 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentModesCreateInfoEXT.pNext ); 15300 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentModesCreateInfoEXT.presentModeCount ); 15301 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentModesCreateInfoEXT.pPresentModes ); 15302 return seed; 15303 } 15304 }; 15305 15306 template <> 15307 struct hash<VULKAN_HPP_NAMESPACE::SwapchainPresentScalingCreateInfoEXT> 15308 { operator ()std::hash15309 std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainPresentScalingCreateInfoEXT const & swapchainPresentScalingCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 15310 { 15311 std::size_t seed = 0; 15312 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentScalingCreateInfoEXT.sType ); 15313 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentScalingCreateInfoEXT.pNext ); 15314 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentScalingCreateInfoEXT.scalingBehavior ); 15315 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentScalingCreateInfoEXT.presentGravityX ); 15316 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentScalingCreateInfoEXT.presentGravityY ); 15317 return seed; 15318 } 15319 }; 15320 15321 template <> 15322 struct hash<VULKAN_HPP_NAMESPACE::TextureLODGatherFormatPropertiesAMD> 15323 { operator ()std::hash15324 std::size_t operator()( VULKAN_HPP_NAMESPACE::TextureLODGatherFormatPropertiesAMD const & textureLODGatherFormatPropertiesAMD ) const VULKAN_HPP_NOEXCEPT 15325 { 15326 std::size_t seed = 0; 15327 VULKAN_HPP_HASH_COMBINE( seed, textureLODGatherFormatPropertiesAMD.sType ); 15328 VULKAN_HPP_HASH_COMBINE( seed, textureLODGatherFormatPropertiesAMD.pNext ); 15329 VULKAN_HPP_HASH_COMBINE( seed, textureLODGatherFormatPropertiesAMD.supportsTextureGatherLODBiasAMD ); 15330 return seed; 15331 } 15332 }; 15333 15334 template <> 15335 struct hash<VULKAN_HPP_NAMESPACE::TilePropertiesQCOM> 15336 { operator ()std::hash15337 std::size_t operator()( VULKAN_HPP_NAMESPACE::TilePropertiesQCOM const & tilePropertiesQCOM ) const VULKAN_HPP_NOEXCEPT 15338 { 15339 std::size_t seed = 0; 15340 VULKAN_HPP_HASH_COMBINE( seed, tilePropertiesQCOM.sType ); 15341 VULKAN_HPP_HASH_COMBINE( seed, tilePropertiesQCOM.pNext ); 15342 VULKAN_HPP_HASH_COMBINE( seed, tilePropertiesQCOM.tileSize ); 15343 VULKAN_HPP_HASH_COMBINE( seed, tilePropertiesQCOM.apronSize ); 15344 VULKAN_HPP_HASH_COMBINE( seed, tilePropertiesQCOM.origin ); 15345 return seed; 15346 } 15347 }; 15348 15349 template <> 15350 struct hash<VULKAN_HPP_NAMESPACE::TimelineSemaphoreSubmitInfo> 15351 { operator ()std::hash15352 std::size_t operator()( VULKAN_HPP_NAMESPACE::TimelineSemaphoreSubmitInfo const & timelineSemaphoreSubmitInfo ) const VULKAN_HPP_NOEXCEPT 15353 { 15354 std::size_t seed = 0; 15355 VULKAN_HPP_HASH_COMBINE( seed, timelineSemaphoreSubmitInfo.sType ); 15356 VULKAN_HPP_HASH_COMBINE( seed, timelineSemaphoreSubmitInfo.pNext ); 15357 VULKAN_HPP_HASH_COMBINE( seed, timelineSemaphoreSubmitInfo.waitSemaphoreValueCount ); 15358 VULKAN_HPP_HASH_COMBINE( seed, timelineSemaphoreSubmitInfo.pWaitSemaphoreValues ); 15359 VULKAN_HPP_HASH_COMBINE( seed, timelineSemaphoreSubmitInfo.signalSemaphoreValueCount ); 15360 VULKAN_HPP_HASH_COMBINE( seed, timelineSemaphoreSubmitInfo.pSignalSemaphoreValues ); 15361 return seed; 15362 } 15363 }; 15364 15365 template <> 15366 struct hash<VULKAN_HPP_NAMESPACE::TraceRaysIndirectCommand2KHR> 15367 { operator ()std::hash15368 std::size_t operator()( VULKAN_HPP_NAMESPACE::TraceRaysIndirectCommand2KHR const & traceRaysIndirectCommand2KHR ) const VULKAN_HPP_NOEXCEPT 15369 { 15370 std::size_t seed = 0; 15371 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.raygenShaderRecordAddress ); 15372 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.raygenShaderRecordSize ); 15373 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.missShaderBindingTableAddress ); 15374 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.missShaderBindingTableSize ); 15375 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.missShaderBindingTableStride ); 15376 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.hitShaderBindingTableAddress ); 15377 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.hitShaderBindingTableSize ); 15378 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.hitShaderBindingTableStride ); 15379 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.callableShaderBindingTableAddress ); 15380 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.callableShaderBindingTableSize ); 15381 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.callableShaderBindingTableStride ); 15382 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.width ); 15383 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.height ); 15384 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.depth ); 15385 return seed; 15386 } 15387 }; 15388 15389 template <> 15390 struct hash<VULKAN_HPP_NAMESPACE::TraceRaysIndirectCommandKHR> 15391 { operator ()std::hash15392 std::size_t operator()( VULKAN_HPP_NAMESPACE::TraceRaysIndirectCommandKHR const & traceRaysIndirectCommandKHR ) const VULKAN_HPP_NOEXCEPT 15393 { 15394 std::size_t seed = 0; 15395 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommandKHR.width ); 15396 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommandKHR.height ); 15397 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommandKHR.depth ); 15398 return seed; 15399 } 15400 }; 15401 15402 template <> 15403 struct hash<VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT> 15404 { operator ()std::hash15405 std::size_t operator()( VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT const & validationCacheCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 15406 { 15407 std::size_t seed = 0; 15408 VULKAN_HPP_HASH_COMBINE( seed, validationCacheCreateInfoEXT.sType ); 15409 VULKAN_HPP_HASH_COMBINE( seed, validationCacheCreateInfoEXT.pNext ); 15410 VULKAN_HPP_HASH_COMBINE( seed, validationCacheCreateInfoEXT.flags ); 15411 VULKAN_HPP_HASH_COMBINE( seed, validationCacheCreateInfoEXT.initialDataSize ); 15412 VULKAN_HPP_HASH_COMBINE( seed, validationCacheCreateInfoEXT.pInitialData ); 15413 return seed; 15414 } 15415 }; 15416 15417 template <> 15418 struct hash<VULKAN_HPP_NAMESPACE::ValidationFeaturesEXT> 15419 { operator ()std::hash15420 std::size_t operator()( VULKAN_HPP_NAMESPACE::ValidationFeaturesEXT const & validationFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 15421 { 15422 std::size_t seed = 0; 15423 VULKAN_HPP_HASH_COMBINE( seed, validationFeaturesEXT.sType ); 15424 VULKAN_HPP_HASH_COMBINE( seed, validationFeaturesEXT.pNext ); 15425 VULKAN_HPP_HASH_COMBINE( seed, validationFeaturesEXT.enabledValidationFeatureCount ); 15426 VULKAN_HPP_HASH_COMBINE( seed, validationFeaturesEXT.pEnabledValidationFeatures ); 15427 VULKAN_HPP_HASH_COMBINE( seed, validationFeaturesEXT.disabledValidationFeatureCount ); 15428 VULKAN_HPP_HASH_COMBINE( seed, validationFeaturesEXT.pDisabledValidationFeatures ); 15429 return seed; 15430 } 15431 }; 15432 15433 template <> 15434 struct hash<VULKAN_HPP_NAMESPACE::ValidationFlagsEXT> 15435 { operator ()std::hash15436 std::size_t operator()( VULKAN_HPP_NAMESPACE::ValidationFlagsEXT const & validationFlagsEXT ) const VULKAN_HPP_NOEXCEPT 15437 { 15438 std::size_t seed = 0; 15439 VULKAN_HPP_HASH_COMBINE( seed, validationFlagsEXT.sType ); 15440 VULKAN_HPP_HASH_COMBINE( seed, validationFlagsEXT.pNext ); 15441 VULKAN_HPP_HASH_COMBINE( seed, validationFlagsEXT.disabledValidationCheckCount ); 15442 VULKAN_HPP_HASH_COMBINE( seed, validationFlagsEXT.pDisabledValidationChecks ); 15443 return seed; 15444 } 15445 }; 15446 15447 template <> 15448 struct hash<VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT> 15449 { operator ()std::hash15450 std::size_t operator()( VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT const & vertexInputAttributeDescription2EXT ) const VULKAN_HPP_NOEXCEPT 15451 { 15452 std::size_t seed = 0; 15453 VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription2EXT.sType ); 15454 VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription2EXT.pNext ); 15455 VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription2EXT.location ); 15456 VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription2EXT.binding ); 15457 VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription2EXT.format ); 15458 VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription2EXT.offset ); 15459 return seed; 15460 } 15461 }; 15462 15463 template <> 15464 struct hash<VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT> 15465 { operator ()std::hash15466 std::size_t operator()( VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT const & vertexInputBindingDescription2EXT ) const VULKAN_HPP_NOEXCEPT 15467 { 15468 std::size_t seed = 0; 15469 VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDescription2EXT.sType ); 15470 VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDescription2EXT.pNext ); 15471 VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDescription2EXT.binding ); 15472 VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDescription2EXT.stride ); 15473 VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDescription2EXT.inputRate ); 15474 VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDescription2EXT.divisor ); 15475 return seed; 15476 } 15477 }; 15478 15479 # if defined( VK_USE_PLATFORM_VI_NN ) 15480 template <> 15481 struct hash<VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN> 15482 { operator ()std::hash15483 std::size_t operator()( VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN const & viSurfaceCreateInfoNN ) const VULKAN_HPP_NOEXCEPT 15484 { 15485 std::size_t seed = 0; 15486 VULKAN_HPP_HASH_COMBINE( seed, viSurfaceCreateInfoNN.sType ); 15487 VULKAN_HPP_HASH_COMBINE( seed, viSurfaceCreateInfoNN.pNext ); 15488 VULKAN_HPP_HASH_COMBINE( seed, viSurfaceCreateInfoNN.flags ); 15489 VULKAN_HPP_HASH_COMBINE( seed, viSurfaceCreateInfoNN.window ); 15490 return seed; 15491 } 15492 }; 15493 # endif /*VK_USE_PLATFORM_VI_NN*/ 15494 15495 template <> 15496 struct hash<VULKAN_HPP_NAMESPACE::VideoPictureResourceInfoKHR> 15497 { operator ()std::hash15498 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoPictureResourceInfoKHR const & videoPictureResourceInfoKHR ) const VULKAN_HPP_NOEXCEPT 15499 { 15500 std::size_t seed = 0; 15501 VULKAN_HPP_HASH_COMBINE( seed, videoPictureResourceInfoKHR.sType ); 15502 VULKAN_HPP_HASH_COMBINE( seed, videoPictureResourceInfoKHR.pNext ); 15503 VULKAN_HPP_HASH_COMBINE( seed, videoPictureResourceInfoKHR.codedOffset ); 15504 VULKAN_HPP_HASH_COMBINE( seed, videoPictureResourceInfoKHR.codedExtent ); 15505 VULKAN_HPP_HASH_COMBINE( seed, videoPictureResourceInfoKHR.baseArrayLayer ); 15506 VULKAN_HPP_HASH_COMBINE( seed, videoPictureResourceInfoKHR.imageViewBinding ); 15507 return seed; 15508 } 15509 }; 15510 15511 template <> 15512 struct hash<VULKAN_HPP_NAMESPACE::VideoReferenceSlotInfoKHR> 15513 { operator ()std::hash15514 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoReferenceSlotInfoKHR const & videoReferenceSlotInfoKHR ) const VULKAN_HPP_NOEXCEPT 15515 { 15516 std::size_t seed = 0; 15517 VULKAN_HPP_HASH_COMBINE( seed, videoReferenceSlotInfoKHR.sType ); 15518 VULKAN_HPP_HASH_COMBINE( seed, videoReferenceSlotInfoKHR.pNext ); 15519 VULKAN_HPP_HASH_COMBINE( seed, videoReferenceSlotInfoKHR.slotIndex ); 15520 VULKAN_HPP_HASH_COMBINE( seed, videoReferenceSlotInfoKHR.pPictureResource ); 15521 return seed; 15522 } 15523 }; 15524 15525 template <> 15526 struct hash<VULKAN_HPP_NAMESPACE::VideoBeginCodingInfoKHR> 15527 { operator ()std::hash15528 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoBeginCodingInfoKHR const & videoBeginCodingInfoKHR ) const VULKAN_HPP_NOEXCEPT 15529 { 15530 std::size_t seed = 0; 15531 VULKAN_HPP_HASH_COMBINE( seed, videoBeginCodingInfoKHR.sType ); 15532 VULKAN_HPP_HASH_COMBINE( seed, videoBeginCodingInfoKHR.pNext ); 15533 VULKAN_HPP_HASH_COMBINE( seed, videoBeginCodingInfoKHR.flags ); 15534 VULKAN_HPP_HASH_COMBINE( seed, videoBeginCodingInfoKHR.videoSession ); 15535 VULKAN_HPP_HASH_COMBINE( seed, videoBeginCodingInfoKHR.videoSessionParameters ); 15536 VULKAN_HPP_HASH_COMBINE( seed, videoBeginCodingInfoKHR.referenceSlotCount ); 15537 VULKAN_HPP_HASH_COMBINE( seed, videoBeginCodingInfoKHR.pReferenceSlots ); 15538 return seed; 15539 } 15540 }; 15541 15542 template <> 15543 struct hash<VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR> 15544 { operator ()std::hash15545 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR const & videoCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT 15546 { 15547 std::size_t seed = 0; 15548 VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.sType ); 15549 VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.pNext ); 15550 VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.flags ); 15551 VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.minBitstreamBufferOffsetAlignment ); 15552 VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.minBitstreamBufferSizeAlignment ); 15553 VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.pictureAccessGranularity ); 15554 VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.minCodedExtent ); 15555 VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.maxCodedExtent ); 15556 VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.maxDpbSlots ); 15557 VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.maxActiveReferencePictures ); 15558 VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.stdHeaderVersion ); 15559 return seed; 15560 } 15561 }; 15562 15563 template <> 15564 struct hash<VULKAN_HPP_NAMESPACE::VideoCodingControlInfoKHR> 15565 { operator ()std::hash15566 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoCodingControlInfoKHR const & videoCodingControlInfoKHR ) const VULKAN_HPP_NOEXCEPT 15567 { 15568 std::size_t seed = 0; 15569 VULKAN_HPP_HASH_COMBINE( seed, videoCodingControlInfoKHR.sType ); 15570 VULKAN_HPP_HASH_COMBINE( seed, videoCodingControlInfoKHR.pNext ); 15571 VULKAN_HPP_HASH_COMBINE( seed, videoCodingControlInfoKHR.flags ); 15572 return seed; 15573 } 15574 }; 15575 15576 template <> 15577 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeAV1CapabilitiesKHR> 15578 { operator ()std::hash15579 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeAV1CapabilitiesKHR const & videoDecodeAV1CapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT 15580 { 15581 std::size_t seed = 0; 15582 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1CapabilitiesKHR.sType ); 15583 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1CapabilitiesKHR.pNext ); 15584 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1CapabilitiesKHR.maxLevel ); 15585 return seed; 15586 } 15587 }; 15588 15589 template <> 15590 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeAV1DpbSlotInfoKHR> 15591 { operator ()std::hash15592 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeAV1DpbSlotInfoKHR const & videoDecodeAV1DpbSlotInfoKHR ) const VULKAN_HPP_NOEXCEPT 15593 { 15594 std::size_t seed = 0; 15595 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1DpbSlotInfoKHR.sType ); 15596 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1DpbSlotInfoKHR.pNext ); 15597 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1DpbSlotInfoKHR.pStdReferenceInfo ); 15598 return seed; 15599 } 15600 }; 15601 15602 template <> 15603 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeAV1PictureInfoKHR> 15604 { operator ()std::hash15605 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeAV1PictureInfoKHR const & videoDecodeAV1PictureInfoKHR ) const VULKAN_HPP_NOEXCEPT 15606 { 15607 std::size_t seed = 0; 15608 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1PictureInfoKHR.sType ); 15609 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1PictureInfoKHR.pNext ); 15610 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1PictureInfoKHR.pStdPictureInfo ); 15611 for ( size_t i = 0; i < VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR; ++i ) 15612 { 15613 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1PictureInfoKHR.referenceNameSlotIndices[i] ); 15614 } 15615 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1PictureInfoKHR.frameHeaderOffset ); 15616 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1PictureInfoKHR.tileCount ); 15617 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1PictureInfoKHR.pTileOffsets ); 15618 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1PictureInfoKHR.pTileSizes ); 15619 return seed; 15620 } 15621 }; 15622 15623 template <> 15624 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeAV1ProfileInfoKHR> 15625 { operator ()std::hash15626 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeAV1ProfileInfoKHR const & videoDecodeAV1ProfileInfoKHR ) const VULKAN_HPP_NOEXCEPT 15627 { 15628 std::size_t seed = 0; 15629 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1ProfileInfoKHR.sType ); 15630 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1ProfileInfoKHR.pNext ); 15631 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1ProfileInfoKHR.stdProfile ); 15632 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1ProfileInfoKHR.filmGrainSupport ); 15633 return seed; 15634 } 15635 }; 15636 15637 template <> 15638 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeAV1SessionParametersCreateInfoKHR> 15639 { operator ()std::hash15640 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeAV1SessionParametersCreateInfoKHR const & videoDecodeAV1SessionParametersCreateInfoKHR ) const 15641 VULKAN_HPP_NOEXCEPT 15642 { 15643 std::size_t seed = 0; 15644 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1SessionParametersCreateInfoKHR.sType ); 15645 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1SessionParametersCreateInfoKHR.pNext ); 15646 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1SessionParametersCreateInfoKHR.pStdSequenceHeader ); 15647 return seed; 15648 } 15649 }; 15650 15651 template <> 15652 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeCapabilitiesKHR> 15653 { operator ()std::hash15654 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeCapabilitiesKHR const & videoDecodeCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT 15655 { 15656 std::size_t seed = 0; 15657 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeCapabilitiesKHR.sType ); 15658 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeCapabilitiesKHR.pNext ); 15659 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeCapabilitiesKHR.flags ); 15660 return seed; 15661 } 15662 }; 15663 15664 template <> 15665 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH264CapabilitiesKHR> 15666 { operator ()std::hash15667 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264CapabilitiesKHR const & videoDecodeH264CapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT 15668 { 15669 std::size_t seed = 0; 15670 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264CapabilitiesKHR.sType ); 15671 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264CapabilitiesKHR.pNext ); 15672 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264CapabilitiesKHR.maxLevelIdc ); 15673 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264CapabilitiesKHR.fieldOffsetGranularity ); 15674 return seed; 15675 } 15676 }; 15677 15678 template <> 15679 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH264DpbSlotInfoKHR> 15680 { operator ()std::hash15681 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264DpbSlotInfoKHR const & videoDecodeH264DpbSlotInfoKHR ) const VULKAN_HPP_NOEXCEPT 15682 { 15683 std::size_t seed = 0; 15684 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264DpbSlotInfoKHR.sType ); 15685 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264DpbSlotInfoKHR.pNext ); 15686 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264DpbSlotInfoKHR.pStdReferenceInfo ); 15687 return seed; 15688 } 15689 }; 15690 15691 template <> 15692 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH264PictureInfoKHR> 15693 { operator ()std::hash15694 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264PictureInfoKHR const & videoDecodeH264PictureInfoKHR ) const VULKAN_HPP_NOEXCEPT 15695 { 15696 std::size_t seed = 0; 15697 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264PictureInfoKHR.sType ); 15698 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264PictureInfoKHR.pNext ); 15699 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264PictureInfoKHR.pStdPictureInfo ); 15700 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264PictureInfoKHR.sliceCount ); 15701 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264PictureInfoKHR.pSliceOffsets ); 15702 return seed; 15703 } 15704 }; 15705 15706 template <> 15707 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH264ProfileInfoKHR> 15708 { operator ()std::hash15709 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264ProfileInfoKHR const & videoDecodeH264ProfileInfoKHR ) const VULKAN_HPP_NOEXCEPT 15710 { 15711 std::size_t seed = 0; 15712 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264ProfileInfoKHR.sType ); 15713 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264ProfileInfoKHR.pNext ); 15714 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264ProfileInfoKHR.stdProfileIdc ); 15715 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264ProfileInfoKHR.pictureLayout ); 15716 return seed; 15717 } 15718 }; 15719 15720 template <> 15721 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH264SessionParametersAddInfoKHR> 15722 { operator ()std::hash15723 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264SessionParametersAddInfoKHR const & videoDecodeH264SessionParametersAddInfoKHR ) const 15724 VULKAN_HPP_NOEXCEPT 15725 { 15726 std::size_t seed = 0; 15727 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersAddInfoKHR.sType ); 15728 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersAddInfoKHR.pNext ); 15729 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersAddInfoKHR.stdSPSCount ); 15730 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersAddInfoKHR.pStdSPSs ); 15731 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersAddInfoKHR.stdPPSCount ); 15732 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersAddInfoKHR.pStdPPSs ); 15733 return seed; 15734 } 15735 }; 15736 15737 template <> 15738 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH264SessionParametersCreateInfoKHR> 15739 { operator ()std::hash15740 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264SessionParametersCreateInfoKHR const & videoDecodeH264SessionParametersCreateInfoKHR ) const 15741 VULKAN_HPP_NOEXCEPT 15742 { 15743 std::size_t seed = 0; 15744 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersCreateInfoKHR.sType ); 15745 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersCreateInfoKHR.pNext ); 15746 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersCreateInfoKHR.maxStdSPSCount ); 15747 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersCreateInfoKHR.maxStdPPSCount ); 15748 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersCreateInfoKHR.pParametersAddInfo ); 15749 return seed; 15750 } 15751 }; 15752 15753 template <> 15754 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH265CapabilitiesKHR> 15755 { operator ()std::hash15756 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265CapabilitiesKHR const & videoDecodeH265CapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT 15757 { 15758 std::size_t seed = 0; 15759 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265CapabilitiesKHR.sType ); 15760 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265CapabilitiesKHR.pNext ); 15761 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265CapabilitiesKHR.maxLevelIdc ); 15762 return seed; 15763 } 15764 }; 15765 15766 template <> 15767 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH265DpbSlotInfoKHR> 15768 { operator ()std::hash15769 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265DpbSlotInfoKHR const & videoDecodeH265DpbSlotInfoKHR ) const VULKAN_HPP_NOEXCEPT 15770 { 15771 std::size_t seed = 0; 15772 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265DpbSlotInfoKHR.sType ); 15773 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265DpbSlotInfoKHR.pNext ); 15774 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265DpbSlotInfoKHR.pStdReferenceInfo ); 15775 return seed; 15776 } 15777 }; 15778 15779 template <> 15780 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH265PictureInfoKHR> 15781 { operator ()std::hash15782 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265PictureInfoKHR const & videoDecodeH265PictureInfoKHR ) const VULKAN_HPP_NOEXCEPT 15783 { 15784 std::size_t seed = 0; 15785 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265PictureInfoKHR.sType ); 15786 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265PictureInfoKHR.pNext ); 15787 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265PictureInfoKHR.pStdPictureInfo ); 15788 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265PictureInfoKHR.sliceSegmentCount ); 15789 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265PictureInfoKHR.pSliceSegmentOffsets ); 15790 return seed; 15791 } 15792 }; 15793 15794 template <> 15795 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH265ProfileInfoKHR> 15796 { operator ()std::hash15797 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265ProfileInfoKHR const & videoDecodeH265ProfileInfoKHR ) const VULKAN_HPP_NOEXCEPT 15798 { 15799 std::size_t seed = 0; 15800 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265ProfileInfoKHR.sType ); 15801 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265ProfileInfoKHR.pNext ); 15802 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265ProfileInfoKHR.stdProfileIdc ); 15803 return seed; 15804 } 15805 }; 15806 15807 template <> 15808 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH265SessionParametersAddInfoKHR> 15809 { operator ()std::hash15810 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265SessionParametersAddInfoKHR const & videoDecodeH265SessionParametersAddInfoKHR ) const 15811 VULKAN_HPP_NOEXCEPT 15812 { 15813 std::size_t seed = 0; 15814 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersAddInfoKHR.sType ); 15815 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersAddInfoKHR.pNext ); 15816 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersAddInfoKHR.stdVPSCount ); 15817 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersAddInfoKHR.pStdVPSs ); 15818 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersAddInfoKHR.stdSPSCount ); 15819 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersAddInfoKHR.pStdSPSs ); 15820 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersAddInfoKHR.stdPPSCount ); 15821 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersAddInfoKHR.pStdPPSs ); 15822 return seed; 15823 } 15824 }; 15825 15826 template <> 15827 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH265SessionParametersCreateInfoKHR> 15828 { operator ()std::hash15829 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265SessionParametersCreateInfoKHR const & videoDecodeH265SessionParametersCreateInfoKHR ) const 15830 VULKAN_HPP_NOEXCEPT 15831 { 15832 std::size_t seed = 0; 15833 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersCreateInfoKHR.sType ); 15834 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersCreateInfoKHR.pNext ); 15835 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersCreateInfoKHR.maxStdVPSCount ); 15836 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersCreateInfoKHR.maxStdSPSCount ); 15837 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersCreateInfoKHR.maxStdPPSCount ); 15838 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersCreateInfoKHR.pParametersAddInfo ); 15839 return seed; 15840 } 15841 }; 15842 15843 template <> 15844 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR> 15845 { operator ()std::hash15846 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR const & videoDecodeInfoKHR ) const VULKAN_HPP_NOEXCEPT 15847 { 15848 std::size_t seed = 0; 15849 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.sType ); 15850 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.pNext ); 15851 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.flags ); 15852 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.srcBuffer ); 15853 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.srcBufferOffset ); 15854 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.srcBufferRange ); 15855 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.dstPictureResource ); 15856 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.pSetupReferenceSlot ); 15857 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.referenceSlotCount ); 15858 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.pReferenceSlots ); 15859 return seed; 15860 } 15861 }; 15862 15863 template <> 15864 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeUsageInfoKHR> 15865 { operator ()std::hash15866 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeUsageInfoKHR const & videoDecodeUsageInfoKHR ) const VULKAN_HPP_NOEXCEPT 15867 { 15868 std::size_t seed = 0; 15869 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeUsageInfoKHR.sType ); 15870 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeUsageInfoKHR.pNext ); 15871 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeUsageInfoKHR.videoUsageHints ); 15872 return seed; 15873 } 15874 }; 15875 15876 template <> 15877 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeCapabilitiesKHR> 15878 { operator ()std::hash15879 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeCapabilitiesKHR const & videoEncodeCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT 15880 { 15881 std::size_t seed = 0; 15882 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.sType ); 15883 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.pNext ); 15884 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.flags ); 15885 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.rateControlModes ); 15886 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.maxRateControlLayers ); 15887 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.maxBitrate ); 15888 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.maxQualityLevels ); 15889 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.encodeInputPictureGranularity ); 15890 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.supportedEncodeFeedbackFlags ); 15891 return seed; 15892 } 15893 }; 15894 15895 template <> 15896 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilitiesKHR> 15897 { operator ()std::hash15898 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilitiesKHR const & videoEncodeH264CapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT 15899 { 15900 std::size_t seed = 0; 15901 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.sType ); 15902 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.pNext ); 15903 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.flags ); 15904 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.maxLevelIdc ); 15905 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.maxSliceCount ); 15906 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.maxPPictureL0ReferenceCount ); 15907 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.maxBPictureL0ReferenceCount ); 15908 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.maxL1ReferenceCount ); 15909 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.maxTemporalLayerCount ); 15910 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.expectDyadicTemporalLayerPattern ); 15911 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.minQp ); 15912 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.maxQp ); 15913 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.prefersGopRemainingFrames ); 15914 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.requiresGopRemainingFrames ); 15915 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.stdSyntaxFlags ); 15916 return seed; 15917 } 15918 }; 15919 15920 template <> 15921 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoKHR> 15922 { operator ()std::hash15923 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoKHR const & videoEncodeH264DpbSlotInfoKHR ) const VULKAN_HPP_NOEXCEPT 15924 { 15925 std::size_t seed = 0; 15926 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264DpbSlotInfoKHR.sType ); 15927 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264DpbSlotInfoKHR.pNext ); 15928 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264DpbSlotInfoKHR.pStdReferenceInfo ); 15929 return seed; 15930 } 15931 }; 15932 15933 template <> 15934 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264FrameSizeKHR> 15935 { operator ()std::hash15936 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264FrameSizeKHR const & videoEncodeH264FrameSizeKHR ) const VULKAN_HPP_NOEXCEPT 15937 { 15938 std::size_t seed = 0; 15939 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264FrameSizeKHR.frameISize ); 15940 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264FrameSizeKHR.framePSize ); 15941 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264FrameSizeKHR.frameBSize ); 15942 return seed; 15943 } 15944 }; 15945 15946 template <> 15947 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264GopRemainingFrameInfoKHR> 15948 { 15949 std::size_t operator ()std::hash15950 operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264GopRemainingFrameInfoKHR const & videoEncodeH264GopRemainingFrameInfoKHR ) const VULKAN_HPP_NOEXCEPT 15951 { 15952 std::size_t seed = 0; 15953 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264GopRemainingFrameInfoKHR.sType ); 15954 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264GopRemainingFrameInfoKHR.pNext ); 15955 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264GopRemainingFrameInfoKHR.useGopRemainingFrames ); 15956 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264GopRemainingFrameInfoKHR.gopRemainingI ); 15957 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264GopRemainingFrameInfoKHR.gopRemainingP ); 15958 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264GopRemainingFrameInfoKHR.gopRemainingB ); 15959 return seed; 15960 } 15961 }; 15962 15963 template <> 15964 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264NaluSliceInfoKHR> 15965 { operator ()std::hash15966 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264NaluSliceInfoKHR const & videoEncodeH264NaluSliceInfoKHR ) const VULKAN_HPP_NOEXCEPT 15967 { 15968 std::size_t seed = 0; 15969 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264NaluSliceInfoKHR.sType ); 15970 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264NaluSliceInfoKHR.pNext ); 15971 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264NaluSliceInfoKHR.constantQp ); 15972 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264NaluSliceInfoKHR.pStdSliceHeader ); 15973 return seed; 15974 } 15975 }; 15976 15977 template <> 15978 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264PictureInfoKHR> 15979 { operator ()std::hash15980 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264PictureInfoKHR const & videoEncodeH264PictureInfoKHR ) const VULKAN_HPP_NOEXCEPT 15981 { 15982 std::size_t seed = 0; 15983 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264PictureInfoKHR.sType ); 15984 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264PictureInfoKHR.pNext ); 15985 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264PictureInfoKHR.naluSliceEntryCount ); 15986 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264PictureInfoKHR.pNaluSliceEntries ); 15987 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264PictureInfoKHR.pStdPictureInfo ); 15988 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264PictureInfoKHR.generatePrefixNalu ); 15989 return seed; 15990 } 15991 }; 15992 15993 template <> 15994 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264ProfileInfoKHR> 15995 { operator ()std::hash15996 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264ProfileInfoKHR const & videoEncodeH264ProfileInfoKHR ) const VULKAN_HPP_NOEXCEPT 15997 { 15998 std::size_t seed = 0; 15999 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264ProfileInfoKHR.sType ); 16000 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264ProfileInfoKHR.pNext ); 16001 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264ProfileInfoKHR.stdProfileIdc ); 16002 return seed; 16003 } 16004 }; 16005 16006 template <> 16007 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264QpKHR> 16008 { operator ()std::hash16009 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264QpKHR const & videoEncodeH264QpKHR ) const VULKAN_HPP_NOEXCEPT 16010 { 16011 std::size_t seed = 0; 16012 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QpKHR.qpI ); 16013 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QpKHR.qpP ); 16014 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QpKHR.qpB ); 16015 return seed; 16016 } 16017 }; 16018 16019 template <> 16020 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264QualityLevelPropertiesKHR> 16021 { 16022 std::size_t operator ()std::hash16023 operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264QualityLevelPropertiesKHR const & videoEncodeH264QualityLevelPropertiesKHR ) const VULKAN_HPP_NOEXCEPT 16024 { 16025 std::size_t seed = 0; 16026 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesKHR.sType ); 16027 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesKHR.pNext ); 16028 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesKHR.preferredRateControlFlags ); 16029 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesKHR.preferredGopFrameCount ); 16030 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesKHR.preferredIdrPeriod ); 16031 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesKHR.preferredConsecutiveBFrameCount ); 16032 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesKHR.preferredTemporalLayerCount ); 16033 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesKHR.preferredConstantQp ); 16034 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesKHR.preferredMaxL0ReferenceCount ); 16035 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesKHR.preferredMaxL1ReferenceCount ); 16036 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesKHR.preferredStdEntropyCodingModeFlag ); 16037 return seed; 16038 } 16039 }; 16040 16041 template <> 16042 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlInfoKHR> 16043 { operator ()std::hash16044 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlInfoKHR const & videoEncodeH264RateControlInfoKHR ) const VULKAN_HPP_NOEXCEPT 16045 { 16046 std::size_t seed = 0; 16047 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlInfoKHR.sType ); 16048 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlInfoKHR.pNext ); 16049 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlInfoKHR.flags ); 16050 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlInfoKHR.gopFrameCount ); 16051 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlInfoKHR.idrPeriod ); 16052 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlInfoKHR.consecutiveBFrameCount ); 16053 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlInfoKHR.temporalLayerCount ); 16054 return seed; 16055 } 16056 }; 16057 16058 template <> 16059 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlLayerInfoKHR> 16060 { 16061 std::size_t operator ()std::hash16062 operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlLayerInfoKHR const & videoEncodeH264RateControlLayerInfoKHR ) const VULKAN_HPP_NOEXCEPT 16063 { 16064 std::size_t seed = 0; 16065 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoKHR.sType ); 16066 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoKHR.pNext ); 16067 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoKHR.useMinQp ); 16068 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoKHR.minQp ); 16069 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoKHR.useMaxQp ); 16070 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoKHR.maxQp ); 16071 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoKHR.useMaxFrameSize ); 16072 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoKHR.maxFrameSize ); 16073 return seed; 16074 } 16075 }; 16076 16077 template <> 16078 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionCreateInfoKHR> 16079 { operator ()std::hash16080 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionCreateInfoKHR const & videoEncodeH264SessionCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 16081 { 16082 std::size_t seed = 0; 16083 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionCreateInfoKHR.sType ); 16084 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionCreateInfoKHR.pNext ); 16085 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionCreateInfoKHR.useMaxLevelIdc ); 16086 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionCreateInfoKHR.maxLevelIdc ); 16087 return seed; 16088 } 16089 }; 16090 16091 template <> 16092 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersAddInfoKHR> 16093 { operator ()std::hash16094 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersAddInfoKHR const & videoEncodeH264SessionParametersAddInfoKHR ) const 16095 VULKAN_HPP_NOEXCEPT 16096 { 16097 std::size_t seed = 0; 16098 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersAddInfoKHR.sType ); 16099 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersAddInfoKHR.pNext ); 16100 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersAddInfoKHR.stdSPSCount ); 16101 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersAddInfoKHR.pStdSPSs ); 16102 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersAddInfoKHR.stdPPSCount ); 16103 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersAddInfoKHR.pStdPPSs ); 16104 return seed; 16105 } 16106 }; 16107 16108 template <> 16109 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersCreateInfoKHR> 16110 { operator ()std::hash16111 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersCreateInfoKHR const & videoEncodeH264SessionParametersCreateInfoKHR ) const 16112 VULKAN_HPP_NOEXCEPT 16113 { 16114 std::size_t seed = 0; 16115 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersCreateInfoKHR.sType ); 16116 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersCreateInfoKHR.pNext ); 16117 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersCreateInfoKHR.maxStdSPSCount ); 16118 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersCreateInfoKHR.maxStdPPSCount ); 16119 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersCreateInfoKHR.pParametersAddInfo ); 16120 return seed; 16121 } 16122 }; 16123 16124 template <> 16125 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersFeedbackInfoKHR> 16126 { operator ()std::hash16127 std::size_t operator()( 16128 VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersFeedbackInfoKHR const & videoEncodeH264SessionParametersFeedbackInfoKHR ) const VULKAN_HPP_NOEXCEPT 16129 { 16130 std::size_t seed = 0; 16131 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersFeedbackInfoKHR.sType ); 16132 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersFeedbackInfoKHR.pNext ); 16133 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersFeedbackInfoKHR.hasStdSPSOverrides ); 16134 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersFeedbackInfoKHR.hasStdPPSOverrides ); 16135 return seed; 16136 } 16137 }; 16138 16139 template <> 16140 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersGetInfoKHR> 16141 { operator ()std::hash16142 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersGetInfoKHR const & videoEncodeH264SessionParametersGetInfoKHR ) const 16143 VULKAN_HPP_NOEXCEPT 16144 { 16145 std::size_t seed = 0; 16146 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersGetInfoKHR.sType ); 16147 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersGetInfoKHR.pNext ); 16148 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersGetInfoKHR.writeStdSPS ); 16149 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersGetInfoKHR.writeStdPPS ); 16150 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersGetInfoKHR.stdSPSId ); 16151 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersGetInfoKHR.stdPPSId ); 16152 return seed; 16153 } 16154 }; 16155 16156 template <> 16157 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265CapabilitiesKHR> 16158 { operator ()std::hash16159 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265CapabilitiesKHR const & videoEncodeH265CapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT 16160 { 16161 std::size_t seed = 0; 16162 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.sType ); 16163 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.pNext ); 16164 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.flags ); 16165 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.maxLevelIdc ); 16166 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.maxSliceSegmentCount ); 16167 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.maxTiles ); 16168 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.ctbSizes ); 16169 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.transformBlockSizes ); 16170 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.maxPPictureL0ReferenceCount ); 16171 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.maxBPictureL0ReferenceCount ); 16172 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.maxL1ReferenceCount ); 16173 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.maxSubLayerCount ); 16174 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.expectDyadicTemporalSubLayerPattern ); 16175 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.minQp ); 16176 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.maxQp ); 16177 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.prefersGopRemainingFrames ); 16178 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.requiresGopRemainingFrames ); 16179 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.stdSyntaxFlags ); 16180 return seed; 16181 } 16182 }; 16183 16184 template <> 16185 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265DpbSlotInfoKHR> 16186 { operator ()std::hash16187 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265DpbSlotInfoKHR const & videoEncodeH265DpbSlotInfoKHR ) const VULKAN_HPP_NOEXCEPT 16188 { 16189 std::size_t seed = 0; 16190 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265DpbSlotInfoKHR.sType ); 16191 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265DpbSlotInfoKHR.pNext ); 16192 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265DpbSlotInfoKHR.pStdReferenceInfo ); 16193 return seed; 16194 } 16195 }; 16196 16197 template <> 16198 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265FrameSizeKHR> 16199 { operator ()std::hash16200 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265FrameSizeKHR const & videoEncodeH265FrameSizeKHR ) const VULKAN_HPP_NOEXCEPT 16201 { 16202 std::size_t seed = 0; 16203 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265FrameSizeKHR.frameISize ); 16204 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265FrameSizeKHR.framePSize ); 16205 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265FrameSizeKHR.frameBSize ); 16206 return seed; 16207 } 16208 }; 16209 16210 template <> 16211 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265GopRemainingFrameInfoKHR> 16212 { 16213 std::size_t operator ()std::hash16214 operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265GopRemainingFrameInfoKHR const & videoEncodeH265GopRemainingFrameInfoKHR ) const VULKAN_HPP_NOEXCEPT 16215 { 16216 std::size_t seed = 0; 16217 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265GopRemainingFrameInfoKHR.sType ); 16218 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265GopRemainingFrameInfoKHR.pNext ); 16219 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265GopRemainingFrameInfoKHR.useGopRemainingFrames ); 16220 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265GopRemainingFrameInfoKHR.gopRemainingI ); 16221 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265GopRemainingFrameInfoKHR.gopRemainingP ); 16222 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265GopRemainingFrameInfoKHR.gopRemainingB ); 16223 return seed; 16224 } 16225 }; 16226 16227 template <> 16228 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceSegmentInfoKHR> 16229 { 16230 std::size_t operator ()std::hash16231 operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceSegmentInfoKHR const & videoEncodeH265NaluSliceSegmentInfoKHR ) const VULKAN_HPP_NOEXCEPT 16232 { 16233 std::size_t seed = 0; 16234 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265NaluSliceSegmentInfoKHR.sType ); 16235 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265NaluSliceSegmentInfoKHR.pNext ); 16236 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265NaluSliceSegmentInfoKHR.constantQp ); 16237 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265NaluSliceSegmentInfoKHR.pStdSliceSegmentHeader ); 16238 return seed; 16239 } 16240 }; 16241 16242 template <> 16243 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265PictureInfoKHR> 16244 { operator ()std::hash16245 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265PictureInfoKHR const & videoEncodeH265PictureInfoKHR ) const VULKAN_HPP_NOEXCEPT 16246 { 16247 std::size_t seed = 0; 16248 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265PictureInfoKHR.sType ); 16249 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265PictureInfoKHR.pNext ); 16250 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265PictureInfoKHR.naluSliceSegmentEntryCount ); 16251 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265PictureInfoKHR.pNaluSliceSegmentEntries ); 16252 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265PictureInfoKHR.pStdPictureInfo ); 16253 return seed; 16254 } 16255 }; 16256 16257 template <> 16258 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265ProfileInfoKHR> 16259 { operator ()std::hash16260 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265ProfileInfoKHR const & videoEncodeH265ProfileInfoKHR ) const VULKAN_HPP_NOEXCEPT 16261 { 16262 std::size_t seed = 0; 16263 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265ProfileInfoKHR.sType ); 16264 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265ProfileInfoKHR.pNext ); 16265 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265ProfileInfoKHR.stdProfileIdc ); 16266 return seed; 16267 } 16268 }; 16269 16270 template <> 16271 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265QpKHR> 16272 { operator ()std::hash16273 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265QpKHR const & videoEncodeH265QpKHR ) const VULKAN_HPP_NOEXCEPT 16274 { 16275 std::size_t seed = 0; 16276 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QpKHR.qpI ); 16277 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QpKHR.qpP ); 16278 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QpKHR.qpB ); 16279 return seed; 16280 } 16281 }; 16282 16283 template <> 16284 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265QualityLevelPropertiesKHR> 16285 { 16286 std::size_t operator ()std::hash16287 operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265QualityLevelPropertiesKHR const & videoEncodeH265QualityLevelPropertiesKHR ) const VULKAN_HPP_NOEXCEPT 16288 { 16289 std::size_t seed = 0; 16290 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesKHR.sType ); 16291 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesKHR.pNext ); 16292 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesKHR.preferredRateControlFlags ); 16293 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesKHR.preferredGopFrameCount ); 16294 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesKHR.preferredIdrPeriod ); 16295 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesKHR.preferredConsecutiveBFrameCount ); 16296 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesKHR.preferredSubLayerCount ); 16297 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesKHR.preferredConstantQp ); 16298 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesKHR.preferredMaxL0ReferenceCount ); 16299 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesKHR.preferredMaxL1ReferenceCount ); 16300 return seed; 16301 } 16302 }; 16303 16304 template <> 16305 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlInfoKHR> 16306 { operator ()std::hash16307 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlInfoKHR const & videoEncodeH265RateControlInfoKHR ) const VULKAN_HPP_NOEXCEPT 16308 { 16309 std::size_t seed = 0; 16310 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlInfoKHR.sType ); 16311 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlInfoKHR.pNext ); 16312 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlInfoKHR.flags ); 16313 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlInfoKHR.gopFrameCount ); 16314 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlInfoKHR.idrPeriod ); 16315 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlInfoKHR.consecutiveBFrameCount ); 16316 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlInfoKHR.subLayerCount ); 16317 return seed; 16318 } 16319 }; 16320 16321 template <> 16322 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlLayerInfoKHR> 16323 { 16324 std::size_t operator ()std::hash16325 operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlLayerInfoKHR const & videoEncodeH265RateControlLayerInfoKHR ) const VULKAN_HPP_NOEXCEPT 16326 { 16327 std::size_t seed = 0; 16328 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoKHR.sType ); 16329 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoKHR.pNext ); 16330 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoKHR.useMinQp ); 16331 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoKHR.minQp ); 16332 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoKHR.useMaxQp ); 16333 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoKHR.maxQp ); 16334 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoKHR.useMaxFrameSize ); 16335 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoKHR.maxFrameSize ); 16336 return seed; 16337 } 16338 }; 16339 16340 template <> 16341 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionCreateInfoKHR> 16342 { operator ()std::hash16343 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionCreateInfoKHR const & videoEncodeH265SessionCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 16344 { 16345 std::size_t seed = 0; 16346 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionCreateInfoKHR.sType ); 16347 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionCreateInfoKHR.pNext ); 16348 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionCreateInfoKHR.useMaxLevelIdc ); 16349 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionCreateInfoKHR.maxLevelIdc ); 16350 return seed; 16351 } 16352 }; 16353 16354 template <> 16355 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersAddInfoKHR> 16356 { operator ()std::hash16357 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersAddInfoKHR const & videoEncodeH265SessionParametersAddInfoKHR ) const 16358 VULKAN_HPP_NOEXCEPT 16359 { 16360 std::size_t seed = 0; 16361 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersAddInfoKHR.sType ); 16362 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersAddInfoKHR.pNext ); 16363 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersAddInfoKHR.stdVPSCount ); 16364 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersAddInfoKHR.pStdVPSs ); 16365 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersAddInfoKHR.stdSPSCount ); 16366 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersAddInfoKHR.pStdSPSs ); 16367 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersAddInfoKHR.stdPPSCount ); 16368 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersAddInfoKHR.pStdPPSs ); 16369 return seed; 16370 } 16371 }; 16372 16373 template <> 16374 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersCreateInfoKHR> 16375 { operator ()std::hash16376 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersCreateInfoKHR const & videoEncodeH265SessionParametersCreateInfoKHR ) const 16377 VULKAN_HPP_NOEXCEPT 16378 { 16379 std::size_t seed = 0; 16380 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersCreateInfoKHR.sType ); 16381 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersCreateInfoKHR.pNext ); 16382 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersCreateInfoKHR.maxStdVPSCount ); 16383 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersCreateInfoKHR.maxStdSPSCount ); 16384 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersCreateInfoKHR.maxStdPPSCount ); 16385 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersCreateInfoKHR.pParametersAddInfo ); 16386 return seed; 16387 } 16388 }; 16389 16390 template <> 16391 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersFeedbackInfoKHR> 16392 { operator ()std::hash16393 std::size_t operator()( 16394 VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersFeedbackInfoKHR const & videoEncodeH265SessionParametersFeedbackInfoKHR ) const VULKAN_HPP_NOEXCEPT 16395 { 16396 std::size_t seed = 0; 16397 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersFeedbackInfoKHR.sType ); 16398 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersFeedbackInfoKHR.pNext ); 16399 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersFeedbackInfoKHR.hasStdVPSOverrides ); 16400 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersFeedbackInfoKHR.hasStdSPSOverrides ); 16401 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersFeedbackInfoKHR.hasStdPPSOverrides ); 16402 return seed; 16403 } 16404 }; 16405 16406 template <> 16407 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersGetInfoKHR> 16408 { operator ()std::hash16409 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersGetInfoKHR const & videoEncodeH265SessionParametersGetInfoKHR ) const 16410 VULKAN_HPP_NOEXCEPT 16411 { 16412 std::size_t seed = 0; 16413 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersGetInfoKHR.sType ); 16414 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersGetInfoKHR.pNext ); 16415 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersGetInfoKHR.writeStdVPS ); 16416 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersGetInfoKHR.writeStdSPS ); 16417 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersGetInfoKHR.writeStdPPS ); 16418 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersGetInfoKHR.stdVPSId ); 16419 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersGetInfoKHR.stdSPSId ); 16420 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersGetInfoKHR.stdPPSId ); 16421 return seed; 16422 } 16423 }; 16424 16425 template <> 16426 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeInfoKHR> 16427 { operator ()std::hash16428 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeInfoKHR const & videoEncodeInfoKHR ) const VULKAN_HPP_NOEXCEPT 16429 { 16430 std::size_t seed = 0; 16431 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.sType ); 16432 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.pNext ); 16433 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.flags ); 16434 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.dstBuffer ); 16435 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.dstBufferOffset ); 16436 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.dstBufferRange ); 16437 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.srcPictureResource ); 16438 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.pSetupReferenceSlot ); 16439 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.referenceSlotCount ); 16440 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.pReferenceSlots ); 16441 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.precedingExternallyEncodedBytes ); 16442 return seed; 16443 } 16444 }; 16445 16446 template <> 16447 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelInfoKHR> 16448 { operator ()std::hash16449 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelInfoKHR const & videoEncodeQualityLevelInfoKHR ) const VULKAN_HPP_NOEXCEPT 16450 { 16451 std::size_t seed = 0; 16452 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQualityLevelInfoKHR.sType ); 16453 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQualityLevelInfoKHR.pNext ); 16454 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQualityLevelInfoKHR.qualityLevel ); 16455 return seed; 16456 } 16457 }; 16458 16459 template <> 16460 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelPropertiesKHR> 16461 { operator ()std::hash16462 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelPropertiesKHR const & videoEncodeQualityLevelPropertiesKHR ) const VULKAN_HPP_NOEXCEPT 16463 { 16464 std::size_t seed = 0; 16465 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQualityLevelPropertiesKHR.sType ); 16466 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQualityLevelPropertiesKHR.pNext ); 16467 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQualityLevelPropertiesKHR.preferredRateControlMode ); 16468 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQualityLevelPropertiesKHR.preferredRateControlLayerCount ); 16469 return seed; 16470 } 16471 }; 16472 16473 template <> 16474 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeRateControlLayerInfoKHR> 16475 { operator ()std::hash16476 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeRateControlLayerInfoKHR const & videoEncodeRateControlLayerInfoKHR ) const VULKAN_HPP_NOEXCEPT 16477 { 16478 std::size_t seed = 0; 16479 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlLayerInfoKHR.sType ); 16480 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlLayerInfoKHR.pNext ); 16481 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlLayerInfoKHR.averageBitrate ); 16482 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlLayerInfoKHR.maxBitrate ); 16483 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlLayerInfoKHR.frameRateNumerator ); 16484 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlLayerInfoKHR.frameRateDenominator ); 16485 return seed; 16486 } 16487 }; 16488 16489 template <> 16490 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeRateControlInfoKHR> 16491 { operator ()std::hash16492 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeRateControlInfoKHR const & videoEncodeRateControlInfoKHR ) const VULKAN_HPP_NOEXCEPT 16493 { 16494 std::size_t seed = 0; 16495 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlInfoKHR.sType ); 16496 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlInfoKHR.pNext ); 16497 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlInfoKHR.flags ); 16498 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlInfoKHR.rateControlMode ); 16499 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlInfoKHR.layerCount ); 16500 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlInfoKHR.pLayers ); 16501 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlInfoKHR.virtualBufferSizeInMs ); 16502 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlInfoKHR.initialVirtualBufferSizeInMs ); 16503 return seed; 16504 } 16505 }; 16506 16507 template <> 16508 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersFeedbackInfoKHR> 16509 { operator ()std::hash16510 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersFeedbackInfoKHR const & videoEncodeSessionParametersFeedbackInfoKHR ) const 16511 VULKAN_HPP_NOEXCEPT 16512 { 16513 std::size_t seed = 0; 16514 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionParametersFeedbackInfoKHR.sType ); 16515 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionParametersFeedbackInfoKHR.pNext ); 16516 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionParametersFeedbackInfoKHR.hasOverrides ); 16517 return seed; 16518 } 16519 }; 16520 16521 template <> 16522 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR> 16523 { 16524 std::size_t operator ()std::hash16525 operator()( VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR const & videoEncodeSessionParametersGetInfoKHR ) const VULKAN_HPP_NOEXCEPT 16526 { 16527 std::size_t seed = 0; 16528 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionParametersGetInfoKHR.sType ); 16529 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionParametersGetInfoKHR.pNext ); 16530 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionParametersGetInfoKHR.videoSessionParameters ); 16531 return seed; 16532 } 16533 }; 16534 16535 template <> 16536 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeUsageInfoKHR> 16537 { operator ()std::hash16538 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeUsageInfoKHR const & videoEncodeUsageInfoKHR ) const VULKAN_HPP_NOEXCEPT 16539 { 16540 std::size_t seed = 0; 16541 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeUsageInfoKHR.sType ); 16542 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeUsageInfoKHR.pNext ); 16543 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeUsageInfoKHR.videoUsageHints ); 16544 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeUsageInfoKHR.videoContentHints ); 16545 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeUsageInfoKHR.tuningMode ); 16546 return seed; 16547 } 16548 }; 16549 16550 template <> 16551 struct hash<VULKAN_HPP_NAMESPACE::VideoEndCodingInfoKHR> 16552 { operator ()std::hash16553 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEndCodingInfoKHR const & videoEndCodingInfoKHR ) const VULKAN_HPP_NOEXCEPT 16554 { 16555 std::size_t seed = 0; 16556 VULKAN_HPP_HASH_COMBINE( seed, videoEndCodingInfoKHR.sType ); 16557 VULKAN_HPP_HASH_COMBINE( seed, videoEndCodingInfoKHR.pNext ); 16558 VULKAN_HPP_HASH_COMBINE( seed, videoEndCodingInfoKHR.flags ); 16559 return seed; 16560 } 16561 }; 16562 16563 template <> 16564 struct hash<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR> 16565 { operator ()std::hash16566 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR const & videoFormatPropertiesKHR ) const VULKAN_HPP_NOEXCEPT 16567 { 16568 std::size_t seed = 0; 16569 VULKAN_HPP_HASH_COMBINE( seed, videoFormatPropertiesKHR.sType ); 16570 VULKAN_HPP_HASH_COMBINE( seed, videoFormatPropertiesKHR.pNext ); 16571 VULKAN_HPP_HASH_COMBINE( seed, videoFormatPropertiesKHR.format ); 16572 VULKAN_HPP_HASH_COMBINE( seed, videoFormatPropertiesKHR.componentMapping ); 16573 VULKAN_HPP_HASH_COMBINE( seed, videoFormatPropertiesKHR.imageCreateFlags ); 16574 VULKAN_HPP_HASH_COMBINE( seed, videoFormatPropertiesKHR.imageType ); 16575 VULKAN_HPP_HASH_COMBINE( seed, videoFormatPropertiesKHR.imageTiling ); 16576 VULKAN_HPP_HASH_COMBINE( seed, videoFormatPropertiesKHR.imageUsageFlags ); 16577 return seed; 16578 } 16579 }; 16580 16581 template <> 16582 struct hash<VULKAN_HPP_NAMESPACE::VideoInlineQueryInfoKHR> 16583 { operator ()std::hash16584 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoInlineQueryInfoKHR const & videoInlineQueryInfoKHR ) const VULKAN_HPP_NOEXCEPT 16585 { 16586 std::size_t seed = 0; 16587 VULKAN_HPP_HASH_COMBINE( seed, videoInlineQueryInfoKHR.sType ); 16588 VULKAN_HPP_HASH_COMBINE( seed, videoInlineQueryInfoKHR.pNext ); 16589 VULKAN_HPP_HASH_COMBINE( seed, videoInlineQueryInfoKHR.queryPool ); 16590 VULKAN_HPP_HASH_COMBINE( seed, videoInlineQueryInfoKHR.firstQuery ); 16591 VULKAN_HPP_HASH_COMBINE( seed, videoInlineQueryInfoKHR.queryCount ); 16592 return seed; 16593 } 16594 }; 16595 16596 template <> 16597 struct hash<VULKAN_HPP_NAMESPACE::VideoProfileListInfoKHR> 16598 { operator ()std::hash16599 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoProfileListInfoKHR const & videoProfileListInfoKHR ) const VULKAN_HPP_NOEXCEPT 16600 { 16601 std::size_t seed = 0; 16602 VULKAN_HPP_HASH_COMBINE( seed, videoProfileListInfoKHR.sType ); 16603 VULKAN_HPP_HASH_COMBINE( seed, videoProfileListInfoKHR.pNext ); 16604 VULKAN_HPP_HASH_COMBINE( seed, videoProfileListInfoKHR.profileCount ); 16605 VULKAN_HPP_HASH_COMBINE( seed, videoProfileListInfoKHR.pProfiles ); 16606 return seed; 16607 } 16608 }; 16609 16610 template <> 16611 struct hash<VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR> 16612 { operator ()std::hash16613 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR const & videoSessionCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 16614 { 16615 std::size_t seed = 0; 16616 VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.sType ); 16617 VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.pNext ); 16618 VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.queueFamilyIndex ); 16619 VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.flags ); 16620 VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.pVideoProfile ); 16621 VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.pictureFormat ); 16622 VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.maxCodedExtent ); 16623 VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.referencePictureFormat ); 16624 VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.maxDpbSlots ); 16625 VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.maxActiveReferencePictures ); 16626 VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.pStdHeaderVersion ); 16627 return seed; 16628 } 16629 }; 16630 16631 template <> 16632 struct hash<VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR> 16633 { operator ()std::hash16634 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR const & videoSessionMemoryRequirementsKHR ) const VULKAN_HPP_NOEXCEPT 16635 { 16636 std::size_t seed = 0; 16637 VULKAN_HPP_HASH_COMBINE( seed, videoSessionMemoryRequirementsKHR.sType ); 16638 VULKAN_HPP_HASH_COMBINE( seed, videoSessionMemoryRequirementsKHR.pNext ); 16639 VULKAN_HPP_HASH_COMBINE( seed, videoSessionMemoryRequirementsKHR.memoryBindIndex ); 16640 VULKAN_HPP_HASH_COMBINE( seed, videoSessionMemoryRequirementsKHR.memoryRequirements ); 16641 return seed; 16642 } 16643 }; 16644 16645 template <> 16646 struct hash<VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR> 16647 { operator ()std::hash16648 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR const & videoSessionParametersCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 16649 { 16650 std::size_t seed = 0; 16651 VULKAN_HPP_HASH_COMBINE( seed, videoSessionParametersCreateInfoKHR.sType ); 16652 VULKAN_HPP_HASH_COMBINE( seed, videoSessionParametersCreateInfoKHR.pNext ); 16653 VULKAN_HPP_HASH_COMBINE( seed, videoSessionParametersCreateInfoKHR.flags ); 16654 VULKAN_HPP_HASH_COMBINE( seed, videoSessionParametersCreateInfoKHR.videoSessionParametersTemplate ); 16655 VULKAN_HPP_HASH_COMBINE( seed, videoSessionParametersCreateInfoKHR.videoSession ); 16656 return seed; 16657 } 16658 }; 16659 16660 template <> 16661 struct hash<VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR> 16662 { operator ()std::hash16663 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR const & videoSessionParametersUpdateInfoKHR ) const VULKAN_HPP_NOEXCEPT 16664 { 16665 std::size_t seed = 0; 16666 VULKAN_HPP_HASH_COMBINE( seed, videoSessionParametersUpdateInfoKHR.sType ); 16667 VULKAN_HPP_HASH_COMBINE( seed, videoSessionParametersUpdateInfoKHR.pNext ); 16668 VULKAN_HPP_HASH_COMBINE( seed, videoSessionParametersUpdateInfoKHR.updateSequenceCount ); 16669 return seed; 16670 } 16671 }; 16672 16673 # if defined( VK_USE_PLATFORM_WAYLAND_KHR ) 16674 template <> 16675 struct hash<VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR> 16676 { operator ()std::hash16677 std::size_t operator()( VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR const & waylandSurfaceCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 16678 { 16679 std::size_t seed = 0; 16680 VULKAN_HPP_HASH_COMBINE( seed, waylandSurfaceCreateInfoKHR.sType ); 16681 VULKAN_HPP_HASH_COMBINE( seed, waylandSurfaceCreateInfoKHR.pNext ); 16682 VULKAN_HPP_HASH_COMBINE( seed, waylandSurfaceCreateInfoKHR.flags ); 16683 VULKAN_HPP_HASH_COMBINE( seed, waylandSurfaceCreateInfoKHR.display ); 16684 VULKAN_HPP_HASH_COMBINE( seed, waylandSurfaceCreateInfoKHR.surface ); 16685 return seed; 16686 } 16687 }; 16688 # endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ 16689 16690 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 16691 template <> 16692 struct hash<VULKAN_HPP_NAMESPACE::Win32KeyedMutexAcquireReleaseInfoKHR> 16693 { operator ()std::hash16694 std::size_t operator()( VULKAN_HPP_NAMESPACE::Win32KeyedMutexAcquireReleaseInfoKHR const & win32KeyedMutexAcquireReleaseInfoKHR ) const VULKAN_HPP_NOEXCEPT 16695 { 16696 std::size_t seed = 0; 16697 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoKHR.sType ); 16698 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoKHR.pNext ); 16699 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoKHR.acquireCount ); 16700 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoKHR.pAcquireSyncs ); 16701 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoKHR.pAcquireKeys ); 16702 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoKHR.pAcquireTimeouts ); 16703 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoKHR.releaseCount ); 16704 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoKHR.pReleaseSyncs ); 16705 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoKHR.pReleaseKeys ); 16706 return seed; 16707 } 16708 }; 16709 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 16710 16711 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 16712 template <> 16713 struct hash<VULKAN_HPP_NAMESPACE::Win32KeyedMutexAcquireReleaseInfoNV> 16714 { operator ()std::hash16715 std::size_t operator()( VULKAN_HPP_NAMESPACE::Win32KeyedMutexAcquireReleaseInfoNV const & win32KeyedMutexAcquireReleaseInfoNV ) const VULKAN_HPP_NOEXCEPT 16716 { 16717 std::size_t seed = 0; 16718 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoNV.sType ); 16719 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoNV.pNext ); 16720 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoNV.acquireCount ); 16721 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoNV.pAcquireSyncs ); 16722 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoNV.pAcquireKeys ); 16723 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoNV.pAcquireTimeoutMilliseconds ); 16724 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoNV.releaseCount ); 16725 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoNV.pReleaseSyncs ); 16726 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoNV.pReleaseKeys ); 16727 return seed; 16728 } 16729 }; 16730 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 16731 16732 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 16733 template <> 16734 struct hash<VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR> 16735 { operator ()std::hash16736 std::size_t operator()( VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR const & win32SurfaceCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 16737 { 16738 std::size_t seed = 0; 16739 VULKAN_HPP_HASH_COMBINE( seed, win32SurfaceCreateInfoKHR.sType ); 16740 VULKAN_HPP_HASH_COMBINE( seed, win32SurfaceCreateInfoKHR.pNext ); 16741 VULKAN_HPP_HASH_COMBINE( seed, win32SurfaceCreateInfoKHR.flags ); 16742 VULKAN_HPP_HASH_COMBINE( seed, win32SurfaceCreateInfoKHR.hinstance ); 16743 VULKAN_HPP_HASH_COMBINE( seed, win32SurfaceCreateInfoKHR.hwnd ); 16744 return seed; 16745 } 16746 }; 16747 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 16748 16749 template <> 16750 struct hash<VULKAN_HPP_NAMESPACE::WriteDescriptorSetAccelerationStructureKHR> 16751 { operator ()std::hash16752 std::size_t operator()( VULKAN_HPP_NAMESPACE::WriteDescriptorSetAccelerationStructureKHR const & writeDescriptorSetAccelerationStructureKHR ) const 16753 VULKAN_HPP_NOEXCEPT 16754 { 16755 std::size_t seed = 0; 16756 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetAccelerationStructureKHR.sType ); 16757 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetAccelerationStructureKHR.pNext ); 16758 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetAccelerationStructureKHR.accelerationStructureCount ); 16759 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetAccelerationStructureKHR.pAccelerationStructures ); 16760 return seed; 16761 } 16762 }; 16763 16764 template <> 16765 struct hash<VULKAN_HPP_NAMESPACE::WriteDescriptorSetAccelerationStructureNV> 16766 { 16767 std::size_t operator ()std::hash16768 operator()( VULKAN_HPP_NAMESPACE::WriteDescriptorSetAccelerationStructureNV const & writeDescriptorSetAccelerationStructureNV ) const VULKAN_HPP_NOEXCEPT 16769 { 16770 std::size_t seed = 0; 16771 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetAccelerationStructureNV.sType ); 16772 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetAccelerationStructureNV.pNext ); 16773 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetAccelerationStructureNV.accelerationStructureCount ); 16774 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetAccelerationStructureNV.pAccelerationStructures ); 16775 return seed; 16776 } 16777 }; 16778 16779 template <> 16780 struct hash<VULKAN_HPP_NAMESPACE::WriteDescriptorSetInlineUniformBlock> 16781 { operator ()std::hash16782 std::size_t operator()( VULKAN_HPP_NAMESPACE::WriteDescriptorSetInlineUniformBlock const & writeDescriptorSetInlineUniformBlock ) const VULKAN_HPP_NOEXCEPT 16783 { 16784 std::size_t seed = 0; 16785 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetInlineUniformBlock.sType ); 16786 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetInlineUniformBlock.pNext ); 16787 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetInlineUniformBlock.dataSize ); 16788 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetInlineUniformBlock.pData ); 16789 return seed; 16790 } 16791 }; 16792 16793 # if defined( VK_USE_PLATFORM_XCB_KHR ) 16794 template <> 16795 struct hash<VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR> 16796 { operator ()std::hash16797 std::size_t operator()( VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR const & xcbSurfaceCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 16798 { 16799 std::size_t seed = 0; 16800 VULKAN_HPP_HASH_COMBINE( seed, xcbSurfaceCreateInfoKHR.sType ); 16801 VULKAN_HPP_HASH_COMBINE( seed, xcbSurfaceCreateInfoKHR.pNext ); 16802 VULKAN_HPP_HASH_COMBINE( seed, xcbSurfaceCreateInfoKHR.flags ); 16803 VULKAN_HPP_HASH_COMBINE( seed, xcbSurfaceCreateInfoKHR.connection ); 16804 VULKAN_HPP_HASH_COMBINE( seed, xcbSurfaceCreateInfoKHR.window ); 16805 return seed; 16806 } 16807 }; 16808 # endif /*VK_USE_PLATFORM_XCB_KHR*/ 16809 16810 # if defined( VK_USE_PLATFORM_XLIB_KHR ) 16811 template <> 16812 struct hash<VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR> 16813 { operator ()std::hash16814 std::size_t operator()( VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR const & xlibSurfaceCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 16815 { 16816 std::size_t seed = 0; 16817 VULKAN_HPP_HASH_COMBINE( seed, xlibSurfaceCreateInfoKHR.sType ); 16818 VULKAN_HPP_HASH_COMBINE( seed, xlibSurfaceCreateInfoKHR.pNext ); 16819 VULKAN_HPP_HASH_COMBINE( seed, xlibSurfaceCreateInfoKHR.flags ); 16820 VULKAN_HPP_HASH_COMBINE( seed, xlibSurfaceCreateInfoKHR.dpy ); 16821 VULKAN_HPP_HASH_COMBINE( seed, xlibSurfaceCreateInfoKHR.window ); 16822 return seed; 16823 } 16824 }; 16825 # endif /*VK_USE_PLATFORM_XLIB_KHR*/ 16826 16827 #endif // 14 <= VULKAN_HPP_CPP_VERSION 16828 16829 } // namespace std 16830 #endif 16831