1 // Copyright 2015-2023 The Khronos Group Inc. 2 // 3 // SPDX-License-Identifier: Apache-2.0 OR MIT 4 // 5 6 // This header is generated from the Khronos Vulkan XML API Registry. 7 8 #ifndef VULKAN_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_USE_PLATFORM_FUCHSIA ) 461 //=== VK_FUCHSIA_buffer_collection === 462 463 template <> 464 struct hash<VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA> 465 { operator ()std::hash466 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA const & bufferCollectionFUCHSIA ) const VULKAN_HPP_NOEXCEPT 467 { 468 return std::hash<VkBufferCollectionFUCHSIA>{}( static_cast<VkBufferCollectionFUCHSIA>( bufferCollectionFUCHSIA ) ); 469 } 470 }; 471 #endif /*VK_USE_PLATFORM_FUCHSIA*/ 472 473 //=== VK_EXT_opacity_micromap === 474 475 template <> 476 struct hash<VULKAN_HPP_NAMESPACE::MicromapEXT> 477 { operator ()std::hash478 std::size_t operator()( VULKAN_HPP_NAMESPACE::MicromapEXT const & micromapEXT ) const VULKAN_HPP_NOEXCEPT 479 { 480 return std::hash<VkMicromapEXT>{}( static_cast<VkMicromapEXT>( micromapEXT ) ); 481 } 482 }; 483 484 //=== VK_NV_optical_flow === 485 486 template <> 487 struct hash<VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV> 488 { operator ()std::hash489 std::size_t operator()( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV const & opticalFlowSessionNV ) const VULKAN_HPP_NOEXCEPT 490 { 491 return std::hash<VkOpticalFlowSessionNV>{}( static_cast<VkOpticalFlowSessionNV>( opticalFlowSessionNV ) ); 492 } 493 }; 494 495 //=== VK_EXT_shader_object === 496 497 template <> 498 struct hash<VULKAN_HPP_NAMESPACE::ShaderEXT> 499 { operator ()std::hash500 std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderEXT const & shaderEXT ) const VULKAN_HPP_NOEXCEPT 501 { 502 return std::hash<VkShaderEXT>{}( static_cast<VkShaderEXT>( shaderEXT ) ); 503 } 504 }; 505 506 #if 14 <= VULKAN_HPP_CPP_VERSION 507 //====================================== 508 //=== HASH structures for structures === 509 //====================================== 510 511 # if !defined( VULKAN_HPP_HASH_COMBINE ) 512 # define VULKAN_HPP_HASH_COMBINE( seed, value ) \ 513 seed ^= std::hash<std::decay<decltype( value )>::type>{}( value ) + 0x9e3779b9 + ( seed << 6 ) + ( seed >> 2 ) 514 # endif 515 516 template <> 517 struct hash<VULKAN_HPP_NAMESPACE::AabbPositionsKHR> 518 { operator ()std::hash519 std::size_t operator()( VULKAN_HPP_NAMESPACE::AabbPositionsKHR const & aabbPositionsKHR ) const VULKAN_HPP_NOEXCEPT 520 { 521 std::size_t seed = 0; 522 VULKAN_HPP_HASH_COMBINE( seed, aabbPositionsKHR.minX ); 523 VULKAN_HPP_HASH_COMBINE( seed, aabbPositionsKHR.minY ); 524 VULKAN_HPP_HASH_COMBINE( seed, aabbPositionsKHR.minZ ); 525 VULKAN_HPP_HASH_COMBINE( seed, aabbPositionsKHR.maxX ); 526 VULKAN_HPP_HASH_COMBINE( seed, aabbPositionsKHR.maxY ); 527 VULKAN_HPP_HASH_COMBINE( seed, aabbPositionsKHR.maxZ ); 528 return seed; 529 } 530 }; 531 532 template <> 533 struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR> 534 { 535 std::size_t operator ()std::hash536 operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR const & accelerationStructureBuildRangeInfoKHR ) const VULKAN_HPP_NOEXCEPT 537 { 538 std::size_t seed = 0; 539 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildRangeInfoKHR.primitiveCount ); 540 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildRangeInfoKHR.primitiveOffset ); 541 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildRangeInfoKHR.firstVertex ); 542 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildRangeInfoKHR.transformOffset ); 543 return seed; 544 } 545 }; 546 547 template <> 548 struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR> 549 { 550 std::size_t operator ()std::hash551 operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR const & accelerationStructureBuildSizesInfoKHR ) const VULKAN_HPP_NOEXCEPT 552 { 553 std::size_t seed = 0; 554 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildSizesInfoKHR.sType ); 555 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildSizesInfoKHR.pNext ); 556 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildSizesInfoKHR.accelerationStructureSize ); 557 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildSizesInfoKHR.updateScratchSize ); 558 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildSizesInfoKHR.buildScratchSize ); 559 return seed; 560 } 561 }; 562 563 template <> 564 struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureCaptureDescriptorDataInfoEXT> 565 { operator ()std::hash566 std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureCaptureDescriptorDataInfoEXT const & accelerationStructureCaptureDescriptorDataInfoEXT ) 567 const VULKAN_HPP_NOEXCEPT 568 { 569 std::size_t seed = 0; 570 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCaptureDescriptorDataInfoEXT.sType ); 571 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCaptureDescriptorDataInfoEXT.pNext ); 572 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCaptureDescriptorDataInfoEXT.accelerationStructure ); 573 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCaptureDescriptorDataInfoEXT.accelerationStructureNV ); 574 return seed; 575 } 576 }; 577 578 template <> 579 struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR> 580 { operator ()std::hash581 std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR const & accelerationStructureCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 582 { 583 std::size_t seed = 0; 584 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoKHR.sType ); 585 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoKHR.pNext ); 586 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoKHR.createFlags ); 587 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoKHR.buffer ); 588 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoKHR.offset ); 589 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoKHR.size ); 590 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoKHR.type ); 591 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoKHR.deviceAddress ); 592 return seed; 593 } 594 }; 595 596 template <> 597 struct hash<VULKAN_HPP_NAMESPACE::GeometryTrianglesNV> 598 { operator ()std::hash599 std::size_t operator()( VULKAN_HPP_NAMESPACE::GeometryTrianglesNV const & geometryTrianglesNV ) const VULKAN_HPP_NOEXCEPT 600 { 601 std::size_t seed = 0; 602 VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.sType ); 603 VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.pNext ); 604 VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.vertexData ); 605 VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.vertexOffset ); 606 VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.vertexCount ); 607 VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.vertexStride ); 608 VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.vertexFormat ); 609 VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.indexData ); 610 VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.indexOffset ); 611 VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.indexCount ); 612 VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.indexType ); 613 VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.transformData ); 614 VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.transformOffset ); 615 return seed; 616 } 617 }; 618 619 template <> 620 struct hash<VULKAN_HPP_NAMESPACE::GeometryAABBNV> 621 { operator ()std::hash622 std::size_t operator()( VULKAN_HPP_NAMESPACE::GeometryAABBNV const & geometryAABBNV ) const VULKAN_HPP_NOEXCEPT 623 { 624 std::size_t seed = 0; 625 VULKAN_HPP_HASH_COMBINE( seed, geometryAABBNV.sType ); 626 VULKAN_HPP_HASH_COMBINE( seed, geometryAABBNV.pNext ); 627 VULKAN_HPP_HASH_COMBINE( seed, geometryAABBNV.aabbData ); 628 VULKAN_HPP_HASH_COMBINE( seed, geometryAABBNV.numAABBs ); 629 VULKAN_HPP_HASH_COMBINE( seed, geometryAABBNV.stride ); 630 VULKAN_HPP_HASH_COMBINE( seed, geometryAABBNV.offset ); 631 return seed; 632 } 633 }; 634 635 template <> 636 struct hash<VULKAN_HPP_NAMESPACE::GeometryDataNV> 637 { operator ()std::hash638 std::size_t operator()( VULKAN_HPP_NAMESPACE::GeometryDataNV const & geometryDataNV ) const VULKAN_HPP_NOEXCEPT 639 { 640 std::size_t seed = 0; 641 VULKAN_HPP_HASH_COMBINE( seed, geometryDataNV.triangles ); 642 VULKAN_HPP_HASH_COMBINE( seed, geometryDataNV.aabbs ); 643 return seed; 644 } 645 }; 646 647 template <> 648 struct hash<VULKAN_HPP_NAMESPACE::GeometryNV> 649 { operator ()std::hash650 std::size_t operator()( VULKAN_HPP_NAMESPACE::GeometryNV const & geometryNV ) const VULKAN_HPP_NOEXCEPT 651 { 652 std::size_t seed = 0; 653 VULKAN_HPP_HASH_COMBINE( seed, geometryNV.sType ); 654 VULKAN_HPP_HASH_COMBINE( seed, geometryNV.pNext ); 655 VULKAN_HPP_HASH_COMBINE( seed, geometryNV.geometryType ); 656 VULKAN_HPP_HASH_COMBINE( seed, geometryNV.geometry ); 657 VULKAN_HPP_HASH_COMBINE( seed, geometryNV.flags ); 658 return seed; 659 } 660 }; 661 662 template <> 663 struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV> 664 { operator ()std::hash665 std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV const & accelerationStructureInfoNV ) const VULKAN_HPP_NOEXCEPT 666 { 667 std::size_t seed = 0; 668 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInfoNV.sType ); 669 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInfoNV.pNext ); 670 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInfoNV.type ); 671 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInfoNV.flags ); 672 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInfoNV.instanceCount ); 673 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInfoNV.geometryCount ); 674 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInfoNV.pGeometries ); 675 return seed; 676 } 677 }; 678 679 template <> 680 struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV> 681 { operator ()std::hash682 std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV const & accelerationStructureCreateInfoNV ) const VULKAN_HPP_NOEXCEPT 683 { 684 std::size_t seed = 0; 685 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoNV.sType ); 686 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoNV.pNext ); 687 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoNV.compactedSize ); 688 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoNV.info ); 689 return seed; 690 } 691 }; 692 693 template <> 694 struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR> 695 { 696 std::size_t operator ()std::hash697 operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR const & accelerationStructureDeviceAddressInfoKHR ) const VULKAN_HPP_NOEXCEPT 698 { 699 std::size_t seed = 0; 700 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureDeviceAddressInfoKHR.sType ); 701 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureDeviceAddressInfoKHR.pNext ); 702 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureDeviceAddressInfoKHR.accelerationStructure ); 703 return seed; 704 } 705 }; 706 707 template <> 708 struct hash<VULKAN_HPP_NAMESPACE::TransformMatrixKHR> 709 { operator ()std::hash710 std::size_t operator()( VULKAN_HPP_NAMESPACE::TransformMatrixKHR const & transformMatrixKHR ) const VULKAN_HPP_NOEXCEPT 711 { 712 std::size_t seed = 0; 713 for ( size_t i = 0; i < 3; ++i ) 714 { 715 for ( size_t j = 0; j < 4; ++j ) 716 { 717 VULKAN_HPP_HASH_COMBINE( seed, transformMatrixKHR.matrix[i][j] ); 718 } 719 } 720 return seed; 721 } 722 }; 723 724 template <> 725 struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureInstanceKHR> 726 { operator ()std::hash727 std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureInstanceKHR const & accelerationStructureInstanceKHR ) const VULKAN_HPP_NOEXCEPT 728 { 729 std::size_t seed = 0; 730 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInstanceKHR.transform ); 731 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInstanceKHR.instanceCustomIndex ); 732 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInstanceKHR.mask ); 733 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInstanceKHR.instanceShaderBindingTableRecordOffset ); 734 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInstanceKHR.flags ); 735 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInstanceKHR.accelerationStructureReference ); 736 return seed; 737 } 738 }; 739 740 template <> 741 struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureMatrixMotionInstanceNV> 742 { operator ()std::hash743 std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureMatrixMotionInstanceNV const & accelerationStructureMatrixMotionInstanceNV ) const 744 VULKAN_HPP_NOEXCEPT 745 { 746 std::size_t seed = 0; 747 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMatrixMotionInstanceNV.transformT0 ); 748 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMatrixMotionInstanceNV.transformT1 ); 749 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMatrixMotionInstanceNV.instanceCustomIndex ); 750 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMatrixMotionInstanceNV.mask ); 751 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMatrixMotionInstanceNV.instanceShaderBindingTableRecordOffset ); 752 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMatrixMotionInstanceNV.flags ); 753 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMatrixMotionInstanceNV.accelerationStructureReference ); 754 return seed; 755 } 756 }; 757 758 template <> 759 struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV> 760 { operator ()std::hash761 std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV const & accelerationStructureMemoryRequirementsInfoNV ) const 762 VULKAN_HPP_NOEXCEPT 763 { 764 std::size_t seed = 0; 765 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMemoryRequirementsInfoNV.sType ); 766 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMemoryRequirementsInfoNV.pNext ); 767 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMemoryRequirementsInfoNV.type ); 768 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMemoryRequirementsInfoNV.accelerationStructure ); 769 return seed; 770 } 771 }; 772 773 template <> 774 struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInfoNV> 775 { operator ()std::hash776 std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInfoNV const & accelerationStructureMotionInfoNV ) const VULKAN_HPP_NOEXCEPT 777 { 778 std::size_t seed = 0; 779 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMotionInfoNV.sType ); 780 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMotionInfoNV.pNext ); 781 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMotionInfoNV.maxInstances ); 782 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMotionInfoNV.flags ); 783 return seed; 784 } 785 }; 786 787 template <> 788 struct hash<VULKAN_HPP_NAMESPACE::SRTDataNV> 789 { operator ()std::hash790 std::size_t operator()( VULKAN_HPP_NAMESPACE::SRTDataNV const & sRTDataNV ) const VULKAN_HPP_NOEXCEPT 791 { 792 std::size_t seed = 0; 793 VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.sx ); 794 VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.a ); 795 VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.b ); 796 VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.pvx ); 797 VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.sy ); 798 VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.c ); 799 VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.pvy ); 800 VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.sz ); 801 VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.pvz ); 802 VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.qx ); 803 VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.qy ); 804 VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.qz ); 805 VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.qw ); 806 VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.tx ); 807 VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.ty ); 808 VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.tz ); 809 return seed; 810 } 811 }; 812 813 template <> 814 struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureSRTMotionInstanceNV> 815 { 816 std::size_t operator ()std::hash817 operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureSRTMotionInstanceNV const & accelerationStructureSRTMotionInstanceNV ) const VULKAN_HPP_NOEXCEPT 818 { 819 std::size_t seed = 0; 820 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureSRTMotionInstanceNV.transformT0 ); 821 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureSRTMotionInstanceNV.transformT1 ); 822 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureSRTMotionInstanceNV.instanceCustomIndex ); 823 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureSRTMotionInstanceNV.mask ); 824 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureSRTMotionInstanceNV.instanceShaderBindingTableRecordOffset ); 825 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureSRTMotionInstanceNV.flags ); 826 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureSRTMotionInstanceNV.accelerationStructureReference ); 827 return seed; 828 } 829 }; 830 831 template <> 832 struct hash<VULKAN_HPP_NAMESPACE::MicromapUsageEXT> 833 { operator ()std::hash834 std::size_t operator()( VULKAN_HPP_NAMESPACE::MicromapUsageEXT const & micromapUsageEXT ) const VULKAN_HPP_NOEXCEPT 835 { 836 std::size_t seed = 0; 837 VULKAN_HPP_HASH_COMBINE( seed, micromapUsageEXT.count ); 838 VULKAN_HPP_HASH_COMBINE( seed, micromapUsageEXT.subdivisionLevel ); 839 VULKAN_HPP_HASH_COMBINE( seed, micromapUsageEXT.format ); 840 return seed; 841 } 842 }; 843 844 template <> 845 struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureVersionInfoKHR> 846 { operator ()std::hash847 std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureVersionInfoKHR const & accelerationStructureVersionInfoKHR ) const VULKAN_HPP_NOEXCEPT 848 { 849 std::size_t seed = 0; 850 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureVersionInfoKHR.sType ); 851 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureVersionInfoKHR.pNext ); 852 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureVersionInfoKHR.pVersionData ); 853 return seed; 854 } 855 }; 856 857 template <> 858 struct hash<VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR> 859 { operator ()std::hash860 std::size_t operator()( VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR const & acquireNextImageInfoKHR ) const VULKAN_HPP_NOEXCEPT 861 { 862 std::size_t seed = 0; 863 VULKAN_HPP_HASH_COMBINE( seed, acquireNextImageInfoKHR.sType ); 864 VULKAN_HPP_HASH_COMBINE( seed, acquireNextImageInfoKHR.pNext ); 865 VULKAN_HPP_HASH_COMBINE( seed, acquireNextImageInfoKHR.swapchain ); 866 VULKAN_HPP_HASH_COMBINE( seed, acquireNextImageInfoKHR.timeout ); 867 VULKAN_HPP_HASH_COMBINE( seed, acquireNextImageInfoKHR.semaphore ); 868 VULKAN_HPP_HASH_COMBINE( seed, acquireNextImageInfoKHR.fence ); 869 VULKAN_HPP_HASH_COMBINE( seed, acquireNextImageInfoKHR.deviceMask ); 870 return seed; 871 } 872 }; 873 874 template <> 875 struct hash<VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR> 876 { operator ()std::hash877 std::size_t operator()( VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR const & acquireProfilingLockInfoKHR ) const VULKAN_HPP_NOEXCEPT 878 { 879 std::size_t seed = 0; 880 VULKAN_HPP_HASH_COMBINE( seed, acquireProfilingLockInfoKHR.sType ); 881 VULKAN_HPP_HASH_COMBINE( seed, acquireProfilingLockInfoKHR.pNext ); 882 VULKAN_HPP_HASH_COMBINE( seed, acquireProfilingLockInfoKHR.flags ); 883 VULKAN_HPP_HASH_COMBINE( seed, acquireProfilingLockInfoKHR.timeout ); 884 return seed; 885 } 886 }; 887 888 template <> 889 struct hash<VULKAN_HPP_NAMESPACE::AllocationCallbacks> 890 { operator ()std::hash891 std::size_t operator()( VULKAN_HPP_NAMESPACE::AllocationCallbacks const & allocationCallbacks ) const VULKAN_HPP_NOEXCEPT 892 { 893 std::size_t seed = 0; 894 VULKAN_HPP_HASH_COMBINE( seed, allocationCallbacks.pUserData ); 895 VULKAN_HPP_HASH_COMBINE( seed, allocationCallbacks.pfnAllocation ); 896 VULKAN_HPP_HASH_COMBINE( seed, allocationCallbacks.pfnReallocation ); 897 VULKAN_HPP_HASH_COMBINE( seed, allocationCallbacks.pfnFree ); 898 VULKAN_HPP_HASH_COMBINE( seed, allocationCallbacks.pfnInternalAllocation ); 899 VULKAN_HPP_HASH_COMBINE( seed, allocationCallbacks.pfnInternalFree ); 900 return seed; 901 } 902 }; 903 904 template <> 905 struct hash<VULKAN_HPP_NAMESPACE::AmigoProfilingSubmitInfoSEC> 906 { operator ()std::hash907 std::size_t operator()( VULKAN_HPP_NAMESPACE::AmigoProfilingSubmitInfoSEC const & amigoProfilingSubmitInfoSEC ) const VULKAN_HPP_NOEXCEPT 908 { 909 std::size_t seed = 0; 910 VULKAN_HPP_HASH_COMBINE( seed, amigoProfilingSubmitInfoSEC.sType ); 911 VULKAN_HPP_HASH_COMBINE( seed, amigoProfilingSubmitInfoSEC.pNext ); 912 VULKAN_HPP_HASH_COMBINE( seed, amigoProfilingSubmitInfoSEC.firstDrawTimestamp ); 913 VULKAN_HPP_HASH_COMBINE( seed, amigoProfilingSubmitInfoSEC.swapBufferTimestamp ); 914 return seed; 915 } 916 }; 917 918 template <> 919 struct hash<VULKAN_HPP_NAMESPACE::ComponentMapping> 920 { operator ()std::hash921 std::size_t operator()( VULKAN_HPP_NAMESPACE::ComponentMapping const & componentMapping ) const VULKAN_HPP_NOEXCEPT 922 { 923 std::size_t seed = 0; 924 VULKAN_HPP_HASH_COMBINE( seed, componentMapping.r ); 925 VULKAN_HPP_HASH_COMBINE( seed, componentMapping.g ); 926 VULKAN_HPP_HASH_COMBINE( seed, componentMapping.b ); 927 VULKAN_HPP_HASH_COMBINE( seed, componentMapping.a ); 928 return seed; 929 } 930 }; 931 932 # if defined( VK_USE_PLATFORM_ANDROID_KHR ) 933 template <> 934 struct hash<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatProperties2ANDROID> 935 { operator ()std::hash936 std::size_t operator()( VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatProperties2ANDROID const & androidHardwareBufferFormatProperties2ANDROID ) const 937 VULKAN_HPP_NOEXCEPT 938 { 939 std::size_t seed = 0; 940 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.sType ); 941 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.pNext ); 942 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.format ); 943 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.externalFormat ); 944 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.formatFeatures ); 945 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.samplerYcbcrConversionComponents ); 946 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.suggestedYcbcrModel ); 947 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.suggestedYcbcrRange ); 948 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.suggestedXChromaOffset ); 949 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.suggestedYChromaOffset ); 950 return seed; 951 } 952 }; 953 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ 954 955 # if defined( VK_USE_PLATFORM_ANDROID_KHR ) 956 template <> 957 struct hash<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatPropertiesANDROID> 958 { operator ()std::hash959 std::size_t operator()( VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatPropertiesANDROID const & androidHardwareBufferFormatPropertiesANDROID ) const 960 VULKAN_HPP_NOEXCEPT 961 { 962 std::size_t seed = 0; 963 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.sType ); 964 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.pNext ); 965 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.format ); 966 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.externalFormat ); 967 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.formatFeatures ); 968 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.samplerYcbcrConversionComponents ); 969 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.suggestedYcbcrModel ); 970 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.suggestedYcbcrRange ); 971 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.suggestedXChromaOffset ); 972 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.suggestedYChromaOffset ); 973 return seed; 974 } 975 }; 976 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ 977 978 # if defined( VK_USE_PLATFORM_ANDROID_KHR ) 979 template <> 980 struct hash<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatResolvePropertiesANDROID> 981 { 982 std::size_t operator ()std::hash983 operator()( VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatResolvePropertiesANDROID const & androidHardwareBufferFormatResolvePropertiesANDROID ) const 984 VULKAN_HPP_NOEXCEPT 985 { 986 std::size_t seed = 0; 987 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatResolvePropertiesANDROID.sType ); 988 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatResolvePropertiesANDROID.pNext ); 989 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatResolvePropertiesANDROID.colorAttachmentFormat ); 990 return seed; 991 } 992 }; 993 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ 994 995 # if defined( VK_USE_PLATFORM_ANDROID_KHR ) 996 template <> 997 struct hash<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID> 998 { 999 std::size_t operator ()std::hash1000 operator()( VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID const & androidHardwareBufferPropertiesANDROID ) const VULKAN_HPP_NOEXCEPT 1001 { 1002 std::size_t seed = 0; 1003 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferPropertiesANDROID.sType ); 1004 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferPropertiesANDROID.pNext ); 1005 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferPropertiesANDROID.allocationSize ); 1006 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferPropertiesANDROID.memoryTypeBits ); 1007 return seed; 1008 } 1009 }; 1010 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ 1011 1012 # if defined( VK_USE_PLATFORM_ANDROID_KHR ) 1013 template <> 1014 struct hash<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferUsageANDROID> 1015 { operator ()std::hash1016 std::size_t operator()( VULKAN_HPP_NAMESPACE::AndroidHardwareBufferUsageANDROID const & androidHardwareBufferUsageANDROID ) const VULKAN_HPP_NOEXCEPT 1017 { 1018 std::size_t seed = 0; 1019 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferUsageANDROID.sType ); 1020 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferUsageANDROID.pNext ); 1021 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferUsageANDROID.androidHardwareBufferUsage ); 1022 return seed; 1023 } 1024 }; 1025 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ 1026 1027 # if defined( VK_USE_PLATFORM_ANDROID_KHR ) 1028 template <> 1029 struct hash<VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR> 1030 { operator ()std::hash1031 std::size_t operator()( VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR const & androidSurfaceCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 1032 { 1033 std::size_t seed = 0; 1034 VULKAN_HPP_HASH_COMBINE( seed, androidSurfaceCreateInfoKHR.sType ); 1035 VULKAN_HPP_HASH_COMBINE( seed, androidSurfaceCreateInfoKHR.pNext ); 1036 VULKAN_HPP_HASH_COMBINE( seed, androidSurfaceCreateInfoKHR.flags ); 1037 VULKAN_HPP_HASH_COMBINE( seed, androidSurfaceCreateInfoKHR.window ); 1038 return seed; 1039 } 1040 }; 1041 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ 1042 1043 template <> 1044 struct hash<VULKAN_HPP_NAMESPACE::ApplicationInfo> 1045 { operator ()std::hash1046 std::size_t operator()( VULKAN_HPP_NAMESPACE::ApplicationInfo const & applicationInfo ) const VULKAN_HPP_NOEXCEPT 1047 { 1048 std::size_t seed = 0; 1049 VULKAN_HPP_HASH_COMBINE( seed, applicationInfo.sType ); 1050 VULKAN_HPP_HASH_COMBINE( seed, applicationInfo.pNext ); 1051 for ( const char * p = applicationInfo.pApplicationName; *p != '\0'; ++p ) 1052 { 1053 VULKAN_HPP_HASH_COMBINE( seed, *p ); 1054 } 1055 VULKAN_HPP_HASH_COMBINE( seed, applicationInfo.applicationVersion ); 1056 for ( const char * p = applicationInfo.pEngineName; *p != '\0'; ++p ) 1057 { 1058 VULKAN_HPP_HASH_COMBINE( seed, *p ); 1059 } 1060 VULKAN_HPP_HASH_COMBINE( seed, applicationInfo.engineVersion ); 1061 VULKAN_HPP_HASH_COMBINE( seed, applicationInfo.apiVersion ); 1062 return seed; 1063 } 1064 }; 1065 1066 template <> 1067 struct hash<VULKAN_HPP_NAMESPACE::AttachmentDescription> 1068 { operator ()std::hash1069 std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentDescription const & attachmentDescription ) const VULKAN_HPP_NOEXCEPT 1070 { 1071 std::size_t seed = 0; 1072 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.flags ); 1073 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.format ); 1074 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.samples ); 1075 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.loadOp ); 1076 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.storeOp ); 1077 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.stencilLoadOp ); 1078 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.stencilStoreOp ); 1079 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.initialLayout ); 1080 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.finalLayout ); 1081 return seed; 1082 } 1083 }; 1084 1085 template <> 1086 struct hash<VULKAN_HPP_NAMESPACE::AttachmentDescription2> 1087 { operator ()std::hash1088 std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentDescription2 const & attachmentDescription2 ) const VULKAN_HPP_NOEXCEPT 1089 { 1090 std::size_t seed = 0; 1091 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.sType ); 1092 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.pNext ); 1093 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.flags ); 1094 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.format ); 1095 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.samples ); 1096 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.loadOp ); 1097 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.storeOp ); 1098 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.stencilLoadOp ); 1099 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.stencilStoreOp ); 1100 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.initialLayout ); 1101 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.finalLayout ); 1102 return seed; 1103 } 1104 }; 1105 1106 template <> 1107 struct hash<VULKAN_HPP_NAMESPACE::AttachmentDescriptionStencilLayout> 1108 { operator ()std::hash1109 std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentDescriptionStencilLayout const & attachmentDescriptionStencilLayout ) const VULKAN_HPP_NOEXCEPT 1110 { 1111 std::size_t seed = 0; 1112 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescriptionStencilLayout.sType ); 1113 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescriptionStencilLayout.pNext ); 1114 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescriptionStencilLayout.stencilInitialLayout ); 1115 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescriptionStencilLayout.stencilFinalLayout ); 1116 return seed; 1117 } 1118 }; 1119 1120 template <> 1121 struct hash<VULKAN_HPP_NAMESPACE::AttachmentReference> 1122 { operator ()std::hash1123 std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentReference const & attachmentReference ) const VULKAN_HPP_NOEXCEPT 1124 { 1125 std::size_t seed = 0; 1126 VULKAN_HPP_HASH_COMBINE( seed, attachmentReference.attachment ); 1127 VULKAN_HPP_HASH_COMBINE( seed, attachmentReference.layout ); 1128 return seed; 1129 } 1130 }; 1131 1132 template <> 1133 struct hash<VULKAN_HPP_NAMESPACE::AttachmentReference2> 1134 { operator ()std::hash1135 std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentReference2 const & attachmentReference2 ) const VULKAN_HPP_NOEXCEPT 1136 { 1137 std::size_t seed = 0; 1138 VULKAN_HPP_HASH_COMBINE( seed, attachmentReference2.sType ); 1139 VULKAN_HPP_HASH_COMBINE( seed, attachmentReference2.pNext ); 1140 VULKAN_HPP_HASH_COMBINE( seed, attachmentReference2.attachment ); 1141 VULKAN_HPP_HASH_COMBINE( seed, attachmentReference2.layout ); 1142 VULKAN_HPP_HASH_COMBINE( seed, attachmentReference2.aspectMask ); 1143 return seed; 1144 } 1145 }; 1146 1147 template <> 1148 struct hash<VULKAN_HPP_NAMESPACE::AttachmentReferenceStencilLayout> 1149 { operator ()std::hash1150 std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentReferenceStencilLayout const & attachmentReferenceStencilLayout ) const VULKAN_HPP_NOEXCEPT 1151 { 1152 std::size_t seed = 0; 1153 VULKAN_HPP_HASH_COMBINE( seed, attachmentReferenceStencilLayout.sType ); 1154 VULKAN_HPP_HASH_COMBINE( seed, attachmentReferenceStencilLayout.pNext ); 1155 VULKAN_HPP_HASH_COMBINE( seed, attachmentReferenceStencilLayout.stencilLayout ); 1156 return seed; 1157 } 1158 }; 1159 1160 template <> 1161 struct hash<VULKAN_HPP_NAMESPACE::AttachmentSampleCountInfoAMD> 1162 { operator ()std::hash1163 std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentSampleCountInfoAMD const & attachmentSampleCountInfoAMD ) const VULKAN_HPP_NOEXCEPT 1164 { 1165 std::size_t seed = 0; 1166 VULKAN_HPP_HASH_COMBINE( seed, attachmentSampleCountInfoAMD.sType ); 1167 VULKAN_HPP_HASH_COMBINE( seed, attachmentSampleCountInfoAMD.pNext ); 1168 VULKAN_HPP_HASH_COMBINE( seed, attachmentSampleCountInfoAMD.colorAttachmentCount ); 1169 VULKAN_HPP_HASH_COMBINE( seed, attachmentSampleCountInfoAMD.pColorAttachmentSamples ); 1170 VULKAN_HPP_HASH_COMBINE( seed, attachmentSampleCountInfoAMD.depthStencilAttachmentSamples ); 1171 return seed; 1172 } 1173 }; 1174 1175 template <> 1176 struct hash<VULKAN_HPP_NAMESPACE::Extent2D> 1177 { operator ()std::hash1178 std::size_t operator()( VULKAN_HPP_NAMESPACE::Extent2D const & extent2D ) const VULKAN_HPP_NOEXCEPT 1179 { 1180 std::size_t seed = 0; 1181 VULKAN_HPP_HASH_COMBINE( seed, extent2D.width ); 1182 VULKAN_HPP_HASH_COMBINE( seed, extent2D.height ); 1183 return seed; 1184 } 1185 }; 1186 1187 template <> 1188 struct hash<VULKAN_HPP_NAMESPACE::SampleLocationEXT> 1189 { operator ()std::hash1190 std::size_t operator()( VULKAN_HPP_NAMESPACE::SampleLocationEXT const & sampleLocationEXT ) const VULKAN_HPP_NOEXCEPT 1191 { 1192 std::size_t seed = 0; 1193 VULKAN_HPP_HASH_COMBINE( seed, sampleLocationEXT.x ); 1194 VULKAN_HPP_HASH_COMBINE( seed, sampleLocationEXT.y ); 1195 return seed; 1196 } 1197 }; 1198 1199 template <> 1200 struct hash<VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT> 1201 { operator ()std::hash1202 std::size_t operator()( VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT const & sampleLocationsInfoEXT ) const VULKAN_HPP_NOEXCEPT 1203 { 1204 std::size_t seed = 0; 1205 VULKAN_HPP_HASH_COMBINE( seed, sampleLocationsInfoEXT.sType ); 1206 VULKAN_HPP_HASH_COMBINE( seed, sampleLocationsInfoEXT.pNext ); 1207 VULKAN_HPP_HASH_COMBINE( seed, sampleLocationsInfoEXT.sampleLocationsPerPixel ); 1208 VULKAN_HPP_HASH_COMBINE( seed, sampleLocationsInfoEXT.sampleLocationGridSize ); 1209 VULKAN_HPP_HASH_COMBINE( seed, sampleLocationsInfoEXT.sampleLocationsCount ); 1210 VULKAN_HPP_HASH_COMBINE( seed, sampleLocationsInfoEXT.pSampleLocations ); 1211 return seed; 1212 } 1213 }; 1214 1215 template <> 1216 struct hash<VULKAN_HPP_NAMESPACE::AttachmentSampleLocationsEXT> 1217 { operator ()std::hash1218 std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentSampleLocationsEXT const & attachmentSampleLocationsEXT ) const VULKAN_HPP_NOEXCEPT 1219 { 1220 std::size_t seed = 0; 1221 VULKAN_HPP_HASH_COMBINE( seed, attachmentSampleLocationsEXT.attachmentIndex ); 1222 VULKAN_HPP_HASH_COMBINE( seed, attachmentSampleLocationsEXT.sampleLocationsInfo ); 1223 return seed; 1224 } 1225 }; 1226 1227 template <> 1228 struct hash<VULKAN_HPP_NAMESPACE::BaseInStructure> 1229 { operator ()std::hash1230 std::size_t operator()( VULKAN_HPP_NAMESPACE::BaseInStructure const & baseInStructure ) const VULKAN_HPP_NOEXCEPT 1231 { 1232 std::size_t seed = 0; 1233 VULKAN_HPP_HASH_COMBINE( seed, baseInStructure.sType ); 1234 VULKAN_HPP_HASH_COMBINE( seed, baseInStructure.pNext ); 1235 return seed; 1236 } 1237 }; 1238 1239 template <> 1240 struct hash<VULKAN_HPP_NAMESPACE::BaseOutStructure> 1241 { operator ()std::hash1242 std::size_t operator()( VULKAN_HPP_NAMESPACE::BaseOutStructure const & baseOutStructure ) const VULKAN_HPP_NOEXCEPT 1243 { 1244 std::size_t seed = 0; 1245 VULKAN_HPP_HASH_COMBINE( seed, baseOutStructure.sType ); 1246 VULKAN_HPP_HASH_COMBINE( seed, baseOutStructure.pNext ); 1247 return seed; 1248 } 1249 }; 1250 1251 template <> 1252 struct hash<VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV> 1253 { 1254 std::size_t operator ()std::hash1255 operator()( VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV const & bindAccelerationStructureMemoryInfoNV ) const VULKAN_HPP_NOEXCEPT 1256 { 1257 std::size_t seed = 0; 1258 VULKAN_HPP_HASH_COMBINE( seed, bindAccelerationStructureMemoryInfoNV.sType ); 1259 VULKAN_HPP_HASH_COMBINE( seed, bindAccelerationStructureMemoryInfoNV.pNext ); 1260 VULKAN_HPP_HASH_COMBINE( seed, bindAccelerationStructureMemoryInfoNV.accelerationStructure ); 1261 VULKAN_HPP_HASH_COMBINE( seed, bindAccelerationStructureMemoryInfoNV.memory ); 1262 VULKAN_HPP_HASH_COMBINE( seed, bindAccelerationStructureMemoryInfoNV.memoryOffset ); 1263 VULKAN_HPP_HASH_COMBINE( seed, bindAccelerationStructureMemoryInfoNV.deviceIndexCount ); 1264 VULKAN_HPP_HASH_COMBINE( seed, bindAccelerationStructureMemoryInfoNV.pDeviceIndices ); 1265 return seed; 1266 } 1267 }; 1268 1269 template <> 1270 struct hash<VULKAN_HPP_NAMESPACE::BindBufferMemoryDeviceGroupInfo> 1271 { operator ()std::hash1272 std::size_t operator()( VULKAN_HPP_NAMESPACE::BindBufferMemoryDeviceGroupInfo const & bindBufferMemoryDeviceGroupInfo ) const VULKAN_HPP_NOEXCEPT 1273 { 1274 std::size_t seed = 0; 1275 VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryDeviceGroupInfo.sType ); 1276 VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryDeviceGroupInfo.pNext ); 1277 VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryDeviceGroupInfo.deviceIndexCount ); 1278 VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryDeviceGroupInfo.pDeviceIndices ); 1279 return seed; 1280 } 1281 }; 1282 1283 template <> 1284 struct hash<VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo> 1285 { operator ()std::hash1286 std::size_t operator()( VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo const & bindBufferMemoryInfo ) const VULKAN_HPP_NOEXCEPT 1287 { 1288 std::size_t seed = 0; 1289 VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryInfo.sType ); 1290 VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryInfo.pNext ); 1291 VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryInfo.buffer ); 1292 VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryInfo.memory ); 1293 VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryInfo.memoryOffset ); 1294 return seed; 1295 } 1296 }; 1297 1298 template <> 1299 struct hash<VULKAN_HPP_NAMESPACE::Offset2D> 1300 { operator ()std::hash1301 std::size_t operator()( VULKAN_HPP_NAMESPACE::Offset2D const & offset2D ) const VULKAN_HPP_NOEXCEPT 1302 { 1303 std::size_t seed = 0; 1304 VULKAN_HPP_HASH_COMBINE( seed, offset2D.x ); 1305 VULKAN_HPP_HASH_COMBINE( seed, offset2D.y ); 1306 return seed; 1307 } 1308 }; 1309 1310 template <> 1311 struct hash<VULKAN_HPP_NAMESPACE::Rect2D> 1312 { operator ()std::hash1313 std::size_t operator()( VULKAN_HPP_NAMESPACE::Rect2D const & rect2D ) const VULKAN_HPP_NOEXCEPT 1314 { 1315 std::size_t seed = 0; 1316 VULKAN_HPP_HASH_COMBINE( seed, rect2D.offset ); 1317 VULKAN_HPP_HASH_COMBINE( seed, rect2D.extent ); 1318 return seed; 1319 } 1320 }; 1321 1322 template <> 1323 struct hash<VULKAN_HPP_NAMESPACE::BindImageMemoryDeviceGroupInfo> 1324 { operator ()std::hash1325 std::size_t operator()( VULKAN_HPP_NAMESPACE::BindImageMemoryDeviceGroupInfo const & bindImageMemoryDeviceGroupInfo ) const VULKAN_HPP_NOEXCEPT 1326 { 1327 std::size_t seed = 0; 1328 VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryDeviceGroupInfo.sType ); 1329 VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryDeviceGroupInfo.pNext ); 1330 VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryDeviceGroupInfo.deviceIndexCount ); 1331 VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryDeviceGroupInfo.pDeviceIndices ); 1332 VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryDeviceGroupInfo.splitInstanceBindRegionCount ); 1333 VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryDeviceGroupInfo.pSplitInstanceBindRegions ); 1334 return seed; 1335 } 1336 }; 1337 1338 template <> 1339 struct hash<VULKAN_HPP_NAMESPACE::BindImageMemoryInfo> 1340 { operator ()std::hash1341 std::size_t operator()( VULKAN_HPP_NAMESPACE::BindImageMemoryInfo const & bindImageMemoryInfo ) const VULKAN_HPP_NOEXCEPT 1342 { 1343 std::size_t seed = 0; 1344 VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryInfo.sType ); 1345 VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryInfo.pNext ); 1346 VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryInfo.image ); 1347 VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryInfo.memory ); 1348 VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryInfo.memoryOffset ); 1349 return seed; 1350 } 1351 }; 1352 1353 template <> 1354 struct hash<VULKAN_HPP_NAMESPACE::BindImageMemorySwapchainInfoKHR> 1355 { operator ()std::hash1356 std::size_t operator()( VULKAN_HPP_NAMESPACE::BindImageMemorySwapchainInfoKHR const & bindImageMemorySwapchainInfoKHR ) const VULKAN_HPP_NOEXCEPT 1357 { 1358 std::size_t seed = 0; 1359 VULKAN_HPP_HASH_COMBINE( seed, bindImageMemorySwapchainInfoKHR.sType ); 1360 VULKAN_HPP_HASH_COMBINE( seed, bindImageMemorySwapchainInfoKHR.pNext ); 1361 VULKAN_HPP_HASH_COMBINE( seed, bindImageMemorySwapchainInfoKHR.swapchain ); 1362 VULKAN_HPP_HASH_COMBINE( seed, bindImageMemorySwapchainInfoKHR.imageIndex ); 1363 return seed; 1364 } 1365 }; 1366 1367 template <> 1368 struct hash<VULKAN_HPP_NAMESPACE::BindImagePlaneMemoryInfo> 1369 { operator ()std::hash1370 std::size_t operator()( VULKAN_HPP_NAMESPACE::BindImagePlaneMemoryInfo const & bindImagePlaneMemoryInfo ) const VULKAN_HPP_NOEXCEPT 1371 { 1372 std::size_t seed = 0; 1373 VULKAN_HPP_HASH_COMBINE( seed, bindImagePlaneMemoryInfo.sType ); 1374 VULKAN_HPP_HASH_COMBINE( seed, bindImagePlaneMemoryInfo.pNext ); 1375 VULKAN_HPP_HASH_COMBINE( seed, bindImagePlaneMemoryInfo.planeAspect ); 1376 return seed; 1377 } 1378 }; 1379 1380 template <> 1381 struct hash<VULKAN_HPP_NAMESPACE::BindIndexBufferIndirectCommandNV> 1382 { operator ()std::hash1383 std::size_t operator()( VULKAN_HPP_NAMESPACE::BindIndexBufferIndirectCommandNV const & bindIndexBufferIndirectCommandNV ) const VULKAN_HPP_NOEXCEPT 1384 { 1385 std::size_t seed = 0; 1386 VULKAN_HPP_HASH_COMBINE( seed, bindIndexBufferIndirectCommandNV.bufferAddress ); 1387 VULKAN_HPP_HASH_COMBINE( seed, bindIndexBufferIndirectCommandNV.size ); 1388 VULKAN_HPP_HASH_COMBINE( seed, bindIndexBufferIndirectCommandNV.indexType ); 1389 return seed; 1390 } 1391 }; 1392 1393 template <> 1394 struct hash<VULKAN_HPP_NAMESPACE::BindPipelineIndirectCommandNV> 1395 { operator ()std::hash1396 std::size_t operator()( VULKAN_HPP_NAMESPACE::BindPipelineIndirectCommandNV const & bindPipelineIndirectCommandNV ) const VULKAN_HPP_NOEXCEPT 1397 { 1398 std::size_t seed = 0; 1399 VULKAN_HPP_HASH_COMBINE( seed, bindPipelineIndirectCommandNV.pipelineAddress ); 1400 return seed; 1401 } 1402 }; 1403 1404 template <> 1405 struct hash<VULKAN_HPP_NAMESPACE::BindShaderGroupIndirectCommandNV> 1406 { operator ()std::hash1407 std::size_t operator()( VULKAN_HPP_NAMESPACE::BindShaderGroupIndirectCommandNV const & bindShaderGroupIndirectCommandNV ) const VULKAN_HPP_NOEXCEPT 1408 { 1409 std::size_t seed = 0; 1410 VULKAN_HPP_HASH_COMBINE( seed, bindShaderGroupIndirectCommandNV.groupIndex ); 1411 return seed; 1412 } 1413 }; 1414 1415 template <> 1416 struct hash<VULKAN_HPP_NAMESPACE::SparseMemoryBind> 1417 { operator ()std::hash1418 std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseMemoryBind const & sparseMemoryBind ) const VULKAN_HPP_NOEXCEPT 1419 { 1420 std::size_t seed = 0; 1421 VULKAN_HPP_HASH_COMBINE( seed, sparseMemoryBind.resourceOffset ); 1422 VULKAN_HPP_HASH_COMBINE( seed, sparseMemoryBind.size ); 1423 VULKAN_HPP_HASH_COMBINE( seed, sparseMemoryBind.memory ); 1424 VULKAN_HPP_HASH_COMBINE( seed, sparseMemoryBind.memoryOffset ); 1425 VULKAN_HPP_HASH_COMBINE( seed, sparseMemoryBind.flags ); 1426 return seed; 1427 } 1428 }; 1429 1430 template <> 1431 struct hash<VULKAN_HPP_NAMESPACE::SparseBufferMemoryBindInfo> 1432 { operator ()std::hash1433 std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseBufferMemoryBindInfo const & sparseBufferMemoryBindInfo ) const VULKAN_HPP_NOEXCEPT 1434 { 1435 std::size_t seed = 0; 1436 VULKAN_HPP_HASH_COMBINE( seed, sparseBufferMemoryBindInfo.buffer ); 1437 VULKAN_HPP_HASH_COMBINE( seed, sparseBufferMemoryBindInfo.bindCount ); 1438 VULKAN_HPP_HASH_COMBINE( seed, sparseBufferMemoryBindInfo.pBinds ); 1439 return seed; 1440 } 1441 }; 1442 1443 template <> 1444 struct hash<VULKAN_HPP_NAMESPACE::SparseImageOpaqueMemoryBindInfo> 1445 { operator ()std::hash1446 std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageOpaqueMemoryBindInfo const & sparseImageOpaqueMemoryBindInfo ) const VULKAN_HPP_NOEXCEPT 1447 { 1448 std::size_t seed = 0; 1449 VULKAN_HPP_HASH_COMBINE( seed, sparseImageOpaqueMemoryBindInfo.image ); 1450 VULKAN_HPP_HASH_COMBINE( seed, sparseImageOpaqueMemoryBindInfo.bindCount ); 1451 VULKAN_HPP_HASH_COMBINE( seed, sparseImageOpaqueMemoryBindInfo.pBinds ); 1452 return seed; 1453 } 1454 }; 1455 1456 template <> 1457 struct hash<VULKAN_HPP_NAMESPACE::ImageSubresource> 1458 { operator ()std::hash1459 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageSubresource const & imageSubresource ) const VULKAN_HPP_NOEXCEPT 1460 { 1461 std::size_t seed = 0; 1462 VULKAN_HPP_HASH_COMBINE( seed, imageSubresource.aspectMask ); 1463 VULKAN_HPP_HASH_COMBINE( seed, imageSubresource.mipLevel ); 1464 VULKAN_HPP_HASH_COMBINE( seed, imageSubresource.arrayLayer ); 1465 return seed; 1466 } 1467 }; 1468 1469 template <> 1470 struct hash<VULKAN_HPP_NAMESPACE::Offset3D> 1471 { operator ()std::hash1472 std::size_t operator()( VULKAN_HPP_NAMESPACE::Offset3D const & offset3D ) const VULKAN_HPP_NOEXCEPT 1473 { 1474 std::size_t seed = 0; 1475 VULKAN_HPP_HASH_COMBINE( seed, offset3D.x ); 1476 VULKAN_HPP_HASH_COMBINE( seed, offset3D.y ); 1477 VULKAN_HPP_HASH_COMBINE( seed, offset3D.z ); 1478 return seed; 1479 } 1480 }; 1481 1482 template <> 1483 struct hash<VULKAN_HPP_NAMESPACE::Extent3D> 1484 { operator ()std::hash1485 std::size_t operator()( VULKAN_HPP_NAMESPACE::Extent3D const & extent3D ) const VULKAN_HPP_NOEXCEPT 1486 { 1487 std::size_t seed = 0; 1488 VULKAN_HPP_HASH_COMBINE( seed, extent3D.width ); 1489 VULKAN_HPP_HASH_COMBINE( seed, extent3D.height ); 1490 VULKAN_HPP_HASH_COMBINE( seed, extent3D.depth ); 1491 return seed; 1492 } 1493 }; 1494 1495 template <> 1496 struct hash<VULKAN_HPP_NAMESPACE::SparseImageMemoryBind> 1497 { operator ()std::hash1498 std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageMemoryBind const & sparseImageMemoryBind ) const VULKAN_HPP_NOEXCEPT 1499 { 1500 std::size_t seed = 0; 1501 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBind.subresource ); 1502 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBind.offset ); 1503 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBind.extent ); 1504 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBind.memory ); 1505 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBind.memoryOffset ); 1506 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBind.flags ); 1507 return seed; 1508 } 1509 }; 1510 1511 template <> 1512 struct hash<VULKAN_HPP_NAMESPACE::SparseImageMemoryBindInfo> 1513 { operator ()std::hash1514 std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageMemoryBindInfo const & sparseImageMemoryBindInfo ) const VULKAN_HPP_NOEXCEPT 1515 { 1516 std::size_t seed = 0; 1517 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBindInfo.image ); 1518 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBindInfo.bindCount ); 1519 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBindInfo.pBinds ); 1520 return seed; 1521 } 1522 }; 1523 1524 template <> 1525 struct hash<VULKAN_HPP_NAMESPACE::BindSparseInfo> 1526 { operator ()std::hash1527 std::size_t operator()( VULKAN_HPP_NAMESPACE::BindSparseInfo const & bindSparseInfo ) const VULKAN_HPP_NOEXCEPT 1528 { 1529 std::size_t seed = 0; 1530 VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.sType ); 1531 VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.pNext ); 1532 VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.waitSemaphoreCount ); 1533 VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.pWaitSemaphores ); 1534 VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.bufferBindCount ); 1535 VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.pBufferBinds ); 1536 VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.imageOpaqueBindCount ); 1537 VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.pImageOpaqueBinds ); 1538 VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.imageBindCount ); 1539 VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.pImageBinds ); 1540 VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.signalSemaphoreCount ); 1541 VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.pSignalSemaphores ); 1542 return seed; 1543 } 1544 }; 1545 1546 template <> 1547 struct hash<VULKAN_HPP_NAMESPACE::BindVertexBufferIndirectCommandNV> 1548 { operator ()std::hash1549 std::size_t operator()( VULKAN_HPP_NAMESPACE::BindVertexBufferIndirectCommandNV const & bindVertexBufferIndirectCommandNV ) const VULKAN_HPP_NOEXCEPT 1550 { 1551 std::size_t seed = 0; 1552 VULKAN_HPP_HASH_COMBINE( seed, bindVertexBufferIndirectCommandNV.bufferAddress ); 1553 VULKAN_HPP_HASH_COMBINE( seed, bindVertexBufferIndirectCommandNV.size ); 1554 VULKAN_HPP_HASH_COMBINE( seed, bindVertexBufferIndirectCommandNV.stride ); 1555 return seed; 1556 } 1557 }; 1558 1559 template <> 1560 struct hash<VULKAN_HPP_NAMESPACE::BindVideoSessionMemoryInfoKHR> 1561 { operator ()std::hash1562 std::size_t operator()( VULKAN_HPP_NAMESPACE::BindVideoSessionMemoryInfoKHR const & bindVideoSessionMemoryInfoKHR ) const VULKAN_HPP_NOEXCEPT 1563 { 1564 std::size_t seed = 0; 1565 VULKAN_HPP_HASH_COMBINE( seed, bindVideoSessionMemoryInfoKHR.sType ); 1566 VULKAN_HPP_HASH_COMBINE( seed, bindVideoSessionMemoryInfoKHR.pNext ); 1567 VULKAN_HPP_HASH_COMBINE( seed, bindVideoSessionMemoryInfoKHR.memoryBindIndex ); 1568 VULKAN_HPP_HASH_COMBINE( seed, bindVideoSessionMemoryInfoKHR.memory ); 1569 VULKAN_HPP_HASH_COMBINE( seed, bindVideoSessionMemoryInfoKHR.memoryOffset ); 1570 VULKAN_HPP_HASH_COMBINE( seed, bindVideoSessionMemoryInfoKHR.memorySize ); 1571 return seed; 1572 } 1573 }; 1574 1575 template <> 1576 struct hash<VULKAN_HPP_NAMESPACE::BlitImageCubicWeightsInfoQCOM> 1577 { operator ()std::hash1578 std::size_t operator()( VULKAN_HPP_NAMESPACE::BlitImageCubicWeightsInfoQCOM const & blitImageCubicWeightsInfoQCOM ) const VULKAN_HPP_NOEXCEPT 1579 { 1580 std::size_t seed = 0; 1581 VULKAN_HPP_HASH_COMBINE( seed, blitImageCubicWeightsInfoQCOM.sType ); 1582 VULKAN_HPP_HASH_COMBINE( seed, blitImageCubicWeightsInfoQCOM.pNext ); 1583 VULKAN_HPP_HASH_COMBINE( seed, blitImageCubicWeightsInfoQCOM.cubicWeights ); 1584 return seed; 1585 } 1586 }; 1587 1588 template <> 1589 struct hash<VULKAN_HPP_NAMESPACE::ImageSubresourceLayers> 1590 { operator ()std::hash1591 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const & imageSubresourceLayers ) const VULKAN_HPP_NOEXCEPT 1592 { 1593 std::size_t seed = 0; 1594 VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceLayers.aspectMask ); 1595 VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceLayers.mipLevel ); 1596 VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceLayers.baseArrayLayer ); 1597 VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceLayers.layerCount ); 1598 return seed; 1599 } 1600 }; 1601 1602 template <> 1603 struct hash<VULKAN_HPP_NAMESPACE::ImageBlit2> 1604 { operator ()std::hash1605 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageBlit2 const & imageBlit2 ) const VULKAN_HPP_NOEXCEPT 1606 { 1607 std::size_t seed = 0; 1608 VULKAN_HPP_HASH_COMBINE( seed, imageBlit2.sType ); 1609 VULKAN_HPP_HASH_COMBINE( seed, imageBlit2.pNext ); 1610 VULKAN_HPP_HASH_COMBINE( seed, imageBlit2.srcSubresource ); 1611 for ( size_t i = 0; i < 2; ++i ) 1612 { 1613 VULKAN_HPP_HASH_COMBINE( seed, imageBlit2.srcOffsets[i] ); 1614 } 1615 VULKAN_HPP_HASH_COMBINE( seed, imageBlit2.dstSubresource ); 1616 for ( size_t i = 0; i < 2; ++i ) 1617 { 1618 VULKAN_HPP_HASH_COMBINE( seed, imageBlit2.dstOffsets[i] ); 1619 } 1620 return seed; 1621 } 1622 }; 1623 1624 template <> 1625 struct hash<VULKAN_HPP_NAMESPACE::BlitImageInfo2> 1626 { operator ()std::hash1627 std::size_t operator()( VULKAN_HPP_NAMESPACE::BlitImageInfo2 const & blitImageInfo2 ) const VULKAN_HPP_NOEXCEPT 1628 { 1629 std::size_t seed = 0; 1630 VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.sType ); 1631 VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.pNext ); 1632 VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.srcImage ); 1633 VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.srcImageLayout ); 1634 VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.dstImage ); 1635 VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.dstImageLayout ); 1636 VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.regionCount ); 1637 VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.pRegions ); 1638 VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.filter ); 1639 return seed; 1640 } 1641 }; 1642 1643 template <> 1644 struct hash<VULKAN_HPP_NAMESPACE::BufferCaptureDescriptorDataInfoEXT> 1645 { operator ()std::hash1646 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCaptureDescriptorDataInfoEXT const & bufferCaptureDescriptorDataInfoEXT ) const VULKAN_HPP_NOEXCEPT 1647 { 1648 std::size_t seed = 0; 1649 VULKAN_HPP_HASH_COMBINE( seed, bufferCaptureDescriptorDataInfoEXT.sType ); 1650 VULKAN_HPP_HASH_COMBINE( seed, bufferCaptureDescriptorDataInfoEXT.pNext ); 1651 VULKAN_HPP_HASH_COMBINE( seed, bufferCaptureDescriptorDataInfoEXT.buffer ); 1652 return seed; 1653 } 1654 }; 1655 1656 # if defined( VK_USE_PLATFORM_FUCHSIA ) 1657 template <> 1658 struct hash<VULKAN_HPP_NAMESPACE::BufferCollectionBufferCreateInfoFUCHSIA> 1659 { 1660 std::size_t operator ()std::hash1661 operator()( VULKAN_HPP_NAMESPACE::BufferCollectionBufferCreateInfoFUCHSIA const & bufferCollectionBufferCreateInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT 1662 { 1663 std::size_t seed = 0; 1664 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionBufferCreateInfoFUCHSIA.sType ); 1665 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionBufferCreateInfoFUCHSIA.pNext ); 1666 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionBufferCreateInfoFUCHSIA.collection ); 1667 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionBufferCreateInfoFUCHSIA.index ); 1668 return seed; 1669 } 1670 }; 1671 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 1672 1673 # if defined( VK_USE_PLATFORM_FUCHSIA ) 1674 template <> 1675 struct hash<VULKAN_HPP_NAMESPACE::BufferCollectionConstraintsInfoFUCHSIA> 1676 { 1677 std::size_t operator ()std::hash1678 operator()( VULKAN_HPP_NAMESPACE::BufferCollectionConstraintsInfoFUCHSIA const & bufferCollectionConstraintsInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT 1679 { 1680 std::size_t seed = 0; 1681 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionConstraintsInfoFUCHSIA.sType ); 1682 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionConstraintsInfoFUCHSIA.pNext ); 1683 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionConstraintsInfoFUCHSIA.minBufferCount ); 1684 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionConstraintsInfoFUCHSIA.maxBufferCount ); 1685 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionConstraintsInfoFUCHSIA.minBufferCountForCamping ); 1686 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionConstraintsInfoFUCHSIA.minBufferCountForDedicatedSlack ); 1687 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionConstraintsInfoFUCHSIA.minBufferCountForSharedSlack ); 1688 return seed; 1689 } 1690 }; 1691 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 1692 1693 # if defined( VK_USE_PLATFORM_FUCHSIA ) 1694 template <> 1695 struct hash<VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA> 1696 { operator ()std::hash1697 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA const & bufferCollectionCreateInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT 1698 { 1699 std::size_t seed = 0; 1700 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionCreateInfoFUCHSIA.sType ); 1701 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionCreateInfoFUCHSIA.pNext ); 1702 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionCreateInfoFUCHSIA.collectionToken ); 1703 return seed; 1704 } 1705 }; 1706 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 1707 1708 # if defined( VK_USE_PLATFORM_FUCHSIA ) 1709 template <> 1710 struct hash<VULKAN_HPP_NAMESPACE::BufferCollectionImageCreateInfoFUCHSIA> 1711 { 1712 std::size_t operator ()std::hash1713 operator()( VULKAN_HPP_NAMESPACE::BufferCollectionImageCreateInfoFUCHSIA const & bufferCollectionImageCreateInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT 1714 { 1715 std::size_t seed = 0; 1716 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionImageCreateInfoFUCHSIA.sType ); 1717 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionImageCreateInfoFUCHSIA.pNext ); 1718 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionImageCreateInfoFUCHSIA.collection ); 1719 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionImageCreateInfoFUCHSIA.index ); 1720 return seed; 1721 } 1722 }; 1723 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 1724 1725 # if defined( VK_USE_PLATFORM_FUCHSIA ) 1726 template <> 1727 struct hash<VULKAN_HPP_NAMESPACE::SysmemColorSpaceFUCHSIA> 1728 { operator ()std::hash1729 std::size_t operator()( VULKAN_HPP_NAMESPACE::SysmemColorSpaceFUCHSIA const & sysmemColorSpaceFUCHSIA ) const VULKAN_HPP_NOEXCEPT 1730 { 1731 std::size_t seed = 0; 1732 VULKAN_HPP_HASH_COMBINE( seed, sysmemColorSpaceFUCHSIA.sType ); 1733 VULKAN_HPP_HASH_COMBINE( seed, sysmemColorSpaceFUCHSIA.pNext ); 1734 VULKAN_HPP_HASH_COMBINE( seed, sysmemColorSpaceFUCHSIA.colorSpace ); 1735 return seed; 1736 } 1737 }; 1738 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 1739 1740 # if defined( VK_USE_PLATFORM_FUCHSIA ) 1741 template <> 1742 struct hash<VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA> 1743 { operator ()std::hash1744 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA const & bufferCollectionPropertiesFUCHSIA ) const VULKAN_HPP_NOEXCEPT 1745 { 1746 std::size_t seed = 0; 1747 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.sType ); 1748 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.pNext ); 1749 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.memoryTypeBits ); 1750 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.bufferCount ); 1751 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.createInfoIndex ); 1752 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.sysmemPixelFormat ); 1753 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.formatFeatures ); 1754 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.sysmemColorSpaceIndex ); 1755 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.samplerYcbcrConversionComponents ); 1756 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.suggestedYcbcrModel ); 1757 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.suggestedYcbcrRange ); 1758 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.suggestedXChromaOffset ); 1759 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.suggestedYChromaOffset ); 1760 return seed; 1761 } 1762 }; 1763 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 1764 1765 template <> 1766 struct hash<VULKAN_HPP_NAMESPACE::BufferCreateInfo> 1767 { operator ()std::hash1768 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCreateInfo const & bufferCreateInfo ) const VULKAN_HPP_NOEXCEPT 1769 { 1770 std::size_t seed = 0; 1771 VULKAN_HPP_HASH_COMBINE( seed, bufferCreateInfo.sType ); 1772 VULKAN_HPP_HASH_COMBINE( seed, bufferCreateInfo.pNext ); 1773 VULKAN_HPP_HASH_COMBINE( seed, bufferCreateInfo.flags ); 1774 VULKAN_HPP_HASH_COMBINE( seed, bufferCreateInfo.size ); 1775 VULKAN_HPP_HASH_COMBINE( seed, bufferCreateInfo.usage ); 1776 VULKAN_HPP_HASH_COMBINE( seed, bufferCreateInfo.sharingMode ); 1777 VULKAN_HPP_HASH_COMBINE( seed, bufferCreateInfo.queueFamilyIndexCount ); 1778 VULKAN_HPP_HASH_COMBINE( seed, bufferCreateInfo.pQueueFamilyIndices ); 1779 return seed; 1780 } 1781 }; 1782 1783 # if defined( VK_USE_PLATFORM_FUCHSIA ) 1784 template <> 1785 struct hash<VULKAN_HPP_NAMESPACE::BufferConstraintsInfoFUCHSIA> 1786 { operator ()std::hash1787 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferConstraintsInfoFUCHSIA const & bufferConstraintsInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT 1788 { 1789 std::size_t seed = 0; 1790 VULKAN_HPP_HASH_COMBINE( seed, bufferConstraintsInfoFUCHSIA.sType ); 1791 VULKAN_HPP_HASH_COMBINE( seed, bufferConstraintsInfoFUCHSIA.pNext ); 1792 VULKAN_HPP_HASH_COMBINE( seed, bufferConstraintsInfoFUCHSIA.createInfo ); 1793 VULKAN_HPP_HASH_COMBINE( seed, bufferConstraintsInfoFUCHSIA.requiredFormatFeatures ); 1794 VULKAN_HPP_HASH_COMBINE( seed, bufferConstraintsInfoFUCHSIA.bufferCollectionConstraints ); 1795 return seed; 1796 } 1797 }; 1798 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 1799 1800 template <> 1801 struct hash<VULKAN_HPP_NAMESPACE::BufferCopy> 1802 { operator ()std::hash1803 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCopy const & bufferCopy ) const VULKAN_HPP_NOEXCEPT 1804 { 1805 std::size_t seed = 0; 1806 VULKAN_HPP_HASH_COMBINE( seed, bufferCopy.srcOffset ); 1807 VULKAN_HPP_HASH_COMBINE( seed, bufferCopy.dstOffset ); 1808 VULKAN_HPP_HASH_COMBINE( seed, bufferCopy.size ); 1809 return seed; 1810 } 1811 }; 1812 1813 template <> 1814 struct hash<VULKAN_HPP_NAMESPACE::BufferCopy2> 1815 { operator ()std::hash1816 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCopy2 const & bufferCopy2 ) const VULKAN_HPP_NOEXCEPT 1817 { 1818 std::size_t seed = 0; 1819 VULKAN_HPP_HASH_COMBINE( seed, bufferCopy2.sType ); 1820 VULKAN_HPP_HASH_COMBINE( seed, bufferCopy2.pNext ); 1821 VULKAN_HPP_HASH_COMBINE( seed, bufferCopy2.srcOffset ); 1822 VULKAN_HPP_HASH_COMBINE( seed, bufferCopy2.dstOffset ); 1823 VULKAN_HPP_HASH_COMBINE( seed, bufferCopy2.size ); 1824 return seed; 1825 } 1826 }; 1827 1828 template <> 1829 struct hash<VULKAN_HPP_NAMESPACE::BufferDeviceAddressCreateInfoEXT> 1830 { operator ()std::hash1831 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferDeviceAddressCreateInfoEXT const & bufferDeviceAddressCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 1832 { 1833 std::size_t seed = 0; 1834 VULKAN_HPP_HASH_COMBINE( seed, bufferDeviceAddressCreateInfoEXT.sType ); 1835 VULKAN_HPP_HASH_COMBINE( seed, bufferDeviceAddressCreateInfoEXT.pNext ); 1836 VULKAN_HPP_HASH_COMBINE( seed, bufferDeviceAddressCreateInfoEXT.deviceAddress ); 1837 return seed; 1838 } 1839 }; 1840 1841 template <> 1842 struct hash<VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo> 1843 { operator ()std::hash1844 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo const & bufferDeviceAddressInfo ) const VULKAN_HPP_NOEXCEPT 1845 { 1846 std::size_t seed = 0; 1847 VULKAN_HPP_HASH_COMBINE( seed, bufferDeviceAddressInfo.sType ); 1848 VULKAN_HPP_HASH_COMBINE( seed, bufferDeviceAddressInfo.pNext ); 1849 VULKAN_HPP_HASH_COMBINE( seed, bufferDeviceAddressInfo.buffer ); 1850 return seed; 1851 } 1852 }; 1853 1854 template <> 1855 struct hash<VULKAN_HPP_NAMESPACE::BufferImageCopy> 1856 { operator ()std::hash1857 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferImageCopy const & bufferImageCopy ) const VULKAN_HPP_NOEXCEPT 1858 { 1859 std::size_t seed = 0; 1860 VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy.bufferOffset ); 1861 VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy.bufferRowLength ); 1862 VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy.bufferImageHeight ); 1863 VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy.imageSubresource ); 1864 VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy.imageOffset ); 1865 VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy.imageExtent ); 1866 return seed; 1867 } 1868 }; 1869 1870 template <> 1871 struct hash<VULKAN_HPP_NAMESPACE::BufferImageCopy2> 1872 { operator ()std::hash1873 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferImageCopy2 const & bufferImageCopy2 ) const VULKAN_HPP_NOEXCEPT 1874 { 1875 std::size_t seed = 0; 1876 VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy2.sType ); 1877 VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy2.pNext ); 1878 VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy2.bufferOffset ); 1879 VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy2.bufferRowLength ); 1880 VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy2.bufferImageHeight ); 1881 VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy2.imageSubresource ); 1882 VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy2.imageOffset ); 1883 VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy2.imageExtent ); 1884 return seed; 1885 } 1886 }; 1887 1888 template <> 1889 struct hash<VULKAN_HPP_NAMESPACE::BufferMemoryBarrier> 1890 { operator ()std::hash1891 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferMemoryBarrier const & bufferMemoryBarrier ) const VULKAN_HPP_NOEXCEPT 1892 { 1893 std::size_t seed = 0; 1894 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.sType ); 1895 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.pNext ); 1896 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.srcAccessMask ); 1897 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.dstAccessMask ); 1898 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.srcQueueFamilyIndex ); 1899 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.dstQueueFamilyIndex ); 1900 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.buffer ); 1901 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.offset ); 1902 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.size ); 1903 return seed; 1904 } 1905 }; 1906 1907 template <> 1908 struct hash<VULKAN_HPP_NAMESPACE::BufferMemoryBarrier2> 1909 { operator ()std::hash1910 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferMemoryBarrier2 const & bufferMemoryBarrier2 ) const VULKAN_HPP_NOEXCEPT 1911 { 1912 std::size_t seed = 0; 1913 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.sType ); 1914 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.pNext ); 1915 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.srcStageMask ); 1916 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.srcAccessMask ); 1917 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.dstStageMask ); 1918 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.dstAccessMask ); 1919 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.srcQueueFamilyIndex ); 1920 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.dstQueueFamilyIndex ); 1921 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.buffer ); 1922 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.offset ); 1923 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.size ); 1924 return seed; 1925 } 1926 }; 1927 1928 template <> 1929 struct hash<VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2> 1930 { operator ()std::hash1931 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 const & bufferMemoryRequirementsInfo2 ) const VULKAN_HPP_NOEXCEPT 1932 { 1933 std::size_t seed = 0; 1934 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryRequirementsInfo2.sType ); 1935 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryRequirementsInfo2.pNext ); 1936 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryRequirementsInfo2.buffer ); 1937 return seed; 1938 } 1939 }; 1940 1941 template <> 1942 struct hash<VULKAN_HPP_NAMESPACE::BufferOpaqueCaptureAddressCreateInfo> 1943 { operator ()std::hash1944 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferOpaqueCaptureAddressCreateInfo const & bufferOpaqueCaptureAddressCreateInfo ) const VULKAN_HPP_NOEXCEPT 1945 { 1946 std::size_t seed = 0; 1947 VULKAN_HPP_HASH_COMBINE( seed, bufferOpaqueCaptureAddressCreateInfo.sType ); 1948 VULKAN_HPP_HASH_COMBINE( seed, bufferOpaqueCaptureAddressCreateInfo.pNext ); 1949 VULKAN_HPP_HASH_COMBINE( seed, bufferOpaqueCaptureAddressCreateInfo.opaqueCaptureAddress ); 1950 return seed; 1951 } 1952 }; 1953 1954 template <> 1955 struct hash<VULKAN_HPP_NAMESPACE::BufferUsageFlags2CreateInfoKHR> 1956 { operator ()std::hash1957 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferUsageFlags2CreateInfoKHR const & bufferUsageFlags2CreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 1958 { 1959 std::size_t seed = 0; 1960 VULKAN_HPP_HASH_COMBINE( seed, bufferUsageFlags2CreateInfoKHR.sType ); 1961 VULKAN_HPP_HASH_COMBINE( seed, bufferUsageFlags2CreateInfoKHR.pNext ); 1962 VULKAN_HPP_HASH_COMBINE( seed, bufferUsageFlags2CreateInfoKHR.usage ); 1963 return seed; 1964 } 1965 }; 1966 1967 template <> 1968 struct hash<VULKAN_HPP_NAMESPACE::BufferViewCreateInfo> 1969 { operator ()std::hash1970 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferViewCreateInfo const & bufferViewCreateInfo ) const VULKAN_HPP_NOEXCEPT 1971 { 1972 std::size_t seed = 0; 1973 VULKAN_HPP_HASH_COMBINE( seed, bufferViewCreateInfo.sType ); 1974 VULKAN_HPP_HASH_COMBINE( seed, bufferViewCreateInfo.pNext ); 1975 VULKAN_HPP_HASH_COMBINE( seed, bufferViewCreateInfo.flags ); 1976 VULKAN_HPP_HASH_COMBINE( seed, bufferViewCreateInfo.buffer ); 1977 VULKAN_HPP_HASH_COMBINE( seed, bufferViewCreateInfo.format ); 1978 VULKAN_HPP_HASH_COMBINE( seed, bufferViewCreateInfo.offset ); 1979 VULKAN_HPP_HASH_COMBINE( seed, bufferViewCreateInfo.range ); 1980 return seed; 1981 } 1982 }; 1983 1984 template <> 1985 struct hash<VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT> 1986 { operator ()std::hash1987 std::size_t operator()( VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT const & calibratedTimestampInfoEXT ) const VULKAN_HPP_NOEXCEPT 1988 { 1989 std::size_t seed = 0; 1990 VULKAN_HPP_HASH_COMBINE( seed, calibratedTimestampInfoEXT.sType ); 1991 VULKAN_HPP_HASH_COMBINE( seed, calibratedTimestampInfoEXT.pNext ); 1992 VULKAN_HPP_HASH_COMBINE( seed, calibratedTimestampInfoEXT.timeDomain ); 1993 return seed; 1994 } 1995 }; 1996 1997 template <> 1998 struct hash<VULKAN_HPP_NAMESPACE::CheckpointData2NV> 1999 { operator ()std::hash2000 std::size_t operator()( VULKAN_HPP_NAMESPACE::CheckpointData2NV const & checkpointData2NV ) const VULKAN_HPP_NOEXCEPT 2001 { 2002 std::size_t seed = 0; 2003 VULKAN_HPP_HASH_COMBINE( seed, checkpointData2NV.sType ); 2004 VULKAN_HPP_HASH_COMBINE( seed, checkpointData2NV.pNext ); 2005 VULKAN_HPP_HASH_COMBINE( seed, checkpointData2NV.stage ); 2006 VULKAN_HPP_HASH_COMBINE( seed, checkpointData2NV.pCheckpointMarker ); 2007 return seed; 2008 } 2009 }; 2010 2011 template <> 2012 struct hash<VULKAN_HPP_NAMESPACE::CheckpointDataNV> 2013 { operator ()std::hash2014 std::size_t operator()( VULKAN_HPP_NAMESPACE::CheckpointDataNV const & checkpointDataNV ) const VULKAN_HPP_NOEXCEPT 2015 { 2016 std::size_t seed = 0; 2017 VULKAN_HPP_HASH_COMBINE( seed, checkpointDataNV.sType ); 2018 VULKAN_HPP_HASH_COMBINE( seed, checkpointDataNV.pNext ); 2019 VULKAN_HPP_HASH_COMBINE( seed, checkpointDataNV.stage ); 2020 VULKAN_HPP_HASH_COMBINE( seed, checkpointDataNV.pCheckpointMarker ); 2021 return seed; 2022 } 2023 }; 2024 2025 template <> 2026 struct hash<VULKAN_HPP_NAMESPACE::ClearDepthStencilValue> 2027 { operator ()std::hash2028 std::size_t operator()( VULKAN_HPP_NAMESPACE::ClearDepthStencilValue const & clearDepthStencilValue ) const VULKAN_HPP_NOEXCEPT 2029 { 2030 std::size_t seed = 0; 2031 VULKAN_HPP_HASH_COMBINE( seed, clearDepthStencilValue.depth ); 2032 VULKAN_HPP_HASH_COMBINE( seed, clearDepthStencilValue.stencil ); 2033 return seed; 2034 } 2035 }; 2036 2037 template <> 2038 struct hash<VULKAN_HPP_NAMESPACE::ClearRect> 2039 { operator ()std::hash2040 std::size_t operator()( VULKAN_HPP_NAMESPACE::ClearRect const & clearRect ) const VULKAN_HPP_NOEXCEPT 2041 { 2042 std::size_t seed = 0; 2043 VULKAN_HPP_HASH_COMBINE( seed, clearRect.rect ); 2044 VULKAN_HPP_HASH_COMBINE( seed, clearRect.baseArrayLayer ); 2045 VULKAN_HPP_HASH_COMBINE( seed, clearRect.layerCount ); 2046 return seed; 2047 } 2048 }; 2049 2050 template <> 2051 struct hash<VULKAN_HPP_NAMESPACE::CoarseSampleLocationNV> 2052 { operator ()std::hash2053 std::size_t operator()( VULKAN_HPP_NAMESPACE::CoarseSampleLocationNV const & coarseSampleLocationNV ) const VULKAN_HPP_NOEXCEPT 2054 { 2055 std::size_t seed = 0; 2056 VULKAN_HPP_HASH_COMBINE( seed, coarseSampleLocationNV.pixelX ); 2057 VULKAN_HPP_HASH_COMBINE( seed, coarseSampleLocationNV.pixelY ); 2058 VULKAN_HPP_HASH_COMBINE( seed, coarseSampleLocationNV.sample ); 2059 return seed; 2060 } 2061 }; 2062 2063 template <> 2064 struct hash<VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV> 2065 { operator ()std::hash2066 std::size_t operator()( VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV const & coarseSampleOrderCustomNV ) const VULKAN_HPP_NOEXCEPT 2067 { 2068 std::size_t seed = 0; 2069 VULKAN_HPP_HASH_COMBINE( seed, coarseSampleOrderCustomNV.shadingRate ); 2070 VULKAN_HPP_HASH_COMBINE( seed, coarseSampleOrderCustomNV.sampleCount ); 2071 VULKAN_HPP_HASH_COMBINE( seed, coarseSampleOrderCustomNV.sampleLocationCount ); 2072 VULKAN_HPP_HASH_COMBINE( seed, coarseSampleOrderCustomNV.pSampleLocations ); 2073 return seed; 2074 } 2075 }; 2076 2077 template <> 2078 struct hash<VULKAN_HPP_NAMESPACE::ColorBlendAdvancedEXT> 2079 { operator ()std::hash2080 std::size_t operator()( VULKAN_HPP_NAMESPACE::ColorBlendAdvancedEXT const & colorBlendAdvancedEXT ) const VULKAN_HPP_NOEXCEPT 2081 { 2082 std::size_t seed = 0; 2083 VULKAN_HPP_HASH_COMBINE( seed, colorBlendAdvancedEXT.advancedBlendOp ); 2084 VULKAN_HPP_HASH_COMBINE( seed, colorBlendAdvancedEXT.srcPremultiplied ); 2085 VULKAN_HPP_HASH_COMBINE( seed, colorBlendAdvancedEXT.dstPremultiplied ); 2086 VULKAN_HPP_HASH_COMBINE( seed, colorBlendAdvancedEXT.blendOverlap ); 2087 VULKAN_HPP_HASH_COMBINE( seed, colorBlendAdvancedEXT.clampResults ); 2088 return seed; 2089 } 2090 }; 2091 2092 template <> 2093 struct hash<VULKAN_HPP_NAMESPACE::ColorBlendEquationEXT> 2094 { operator ()std::hash2095 std::size_t operator()( VULKAN_HPP_NAMESPACE::ColorBlendEquationEXT const & colorBlendEquationEXT ) const VULKAN_HPP_NOEXCEPT 2096 { 2097 std::size_t seed = 0; 2098 VULKAN_HPP_HASH_COMBINE( seed, colorBlendEquationEXT.srcColorBlendFactor ); 2099 VULKAN_HPP_HASH_COMBINE( seed, colorBlendEquationEXT.dstColorBlendFactor ); 2100 VULKAN_HPP_HASH_COMBINE( seed, colorBlendEquationEXT.colorBlendOp ); 2101 VULKAN_HPP_HASH_COMBINE( seed, colorBlendEquationEXT.srcAlphaBlendFactor ); 2102 VULKAN_HPP_HASH_COMBINE( seed, colorBlendEquationEXT.dstAlphaBlendFactor ); 2103 VULKAN_HPP_HASH_COMBINE( seed, colorBlendEquationEXT.alphaBlendOp ); 2104 return seed; 2105 } 2106 }; 2107 2108 template <> 2109 struct hash<VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo> 2110 { operator ()std::hash2111 std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo const & commandBufferAllocateInfo ) const VULKAN_HPP_NOEXCEPT 2112 { 2113 std::size_t seed = 0; 2114 VULKAN_HPP_HASH_COMBINE( seed, commandBufferAllocateInfo.sType ); 2115 VULKAN_HPP_HASH_COMBINE( seed, commandBufferAllocateInfo.pNext ); 2116 VULKAN_HPP_HASH_COMBINE( seed, commandBufferAllocateInfo.commandPool ); 2117 VULKAN_HPP_HASH_COMBINE( seed, commandBufferAllocateInfo.level ); 2118 VULKAN_HPP_HASH_COMBINE( seed, commandBufferAllocateInfo.commandBufferCount ); 2119 return seed; 2120 } 2121 }; 2122 2123 template <> 2124 struct hash<VULKAN_HPP_NAMESPACE::CommandBufferInheritanceInfo> 2125 { operator ()std::hash2126 std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceInfo const & commandBufferInheritanceInfo ) const VULKAN_HPP_NOEXCEPT 2127 { 2128 std::size_t seed = 0; 2129 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceInfo.sType ); 2130 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceInfo.pNext ); 2131 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceInfo.renderPass ); 2132 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceInfo.subpass ); 2133 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceInfo.framebuffer ); 2134 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceInfo.occlusionQueryEnable ); 2135 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceInfo.queryFlags ); 2136 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceInfo.pipelineStatistics ); 2137 return seed; 2138 } 2139 }; 2140 2141 template <> 2142 struct hash<VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo> 2143 { operator ()std::hash2144 std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo const & commandBufferBeginInfo ) const VULKAN_HPP_NOEXCEPT 2145 { 2146 std::size_t seed = 0; 2147 VULKAN_HPP_HASH_COMBINE( seed, commandBufferBeginInfo.sType ); 2148 VULKAN_HPP_HASH_COMBINE( seed, commandBufferBeginInfo.pNext ); 2149 VULKAN_HPP_HASH_COMBINE( seed, commandBufferBeginInfo.flags ); 2150 VULKAN_HPP_HASH_COMBINE( seed, commandBufferBeginInfo.pInheritanceInfo ); 2151 return seed; 2152 } 2153 }; 2154 2155 template <> 2156 struct hash<VULKAN_HPP_NAMESPACE::CommandBufferInheritanceConditionalRenderingInfoEXT> 2157 { 2158 std::size_t operator ()std::hash2159 operator()( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceConditionalRenderingInfoEXT const & commandBufferInheritanceConditionalRenderingInfoEXT ) const 2160 VULKAN_HPP_NOEXCEPT 2161 { 2162 std::size_t seed = 0; 2163 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceConditionalRenderingInfoEXT.sType ); 2164 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceConditionalRenderingInfoEXT.pNext ); 2165 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceConditionalRenderingInfoEXT.conditionalRenderingEnable ); 2166 return seed; 2167 } 2168 }; 2169 2170 template <> 2171 struct hash<VULKAN_HPP_NAMESPACE::CommandBufferInheritanceRenderPassTransformInfoQCOM> 2172 { 2173 std::size_t operator ()std::hash2174 operator()( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceRenderPassTransformInfoQCOM const & commandBufferInheritanceRenderPassTransformInfoQCOM ) const 2175 VULKAN_HPP_NOEXCEPT 2176 { 2177 std::size_t seed = 0; 2178 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderPassTransformInfoQCOM.sType ); 2179 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderPassTransformInfoQCOM.pNext ); 2180 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderPassTransformInfoQCOM.transform ); 2181 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderPassTransformInfoQCOM.renderArea ); 2182 return seed; 2183 } 2184 }; 2185 2186 template <> 2187 struct hash<VULKAN_HPP_NAMESPACE::CommandBufferInheritanceRenderingInfo> 2188 { 2189 std::size_t operator ()std::hash2190 operator()( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceRenderingInfo const & commandBufferInheritanceRenderingInfo ) const VULKAN_HPP_NOEXCEPT 2191 { 2192 std::size_t seed = 0; 2193 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.sType ); 2194 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.pNext ); 2195 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.flags ); 2196 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.viewMask ); 2197 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.colorAttachmentCount ); 2198 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.pColorAttachmentFormats ); 2199 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.depthAttachmentFormat ); 2200 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.stencilAttachmentFormat ); 2201 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.rasterizationSamples ); 2202 return seed; 2203 } 2204 }; 2205 2206 template <> 2207 struct hash<VULKAN_HPP_NAMESPACE::Viewport> 2208 { operator ()std::hash2209 std::size_t operator()( VULKAN_HPP_NAMESPACE::Viewport const & viewport ) const VULKAN_HPP_NOEXCEPT 2210 { 2211 std::size_t seed = 0; 2212 VULKAN_HPP_HASH_COMBINE( seed, viewport.x ); 2213 VULKAN_HPP_HASH_COMBINE( seed, viewport.y ); 2214 VULKAN_HPP_HASH_COMBINE( seed, viewport.width ); 2215 VULKAN_HPP_HASH_COMBINE( seed, viewport.height ); 2216 VULKAN_HPP_HASH_COMBINE( seed, viewport.minDepth ); 2217 VULKAN_HPP_HASH_COMBINE( seed, viewport.maxDepth ); 2218 return seed; 2219 } 2220 }; 2221 2222 template <> 2223 struct hash<VULKAN_HPP_NAMESPACE::CommandBufferInheritanceViewportScissorInfoNV> 2224 { operator ()std::hash2225 std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceViewportScissorInfoNV const & commandBufferInheritanceViewportScissorInfoNV ) const 2226 VULKAN_HPP_NOEXCEPT 2227 { 2228 std::size_t seed = 0; 2229 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceViewportScissorInfoNV.sType ); 2230 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceViewportScissorInfoNV.pNext ); 2231 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceViewportScissorInfoNV.viewportScissor2D ); 2232 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceViewportScissorInfoNV.viewportDepthCount ); 2233 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceViewportScissorInfoNV.pViewportDepths ); 2234 return seed; 2235 } 2236 }; 2237 2238 template <> 2239 struct hash<VULKAN_HPP_NAMESPACE::CommandBufferSubmitInfo> 2240 { operator ()std::hash2241 std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBufferSubmitInfo const & commandBufferSubmitInfo ) const VULKAN_HPP_NOEXCEPT 2242 { 2243 std::size_t seed = 0; 2244 VULKAN_HPP_HASH_COMBINE( seed, commandBufferSubmitInfo.sType ); 2245 VULKAN_HPP_HASH_COMBINE( seed, commandBufferSubmitInfo.pNext ); 2246 VULKAN_HPP_HASH_COMBINE( seed, commandBufferSubmitInfo.commandBuffer ); 2247 VULKAN_HPP_HASH_COMBINE( seed, commandBufferSubmitInfo.deviceMask ); 2248 return seed; 2249 } 2250 }; 2251 2252 template <> 2253 struct hash<VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo> 2254 { operator ()std::hash2255 std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo const & commandPoolCreateInfo ) const VULKAN_HPP_NOEXCEPT 2256 { 2257 std::size_t seed = 0; 2258 VULKAN_HPP_HASH_COMBINE( seed, commandPoolCreateInfo.sType ); 2259 VULKAN_HPP_HASH_COMBINE( seed, commandPoolCreateInfo.pNext ); 2260 VULKAN_HPP_HASH_COMBINE( seed, commandPoolCreateInfo.flags ); 2261 VULKAN_HPP_HASH_COMBINE( seed, commandPoolCreateInfo.queueFamilyIndex ); 2262 return seed; 2263 } 2264 }; 2265 2266 template <> 2267 struct hash<VULKAN_HPP_NAMESPACE::SpecializationMapEntry> 2268 { operator ()std::hash2269 std::size_t operator()( VULKAN_HPP_NAMESPACE::SpecializationMapEntry const & specializationMapEntry ) const VULKAN_HPP_NOEXCEPT 2270 { 2271 std::size_t seed = 0; 2272 VULKAN_HPP_HASH_COMBINE( seed, specializationMapEntry.constantID ); 2273 VULKAN_HPP_HASH_COMBINE( seed, specializationMapEntry.offset ); 2274 VULKAN_HPP_HASH_COMBINE( seed, specializationMapEntry.size ); 2275 return seed; 2276 } 2277 }; 2278 2279 template <> 2280 struct hash<VULKAN_HPP_NAMESPACE::SpecializationInfo> 2281 { operator ()std::hash2282 std::size_t operator()( VULKAN_HPP_NAMESPACE::SpecializationInfo const & specializationInfo ) const VULKAN_HPP_NOEXCEPT 2283 { 2284 std::size_t seed = 0; 2285 VULKAN_HPP_HASH_COMBINE( seed, specializationInfo.mapEntryCount ); 2286 VULKAN_HPP_HASH_COMBINE( seed, specializationInfo.pMapEntries ); 2287 VULKAN_HPP_HASH_COMBINE( seed, specializationInfo.dataSize ); 2288 VULKAN_HPP_HASH_COMBINE( seed, specializationInfo.pData ); 2289 return seed; 2290 } 2291 }; 2292 2293 template <> 2294 struct hash<VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo> 2295 { operator ()std::hash2296 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo const & pipelineShaderStageCreateInfo ) const VULKAN_HPP_NOEXCEPT 2297 { 2298 std::size_t seed = 0; 2299 VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageCreateInfo.sType ); 2300 VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageCreateInfo.pNext ); 2301 VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageCreateInfo.flags ); 2302 VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageCreateInfo.stage ); 2303 VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageCreateInfo.module ); 2304 for ( const char * p = pipelineShaderStageCreateInfo.pName; *p != '\0'; ++p ) 2305 { 2306 VULKAN_HPP_HASH_COMBINE( seed, *p ); 2307 } 2308 VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageCreateInfo.pSpecializationInfo ); 2309 return seed; 2310 } 2311 }; 2312 2313 template <> 2314 struct hash<VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> 2315 { operator ()std::hash2316 std::size_t operator()( VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo const & computePipelineCreateInfo ) const VULKAN_HPP_NOEXCEPT 2317 { 2318 std::size_t seed = 0; 2319 VULKAN_HPP_HASH_COMBINE( seed, computePipelineCreateInfo.sType ); 2320 VULKAN_HPP_HASH_COMBINE( seed, computePipelineCreateInfo.pNext ); 2321 VULKAN_HPP_HASH_COMBINE( seed, computePipelineCreateInfo.flags ); 2322 VULKAN_HPP_HASH_COMBINE( seed, computePipelineCreateInfo.stage ); 2323 VULKAN_HPP_HASH_COMBINE( seed, computePipelineCreateInfo.layout ); 2324 VULKAN_HPP_HASH_COMBINE( seed, computePipelineCreateInfo.basePipelineHandle ); 2325 VULKAN_HPP_HASH_COMBINE( seed, computePipelineCreateInfo.basePipelineIndex ); 2326 return seed; 2327 } 2328 }; 2329 2330 template <> 2331 struct hash<VULKAN_HPP_NAMESPACE::ComputePipelineIndirectBufferInfoNV> 2332 { operator ()std::hash2333 std::size_t operator()( VULKAN_HPP_NAMESPACE::ComputePipelineIndirectBufferInfoNV const & computePipelineIndirectBufferInfoNV ) const VULKAN_HPP_NOEXCEPT 2334 { 2335 std::size_t seed = 0; 2336 VULKAN_HPP_HASH_COMBINE( seed, computePipelineIndirectBufferInfoNV.sType ); 2337 VULKAN_HPP_HASH_COMBINE( seed, computePipelineIndirectBufferInfoNV.pNext ); 2338 VULKAN_HPP_HASH_COMBINE( seed, computePipelineIndirectBufferInfoNV.deviceAddress ); 2339 VULKAN_HPP_HASH_COMBINE( seed, computePipelineIndirectBufferInfoNV.size ); 2340 VULKAN_HPP_HASH_COMBINE( seed, computePipelineIndirectBufferInfoNV.pipelineDeviceAddressCaptureReplay ); 2341 return seed; 2342 } 2343 }; 2344 2345 template <> 2346 struct hash<VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfoEXT> 2347 { operator ()std::hash2348 std::size_t operator()( VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfoEXT const & conditionalRenderingBeginInfoEXT ) const VULKAN_HPP_NOEXCEPT 2349 { 2350 std::size_t seed = 0; 2351 VULKAN_HPP_HASH_COMBINE( seed, conditionalRenderingBeginInfoEXT.sType ); 2352 VULKAN_HPP_HASH_COMBINE( seed, conditionalRenderingBeginInfoEXT.pNext ); 2353 VULKAN_HPP_HASH_COMBINE( seed, conditionalRenderingBeginInfoEXT.buffer ); 2354 VULKAN_HPP_HASH_COMBINE( seed, conditionalRenderingBeginInfoEXT.offset ); 2355 VULKAN_HPP_HASH_COMBINE( seed, conditionalRenderingBeginInfoEXT.flags ); 2356 return seed; 2357 } 2358 }; 2359 2360 template <> 2361 struct hash<VULKAN_HPP_NAMESPACE::ConformanceVersion> 2362 { operator ()std::hash2363 std::size_t operator()( VULKAN_HPP_NAMESPACE::ConformanceVersion const & conformanceVersion ) const VULKAN_HPP_NOEXCEPT 2364 { 2365 std::size_t seed = 0; 2366 VULKAN_HPP_HASH_COMBINE( seed, conformanceVersion.major ); 2367 VULKAN_HPP_HASH_COMBINE( seed, conformanceVersion.minor ); 2368 VULKAN_HPP_HASH_COMBINE( seed, conformanceVersion.subminor ); 2369 VULKAN_HPP_HASH_COMBINE( seed, conformanceVersion.patch ); 2370 return seed; 2371 } 2372 }; 2373 2374 template <> 2375 struct hash<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR> 2376 { operator ()std::hash2377 std::size_t operator()( VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR const & cooperativeMatrixPropertiesKHR ) const VULKAN_HPP_NOEXCEPT 2378 { 2379 std::size_t seed = 0; 2380 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.sType ); 2381 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.pNext ); 2382 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.MSize ); 2383 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.NSize ); 2384 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.KSize ); 2385 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.AType ); 2386 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.BType ); 2387 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.CType ); 2388 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.ResultType ); 2389 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.saturatingAccumulation ); 2390 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.scope ); 2391 return seed; 2392 } 2393 }; 2394 2395 template <> 2396 struct hash<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV> 2397 { operator ()std::hash2398 std::size_t operator()( VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV const & cooperativeMatrixPropertiesNV ) const VULKAN_HPP_NOEXCEPT 2399 { 2400 std::size_t seed = 0; 2401 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.sType ); 2402 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.pNext ); 2403 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.MSize ); 2404 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.NSize ); 2405 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.KSize ); 2406 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.AType ); 2407 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.BType ); 2408 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.CType ); 2409 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.DType ); 2410 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.scope ); 2411 return seed; 2412 } 2413 }; 2414 2415 template <> 2416 struct hash<VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR> 2417 { operator ()std::hash2418 std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR const & copyAccelerationStructureInfoKHR ) const VULKAN_HPP_NOEXCEPT 2419 { 2420 std::size_t seed = 0; 2421 VULKAN_HPP_HASH_COMBINE( seed, copyAccelerationStructureInfoKHR.sType ); 2422 VULKAN_HPP_HASH_COMBINE( seed, copyAccelerationStructureInfoKHR.pNext ); 2423 VULKAN_HPP_HASH_COMBINE( seed, copyAccelerationStructureInfoKHR.src ); 2424 VULKAN_HPP_HASH_COMBINE( seed, copyAccelerationStructureInfoKHR.dst ); 2425 VULKAN_HPP_HASH_COMBINE( seed, copyAccelerationStructureInfoKHR.mode ); 2426 return seed; 2427 } 2428 }; 2429 2430 template <> 2431 struct hash<VULKAN_HPP_NAMESPACE::CopyBufferInfo2> 2432 { operator ()std::hash2433 std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyBufferInfo2 const & copyBufferInfo2 ) const VULKAN_HPP_NOEXCEPT 2434 { 2435 std::size_t seed = 0; 2436 VULKAN_HPP_HASH_COMBINE( seed, copyBufferInfo2.sType ); 2437 VULKAN_HPP_HASH_COMBINE( seed, copyBufferInfo2.pNext ); 2438 VULKAN_HPP_HASH_COMBINE( seed, copyBufferInfo2.srcBuffer ); 2439 VULKAN_HPP_HASH_COMBINE( seed, copyBufferInfo2.dstBuffer ); 2440 VULKAN_HPP_HASH_COMBINE( seed, copyBufferInfo2.regionCount ); 2441 VULKAN_HPP_HASH_COMBINE( seed, copyBufferInfo2.pRegions ); 2442 return seed; 2443 } 2444 }; 2445 2446 template <> 2447 struct hash<VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2> 2448 { operator ()std::hash2449 std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 const & copyBufferToImageInfo2 ) const VULKAN_HPP_NOEXCEPT 2450 { 2451 std::size_t seed = 0; 2452 VULKAN_HPP_HASH_COMBINE( seed, copyBufferToImageInfo2.sType ); 2453 VULKAN_HPP_HASH_COMBINE( seed, copyBufferToImageInfo2.pNext ); 2454 VULKAN_HPP_HASH_COMBINE( seed, copyBufferToImageInfo2.srcBuffer ); 2455 VULKAN_HPP_HASH_COMBINE( seed, copyBufferToImageInfo2.dstImage ); 2456 VULKAN_HPP_HASH_COMBINE( seed, copyBufferToImageInfo2.dstImageLayout ); 2457 VULKAN_HPP_HASH_COMBINE( seed, copyBufferToImageInfo2.regionCount ); 2458 VULKAN_HPP_HASH_COMBINE( seed, copyBufferToImageInfo2.pRegions ); 2459 return seed; 2460 } 2461 }; 2462 2463 template <> 2464 struct hash<VULKAN_HPP_NAMESPACE::CopyCommandTransformInfoQCOM> 2465 { operator ()std::hash2466 std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyCommandTransformInfoQCOM const & copyCommandTransformInfoQCOM ) const VULKAN_HPP_NOEXCEPT 2467 { 2468 std::size_t seed = 0; 2469 VULKAN_HPP_HASH_COMBINE( seed, copyCommandTransformInfoQCOM.sType ); 2470 VULKAN_HPP_HASH_COMBINE( seed, copyCommandTransformInfoQCOM.pNext ); 2471 VULKAN_HPP_HASH_COMBINE( seed, copyCommandTransformInfoQCOM.transform ); 2472 return seed; 2473 } 2474 }; 2475 2476 template <> 2477 struct hash<VULKAN_HPP_NAMESPACE::CopyDescriptorSet> 2478 { operator ()std::hash2479 std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyDescriptorSet const & copyDescriptorSet ) const VULKAN_HPP_NOEXCEPT 2480 { 2481 std::size_t seed = 0; 2482 VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.sType ); 2483 VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.pNext ); 2484 VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.srcSet ); 2485 VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.srcBinding ); 2486 VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.srcArrayElement ); 2487 VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.dstSet ); 2488 VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.dstBinding ); 2489 VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.dstArrayElement ); 2490 VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.descriptorCount ); 2491 return seed; 2492 } 2493 }; 2494 2495 template <> 2496 struct hash<VULKAN_HPP_NAMESPACE::ImageCopy2> 2497 { operator ()std::hash2498 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageCopy2 const & imageCopy2 ) const VULKAN_HPP_NOEXCEPT 2499 { 2500 std::size_t seed = 0; 2501 VULKAN_HPP_HASH_COMBINE( seed, imageCopy2.sType ); 2502 VULKAN_HPP_HASH_COMBINE( seed, imageCopy2.pNext ); 2503 VULKAN_HPP_HASH_COMBINE( seed, imageCopy2.srcSubresource ); 2504 VULKAN_HPP_HASH_COMBINE( seed, imageCopy2.srcOffset ); 2505 VULKAN_HPP_HASH_COMBINE( seed, imageCopy2.dstSubresource ); 2506 VULKAN_HPP_HASH_COMBINE( seed, imageCopy2.dstOffset ); 2507 VULKAN_HPP_HASH_COMBINE( seed, imageCopy2.extent ); 2508 return seed; 2509 } 2510 }; 2511 2512 template <> 2513 struct hash<VULKAN_HPP_NAMESPACE::CopyImageInfo2> 2514 { operator ()std::hash2515 std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyImageInfo2 const & copyImageInfo2 ) const VULKAN_HPP_NOEXCEPT 2516 { 2517 std::size_t seed = 0; 2518 VULKAN_HPP_HASH_COMBINE( seed, copyImageInfo2.sType ); 2519 VULKAN_HPP_HASH_COMBINE( seed, copyImageInfo2.pNext ); 2520 VULKAN_HPP_HASH_COMBINE( seed, copyImageInfo2.srcImage ); 2521 VULKAN_HPP_HASH_COMBINE( seed, copyImageInfo2.srcImageLayout ); 2522 VULKAN_HPP_HASH_COMBINE( seed, copyImageInfo2.dstImage ); 2523 VULKAN_HPP_HASH_COMBINE( seed, copyImageInfo2.dstImageLayout ); 2524 VULKAN_HPP_HASH_COMBINE( seed, copyImageInfo2.regionCount ); 2525 VULKAN_HPP_HASH_COMBINE( seed, copyImageInfo2.pRegions ); 2526 return seed; 2527 } 2528 }; 2529 2530 template <> 2531 struct hash<VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2> 2532 { operator ()std::hash2533 std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 const & copyImageToBufferInfo2 ) const VULKAN_HPP_NOEXCEPT 2534 { 2535 std::size_t seed = 0; 2536 VULKAN_HPP_HASH_COMBINE( seed, copyImageToBufferInfo2.sType ); 2537 VULKAN_HPP_HASH_COMBINE( seed, copyImageToBufferInfo2.pNext ); 2538 VULKAN_HPP_HASH_COMBINE( seed, copyImageToBufferInfo2.srcImage ); 2539 VULKAN_HPP_HASH_COMBINE( seed, copyImageToBufferInfo2.srcImageLayout ); 2540 VULKAN_HPP_HASH_COMBINE( seed, copyImageToBufferInfo2.dstBuffer ); 2541 VULKAN_HPP_HASH_COMBINE( seed, copyImageToBufferInfo2.regionCount ); 2542 VULKAN_HPP_HASH_COMBINE( seed, copyImageToBufferInfo2.pRegions ); 2543 return seed; 2544 } 2545 }; 2546 2547 template <> 2548 struct hash<VULKAN_HPP_NAMESPACE::CopyImageToImageInfoEXT> 2549 { operator ()std::hash2550 std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyImageToImageInfoEXT const & copyImageToImageInfoEXT ) const VULKAN_HPP_NOEXCEPT 2551 { 2552 std::size_t seed = 0; 2553 VULKAN_HPP_HASH_COMBINE( seed, copyImageToImageInfoEXT.sType ); 2554 VULKAN_HPP_HASH_COMBINE( seed, copyImageToImageInfoEXT.pNext ); 2555 VULKAN_HPP_HASH_COMBINE( seed, copyImageToImageInfoEXT.flags ); 2556 VULKAN_HPP_HASH_COMBINE( seed, copyImageToImageInfoEXT.srcImage ); 2557 VULKAN_HPP_HASH_COMBINE( seed, copyImageToImageInfoEXT.srcImageLayout ); 2558 VULKAN_HPP_HASH_COMBINE( seed, copyImageToImageInfoEXT.dstImage ); 2559 VULKAN_HPP_HASH_COMBINE( seed, copyImageToImageInfoEXT.dstImageLayout ); 2560 VULKAN_HPP_HASH_COMBINE( seed, copyImageToImageInfoEXT.regionCount ); 2561 VULKAN_HPP_HASH_COMBINE( seed, copyImageToImageInfoEXT.pRegions ); 2562 return seed; 2563 } 2564 }; 2565 2566 template <> 2567 struct hash<VULKAN_HPP_NAMESPACE::ImageToMemoryCopyEXT> 2568 { operator ()std::hash2569 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageToMemoryCopyEXT const & imageToMemoryCopyEXT ) const VULKAN_HPP_NOEXCEPT 2570 { 2571 std::size_t seed = 0; 2572 VULKAN_HPP_HASH_COMBINE( seed, imageToMemoryCopyEXT.sType ); 2573 VULKAN_HPP_HASH_COMBINE( seed, imageToMemoryCopyEXT.pNext ); 2574 VULKAN_HPP_HASH_COMBINE( seed, imageToMemoryCopyEXT.pHostPointer ); 2575 VULKAN_HPP_HASH_COMBINE( seed, imageToMemoryCopyEXT.memoryRowLength ); 2576 VULKAN_HPP_HASH_COMBINE( seed, imageToMemoryCopyEXT.memoryImageHeight ); 2577 VULKAN_HPP_HASH_COMBINE( seed, imageToMemoryCopyEXT.imageSubresource ); 2578 VULKAN_HPP_HASH_COMBINE( seed, imageToMemoryCopyEXT.imageOffset ); 2579 VULKAN_HPP_HASH_COMBINE( seed, imageToMemoryCopyEXT.imageExtent ); 2580 return seed; 2581 } 2582 }; 2583 2584 template <> 2585 struct hash<VULKAN_HPP_NAMESPACE::CopyImageToMemoryInfoEXT> 2586 { operator ()std::hash2587 std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyImageToMemoryInfoEXT const & copyImageToMemoryInfoEXT ) const VULKAN_HPP_NOEXCEPT 2588 { 2589 std::size_t seed = 0; 2590 VULKAN_HPP_HASH_COMBINE( seed, copyImageToMemoryInfoEXT.sType ); 2591 VULKAN_HPP_HASH_COMBINE( seed, copyImageToMemoryInfoEXT.pNext ); 2592 VULKAN_HPP_HASH_COMBINE( seed, copyImageToMemoryInfoEXT.flags ); 2593 VULKAN_HPP_HASH_COMBINE( seed, copyImageToMemoryInfoEXT.srcImage ); 2594 VULKAN_HPP_HASH_COMBINE( seed, copyImageToMemoryInfoEXT.srcImageLayout ); 2595 VULKAN_HPP_HASH_COMBINE( seed, copyImageToMemoryInfoEXT.regionCount ); 2596 VULKAN_HPP_HASH_COMBINE( seed, copyImageToMemoryInfoEXT.pRegions ); 2597 return seed; 2598 } 2599 }; 2600 2601 template <> 2602 struct hash<VULKAN_HPP_NAMESPACE::CopyMemoryIndirectCommandNV> 2603 { operator ()std::hash2604 std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyMemoryIndirectCommandNV const & copyMemoryIndirectCommandNV ) const VULKAN_HPP_NOEXCEPT 2605 { 2606 std::size_t seed = 0; 2607 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryIndirectCommandNV.srcAddress ); 2608 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryIndirectCommandNV.dstAddress ); 2609 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryIndirectCommandNV.size ); 2610 return seed; 2611 } 2612 }; 2613 2614 template <> 2615 struct hash<VULKAN_HPP_NAMESPACE::CopyMemoryToImageIndirectCommandNV> 2616 { operator ()std::hash2617 std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyMemoryToImageIndirectCommandNV const & copyMemoryToImageIndirectCommandNV ) const VULKAN_HPP_NOEXCEPT 2618 { 2619 std::size_t seed = 0; 2620 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectCommandNV.srcAddress ); 2621 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectCommandNV.bufferRowLength ); 2622 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectCommandNV.bufferImageHeight ); 2623 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectCommandNV.imageSubresource ); 2624 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectCommandNV.imageOffset ); 2625 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectCommandNV.imageExtent ); 2626 return seed; 2627 } 2628 }; 2629 2630 template <> 2631 struct hash<VULKAN_HPP_NAMESPACE::MemoryToImageCopyEXT> 2632 { operator ()std::hash2633 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryToImageCopyEXT const & memoryToImageCopyEXT ) const VULKAN_HPP_NOEXCEPT 2634 { 2635 std::size_t seed = 0; 2636 VULKAN_HPP_HASH_COMBINE( seed, memoryToImageCopyEXT.sType ); 2637 VULKAN_HPP_HASH_COMBINE( seed, memoryToImageCopyEXT.pNext ); 2638 VULKAN_HPP_HASH_COMBINE( seed, memoryToImageCopyEXT.pHostPointer ); 2639 VULKAN_HPP_HASH_COMBINE( seed, memoryToImageCopyEXT.memoryRowLength ); 2640 VULKAN_HPP_HASH_COMBINE( seed, memoryToImageCopyEXT.memoryImageHeight ); 2641 VULKAN_HPP_HASH_COMBINE( seed, memoryToImageCopyEXT.imageSubresource ); 2642 VULKAN_HPP_HASH_COMBINE( seed, memoryToImageCopyEXT.imageOffset ); 2643 VULKAN_HPP_HASH_COMBINE( seed, memoryToImageCopyEXT.imageExtent ); 2644 return seed; 2645 } 2646 }; 2647 2648 template <> 2649 struct hash<VULKAN_HPP_NAMESPACE::CopyMemoryToImageInfoEXT> 2650 { operator ()std::hash2651 std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyMemoryToImageInfoEXT const & copyMemoryToImageInfoEXT ) const VULKAN_HPP_NOEXCEPT 2652 { 2653 std::size_t seed = 0; 2654 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageInfoEXT.sType ); 2655 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageInfoEXT.pNext ); 2656 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageInfoEXT.flags ); 2657 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageInfoEXT.dstImage ); 2658 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageInfoEXT.dstImageLayout ); 2659 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageInfoEXT.regionCount ); 2660 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageInfoEXT.pRegions ); 2661 return seed; 2662 } 2663 }; 2664 2665 template <> 2666 struct hash<VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT> 2667 { operator ()std::hash2668 std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT const & copyMicromapInfoEXT ) const VULKAN_HPP_NOEXCEPT 2669 { 2670 std::size_t seed = 0; 2671 VULKAN_HPP_HASH_COMBINE( seed, copyMicromapInfoEXT.sType ); 2672 VULKAN_HPP_HASH_COMBINE( seed, copyMicromapInfoEXT.pNext ); 2673 VULKAN_HPP_HASH_COMBINE( seed, copyMicromapInfoEXT.src ); 2674 VULKAN_HPP_HASH_COMBINE( seed, copyMicromapInfoEXT.dst ); 2675 VULKAN_HPP_HASH_COMBINE( seed, copyMicromapInfoEXT.mode ); 2676 return seed; 2677 } 2678 }; 2679 2680 template <> 2681 struct hash<VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX> 2682 { operator ()std::hash2683 std::size_t operator()( VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX const & cuFunctionCreateInfoNVX ) const VULKAN_HPP_NOEXCEPT 2684 { 2685 std::size_t seed = 0; 2686 VULKAN_HPP_HASH_COMBINE( seed, cuFunctionCreateInfoNVX.sType ); 2687 VULKAN_HPP_HASH_COMBINE( seed, cuFunctionCreateInfoNVX.pNext ); 2688 VULKAN_HPP_HASH_COMBINE( seed, cuFunctionCreateInfoNVX.module ); 2689 for ( const char * p = cuFunctionCreateInfoNVX.pName; *p != '\0'; ++p ) 2690 { 2691 VULKAN_HPP_HASH_COMBINE( seed, *p ); 2692 } 2693 return seed; 2694 } 2695 }; 2696 2697 template <> 2698 struct hash<VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX> 2699 { operator ()std::hash2700 std::size_t operator()( VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX const & cuLaunchInfoNVX ) const VULKAN_HPP_NOEXCEPT 2701 { 2702 std::size_t seed = 0; 2703 VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.sType ); 2704 VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.pNext ); 2705 VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.function ); 2706 VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.gridDimX ); 2707 VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.gridDimY ); 2708 VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.gridDimZ ); 2709 VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.blockDimX ); 2710 VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.blockDimY ); 2711 VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.blockDimZ ); 2712 VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.sharedMemBytes ); 2713 VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.paramCount ); 2714 VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.pParams ); 2715 VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.extraCount ); 2716 VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.pExtras ); 2717 return seed; 2718 } 2719 }; 2720 2721 template <> 2722 struct hash<VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX> 2723 { operator ()std::hash2724 std::size_t operator()( VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX const & cuModuleCreateInfoNVX ) const VULKAN_HPP_NOEXCEPT 2725 { 2726 std::size_t seed = 0; 2727 VULKAN_HPP_HASH_COMBINE( seed, cuModuleCreateInfoNVX.sType ); 2728 VULKAN_HPP_HASH_COMBINE( seed, cuModuleCreateInfoNVX.pNext ); 2729 VULKAN_HPP_HASH_COMBINE( seed, cuModuleCreateInfoNVX.dataSize ); 2730 VULKAN_HPP_HASH_COMBINE( seed, cuModuleCreateInfoNVX.pData ); 2731 return seed; 2732 } 2733 }; 2734 2735 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 2736 template <> 2737 struct hash<VULKAN_HPP_NAMESPACE::D3D12FenceSubmitInfoKHR> 2738 { operator ()std::hash2739 std::size_t operator()( VULKAN_HPP_NAMESPACE::D3D12FenceSubmitInfoKHR const & d3D12FenceSubmitInfoKHR ) const VULKAN_HPP_NOEXCEPT 2740 { 2741 std::size_t seed = 0; 2742 VULKAN_HPP_HASH_COMBINE( seed, d3D12FenceSubmitInfoKHR.sType ); 2743 VULKAN_HPP_HASH_COMBINE( seed, d3D12FenceSubmitInfoKHR.pNext ); 2744 VULKAN_HPP_HASH_COMBINE( seed, d3D12FenceSubmitInfoKHR.waitSemaphoreValuesCount ); 2745 VULKAN_HPP_HASH_COMBINE( seed, d3D12FenceSubmitInfoKHR.pWaitSemaphoreValues ); 2746 VULKAN_HPP_HASH_COMBINE( seed, d3D12FenceSubmitInfoKHR.signalSemaphoreValuesCount ); 2747 VULKAN_HPP_HASH_COMBINE( seed, d3D12FenceSubmitInfoKHR.pSignalSemaphoreValues ); 2748 return seed; 2749 } 2750 }; 2751 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 2752 2753 template <> 2754 struct hash<VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT> 2755 { operator ()std::hash2756 std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT const & debugMarkerMarkerInfoEXT ) const VULKAN_HPP_NOEXCEPT 2757 { 2758 std::size_t seed = 0; 2759 VULKAN_HPP_HASH_COMBINE( seed, debugMarkerMarkerInfoEXT.sType ); 2760 VULKAN_HPP_HASH_COMBINE( seed, debugMarkerMarkerInfoEXT.pNext ); 2761 for ( const char * p = debugMarkerMarkerInfoEXT.pMarkerName; *p != '\0'; ++p ) 2762 { 2763 VULKAN_HPP_HASH_COMBINE( seed, *p ); 2764 } 2765 for ( size_t i = 0; i < 4; ++i ) 2766 { 2767 VULKAN_HPP_HASH_COMBINE( seed, debugMarkerMarkerInfoEXT.color[i] ); 2768 } 2769 return seed; 2770 } 2771 }; 2772 2773 template <> 2774 struct hash<VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT> 2775 { operator ()std::hash2776 std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT const & debugMarkerObjectNameInfoEXT ) const VULKAN_HPP_NOEXCEPT 2777 { 2778 std::size_t seed = 0; 2779 VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectNameInfoEXT.sType ); 2780 VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectNameInfoEXT.pNext ); 2781 VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectNameInfoEXT.objectType ); 2782 VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectNameInfoEXT.object ); 2783 for ( const char * p = debugMarkerObjectNameInfoEXT.pObjectName; *p != '\0'; ++p ) 2784 { 2785 VULKAN_HPP_HASH_COMBINE( seed, *p ); 2786 } 2787 return seed; 2788 } 2789 }; 2790 2791 template <> 2792 struct hash<VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT> 2793 { operator ()std::hash2794 std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT const & debugMarkerObjectTagInfoEXT ) const VULKAN_HPP_NOEXCEPT 2795 { 2796 std::size_t seed = 0; 2797 VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectTagInfoEXT.sType ); 2798 VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectTagInfoEXT.pNext ); 2799 VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectTagInfoEXT.objectType ); 2800 VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectTagInfoEXT.object ); 2801 VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectTagInfoEXT.tagName ); 2802 VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectTagInfoEXT.tagSize ); 2803 VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectTagInfoEXT.pTag ); 2804 return seed; 2805 } 2806 }; 2807 2808 template <> 2809 struct hash<VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT> 2810 { operator ()std::hash2811 std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT const & debugReportCallbackCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 2812 { 2813 std::size_t seed = 0; 2814 VULKAN_HPP_HASH_COMBINE( seed, debugReportCallbackCreateInfoEXT.sType ); 2815 VULKAN_HPP_HASH_COMBINE( seed, debugReportCallbackCreateInfoEXT.pNext ); 2816 VULKAN_HPP_HASH_COMBINE( seed, debugReportCallbackCreateInfoEXT.flags ); 2817 VULKAN_HPP_HASH_COMBINE( seed, debugReportCallbackCreateInfoEXT.pfnCallback ); 2818 VULKAN_HPP_HASH_COMBINE( seed, debugReportCallbackCreateInfoEXT.pUserData ); 2819 return seed; 2820 } 2821 }; 2822 2823 template <> 2824 struct hash<VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT> 2825 { operator ()std::hash2826 std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT const & debugUtilsLabelEXT ) const VULKAN_HPP_NOEXCEPT 2827 { 2828 std::size_t seed = 0; 2829 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsLabelEXT.sType ); 2830 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsLabelEXT.pNext ); 2831 for ( const char * p = debugUtilsLabelEXT.pLabelName; *p != '\0'; ++p ) 2832 { 2833 VULKAN_HPP_HASH_COMBINE( seed, *p ); 2834 } 2835 for ( size_t i = 0; i < 4; ++i ) 2836 { 2837 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsLabelEXT.color[i] ); 2838 } 2839 return seed; 2840 } 2841 }; 2842 2843 template <> 2844 struct hash<VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT> 2845 { operator ()std::hash2846 std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT const & debugUtilsObjectNameInfoEXT ) const VULKAN_HPP_NOEXCEPT 2847 { 2848 std::size_t seed = 0; 2849 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectNameInfoEXT.sType ); 2850 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectNameInfoEXT.pNext ); 2851 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectNameInfoEXT.objectType ); 2852 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectNameInfoEXT.objectHandle ); 2853 for ( const char * p = debugUtilsObjectNameInfoEXT.pObjectName; *p != '\0'; ++p ) 2854 { 2855 VULKAN_HPP_HASH_COMBINE( seed, *p ); 2856 } 2857 return seed; 2858 } 2859 }; 2860 2861 template <> 2862 struct hash<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataEXT> 2863 { operator ()std::hash2864 std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataEXT const & debugUtilsMessengerCallbackDataEXT ) const VULKAN_HPP_NOEXCEPT 2865 { 2866 std::size_t seed = 0; 2867 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.sType ); 2868 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.pNext ); 2869 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.flags ); 2870 for ( const char * p = debugUtilsMessengerCallbackDataEXT.pMessageIdName; *p != '\0'; ++p ) 2871 { 2872 VULKAN_HPP_HASH_COMBINE( seed, *p ); 2873 } 2874 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.messageIdNumber ); 2875 for ( const char * p = debugUtilsMessengerCallbackDataEXT.pMessage; *p != '\0'; ++p ) 2876 { 2877 VULKAN_HPP_HASH_COMBINE( seed, *p ); 2878 } 2879 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.queueLabelCount ); 2880 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.pQueueLabels ); 2881 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.cmdBufLabelCount ); 2882 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.pCmdBufLabels ); 2883 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.objectCount ); 2884 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.pObjects ); 2885 return seed; 2886 } 2887 }; 2888 2889 template <> 2890 struct hash<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT> 2891 { operator ()std::hash2892 std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT const & debugUtilsMessengerCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 2893 { 2894 std::size_t seed = 0; 2895 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCreateInfoEXT.sType ); 2896 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCreateInfoEXT.pNext ); 2897 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCreateInfoEXT.flags ); 2898 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCreateInfoEXT.messageSeverity ); 2899 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCreateInfoEXT.messageType ); 2900 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCreateInfoEXT.pfnUserCallback ); 2901 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCreateInfoEXT.pUserData ); 2902 return seed; 2903 } 2904 }; 2905 2906 template <> 2907 struct hash<VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT> 2908 { operator ()std::hash2909 std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT const & debugUtilsObjectTagInfoEXT ) const VULKAN_HPP_NOEXCEPT 2910 { 2911 std::size_t seed = 0; 2912 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectTagInfoEXT.sType ); 2913 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectTagInfoEXT.pNext ); 2914 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectTagInfoEXT.objectType ); 2915 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectTagInfoEXT.objectHandle ); 2916 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectTagInfoEXT.tagName ); 2917 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectTagInfoEXT.tagSize ); 2918 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectTagInfoEXT.pTag ); 2919 return seed; 2920 } 2921 }; 2922 2923 template <> 2924 struct hash<VULKAN_HPP_NAMESPACE::DecompressMemoryRegionNV> 2925 { operator ()std::hash2926 std::size_t operator()( VULKAN_HPP_NAMESPACE::DecompressMemoryRegionNV const & decompressMemoryRegionNV ) const VULKAN_HPP_NOEXCEPT 2927 { 2928 std::size_t seed = 0; 2929 VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryRegionNV.srcAddress ); 2930 VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryRegionNV.dstAddress ); 2931 VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryRegionNV.compressedSize ); 2932 VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryRegionNV.decompressedSize ); 2933 VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryRegionNV.decompressionMethod ); 2934 return seed; 2935 } 2936 }; 2937 2938 template <> 2939 struct hash<VULKAN_HPP_NAMESPACE::DedicatedAllocationBufferCreateInfoNV> 2940 { 2941 std::size_t operator ()std::hash2942 operator()( VULKAN_HPP_NAMESPACE::DedicatedAllocationBufferCreateInfoNV const & dedicatedAllocationBufferCreateInfoNV ) const VULKAN_HPP_NOEXCEPT 2943 { 2944 std::size_t seed = 0; 2945 VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationBufferCreateInfoNV.sType ); 2946 VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationBufferCreateInfoNV.pNext ); 2947 VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationBufferCreateInfoNV.dedicatedAllocation ); 2948 return seed; 2949 } 2950 }; 2951 2952 template <> 2953 struct hash<VULKAN_HPP_NAMESPACE::DedicatedAllocationImageCreateInfoNV> 2954 { operator ()std::hash2955 std::size_t operator()( VULKAN_HPP_NAMESPACE::DedicatedAllocationImageCreateInfoNV const & dedicatedAllocationImageCreateInfoNV ) const VULKAN_HPP_NOEXCEPT 2956 { 2957 std::size_t seed = 0; 2958 VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationImageCreateInfoNV.sType ); 2959 VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationImageCreateInfoNV.pNext ); 2960 VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationImageCreateInfoNV.dedicatedAllocation ); 2961 return seed; 2962 } 2963 }; 2964 2965 template <> 2966 struct hash<VULKAN_HPP_NAMESPACE::DedicatedAllocationMemoryAllocateInfoNV> 2967 { 2968 std::size_t operator ()std::hash2969 operator()( VULKAN_HPP_NAMESPACE::DedicatedAllocationMemoryAllocateInfoNV const & dedicatedAllocationMemoryAllocateInfoNV ) const VULKAN_HPP_NOEXCEPT 2970 { 2971 std::size_t seed = 0; 2972 VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationMemoryAllocateInfoNV.sType ); 2973 VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationMemoryAllocateInfoNV.pNext ); 2974 VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationMemoryAllocateInfoNV.image ); 2975 VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationMemoryAllocateInfoNV.buffer ); 2976 return seed; 2977 } 2978 }; 2979 2980 template <> 2981 struct hash<VULKAN_HPP_NAMESPACE::MemoryBarrier2> 2982 { operator ()std::hash2983 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryBarrier2 const & memoryBarrier2 ) const VULKAN_HPP_NOEXCEPT 2984 { 2985 std::size_t seed = 0; 2986 VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier2.sType ); 2987 VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier2.pNext ); 2988 VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier2.srcStageMask ); 2989 VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier2.srcAccessMask ); 2990 VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier2.dstStageMask ); 2991 VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier2.dstAccessMask ); 2992 return seed; 2993 } 2994 }; 2995 2996 template <> 2997 struct hash<VULKAN_HPP_NAMESPACE::ImageSubresourceRange> 2998 { operator ()std::hash2999 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageSubresourceRange const & imageSubresourceRange ) const VULKAN_HPP_NOEXCEPT 3000 { 3001 std::size_t seed = 0; 3002 VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceRange.aspectMask ); 3003 VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceRange.baseMipLevel ); 3004 VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceRange.levelCount ); 3005 VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceRange.baseArrayLayer ); 3006 VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceRange.layerCount ); 3007 return seed; 3008 } 3009 }; 3010 3011 template <> 3012 struct hash<VULKAN_HPP_NAMESPACE::ImageMemoryBarrier2> 3013 { operator ()std::hash3014 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageMemoryBarrier2 const & imageMemoryBarrier2 ) const VULKAN_HPP_NOEXCEPT 3015 { 3016 std::size_t seed = 0; 3017 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.sType ); 3018 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.pNext ); 3019 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.srcStageMask ); 3020 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.srcAccessMask ); 3021 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.dstStageMask ); 3022 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.dstAccessMask ); 3023 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.oldLayout ); 3024 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.newLayout ); 3025 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.srcQueueFamilyIndex ); 3026 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.dstQueueFamilyIndex ); 3027 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.image ); 3028 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.subresourceRange ); 3029 return seed; 3030 } 3031 }; 3032 3033 template <> 3034 struct hash<VULKAN_HPP_NAMESPACE::DependencyInfo> 3035 { operator ()std::hash3036 std::size_t operator()( VULKAN_HPP_NAMESPACE::DependencyInfo const & dependencyInfo ) const VULKAN_HPP_NOEXCEPT 3037 { 3038 std::size_t seed = 0; 3039 VULKAN_HPP_HASH_COMBINE( seed, dependencyInfo.sType ); 3040 VULKAN_HPP_HASH_COMBINE( seed, dependencyInfo.pNext ); 3041 VULKAN_HPP_HASH_COMBINE( seed, dependencyInfo.dependencyFlags ); 3042 VULKAN_HPP_HASH_COMBINE( seed, dependencyInfo.memoryBarrierCount ); 3043 VULKAN_HPP_HASH_COMBINE( seed, dependencyInfo.pMemoryBarriers ); 3044 VULKAN_HPP_HASH_COMBINE( seed, dependencyInfo.bufferMemoryBarrierCount ); 3045 VULKAN_HPP_HASH_COMBINE( seed, dependencyInfo.pBufferMemoryBarriers ); 3046 VULKAN_HPP_HASH_COMBINE( seed, dependencyInfo.imageMemoryBarrierCount ); 3047 VULKAN_HPP_HASH_COMBINE( seed, dependencyInfo.pImageMemoryBarriers ); 3048 return seed; 3049 } 3050 }; 3051 3052 template <> 3053 struct hash<VULKAN_HPP_NAMESPACE::DepthBiasInfoEXT> 3054 { operator ()std::hash3055 std::size_t operator()( VULKAN_HPP_NAMESPACE::DepthBiasInfoEXT const & depthBiasInfoEXT ) const VULKAN_HPP_NOEXCEPT 3056 { 3057 std::size_t seed = 0; 3058 VULKAN_HPP_HASH_COMBINE( seed, depthBiasInfoEXT.sType ); 3059 VULKAN_HPP_HASH_COMBINE( seed, depthBiasInfoEXT.pNext ); 3060 VULKAN_HPP_HASH_COMBINE( seed, depthBiasInfoEXT.depthBiasConstantFactor ); 3061 VULKAN_HPP_HASH_COMBINE( seed, depthBiasInfoEXT.depthBiasClamp ); 3062 VULKAN_HPP_HASH_COMBINE( seed, depthBiasInfoEXT.depthBiasSlopeFactor ); 3063 return seed; 3064 } 3065 }; 3066 3067 template <> 3068 struct hash<VULKAN_HPP_NAMESPACE::DepthBiasRepresentationInfoEXT> 3069 { operator ()std::hash3070 std::size_t operator()( VULKAN_HPP_NAMESPACE::DepthBiasRepresentationInfoEXT const & depthBiasRepresentationInfoEXT ) const VULKAN_HPP_NOEXCEPT 3071 { 3072 std::size_t seed = 0; 3073 VULKAN_HPP_HASH_COMBINE( seed, depthBiasRepresentationInfoEXT.sType ); 3074 VULKAN_HPP_HASH_COMBINE( seed, depthBiasRepresentationInfoEXT.pNext ); 3075 VULKAN_HPP_HASH_COMBINE( seed, depthBiasRepresentationInfoEXT.depthBiasRepresentation ); 3076 VULKAN_HPP_HASH_COMBINE( seed, depthBiasRepresentationInfoEXT.depthBiasExact ); 3077 return seed; 3078 } 3079 }; 3080 3081 template <> 3082 struct hash<VULKAN_HPP_NAMESPACE::DescriptorAddressInfoEXT> 3083 { operator ()std::hash3084 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorAddressInfoEXT const & descriptorAddressInfoEXT ) const VULKAN_HPP_NOEXCEPT 3085 { 3086 std::size_t seed = 0; 3087 VULKAN_HPP_HASH_COMBINE( seed, descriptorAddressInfoEXT.sType ); 3088 VULKAN_HPP_HASH_COMBINE( seed, descriptorAddressInfoEXT.pNext ); 3089 VULKAN_HPP_HASH_COMBINE( seed, descriptorAddressInfoEXT.address ); 3090 VULKAN_HPP_HASH_COMBINE( seed, descriptorAddressInfoEXT.range ); 3091 VULKAN_HPP_HASH_COMBINE( seed, descriptorAddressInfoEXT.format ); 3092 return seed; 3093 } 3094 }; 3095 3096 template <> 3097 struct hash<VULKAN_HPP_NAMESPACE::DescriptorBufferBindingInfoEXT> 3098 { operator ()std::hash3099 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorBufferBindingInfoEXT const & descriptorBufferBindingInfoEXT ) const VULKAN_HPP_NOEXCEPT 3100 { 3101 std::size_t seed = 0; 3102 VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferBindingInfoEXT.sType ); 3103 VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferBindingInfoEXT.pNext ); 3104 VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferBindingInfoEXT.address ); 3105 VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferBindingInfoEXT.usage ); 3106 return seed; 3107 } 3108 }; 3109 3110 template <> 3111 struct hash<VULKAN_HPP_NAMESPACE::DescriptorBufferBindingPushDescriptorBufferHandleEXT> 3112 { operator ()std::hash3113 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorBufferBindingPushDescriptorBufferHandleEXT const & 3114 descriptorBufferBindingPushDescriptorBufferHandleEXT ) const VULKAN_HPP_NOEXCEPT 3115 { 3116 std::size_t seed = 0; 3117 VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferBindingPushDescriptorBufferHandleEXT.sType ); 3118 VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferBindingPushDescriptorBufferHandleEXT.pNext ); 3119 VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferBindingPushDescriptorBufferHandleEXT.buffer ); 3120 return seed; 3121 } 3122 }; 3123 3124 template <> 3125 struct hash<VULKAN_HPP_NAMESPACE::DescriptorBufferInfo> 3126 { operator ()std::hash3127 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorBufferInfo const & descriptorBufferInfo ) const VULKAN_HPP_NOEXCEPT 3128 { 3129 std::size_t seed = 0; 3130 VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferInfo.buffer ); 3131 VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferInfo.offset ); 3132 VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferInfo.range ); 3133 return seed; 3134 } 3135 }; 3136 3137 template <> 3138 struct hash<VULKAN_HPP_NAMESPACE::DescriptorImageInfo> 3139 { operator ()std::hash3140 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorImageInfo const & descriptorImageInfo ) const VULKAN_HPP_NOEXCEPT 3141 { 3142 std::size_t seed = 0; 3143 VULKAN_HPP_HASH_COMBINE( seed, descriptorImageInfo.sampler ); 3144 VULKAN_HPP_HASH_COMBINE( seed, descriptorImageInfo.imageView ); 3145 VULKAN_HPP_HASH_COMBINE( seed, descriptorImageInfo.imageLayout ); 3146 return seed; 3147 } 3148 }; 3149 3150 template <> 3151 struct hash<VULKAN_HPP_NAMESPACE::DescriptorPoolSize> 3152 { operator ()std::hash3153 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorPoolSize const & descriptorPoolSize ) const VULKAN_HPP_NOEXCEPT 3154 { 3155 std::size_t seed = 0; 3156 VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolSize.type ); 3157 VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolSize.descriptorCount ); 3158 return seed; 3159 } 3160 }; 3161 3162 template <> 3163 struct hash<VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo> 3164 { operator ()std::hash3165 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo const & descriptorPoolCreateInfo ) const VULKAN_HPP_NOEXCEPT 3166 { 3167 std::size_t seed = 0; 3168 VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolCreateInfo.sType ); 3169 VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolCreateInfo.pNext ); 3170 VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolCreateInfo.flags ); 3171 VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolCreateInfo.maxSets ); 3172 VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolCreateInfo.poolSizeCount ); 3173 VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolCreateInfo.pPoolSizes ); 3174 return seed; 3175 } 3176 }; 3177 3178 template <> 3179 struct hash<VULKAN_HPP_NAMESPACE::DescriptorPoolInlineUniformBlockCreateInfo> 3180 { operator ()std::hash3181 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorPoolInlineUniformBlockCreateInfo const & descriptorPoolInlineUniformBlockCreateInfo ) const 3182 VULKAN_HPP_NOEXCEPT 3183 { 3184 std::size_t seed = 0; 3185 VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolInlineUniformBlockCreateInfo.sType ); 3186 VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolInlineUniformBlockCreateInfo.pNext ); 3187 VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolInlineUniformBlockCreateInfo.maxInlineUniformBlockBindings ); 3188 return seed; 3189 } 3190 }; 3191 3192 template <> 3193 struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo> 3194 { operator ()std::hash3195 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo const & descriptorSetAllocateInfo ) const VULKAN_HPP_NOEXCEPT 3196 { 3197 std::size_t seed = 0; 3198 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetAllocateInfo.sType ); 3199 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetAllocateInfo.pNext ); 3200 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetAllocateInfo.descriptorPool ); 3201 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetAllocateInfo.descriptorSetCount ); 3202 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetAllocateInfo.pSetLayouts ); 3203 return seed; 3204 } 3205 }; 3206 3207 template <> 3208 struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetBindingReferenceVALVE> 3209 { operator ()std::hash3210 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetBindingReferenceVALVE const & descriptorSetBindingReferenceVALVE ) const VULKAN_HPP_NOEXCEPT 3211 { 3212 std::size_t seed = 0; 3213 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetBindingReferenceVALVE.sType ); 3214 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetBindingReferenceVALVE.pNext ); 3215 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetBindingReferenceVALVE.descriptorSetLayout ); 3216 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetBindingReferenceVALVE.binding ); 3217 return seed; 3218 } 3219 }; 3220 3221 template <> 3222 struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBinding> 3223 { operator ()std::hash3224 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBinding const & descriptorSetLayoutBinding ) const VULKAN_HPP_NOEXCEPT 3225 { 3226 std::size_t seed = 0; 3227 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutBinding.binding ); 3228 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutBinding.descriptorType ); 3229 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutBinding.descriptorCount ); 3230 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutBinding.stageFlags ); 3231 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutBinding.pImmutableSamplers ); 3232 return seed; 3233 } 3234 }; 3235 3236 template <> 3237 struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBindingFlagsCreateInfo> 3238 { 3239 std::size_t operator ()std::hash3240 operator()( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBindingFlagsCreateInfo const & descriptorSetLayoutBindingFlagsCreateInfo ) const VULKAN_HPP_NOEXCEPT 3241 { 3242 std::size_t seed = 0; 3243 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutBindingFlagsCreateInfo.sType ); 3244 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutBindingFlagsCreateInfo.pNext ); 3245 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutBindingFlagsCreateInfo.bindingCount ); 3246 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutBindingFlagsCreateInfo.pBindingFlags ); 3247 return seed; 3248 } 3249 }; 3250 3251 template <> 3252 struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo> 3253 { operator ()std::hash3254 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo const & descriptorSetLayoutCreateInfo ) const VULKAN_HPP_NOEXCEPT 3255 { 3256 std::size_t seed = 0; 3257 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutCreateInfo.sType ); 3258 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutCreateInfo.pNext ); 3259 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutCreateInfo.flags ); 3260 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutCreateInfo.bindingCount ); 3261 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutCreateInfo.pBindings ); 3262 return seed; 3263 } 3264 }; 3265 3266 template <> 3267 struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutHostMappingInfoVALVE> 3268 { 3269 std::size_t operator ()std::hash3270 operator()( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutHostMappingInfoVALVE const & descriptorSetLayoutHostMappingInfoVALVE ) const VULKAN_HPP_NOEXCEPT 3271 { 3272 std::size_t seed = 0; 3273 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutHostMappingInfoVALVE.sType ); 3274 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutHostMappingInfoVALVE.pNext ); 3275 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutHostMappingInfoVALVE.descriptorOffset ); 3276 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutHostMappingInfoVALVE.descriptorSize ); 3277 return seed; 3278 } 3279 }; 3280 3281 template <> 3282 struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport> 3283 { operator ()std::hash3284 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport const & descriptorSetLayoutSupport ) const VULKAN_HPP_NOEXCEPT 3285 { 3286 std::size_t seed = 0; 3287 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutSupport.sType ); 3288 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutSupport.pNext ); 3289 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutSupport.supported ); 3290 return seed; 3291 } 3292 }; 3293 3294 template <> 3295 struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetVariableDescriptorCountAllocateInfo> 3296 { operator ()std::hash3297 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetVariableDescriptorCountAllocateInfo const & descriptorSetVariableDescriptorCountAllocateInfo ) 3298 const VULKAN_HPP_NOEXCEPT 3299 { 3300 std::size_t seed = 0; 3301 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetVariableDescriptorCountAllocateInfo.sType ); 3302 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetVariableDescriptorCountAllocateInfo.pNext ); 3303 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetVariableDescriptorCountAllocateInfo.descriptorSetCount ); 3304 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetVariableDescriptorCountAllocateInfo.pDescriptorCounts ); 3305 return seed; 3306 } 3307 }; 3308 3309 template <> 3310 struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetVariableDescriptorCountLayoutSupport> 3311 { operator ()std::hash3312 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetVariableDescriptorCountLayoutSupport const & descriptorSetVariableDescriptorCountLayoutSupport ) 3313 const VULKAN_HPP_NOEXCEPT 3314 { 3315 std::size_t seed = 0; 3316 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetVariableDescriptorCountLayoutSupport.sType ); 3317 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetVariableDescriptorCountLayoutSupport.pNext ); 3318 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetVariableDescriptorCountLayoutSupport.maxVariableDescriptorCount ); 3319 return seed; 3320 } 3321 }; 3322 3323 template <> 3324 struct hash<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateEntry> 3325 { operator ()std::hash3326 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateEntry const & descriptorUpdateTemplateEntry ) const VULKAN_HPP_NOEXCEPT 3327 { 3328 std::size_t seed = 0; 3329 VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateEntry.dstBinding ); 3330 VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateEntry.dstArrayElement ); 3331 VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateEntry.descriptorCount ); 3332 VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateEntry.descriptorType ); 3333 VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateEntry.offset ); 3334 VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateEntry.stride ); 3335 return seed; 3336 } 3337 }; 3338 3339 template <> 3340 struct hash<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo> 3341 { operator ()std::hash3342 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo const & descriptorUpdateTemplateCreateInfo ) const VULKAN_HPP_NOEXCEPT 3343 { 3344 std::size_t seed = 0; 3345 VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.sType ); 3346 VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.pNext ); 3347 VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.flags ); 3348 VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.descriptorUpdateEntryCount ); 3349 VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.pDescriptorUpdateEntries ); 3350 VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.templateType ); 3351 VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.descriptorSetLayout ); 3352 VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.pipelineBindPoint ); 3353 VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.pipelineLayout ); 3354 VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.set ); 3355 return seed; 3356 } 3357 }; 3358 3359 template <> 3360 struct hash<VULKAN_HPP_NAMESPACE::DeviceAddressBindingCallbackDataEXT> 3361 { operator ()std::hash3362 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceAddressBindingCallbackDataEXT const & deviceAddressBindingCallbackDataEXT ) const VULKAN_HPP_NOEXCEPT 3363 { 3364 std::size_t seed = 0; 3365 VULKAN_HPP_HASH_COMBINE( seed, deviceAddressBindingCallbackDataEXT.sType ); 3366 VULKAN_HPP_HASH_COMBINE( seed, deviceAddressBindingCallbackDataEXT.pNext ); 3367 VULKAN_HPP_HASH_COMBINE( seed, deviceAddressBindingCallbackDataEXT.flags ); 3368 VULKAN_HPP_HASH_COMBINE( seed, deviceAddressBindingCallbackDataEXT.baseAddress ); 3369 VULKAN_HPP_HASH_COMBINE( seed, deviceAddressBindingCallbackDataEXT.size ); 3370 VULKAN_HPP_HASH_COMBINE( seed, deviceAddressBindingCallbackDataEXT.bindingType ); 3371 return seed; 3372 } 3373 }; 3374 3375 template <> 3376 struct hash<VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements> 3377 { operator ()std::hash3378 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements const & deviceBufferMemoryRequirements ) const VULKAN_HPP_NOEXCEPT 3379 { 3380 std::size_t seed = 0; 3381 VULKAN_HPP_HASH_COMBINE( seed, deviceBufferMemoryRequirements.sType ); 3382 VULKAN_HPP_HASH_COMBINE( seed, deviceBufferMemoryRequirements.pNext ); 3383 VULKAN_HPP_HASH_COMBINE( seed, deviceBufferMemoryRequirements.pCreateInfo ); 3384 return seed; 3385 } 3386 }; 3387 3388 template <> 3389 struct hash<VULKAN_HPP_NAMESPACE::DeviceQueueCreateInfo> 3390 { operator ()std::hash3391 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceQueueCreateInfo const & deviceQueueCreateInfo ) const VULKAN_HPP_NOEXCEPT 3392 { 3393 std::size_t seed = 0; 3394 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueCreateInfo.sType ); 3395 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueCreateInfo.pNext ); 3396 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueCreateInfo.flags ); 3397 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueCreateInfo.queueFamilyIndex ); 3398 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueCreateInfo.queueCount ); 3399 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueCreateInfo.pQueuePriorities ); 3400 return seed; 3401 } 3402 }; 3403 3404 template <> 3405 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures> 3406 { operator ()std::hash3407 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures const & physicalDeviceFeatures ) const VULKAN_HPP_NOEXCEPT 3408 { 3409 std::size_t seed = 0; 3410 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.robustBufferAccess ); 3411 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.fullDrawIndexUint32 ); 3412 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.imageCubeArray ); 3413 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.independentBlend ); 3414 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.geometryShader ); 3415 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.tessellationShader ); 3416 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sampleRateShading ); 3417 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.dualSrcBlend ); 3418 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.logicOp ); 3419 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.multiDrawIndirect ); 3420 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.drawIndirectFirstInstance ); 3421 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.depthClamp ); 3422 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.depthBiasClamp ); 3423 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.fillModeNonSolid ); 3424 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.depthBounds ); 3425 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.wideLines ); 3426 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.largePoints ); 3427 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.alphaToOne ); 3428 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.multiViewport ); 3429 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.samplerAnisotropy ); 3430 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.textureCompressionETC2 ); 3431 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.textureCompressionASTC_LDR ); 3432 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.textureCompressionBC ); 3433 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.occlusionQueryPrecise ); 3434 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.pipelineStatisticsQuery ); 3435 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.vertexPipelineStoresAndAtomics ); 3436 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.fragmentStoresAndAtomics ); 3437 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderTessellationAndGeometryPointSize ); 3438 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderImageGatherExtended ); 3439 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderStorageImageExtendedFormats ); 3440 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderStorageImageMultisample ); 3441 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderStorageImageReadWithoutFormat ); 3442 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderStorageImageWriteWithoutFormat ); 3443 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderUniformBufferArrayDynamicIndexing ); 3444 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderSampledImageArrayDynamicIndexing ); 3445 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderStorageBufferArrayDynamicIndexing ); 3446 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderStorageImageArrayDynamicIndexing ); 3447 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderClipDistance ); 3448 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderCullDistance ); 3449 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderFloat64 ); 3450 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderInt64 ); 3451 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderInt16 ); 3452 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderResourceResidency ); 3453 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderResourceMinLod ); 3454 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sparseBinding ); 3455 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sparseResidencyBuffer ); 3456 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sparseResidencyImage2D ); 3457 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sparseResidencyImage3D ); 3458 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sparseResidency2Samples ); 3459 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sparseResidency4Samples ); 3460 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sparseResidency8Samples ); 3461 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sparseResidency16Samples ); 3462 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sparseResidencyAliased ); 3463 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.variableMultisampleRate ); 3464 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.inheritedQueries ); 3465 return seed; 3466 } 3467 }; 3468 3469 template <> 3470 struct hash<VULKAN_HPP_NAMESPACE::DeviceCreateInfo> 3471 { operator ()std::hash3472 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceCreateInfo const & deviceCreateInfo ) const VULKAN_HPP_NOEXCEPT 3473 { 3474 std::size_t seed = 0; 3475 VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.sType ); 3476 VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.pNext ); 3477 VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.flags ); 3478 VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.queueCreateInfoCount ); 3479 VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.pQueueCreateInfos ); 3480 VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.enabledLayerCount ); 3481 for ( size_t i = 0; i < deviceCreateInfo.enabledLayerCount; ++i ) 3482 { 3483 for ( const char * p = deviceCreateInfo.ppEnabledLayerNames[i]; *p != '\0'; ++p ) 3484 { 3485 VULKAN_HPP_HASH_COMBINE( seed, *p ); 3486 } 3487 } 3488 VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.enabledExtensionCount ); 3489 for ( size_t i = 0; i < deviceCreateInfo.enabledExtensionCount; ++i ) 3490 { 3491 for ( const char * p = deviceCreateInfo.ppEnabledExtensionNames[i]; *p != '\0'; ++p ) 3492 { 3493 VULKAN_HPP_HASH_COMBINE( seed, *p ); 3494 } 3495 } 3496 VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.pEnabledFeatures ); 3497 return seed; 3498 } 3499 }; 3500 3501 template <> 3502 struct hash<VULKAN_HPP_NAMESPACE::DeviceDeviceMemoryReportCreateInfoEXT> 3503 { 3504 std::size_t operator ()std::hash3505 operator()( VULKAN_HPP_NAMESPACE::DeviceDeviceMemoryReportCreateInfoEXT const & deviceDeviceMemoryReportCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 3506 { 3507 std::size_t seed = 0; 3508 VULKAN_HPP_HASH_COMBINE( seed, deviceDeviceMemoryReportCreateInfoEXT.sType ); 3509 VULKAN_HPP_HASH_COMBINE( seed, deviceDeviceMemoryReportCreateInfoEXT.pNext ); 3510 VULKAN_HPP_HASH_COMBINE( seed, deviceDeviceMemoryReportCreateInfoEXT.flags ); 3511 VULKAN_HPP_HASH_COMBINE( seed, deviceDeviceMemoryReportCreateInfoEXT.pfnUserCallback ); 3512 VULKAN_HPP_HASH_COMBINE( seed, deviceDeviceMemoryReportCreateInfoEXT.pUserData ); 3513 return seed; 3514 } 3515 }; 3516 3517 template <> 3518 struct hash<VULKAN_HPP_NAMESPACE::DeviceDiagnosticsConfigCreateInfoNV> 3519 { operator ()std::hash3520 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceDiagnosticsConfigCreateInfoNV const & deviceDiagnosticsConfigCreateInfoNV ) const VULKAN_HPP_NOEXCEPT 3521 { 3522 std::size_t seed = 0; 3523 VULKAN_HPP_HASH_COMBINE( seed, deviceDiagnosticsConfigCreateInfoNV.sType ); 3524 VULKAN_HPP_HASH_COMBINE( seed, deviceDiagnosticsConfigCreateInfoNV.pNext ); 3525 VULKAN_HPP_HASH_COMBINE( seed, deviceDiagnosticsConfigCreateInfoNV.flags ); 3526 return seed; 3527 } 3528 }; 3529 3530 template <> 3531 struct hash<VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT> 3532 { operator ()std::hash3533 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT const & deviceEventInfoEXT ) const VULKAN_HPP_NOEXCEPT 3534 { 3535 std::size_t seed = 0; 3536 VULKAN_HPP_HASH_COMBINE( seed, deviceEventInfoEXT.sType ); 3537 VULKAN_HPP_HASH_COMBINE( seed, deviceEventInfoEXT.pNext ); 3538 VULKAN_HPP_HASH_COMBINE( seed, deviceEventInfoEXT.deviceEvent ); 3539 return seed; 3540 } 3541 }; 3542 3543 template <> 3544 struct hash<VULKAN_HPP_NAMESPACE::DeviceFaultAddressInfoEXT> 3545 { operator ()std::hash3546 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceFaultAddressInfoEXT const & deviceFaultAddressInfoEXT ) const VULKAN_HPP_NOEXCEPT 3547 { 3548 std::size_t seed = 0; 3549 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultAddressInfoEXT.addressType ); 3550 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultAddressInfoEXT.reportedAddress ); 3551 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultAddressInfoEXT.addressPrecision ); 3552 return seed; 3553 } 3554 }; 3555 3556 template <> 3557 struct hash<VULKAN_HPP_NAMESPACE::DeviceFaultCountsEXT> 3558 { operator ()std::hash3559 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceFaultCountsEXT const & deviceFaultCountsEXT ) const VULKAN_HPP_NOEXCEPT 3560 { 3561 std::size_t seed = 0; 3562 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultCountsEXT.sType ); 3563 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultCountsEXT.pNext ); 3564 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultCountsEXT.addressInfoCount ); 3565 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultCountsEXT.vendorInfoCount ); 3566 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultCountsEXT.vendorBinarySize ); 3567 return seed; 3568 } 3569 }; 3570 3571 template <> 3572 struct hash<VULKAN_HPP_NAMESPACE::DeviceFaultVendorInfoEXT> 3573 { operator ()std::hash3574 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceFaultVendorInfoEXT const & deviceFaultVendorInfoEXT ) const VULKAN_HPP_NOEXCEPT 3575 { 3576 std::size_t seed = 0; 3577 for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) 3578 { 3579 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorInfoEXT.description[i] ); 3580 } 3581 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorInfoEXT.vendorFaultCode ); 3582 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorInfoEXT.vendorFaultData ); 3583 return seed; 3584 } 3585 }; 3586 3587 template <> 3588 struct hash<VULKAN_HPP_NAMESPACE::DeviceFaultInfoEXT> 3589 { operator ()std::hash3590 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceFaultInfoEXT const & deviceFaultInfoEXT ) const VULKAN_HPP_NOEXCEPT 3591 { 3592 std::size_t seed = 0; 3593 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultInfoEXT.sType ); 3594 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultInfoEXT.pNext ); 3595 for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) 3596 { 3597 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultInfoEXT.description[i] ); 3598 } 3599 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultInfoEXT.pAddressInfos ); 3600 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultInfoEXT.pVendorInfos ); 3601 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultInfoEXT.pVendorBinaryData ); 3602 return seed; 3603 } 3604 }; 3605 3606 template <> 3607 struct hash<VULKAN_HPP_NAMESPACE::DeviceFaultVendorBinaryHeaderVersionOneEXT> 3608 { operator ()std::hash3609 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceFaultVendorBinaryHeaderVersionOneEXT const & deviceFaultVendorBinaryHeaderVersionOneEXT ) const 3610 VULKAN_HPP_NOEXCEPT 3611 { 3612 std::size_t seed = 0; 3613 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.headerSize ); 3614 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.headerVersion ); 3615 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.vendorID ); 3616 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.deviceID ); 3617 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.driverVersion ); 3618 for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) 3619 { 3620 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.pipelineCacheUUID[i] ); 3621 } 3622 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.applicationNameOffset ); 3623 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.applicationVersion ); 3624 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.engineNameOffset ); 3625 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.engineVersion ); 3626 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.apiVersion ); 3627 return seed; 3628 } 3629 }; 3630 3631 template <> 3632 struct hash<VULKAN_HPP_NAMESPACE::DeviceGroupBindSparseInfo> 3633 { operator ()std::hash3634 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupBindSparseInfo const & deviceGroupBindSparseInfo ) const VULKAN_HPP_NOEXCEPT 3635 { 3636 std::size_t seed = 0; 3637 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupBindSparseInfo.sType ); 3638 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupBindSparseInfo.pNext ); 3639 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupBindSparseInfo.resourceDeviceIndex ); 3640 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupBindSparseInfo.memoryDeviceIndex ); 3641 return seed; 3642 } 3643 }; 3644 3645 template <> 3646 struct hash<VULKAN_HPP_NAMESPACE::DeviceGroupCommandBufferBeginInfo> 3647 { operator ()std::hash3648 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupCommandBufferBeginInfo const & deviceGroupCommandBufferBeginInfo ) const VULKAN_HPP_NOEXCEPT 3649 { 3650 std::size_t seed = 0; 3651 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupCommandBufferBeginInfo.sType ); 3652 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupCommandBufferBeginInfo.pNext ); 3653 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupCommandBufferBeginInfo.deviceMask ); 3654 return seed; 3655 } 3656 }; 3657 3658 template <> 3659 struct hash<VULKAN_HPP_NAMESPACE::DeviceGroupDeviceCreateInfo> 3660 { operator ()std::hash3661 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupDeviceCreateInfo const & deviceGroupDeviceCreateInfo ) const VULKAN_HPP_NOEXCEPT 3662 { 3663 std::size_t seed = 0; 3664 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupDeviceCreateInfo.sType ); 3665 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupDeviceCreateInfo.pNext ); 3666 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupDeviceCreateInfo.physicalDeviceCount ); 3667 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupDeviceCreateInfo.pPhysicalDevices ); 3668 return seed; 3669 } 3670 }; 3671 3672 template <> 3673 struct hash<VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR> 3674 { operator ()std::hash3675 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR const & deviceGroupPresentCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT 3676 { 3677 std::size_t seed = 0; 3678 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupPresentCapabilitiesKHR.sType ); 3679 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupPresentCapabilitiesKHR.pNext ); 3680 for ( size_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; ++i ) 3681 { 3682 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupPresentCapabilitiesKHR.presentMask[i] ); 3683 } 3684 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupPresentCapabilitiesKHR.modes ); 3685 return seed; 3686 } 3687 }; 3688 3689 template <> 3690 struct hash<VULKAN_HPP_NAMESPACE::DeviceGroupPresentInfoKHR> 3691 { operator ()std::hash3692 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupPresentInfoKHR const & deviceGroupPresentInfoKHR ) const VULKAN_HPP_NOEXCEPT 3693 { 3694 std::size_t seed = 0; 3695 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupPresentInfoKHR.sType ); 3696 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupPresentInfoKHR.pNext ); 3697 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupPresentInfoKHR.swapchainCount ); 3698 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupPresentInfoKHR.pDeviceMasks ); 3699 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupPresentInfoKHR.mode ); 3700 return seed; 3701 } 3702 }; 3703 3704 template <> 3705 struct hash<VULKAN_HPP_NAMESPACE::DeviceGroupRenderPassBeginInfo> 3706 { operator ()std::hash3707 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupRenderPassBeginInfo const & deviceGroupRenderPassBeginInfo ) const VULKAN_HPP_NOEXCEPT 3708 { 3709 std::size_t seed = 0; 3710 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupRenderPassBeginInfo.sType ); 3711 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupRenderPassBeginInfo.pNext ); 3712 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupRenderPassBeginInfo.deviceMask ); 3713 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupRenderPassBeginInfo.deviceRenderAreaCount ); 3714 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupRenderPassBeginInfo.pDeviceRenderAreas ); 3715 return seed; 3716 } 3717 }; 3718 3719 template <> 3720 struct hash<VULKAN_HPP_NAMESPACE::DeviceGroupSubmitInfo> 3721 { operator ()std::hash3722 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupSubmitInfo const & deviceGroupSubmitInfo ) const VULKAN_HPP_NOEXCEPT 3723 { 3724 std::size_t seed = 0; 3725 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSubmitInfo.sType ); 3726 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSubmitInfo.pNext ); 3727 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSubmitInfo.waitSemaphoreCount ); 3728 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSubmitInfo.pWaitSemaphoreDeviceIndices ); 3729 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSubmitInfo.commandBufferCount ); 3730 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSubmitInfo.pCommandBufferDeviceMasks ); 3731 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSubmitInfo.signalSemaphoreCount ); 3732 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSubmitInfo.pSignalSemaphoreDeviceIndices ); 3733 return seed; 3734 } 3735 }; 3736 3737 template <> 3738 struct hash<VULKAN_HPP_NAMESPACE::DeviceGroupSwapchainCreateInfoKHR> 3739 { operator ()std::hash3740 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupSwapchainCreateInfoKHR const & deviceGroupSwapchainCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 3741 { 3742 std::size_t seed = 0; 3743 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSwapchainCreateInfoKHR.sType ); 3744 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSwapchainCreateInfoKHR.pNext ); 3745 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSwapchainCreateInfoKHR.modes ); 3746 return seed; 3747 } 3748 }; 3749 3750 template <> 3751 struct hash<VULKAN_HPP_NAMESPACE::ImageCreateInfo> 3752 { operator ()std::hash3753 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageCreateInfo const & imageCreateInfo ) const VULKAN_HPP_NOEXCEPT 3754 { 3755 std::size_t seed = 0; 3756 VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.sType ); 3757 VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.pNext ); 3758 VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.flags ); 3759 VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.imageType ); 3760 VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.format ); 3761 VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.extent ); 3762 VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.mipLevels ); 3763 VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.arrayLayers ); 3764 VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.samples ); 3765 VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.tiling ); 3766 VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.usage ); 3767 VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.sharingMode ); 3768 VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.queueFamilyIndexCount ); 3769 VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.pQueueFamilyIndices ); 3770 VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.initialLayout ); 3771 return seed; 3772 } 3773 }; 3774 3775 template <> 3776 struct hash<VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements> 3777 { operator ()std::hash3778 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements const & deviceImageMemoryRequirements ) const VULKAN_HPP_NOEXCEPT 3779 { 3780 std::size_t seed = 0; 3781 VULKAN_HPP_HASH_COMBINE( seed, deviceImageMemoryRequirements.sType ); 3782 VULKAN_HPP_HASH_COMBINE( seed, deviceImageMemoryRequirements.pNext ); 3783 VULKAN_HPP_HASH_COMBINE( seed, deviceImageMemoryRequirements.pCreateInfo ); 3784 VULKAN_HPP_HASH_COMBINE( seed, deviceImageMemoryRequirements.planeAspect ); 3785 return seed; 3786 } 3787 }; 3788 3789 template <> 3790 struct hash<VULKAN_HPP_NAMESPACE::ImageSubresource2KHR> 3791 { operator ()std::hash3792 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageSubresource2KHR const & imageSubresource2KHR ) const VULKAN_HPP_NOEXCEPT 3793 { 3794 std::size_t seed = 0; 3795 VULKAN_HPP_HASH_COMBINE( seed, imageSubresource2KHR.sType ); 3796 VULKAN_HPP_HASH_COMBINE( seed, imageSubresource2KHR.pNext ); 3797 VULKAN_HPP_HASH_COMBINE( seed, imageSubresource2KHR.imageSubresource ); 3798 return seed; 3799 } 3800 }; 3801 3802 template <> 3803 struct hash<VULKAN_HPP_NAMESPACE::DeviceImageSubresourceInfoKHR> 3804 { operator ()std::hash3805 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceImageSubresourceInfoKHR const & deviceImageSubresourceInfoKHR ) const VULKAN_HPP_NOEXCEPT 3806 { 3807 std::size_t seed = 0; 3808 VULKAN_HPP_HASH_COMBINE( seed, deviceImageSubresourceInfoKHR.sType ); 3809 VULKAN_HPP_HASH_COMBINE( seed, deviceImageSubresourceInfoKHR.pNext ); 3810 VULKAN_HPP_HASH_COMBINE( seed, deviceImageSubresourceInfoKHR.pCreateInfo ); 3811 VULKAN_HPP_HASH_COMBINE( seed, deviceImageSubresourceInfoKHR.pSubresource ); 3812 return seed; 3813 } 3814 }; 3815 3816 template <> 3817 struct hash<VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo> 3818 { operator ()std::hash3819 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo const & deviceMemoryOpaqueCaptureAddressInfo ) const VULKAN_HPP_NOEXCEPT 3820 { 3821 std::size_t seed = 0; 3822 VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryOpaqueCaptureAddressInfo.sType ); 3823 VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryOpaqueCaptureAddressInfo.pNext ); 3824 VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryOpaqueCaptureAddressInfo.memory ); 3825 return seed; 3826 } 3827 }; 3828 3829 template <> 3830 struct hash<VULKAN_HPP_NAMESPACE::DeviceMemoryOverallocationCreateInfoAMD> 3831 { 3832 std::size_t operator ()std::hash3833 operator()( VULKAN_HPP_NAMESPACE::DeviceMemoryOverallocationCreateInfoAMD const & deviceMemoryOverallocationCreateInfoAMD ) const VULKAN_HPP_NOEXCEPT 3834 { 3835 std::size_t seed = 0; 3836 VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryOverallocationCreateInfoAMD.sType ); 3837 VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryOverallocationCreateInfoAMD.pNext ); 3838 VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryOverallocationCreateInfoAMD.overallocationBehavior ); 3839 return seed; 3840 } 3841 }; 3842 3843 template <> 3844 struct hash<VULKAN_HPP_NAMESPACE::DeviceMemoryReportCallbackDataEXT> 3845 { operator ()std::hash3846 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceMemoryReportCallbackDataEXT const & deviceMemoryReportCallbackDataEXT ) const VULKAN_HPP_NOEXCEPT 3847 { 3848 std::size_t seed = 0; 3849 VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryReportCallbackDataEXT.sType ); 3850 VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryReportCallbackDataEXT.pNext ); 3851 VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryReportCallbackDataEXT.flags ); 3852 VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryReportCallbackDataEXT.type ); 3853 VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryReportCallbackDataEXT.memoryObjectId ); 3854 VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryReportCallbackDataEXT.size ); 3855 VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryReportCallbackDataEXT.objectType ); 3856 VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryReportCallbackDataEXT.objectHandle ); 3857 VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryReportCallbackDataEXT.heapIndex ); 3858 return seed; 3859 } 3860 }; 3861 3862 template <> 3863 struct hash<VULKAN_HPP_NAMESPACE::DevicePrivateDataCreateInfo> 3864 { operator ()std::hash3865 std::size_t operator()( VULKAN_HPP_NAMESPACE::DevicePrivateDataCreateInfo const & devicePrivateDataCreateInfo ) const VULKAN_HPP_NOEXCEPT 3866 { 3867 std::size_t seed = 0; 3868 VULKAN_HPP_HASH_COMBINE( seed, devicePrivateDataCreateInfo.sType ); 3869 VULKAN_HPP_HASH_COMBINE( seed, devicePrivateDataCreateInfo.pNext ); 3870 VULKAN_HPP_HASH_COMBINE( seed, devicePrivateDataCreateInfo.privateDataSlotRequestCount ); 3871 return seed; 3872 } 3873 }; 3874 3875 template <> 3876 struct hash<VULKAN_HPP_NAMESPACE::DeviceQueueGlobalPriorityCreateInfoKHR> 3877 { 3878 std::size_t operator ()std::hash3879 operator()( VULKAN_HPP_NAMESPACE::DeviceQueueGlobalPriorityCreateInfoKHR const & deviceQueueGlobalPriorityCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 3880 { 3881 std::size_t seed = 0; 3882 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueGlobalPriorityCreateInfoKHR.sType ); 3883 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueGlobalPriorityCreateInfoKHR.pNext ); 3884 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueGlobalPriorityCreateInfoKHR.globalPriority ); 3885 return seed; 3886 } 3887 }; 3888 3889 template <> 3890 struct hash<VULKAN_HPP_NAMESPACE::DeviceQueueInfo2> 3891 { operator ()std::hash3892 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceQueueInfo2 const & deviceQueueInfo2 ) const VULKAN_HPP_NOEXCEPT 3893 { 3894 std::size_t seed = 0; 3895 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueInfo2.sType ); 3896 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueInfo2.pNext ); 3897 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueInfo2.flags ); 3898 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueInfo2.queueFamilyIndex ); 3899 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueInfo2.queueIndex ); 3900 return seed; 3901 } 3902 }; 3903 3904 template <> 3905 struct hash<VULKAN_HPP_NAMESPACE::DirectDriverLoadingInfoLUNARG> 3906 { operator ()std::hash3907 std::size_t operator()( VULKAN_HPP_NAMESPACE::DirectDriverLoadingInfoLUNARG const & directDriverLoadingInfoLUNARG ) const VULKAN_HPP_NOEXCEPT 3908 { 3909 std::size_t seed = 0; 3910 VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingInfoLUNARG.sType ); 3911 VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingInfoLUNARG.pNext ); 3912 VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingInfoLUNARG.flags ); 3913 VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingInfoLUNARG.pfnGetInstanceProcAddr ); 3914 return seed; 3915 } 3916 }; 3917 3918 template <> 3919 struct hash<VULKAN_HPP_NAMESPACE::DirectDriverLoadingListLUNARG> 3920 { operator ()std::hash3921 std::size_t operator()( VULKAN_HPP_NAMESPACE::DirectDriverLoadingListLUNARG const & directDriverLoadingListLUNARG ) const VULKAN_HPP_NOEXCEPT 3922 { 3923 std::size_t seed = 0; 3924 VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingListLUNARG.sType ); 3925 VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingListLUNARG.pNext ); 3926 VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingListLUNARG.mode ); 3927 VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingListLUNARG.driverCount ); 3928 VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingListLUNARG.pDrivers ); 3929 return seed; 3930 } 3931 }; 3932 3933 # if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) 3934 template <> 3935 struct hash<VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT> 3936 { operator ()std::hash3937 std::size_t operator()( VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT const & directFBSurfaceCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 3938 { 3939 std::size_t seed = 0; 3940 VULKAN_HPP_HASH_COMBINE( seed, directFBSurfaceCreateInfoEXT.sType ); 3941 VULKAN_HPP_HASH_COMBINE( seed, directFBSurfaceCreateInfoEXT.pNext ); 3942 VULKAN_HPP_HASH_COMBINE( seed, directFBSurfaceCreateInfoEXT.flags ); 3943 VULKAN_HPP_HASH_COMBINE( seed, directFBSurfaceCreateInfoEXT.dfb ); 3944 VULKAN_HPP_HASH_COMBINE( seed, directFBSurfaceCreateInfoEXT.surface ); 3945 return seed; 3946 } 3947 }; 3948 # endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ 3949 3950 template <> 3951 struct hash<VULKAN_HPP_NAMESPACE::DispatchIndirectCommand> 3952 { operator ()std::hash3953 std::size_t operator()( VULKAN_HPP_NAMESPACE::DispatchIndirectCommand const & dispatchIndirectCommand ) const VULKAN_HPP_NOEXCEPT 3954 { 3955 std::size_t seed = 0; 3956 VULKAN_HPP_HASH_COMBINE( seed, dispatchIndirectCommand.x ); 3957 VULKAN_HPP_HASH_COMBINE( seed, dispatchIndirectCommand.y ); 3958 VULKAN_HPP_HASH_COMBINE( seed, dispatchIndirectCommand.z ); 3959 return seed; 3960 } 3961 }; 3962 3963 template <> 3964 struct hash<VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT> 3965 { operator ()std::hash3966 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT const & displayEventInfoEXT ) const VULKAN_HPP_NOEXCEPT 3967 { 3968 std::size_t seed = 0; 3969 VULKAN_HPP_HASH_COMBINE( seed, displayEventInfoEXT.sType ); 3970 VULKAN_HPP_HASH_COMBINE( seed, displayEventInfoEXT.pNext ); 3971 VULKAN_HPP_HASH_COMBINE( seed, displayEventInfoEXT.displayEvent ); 3972 return seed; 3973 } 3974 }; 3975 3976 template <> 3977 struct hash<VULKAN_HPP_NAMESPACE::DisplayModeParametersKHR> 3978 { operator ()std::hash3979 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayModeParametersKHR const & displayModeParametersKHR ) const VULKAN_HPP_NOEXCEPT 3980 { 3981 std::size_t seed = 0; 3982 VULKAN_HPP_HASH_COMBINE( seed, displayModeParametersKHR.visibleRegion ); 3983 VULKAN_HPP_HASH_COMBINE( seed, displayModeParametersKHR.refreshRate ); 3984 return seed; 3985 } 3986 }; 3987 3988 template <> 3989 struct hash<VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR> 3990 { operator ()std::hash3991 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR const & displayModeCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 3992 { 3993 std::size_t seed = 0; 3994 VULKAN_HPP_HASH_COMBINE( seed, displayModeCreateInfoKHR.sType ); 3995 VULKAN_HPP_HASH_COMBINE( seed, displayModeCreateInfoKHR.pNext ); 3996 VULKAN_HPP_HASH_COMBINE( seed, displayModeCreateInfoKHR.flags ); 3997 VULKAN_HPP_HASH_COMBINE( seed, displayModeCreateInfoKHR.parameters ); 3998 return seed; 3999 } 4000 }; 4001 4002 template <> 4003 struct hash<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR> 4004 { operator ()std::hash4005 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR const & displayModePropertiesKHR ) const VULKAN_HPP_NOEXCEPT 4006 { 4007 std::size_t seed = 0; 4008 VULKAN_HPP_HASH_COMBINE( seed, displayModePropertiesKHR.displayMode ); 4009 VULKAN_HPP_HASH_COMBINE( seed, displayModePropertiesKHR.parameters ); 4010 return seed; 4011 } 4012 }; 4013 4014 template <> 4015 struct hash<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR> 4016 { operator ()std::hash4017 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR const & displayModeProperties2KHR ) const VULKAN_HPP_NOEXCEPT 4018 { 4019 std::size_t seed = 0; 4020 VULKAN_HPP_HASH_COMBINE( seed, displayModeProperties2KHR.sType ); 4021 VULKAN_HPP_HASH_COMBINE( seed, displayModeProperties2KHR.pNext ); 4022 VULKAN_HPP_HASH_COMBINE( seed, displayModeProperties2KHR.displayModeProperties ); 4023 return seed; 4024 } 4025 }; 4026 4027 template <> 4028 struct hash<VULKAN_HPP_NAMESPACE::DisplayNativeHdrSurfaceCapabilitiesAMD> 4029 { 4030 std::size_t operator ()std::hash4031 operator()( VULKAN_HPP_NAMESPACE::DisplayNativeHdrSurfaceCapabilitiesAMD const & displayNativeHdrSurfaceCapabilitiesAMD ) const VULKAN_HPP_NOEXCEPT 4032 { 4033 std::size_t seed = 0; 4034 VULKAN_HPP_HASH_COMBINE( seed, displayNativeHdrSurfaceCapabilitiesAMD.sType ); 4035 VULKAN_HPP_HASH_COMBINE( seed, displayNativeHdrSurfaceCapabilitiesAMD.pNext ); 4036 VULKAN_HPP_HASH_COMBINE( seed, displayNativeHdrSurfaceCapabilitiesAMD.localDimmingSupport ); 4037 return seed; 4038 } 4039 }; 4040 4041 template <> 4042 struct hash<VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR> 4043 { operator ()std::hash4044 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR const & displayPlaneCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT 4045 { 4046 std::size_t seed = 0; 4047 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilitiesKHR.supportedAlpha ); 4048 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilitiesKHR.minSrcPosition ); 4049 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilitiesKHR.maxSrcPosition ); 4050 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilitiesKHR.minSrcExtent ); 4051 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilitiesKHR.maxSrcExtent ); 4052 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilitiesKHR.minDstPosition ); 4053 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilitiesKHR.maxDstPosition ); 4054 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilitiesKHR.minDstExtent ); 4055 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilitiesKHR.maxDstExtent ); 4056 return seed; 4057 } 4058 }; 4059 4060 template <> 4061 struct hash<VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR> 4062 { operator ()std::hash4063 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR const & displayPlaneCapabilities2KHR ) const VULKAN_HPP_NOEXCEPT 4064 { 4065 std::size_t seed = 0; 4066 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilities2KHR.sType ); 4067 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilities2KHR.pNext ); 4068 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilities2KHR.capabilities ); 4069 return seed; 4070 } 4071 }; 4072 4073 template <> 4074 struct hash<VULKAN_HPP_NAMESPACE::DisplayPlaneInfo2KHR> 4075 { operator ()std::hash4076 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPlaneInfo2KHR const & displayPlaneInfo2KHR ) const VULKAN_HPP_NOEXCEPT 4077 { 4078 std::size_t seed = 0; 4079 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneInfo2KHR.sType ); 4080 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneInfo2KHR.pNext ); 4081 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneInfo2KHR.mode ); 4082 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneInfo2KHR.planeIndex ); 4083 return seed; 4084 } 4085 }; 4086 4087 template <> 4088 struct hash<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR> 4089 { operator ()std::hash4090 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR const & displayPlanePropertiesKHR ) const VULKAN_HPP_NOEXCEPT 4091 { 4092 std::size_t seed = 0; 4093 VULKAN_HPP_HASH_COMBINE( seed, displayPlanePropertiesKHR.currentDisplay ); 4094 VULKAN_HPP_HASH_COMBINE( seed, displayPlanePropertiesKHR.currentStackIndex ); 4095 return seed; 4096 } 4097 }; 4098 4099 template <> 4100 struct hash<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR> 4101 { operator ()std::hash4102 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR const & displayPlaneProperties2KHR ) const VULKAN_HPP_NOEXCEPT 4103 { 4104 std::size_t seed = 0; 4105 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneProperties2KHR.sType ); 4106 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneProperties2KHR.pNext ); 4107 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneProperties2KHR.displayPlaneProperties ); 4108 return seed; 4109 } 4110 }; 4111 4112 template <> 4113 struct hash<VULKAN_HPP_NAMESPACE::DisplayPowerInfoEXT> 4114 { operator ()std::hash4115 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPowerInfoEXT const & displayPowerInfoEXT ) const VULKAN_HPP_NOEXCEPT 4116 { 4117 std::size_t seed = 0; 4118 VULKAN_HPP_HASH_COMBINE( seed, displayPowerInfoEXT.sType ); 4119 VULKAN_HPP_HASH_COMBINE( seed, displayPowerInfoEXT.pNext ); 4120 VULKAN_HPP_HASH_COMBINE( seed, displayPowerInfoEXT.powerState ); 4121 return seed; 4122 } 4123 }; 4124 4125 template <> 4126 struct hash<VULKAN_HPP_NAMESPACE::DisplayPresentInfoKHR> 4127 { operator ()std::hash4128 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPresentInfoKHR const & displayPresentInfoKHR ) const VULKAN_HPP_NOEXCEPT 4129 { 4130 std::size_t seed = 0; 4131 VULKAN_HPP_HASH_COMBINE( seed, displayPresentInfoKHR.sType ); 4132 VULKAN_HPP_HASH_COMBINE( seed, displayPresentInfoKHR.pNext ); 4133 VULKAN_HPP_HASH_COMBINE( seed, displayPresentInfoKHR.srcRect ); 4134 VULKAN_HPP_HASH_COMBINE( seed, displayPresentInfoKHR.dstRect ); 4135 VULKAN_HPP_HASH_COMBINE( seed, displayPresentInfoKHR.persistent ); 4136 return seed; 4137 } 4138 }; 4139 4140 template <> 4141 struct hash<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR> 4142 { operator ()std::hash4143 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR const & displayPropertiesKHR ) const VULKAN_HPP_NOEXCEPT 4144 { 4145 std::size_t seed = 0; 4146 VULKAN_HPP_HASH_COMBINE( seed, displayPropertiesKHR.display ); 4147 for ( const char * p = displayPropertiesKHR.displayName; *p != '\0'; ++p ) 4148 { 4149 VULKAN_HPP_HASH_COMBINE( seed, *p ); 4150 } 4151 VULKAN_HPP_HASH_COMBINE( seed, displayPropertiesKHR.physicalDimensions ); 4152 VULKAN_HPP_HASH_COMBINE( seed, displayPropertiesKHR.physicalResolution ); 4153 VULKAN_HPP_HASH_COMBINE( seed, displayPropertiesKHR.supportedTransforms ); 4154 VULKAN_HPP_HASH_COMBINE( seed, displayPropertiesKHR.planeReorderPossible ); 4155 VULKAN_HPP_HASH_COMBINE( seed, displayPropertiesKHR.persistentContent ); 4156 return seed; 4157 } 4158 }; 4159 4160 template <> 4161 struct hash<VULKAN_HPP_NAMESPACE::DisplayProperties2KHR> 4162 { operator ()std::hash4163 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayProperties2KHR const & displayProperties2KHR ) const VULKAN_HPP_NOEXCEPT 4164 { 4165 std::size_t seed = 0; 4166 VULKAN_HPP_HASH_COMBINE( seed, displayProperties2KHR.sType ); 4167 VULKAN_HPP_HASH_COMBINE( seed, displayProperties2KHR.pNext ); 4168 VULKAN_HPP_HASH_COMBINE( seed, displayProperties2KHR.displayProperties ); 4169 return seed; 4170 } 4171 }; 4172 4173 template <> 4174 struct hash<VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR> 4175 { operator ()std::hash4176 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR const & displaySurfaceCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 4177 { 4178 std::size_t seed = 0; 4179 VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.sType ); 4180 VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.pNext ); 4181 VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.flags ); 4182 VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.displayMode ); 4183 VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.planeIndex ); 4184 VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.planeStackIndex ); 4185 VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.transform ); 4186 VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.globalAlpha ); 4187 VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.alphaMode ); 4188 VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.imageExtent ); 4189 return seed; 4190 } 4191 }; 4192 4193 template <> 4194 struct hash<VULKAN_HPP_NAMESPACE::DrawIndexedIndirectCommand> 4195 { operator ()std::hash4196 std::size_t operator()( VULKAN_HPP_NAMESPACE::DrawIndexedIndirectCommand const & drawIndexedIndirectCommand ) const VULKAN_HPP_NOEXCEPT 4197 { 4198 std::size_t seed = 0; 4199 VULKAN_HPP_HASH_COMBINE( seed, drawIndexedIndirectCommand.indexCount ); 4200 VULKAN_HPP_HASH_COMBINE( seed, drawIndexedIndirectCommand.instanceCount ); 4201 VULKAN_HPP_HASH_COMBINE( seed, drawIndexedIndirectCommand.firstIndex ); 4202 VULKAN_HPP_HASH_COMBINE( seed, drawIndexedIndirectCommand.vertexOffset ); 4203 VULKAN_HPP_HASH_COMBINE( seed, drawIndexedIndirectCommand.firstInstance ); 4204 return seed; 4205 } 4206 }; 4207 4208 template <> 4209 struct hash<VULKAN_HPP_NAMESPACE::DrawIndirectCommand> 4210 { operator ()std::hash4211 std::size_t operator()( VULKAN_HPP_NAMESPACE::DrawIndirectCommand const & drawIndirectCommand ) const VULKAN_HPP_NOEXCEPT 4212 { 4213 std::size_t seed = 0; 4214 VULKAN_HPP_HASH_COMBINE( seed, drawIndirectCommand.vertexCount ); 4215 VULKAN_HPP_HASH_COMBINE( seed, drawIndirectCommand.instanceCount ); 4216 VULKAN_HPP_HASH_COMBINE( seed, drawIndirectCommand.firstVertex ); 4217 VULKAN_HPP_HASH_COMBINE( seed, drawIndirectCommand.firstInstance ); 4218 return seed; 4219 } 4220 }; 4221 4222 template <> 4223 struct hash<VULKAN_HPP_NAMESPACE::DrawMeshTasksIndirectCommandEXT> 4224 { operator ()std::hash4225 std::size_t operator()( VULKAN_HPP_NAMESPACE::DrawMeshTasksIndirectCommandEXT const & drawMeshTasksIndirectCommandEXT ) const VULKAN_HPP_NOEXCEPT 4226 { 4227 std::size_t seed = 0; 4228 VULKAN_HPP_HASH_COMBINE( seed, drawMeshTasksIndirectCommandEXT.groupCountX ); 4229 VULKAN_HPP_HASH_COMBINE( seed, drawMeshTasksIndirectCommandEXT.groupCountY ); 4230 VULKAN_HPP_HASH_COMBINE( seed, drawMeshTasksIndirectCommandEXT.groupCountZ ); 4231 return seed; 4232 } 4233 }; 4234 4235 template <> 4236 struct hash<VULKAN_HPP_NAMESPACE::DrawMeshTasksIndirectCommandNV> 4237 { operator ()std::hash4238 std::size_t operator()( VULKAN_HPP_NAMESPACE::DrawMeshTasksIndirectCommandNV const & drawMeshTasksIndirectCommandNV ) const VULKAN_HPP_NOEXCEPT 4239 { 4240 std::size_t seed = 0; 4241 VULKAN_HPP_HASH_COMBINE( seed, drawMeshTasksIndirectCommandNV.taskCount ); 4242 VULKAN_HPP_HASH_COMBINE( seed, drawMeshTasksIndirectCommandNV.firstTask ); 4243 return seed; 4244 } 4245 }; 4246 4247 template <> 4248 struct hash<VULKAN_HPP_NAMESPACE::DrmFormatModifierProperties2EXT> 4249 { operator ()std::hash4250 std::size_t operator()( VULKAN_HPP_NAMESPACE::DrmFormatModifierProperties2EXT const & drmFormatModifierProperties2EXT ) const VULKAN_HPP_NOEXCEPT 4251 { 4252 std::size_t seed = 0; 4253 VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierProperties2EXT.drmFormatModifier ); 4254 VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierProperties2EXT.drmFormatModifierPlaneCount ); 4255 VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierProperties2EXT.drmFormatModifierTilingFeatures ); 4256 return seed; 4257 } 4258 }; 4259 4260 template <> 4261 struct hash<VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesEXT> 4262 { operator ()std::hash4263 std::size_t operator()( VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesEXT const & drmFormatModifierPropertiesEXT ) const VULKAN_HPP_NOEXCEPT 4264 { 4265 std::size_t seed = 0; 4266 VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesEXT.drmFormatModifier ); 4267 VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesEXT.drmFormatModifierPlaneCount ); 4268 VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesEXT.drmFormatModifierTilingFeatures ); 4269 return seed; 4270 } 4271 }; 4272 4273 template <> 4274 struct hash<VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesList2EXT> 4275 { operator ()std::hash4276 std::size_t operator()( VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesList2EXT const & drmFormatModifierPropertiesList2EXT ) const VULKAN_HPP_NOEXCEPT 4277 { 4278 std::size_t seed = 0; 4279 VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesList2EXT.sType ); 4280 VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesList2EXT.pNext ); 4281 VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesList2EXT.drmFormatModifierCount ); 4282 VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesList2EXT.pDrmFormatModifierProperties ); 4283 return seed; 4284 } 4285 }; 4286 4287 template <> 4288 struct hash<VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesListEXT> 4289 { operator ()std::hash4290 std::size_t operator()( VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesListEXT const & drmFormatModifierPropertiesListEXT ) const VULKAN_HPP_NOEXCEPT 4291 { 4292 std::size_t seed = 0; 4293 VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesListEXT.sType ); 4294 VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesListEXT.pNext ); 4295 VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesListEXT.drmFormatModifierCount ); 4296 VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesListEXT.pDrmFormatModifierProperties ); 4297 return seed; 4298 } 4299 }; 4300 4301 template <> 4302 struct hash<VULKAN_HPP_NAMESPACE::EventCreateInfo> 4303 { operator ()std::hash4304 std::size_t operator()( VULKAN_HPP_NAMESPACE::EventCreateInfo const & eventCreateInfo ) const VULKAN_HPP_NOEXCEPT 4305 { 4306 std::size_t seed = 0; 4307 VULKAN_HPP_HASH_COMBINE( seed, eventCreateInfo.sType ); 4308 VULKAN_HPP_HASH_COMBINE( seed, eventCreateInfo.pNext ); 4309 VULKAN_HPP_HASH_COMBINE( seed, eventCreateInfo.flags ); 4310 return seed; 4311 } 4312 }; 4313 4314 template <> 4315 struct hash<VULKAN_HPP_NAMESPACE::PipelineLibraryCreateInfoKHR> 4316 { operator ()std::hash4317 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineLibraryCreateInfoKHR const & pipelineLibraryCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 4318 { 4319 std::size_t seed = 0; 4320 VULKAN_HPP_HASH_COMBINE( seed, pipelineLibraryCreateInfoKHR.sType ); 4321 VULKAN_HPP_HASH_COMBINE( seed, pipelineLibraryCreateInfoKHR.pNext ); 4322 VULKAN_HPP_HASH_COMBINE( seed, pipelineLibraryCreateInfoKHR.libraryCount ); 4323 VULKAN_HPP_HASH_COMBINE( seed, pipelineLibraryCreateInfoKHR.pLibraries ); 4324 return seed; 4325 } 4326 }; 4327 4328 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 4329 template <> 4330 struct hash<VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX> 4331 { operator ()std::hash4332 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX const & executionGraphPipelineCreateInfoAMDX ) const VULKAN_HPP_NOEXCEPT 4333 { 4334 std::size_t seed = 0; 4335 VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineCreateInfoAMDX.sType ); 4336 VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineCreateInfoAMDX.pNext ); 4337 VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineCreateInfoAMDX.flags ); 4338 VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineCreateInfoAMDX.stageCount ); 4339 VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineCreateInfoAMDX.pStages ); 4340 VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineCreateInfoAMDX.pLibraryInfo ); 4341 VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineCreateInfoAMDX.layout ); 4342 VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineCreateInfoAMDX.basePipelineHandle ); 4343 VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineCreateInfoAMDX.basePipelineIndex ); 4344 return seed; 4345 } 4346 }; 4347 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 4348 4349 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 4350 template <> 4351 struct hash<VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineScratchSizeAMDX> 4352 { 4353 std::size_t operator ()std::hash4354 operator()( VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineScratchSizeAMDX const & executionGraphPipelineScratchSizeAMDX ) const VULKAN_HPP_NOEXCEPT 4355 { 4356 std::size_t seed = 0; 4357 VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineScratchSizeAMDX.sType ); 4358 VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineScratchSizeAMDX.pNext ); 4359 VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineScratchSizeAMDX.size ); 4360 return seed; 4361 } 4362 }; 4363 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 4364 4365 template <> 4366 struct hash<VULKAN_HPP_NAMESPACE::ExportFenceCreateInfo> 4367 { operator ()std::hash4368 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportFenceCreateInfo const & exportFenceCreateInfo ) const VULKAN_HPP_NOEXCEPT 4369 { 4370 std::size_t seed = 0; 4371 VULKAN_HPP_HASH_COMBINE( seed, exportFenceCreateInfo.sType ); 4372 VULKAN_HPP_HASH_COMBINE( seed, exportFenceCreateInfo.pNext ); 4373 VULKAN_HPP_HASH_COMBINE( seed, exportFenceCreateInfo.handleTypes ); 4374 return seed; 4375 } 4376 }; 4377 4378 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 4379 template <> 4380 struct hash<VULKAN_HPP_NAMESPACE::ExportFenceWin32HandleInfoKHR> 4381 { operator ()std::hash4382 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportFenceWin32HandleInfoKHR const & exportFenceWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT 4383 { 4384 std::size_t seed = 0; 4385 VULKAN_HPP_HASH_COMBINE( seed, exportFenceWin32HandleInfoKHR.sType ); 4386 VULKAN_HPP_HASH_COMBINE( seed, exportFenceWin32HandleInfoKHR.pNext ); 4387 VULKAN_HPP_HASH_COMBINE( seed, exportFenceWin32HandleInfoKHR.pAttributes ); 4388 VULKAN_HPP_HASH_COMBINE( seed, exportFenceWin32HandleInfoKHR.dwAccess ); 4389 VULKAN_HPP_HASH_COMBINE( seed, exportFenceWin32HandleInfoKHR.name ); 4390 return seed; 4391 } 4392 }; 4393 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 4394 4395 template <> 4396 struct hash<VULKAN_HPP_NAMESPACE::ExportMemoryAllocateInfo> 4397 { operator ()std::hash4398 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMemoryAllocateInfo const & exportMemoryAllocateInfo ) const VULKAN_HPP_NOEXCEPT 4399 { 4400 std::size_t seed = 0; 4401 VULKAN_HPP_HASH_COMBINE( seed, exportMemoryAllocateInfo.sType ); 4402 VULKAN_HPP_HASH_COMBINE( seed, exportMemoryAllocateInfo.pNext ); 4403 VULKAN_HPP_HASH_COMBINE( seed, exportMemoryAllocateInfo.handleTypes ); 4404 return seed; 4405 } 4406 }; 4407 4408 template <> 4409 struct hash<VULKAN_HPP_NAMESPACE::ExportMemoryAllocateInfoNV> 4410 { operator ()std::hash4411 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMemoryAllocateInfoNV const & exportMemoryAllocateInfoNV ) const VULKAN_HPP_NOEXCEPT 4412 { 4413 std::size_t seed = 0; 4414 VULKAN_HPP_HASH_COMBINE( seed, exportMemoryAllocateInfoNV.sType ); 4415 VULKAN_HPP_HASH_COMBINE( seed, exportMemoryAllocateInfoNV.pNext ); 4416 VULKAN_HPP_HASH_COMBINE( seed, exportMemoryAllocateInfoNV.handleTypes ); 4417 return seed; 4418 } 4419 }; 4420 4421 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 4422 template <> 4423 struct hash<VULKAN_HPP_NAMESPACE::ExportMemoryWin32HandleInfoKHR> 4424 { operator ()std::hash4425 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMemoryWin32HandleInfoKHR const & exportMemoryWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT 4426 { 4427 std::size_t seed = 0; 4428 VULKAN_HPP_HASH_COMBINE( seed, exportMemoryWin32HandleInfoKHR.sType ); 4429 VULKAN_HPP_HASH_COMBINE( seed, exportMemoryWin32HandleInfoKHR.pNext ); 4430 VULKAN_HPP_HASH_COMBINE( seed, exportMemoryWin32HandleInfoKHR.pAttributes ); 4431 VULKAN_HPP_HASH_COMBINE( seed, exportMemoryWin32HandleInfoKHR.dwAccess ); 4432 VULKAN_HPP_HASH_COMBINE( seed, exportMemoryWin32HandleInfoKHR.name ); 4433 return seed; 4434 } 4435 }; 4436 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 4437 4438 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 4439 template <> 4440 struct hash<VULKAN_HPP_NAMESPACE::ExportMemoryWin32HandleInfoNV> 4441 { operator ()std::hash4442 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMemoryWin32HandleInfoNV const & exportMemoryWin32HandleInfoNV ) const VULKAN_HPP_NOEXCEPT 4443 { 4444 std::size_t seed = 0; 4445 VULKAN_HPP_HASH_COMBINE( seed, exportMemoryWin32HandleInfoNV.sType ); 4446 VULKAN_HPP_HASH_COMBINE( seed, exportMemoryWin32HandleInfoNV.pNext ); 4447 VULKAN_HPP_HASH_COMBINE( seed, exportMemoryWin32HandleInfoNV.pAttributes ); 4448 VULKAN_HPP_HASH_COMBINE( seed, exportMemoryWin32HandleInfoNV.dwAccess ); 4449 return seed; 4450 } 4451 }; 4452 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 4453 4454 # if defined( VK_USE_PLATFORM_METAL_EXT ) 4455 template <> 4456 struct hash<VULKAN_HPP_NAMESPACE::ExportMetalBufferInfoEXT> 4457 { operator ()std::hash4458 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMetalBufferInfoEXT const & exportMetalBufferInfoEXT ) const VULKAN_HPP_NOEXCEPT 4459 { 4460 std::size_t seed = 0; 4461 VULKAN_HPP_HASH_COMBINE( seed, exportMetalBufferInfoEXT.sType ); 4462 VULKAN_HPP_HASH_COMBINE( seed, exportMetalBufferInfoEXT.pNext ); 4463 VULKAN_HPP_HASH_COMBINE( seed, exportMetalBufferInfoEXT.memory ); 4464 VULKAN_HPP_HASH_COMBINE( seed, exportMetalBufferInfoEXT.mtlBuffer ); 4465 return seed; 4466 } 4467 }; 4468 # endif /*VK_USE_PLATFORM_METAL_EXT*/ 4469 4470 # if defined( VK_USE_PLATFORM_METAL_EXT ) 4471 template <> 4472 struct hash<VULKAN_HPP_NAMESPACE::ExportMetalCommandQueueInfoEXT> 4473 { operator ()std::hash4474 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMetalCommandQueueInfoEXT const & exportMetalCommandQueueInfoEXT ) const VULKAN_HPP_NOEXCEPT 4475 { 4476 std::size_t seed = 0; 4477 VULKAN_HPP_HASH_COMBINE( seed, exportMetalCommandQueueInfoEXT.sType ); 4478 VULKAN_HPP_HASH_COMBINE( seed, exportMetalCommandQueueInfoEXT.pNext ); 4479 VULKAN_HPP_HASH_COMBINE( seed, exportMetalCommandQueueInfoEXT.queue ); 4480 VULKAN_HPP_HASH_COMBINE( seed, exportMetalCommandQueueInfoEXT.mtlCommandQueue ); 4481 return seed; 4482 } 4483 }; 4484 # endif /*VK_USE_PLATFORM_METAL_EXT*/ 4485 4486 # if defined( VK_USE_PLATFORM_METAL_EXT ) 4487 template <> 4488 struct hash<VULKAN_HPP_NAMESPACE::ExportMetalDeviceInfoEXT> 4489 { operator ()std::hash4490 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMetalDeviceInfoEXT const & exportMetalDeviceInfoEXT ) const VULKAN_HPP_NOEXCEPT 4491 { 4492 std::size_t seed = 0; 4493 VULKAN_HPP_HASH_COMBINE( seed, exportMetalDeviceInfoEXT.sType ); 4494 VULKAN_HPP_HASH_COMBINE( seed, exportMetalDeviceInfoEXT.pNext ); 4495 VULKAN_HPP_HASH_COMBINE( seed, exportMetalDeviceInfoEXT.mtlDevice ); 4496 return seed; 4497 } 4498 }; 4499 # endif /*VK_USE_PLATFORM_METAL_EXT*/ 4500 4501 # if defined( VK_USE_PLATFORM_METAL_EXT ) 4502 template <> 4503 struct hash<VULKAN_HPP_NAMESPACE::ExportMetalIOSurfaceInfoEXT> 4504 { operator ()std::hash4505 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMetalIOSurfaceInfoEXT const & exportMetalIOSurfaceInfoEXT ) const VULKAN_HPP_NOEXCEPT 4506 { 4507 std::size_t seed = 0; 4508 VULKAN_HPP_HASH_COMBINE( seed, exportMetalIOSurfaceInfoEXT.sType ); 4509 VULKAN_HPP_HASH_COMBINE( seed, exportMetalIOSurfaceInfoEXT.pNext ); 4510 VULKAN_HPP_HASH_COMBINE( seed, exportMetalIOSurfaceInfoEXT.image ); 4511 VULKAN_HPP_HASH_COMBINE( seed, exportMetalIOSurfaceInfoEXT.ioSurface ); 4512 return seed; 4513 } 4514 }; 4515 # endif /*VK_USE_PLATFORM_METAL_EXT*/ 4516 4517 # if defined( VK_USE_PLATFORM_METAL_EXT ) 4518 template <> 4519 struct hash<VULKAN_HPP_NAMESPACE::ExportMetalObjectCreateInfoEXT> 4520 { operator ()std::hash4521 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMetalObjectCreateInfoEXT const & exportMetalObjectCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 4522 { 4523 std::size_t seed = 0; 4524 VULKAN_HPP_HASH_COMBINE( seed, exportMetalObjectCreateInfoEXT.sType ); 4525 VULKAN_HPP_HASH_COMBINE( seed, exportMetalObjectCreateInfoEXT.pNext ); 4526 VULKAN_HPP_HASH_COMBINE( seed, exportMetalObjectCreateInfoEXT.exportObjectType ); 4527 return seed; 4528 } 4529 }; 4530 # endif /*VK_USE_PLATFORM_METAL_EXT*/ 4531 4532 # if defined( VK_USE_PLATFORM_METAL_EXT ) 4533 template <> 4534 struct hash<VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT> 4535 { operator ()std::hash4536 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT const & exportMetalObjectsInfoEXT ) const VULKAN_HPP_NOEXCEPT 4537 { 4538 std::size_t seed = 0; 4539 VULKAN_HPP_HASH_COMBINE( seed, exportMetalObjectsInfoEXT.sType ); 4540 VULKAN_HPP_HASH_COMBINE( seed, exportMetalObjectsInfoEXT.pNext ); 4541 return seed; 4542 } 4543 }; 4544 # endif /*VK_USE_PLATFORM_METAL_EXT*/ 4545 4546 # if defined( VK_USE_PLATFORM_METAL_EXT ) 4547 template <> 4548 struct hash<VULKAN_HPP_NAMESPACE::ExportMetalSharedEventInfoEXT> 4549 { operator ()std::hash4550 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMetalSharedEventInfoEXT const & exportMetalSharedEventInfoEXT ) const VULKAN_HPP_NOEXCEPT 4551 { 4552 std::size_t seed = 0; 4553 VULKAN_HPP_HASH_COMBINE( seed, exportMetalSharedEventInfoEXT.sType ); 4554 VULKAN_HPP_HASH_COMBINE( seed, exportMetalSharedEventInfoEXT.pNext ); 4555 VULKAN_HPP_HASH_COMBINE( seed, exportMetalSharedEventInfoEXT.semaphore ); 4556 VULKAN_HPP_HASH_COMBINE( seed, exportMetalSharedEventInfoEXT.event ); 4557 VULKAN_HPP_HASH_COMBINE( seed, exportMetalSharedEventInfoEXT.mtlSharedEvent ); 4558 return seed; 4559 } 4560 }; 4561 # endif /*VK_USE_PLATFORM_METAL_EXT*/ 4562 4563 # if defined( VK_USE_PLATFORM_METAL_EXT ) 4564 template <> 4565 struct hash<VULKAN_HPP_NAMESPACE::ExportMetalTextureInfoEXT> 4566 { operator ()std::hash4567 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMetalTextureInfoEXT const & exportMetalTextureInfoEXT ) const VULKAN_HPP_NOEXCEPT 4568 { 4569 std::size_t seed = 0; 4570 VULKAN_HPP_HASH_COMBINE( seed, exportMetalTextureInfoEXT.sType ); 4571 VULKAN_HPP_HASH_COMBINE( seed, exportMetalTextureInfoEXT.pNext ); 4572 VULKAN_HPP_HASH_COMBINE( seed, exportMetalTextureInfoEXT.image ); 4573 VULKAN_HPP_HASH_COMBINE( seed, exportMetalTextureInfoEXT.imageView ); 4574 VULKAN_HPP_HASH_COMBINE( seed, exportMetalTextureInfoEXT.bufferView ); 4575 VULKAN_HPP_HASH_COMBINE( seed, exportMetalTextureInfoEXT.plane ); 4576 VULKAN_HPP_HASH_COMBINE( seed, exportMetalTextureInfoEXT.mtlTexture ); 4577 return seed; 4578 } 4579 }; 4580 # endif /*VK_USE_PLATFORM_METAL_EXT*/ 4581 4582 template <> 4583 struct hash<VULKAN_HPP_NAMESPACE::ExportSemaphoreCreateInfo> 4584 { operator ()std::hash4585 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportSemaphoreCreateInfo const & exportSemaphoreCreateInfo ) const VULKAN_HPP_NOEXCEPT 4586 { 4587 std::size_t seed = 0; 4588 VULKAN_HPP_HASH_COMBINE( seed, exportSemaphoreCreateInfo.sType ); 4589 VULKAN_HPP_HASH_COMBINE( seed, exportSemaphoreCreateInfo.pNext ); 4590 VULKAN_HPP_HASH_COMBINE( seed, exportSemaphoreCreateInfo.handleTypes ); 4591 return seed; 4592 } 4593 }; 4594 4595 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 4596 template <> 4597 struct hash<VULKAN_HPP_NAMESPACE::ExportSemaphoreWin32HandleInfoKHR> 4598 { operator ()std::hash4599 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportSemaphoreWin32HandleInfoKHR const & exportSemaphoreWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT 4600 { 4601 std::size_t seed = 0; 4602 VULKAN_HPP_HASH_COMBINE( seed, exportSemaphoreWin32HandleInfoKHR.sType ); 4603 VULKAN_HPP_HASH_COMBINE( seed, exportSemaphoreWin32HandleInfoKHR.pNext ); 4604 VULKAN_HPP_HASH_COMBINE( seed, exportSemaphoreWin32HandleInfoKHR.pAttributes ); 4605 VULKAN_HPP_HASH_COMBINE( seed, exportSemaphoreWin32HandleInfoKHR.dwAccess ); 4606 VULKAN_HPP_HASH_COMBINE( seed, exportSemaphoreWin32HandleInfoKHR.name ); 4607 return seed; 4608 } 4609 }; 4610 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 4611 4612 template <> 4613 struct hash<VULKAN_HPP_NAMESPACE::ExtensionProperties> 4614 { operator ()std::hash4615 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExtensionProperties const & extensionProperties ) const VULKAN_HPP_NOEXCEPT 4616 { 4617 std::size_t seed = 0; 4618 for ( size_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i ) 4619 { 4620 VULKAN_HPP_HASH_COMBINE( seed, extensionProperties.extensionName[i] ); 4621 } 4622 VULKAN_HPP_HASH_COMBINE( seed, extensionProperties.specVersion ); 4623 return seed; 4624 } 4625 }; 4626 4627 template <> 4628 struct hash<VULKAN_HPP_NAMESPACE::ExternalMemoryProperties> 4629 { operator ()std::hash4630 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalMemoryProperties const & externalMemoryProperties ) const VULKAN_HPP_NOEXCEPT 4631 { 4632 std::size_t seed = 0; 4633 VULKAN_HPP_HASH_COMBINE( seed, externalMemoryProperties.externalMemoryFeatures ); 4634 VULKAN_HPP_HASH_COMBINE( seed, externalMemoryProperties.exportFromImportedHandleTypes ); 4635 VULKAN_HPP_HASH_COMBINE( seed, externalMemoryProperties.compatibleHandleTypes ); 4636 return seed; 4637 } 4638 }; 4639 4640 template <> 4641 struct hash<VULKAN_HPP_NAMESPACE::ExternalBufferProperties> 4642 { operator ()std::hash4643 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalBufferProperties const & externalBufferProperties ) const VULKAN_HPP_NOEXCEPT 4644 { 4645 std::size_t seed = 0; 4646 VULKAN_HPP_HASH_COMBINE( seed, externalBufferProperties.sType ); 4647 VULKAN_HPP_HASH_COMBINE( seed, externalBufferProperties.pNext ); 4648 VULKAN_HPP_HASH_COMBINE( seed, externalBufferProperties.externalMemoryProperties ); 4649 return seed; 4650 } 4651 }; 4652 4653 template <> 4654 struct hash<VULKAN_HPP_NAMESPACE::ExternalFenceProperties> 4655 { operator ()std::hash4656 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalFenceProperties const & externalFenceProperties ) const VULKAN_HPP_NOEXCEPT 4657 { 4658 std::size_t seed = 0; 4659 VULKAN_HPP_HASH_COMBINE( seed, externalFenceProperties.sType ); 4660 VULKAN_HPP_HASH_COMBINE( seed, externalFenceProperties.pNext ); 4661 VULKAN_HPP_HASH_COMBINE( seed, externalFenceProperties.exportFromImportedHandleTypes ); 4662 VULKAN_HPP_HASH_COMBINE( seed, externalFenceProperties.compatibleHandleTypes ); 4663 VULKAN_HPP_HASH_COMBINE( seed, externalFenceProperties.externalFenceFeatures ); 4664 return seed; 4665 } 4666 }; 4667 4668 # if defined( VK_USE_PLATFORM_ANDROID_KHR ) 4669 template <> 4670 struct hash<VULKAN_HPP_NAMESPACE::ExternalFormatANDROID> 4671 { operator ()std::hash4672 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalFormatANDROID const & externalFormatANDROID ) const VULKAN_HPP_NOEXCEPT 4673 { 4674 std::size_t seed = 0; 4675 VULKAN_HPP_HASH_COMBINE( seed, externalFormatANDROID.sType ); 4676 VULKAN_HPP_HASH_COMBINE( seed, externalFormatANDROID.pNext ); 4677 VULKAN_HPP_HASH_COMBINE( seed, externalFormatANDROID.externalFormat ); 4678 return seed; 4679 } 4680 }; 4681 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ 4682 4683 # if defined( VK_USE_PLATFORM_SCREEN_QNX ) 4684 template <> 4685 struct hash<VULKAN_HPP_NAMESPACE::ExternalFormatQNX> 4686 { operator ()std::hash4687 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalFormatQNX const & externalFormatQNX ) const VULKAN_HPP_NOEXCEPT 4688 { 4689 std::size_t seed = 0; 4690 VULKAN_HPP_HASH_COMBINE( seed, externalFormatQNX.sType ); 4691 VULKAN_HPP_HASH_COMBINE( seed, externalFormatQNX.pNext ); 4692 VULKAN_HPP_HASH_COMBINE( seed, externalFormatQNX.externalFormat ); 4693 return seed; 4694 } 4695 }; 4696 # endif /*VK_USE_PLATFORM_SCREEN_QNX*/ 4697 4698 template <> 4699 struct hash<VULKAN_HPP_NAMESPACE::ExternalImageFormatProperties> 4700 { operator ()std::hash4701 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalImageFormatProperties const & externalImageFormatProperties ) const VULKAN_HPP_NOEXCEPT 4702 { 4703 std::size_t seed = 0; 4704 VULKAN_HPP_HASH_COMBINE( seed, externalImageFormatProperties.sType ); 4705 VULKAN_HPP_HASH_COMBINE( seed, externalImageFormatProperties.pNext ); 4706 VULKAN_HPP_HASH_COMBINE( seed, externalImageFormatProperties.externalMemoryProperties ); 4707 return seed; 4708 } 4709 }; 4710 4711 template <> 4712 struct hash<VULKAN_HPP_NAMESPACE::ImageFormatProperties> 4713 { operator ()std::hash4714 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageFormatProperties const & imageFormatProperties ) const VULKAN_HPP_NOEXCEPT 4715 { 4716 std::size_t seed = 0; 4717 VULKAN_HPP_HASH_COMBINE( seed, imageFormatProperties.maxExtent ); 4718 VULKAN_HPP_HASH_COMBINE( seed, imageFormatProperties.maxMipLevels ); 4719 VULKAN_HPP_HASH_COMBINE( seed, imageFormatProperties.maxArrayLayers ); 4720 VULKAN_HPP_HASH_COMBINE( seed, imageFormatProperties.sampleCounts ); 4721 VULKAN_HPP_HASH_COMBINE( seed, imageFormatProperties.maxResourceSize ); 4722 return seed; 4723 } 4724 }; 4725 4726 template <> 4727 struct hash<VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV> 4728 { operator ()std::hash4729 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV const & externalImageFormatPropertiesNV ) const VULKAN_HPP_NOEXCEPT 4730 { 4731 std::size_t seed = 0; 4732 VULKAN_HPP_HASH_COMBINE( seed, externalImageFormatPropertiesNV.imageFormatProperties ); 4733 VULKAN_HPP_HASH_COMBINE( seed, externalImageFormatPropertiesNV.externalMemoryFeatures ); 4734 VULKAN_HPP_HASH_COMBINE( seed, externalImageFormatPropertiesNV.exportFromImportedHandleTypes ); 4735 VULKAN_HPP_HASH_COMBINE( seed, externalImageFormatPropertiesNV.compatibleHandleTypes ); 4736 return seed; 4737 } 4738 }; 4739 4740 template <> 4741 struct hash<VULKAN_HPP_NAMESPACE::ExternalMemoryAcquireUnmodifiedEXT> 4742 { operator ()std::hash4743 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalMemoryAcquireUnmodifiedEXT const & externalMemoryAcquireUnmodifiedEXT ) const VULKAN_HPP_NOEXCEPT 4744 { 4745 std::size_t seed = 0; 4746 VULKAN_HPP_HASH_COMBINE( seed, externalMemoryAcquireUnmodifiedEXT.sType ); 4747 VULKAN_HPP_HASH_COMBINE( seed, externalMemoryAcquireUnmodifiedEXT.pNext ); 4748 VULKAN_HPP_HASH_COMBINE( seed, externalMemoryAcquireUnmodifiedEXT.acquireUnmodifiedMemory ); 4749 return seed; 4750 } 4751 }; 4752 4753 template <> 4754 struct hash<VULKAN_HPP_NAMESPACE::ExternalMemoryBufferCreateInfo> 4755 { operator ()std::hash4756 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalMemoryBufferCreateInfo const & externalMemoryBufferCreateInfo ) const VULKAN_HPP_NOEXCEPT 4757 { 4758 std::size_t seed = 0; 4759 VULKAN_HPP_HASH_COMBINE( seed, externalMemoryBufferCreateInfo.sType ); 4760 VULKAN_HPP_HASH_COMBINE( seed, externalMemoryBufferCreateInfo.pNext ); 4761 VULKAN_HPP_HASH_COMBINE( seed, externalMemoryBufferCreateInfo.handleTypes ); 4762 return seed; 4763 } 4764 }; 4765 4766 template <> 4767 struct hash<VULKAN_HPP_NAMESPACE::ExternalMemoryImageCreateInfo> 4768 { operator ()std::hash4769 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalMemoryImageCreateInfo const & externalMemoryImageCreateInfo ) const VULKAN_HPP_NOEXCEPT 4770 { 4771 std::size_t seed = 0; 4772 VULKAN_HPP_HASH_COMBINE( seed, externalMemoryImageCreateInfo.sType ); 4773 VULKAN_HPP_HASH_COMBINE( seed, externalMemoryImageCreateInfo.pNext ); 4774 VULKAN_HPP_HASH_COMBINE( seed, externalMemoryImageCreateInfo.handleTypes ); 4775 return seed; 4776 } 4777 }; 4778 4779 template <> 4780 struct hash<VULKAN_HPP_NAMESPACE::ExternalMemoryImageCreateInfoNV> 4781 { operator ()std::hash4782 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalMemoryImageCreateInfoNV const & externalMemoryImageCreateInfoNV ) const VULKAN_HPP_NOEXCEPT 4783 { 4784 std::size_t seed = 0; 4785 VULKAN_HPP_HASH_COMBINE( seed, externalMemoryImageCreateInfoNV.sType ); 4786 VULKAN_HPP_HASH_COMBINE( seed, externalMemoryImageCreateInfoNV.pNext ); 4787 VULKAN_HPP_HASH_COMBINE( seed, externalMemoryImageCreateInfoNV.handleTypes ); 4788 return seed; 4789 } 4790 }; 4791 4792 template <> 4793 struct hash<VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties> 4794 { operator ()std::hash4795 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties const & externalSemaphoreProperties ) const VULKAN_HPP_NOEXCEPT 4796 { 4797 std::size_t seed = 0; 4798 VULKAN_HPP_HASH_COMBINE( seed, externalSemaphoreProperties.sType ); 4799 VULKAN_HPP_HASH_COMBINE( seed, externalSemaphoreProperties.pNext ); 4800 VULKAN_HPP_HASH_COMBINE( seed, externalSemaphoreProperties.exportFromImportedHandleTypes ); 4801 VULKAN_HPP_HASH_COMBINE( seed, externalSemaphoreProperties.compatibleHandleTypes ); 4802 VULKAN_HPP_HASH_COMBINE( seed, externalSemaphoreProperties.externalSemaphoreFeatures ); 4803 return seed; 4804 } 4805 }; 4806 4807 template <> 4808 struct hash<VULKAN_HPP_NAMESPACE::FenceCreateInfo> 4809 { operator ()std::hash4810 std::size_t operator()( VULKAN_HPP_NAMESPACE::FenceCreateInfo const & fenceCreateInfo ) const VULKAN_HPP_NOEXCEPT 4811 { 4812 std::size_t seed = 0; 4813 VULKAN_HPP_HASH_COMBINE( seed, fenceCreateInfo.sType ); 4814 VULKAN_HPP_HASH_COMBINE( seed, fenceCreateInfo.pNext ); 4815 VULKAN_HPP_HASH_COMBINE( seed, fenceCreateInfo.flags ); 4816 return seed; 4817 } 4818 }; 4819 4820 template <> 4821 struct hash<VULKAN_HPP_NAMESPACE::FenceGetFdInfoKHR> 4822 { operator ()std::hash4823 std::size_t operator()( VULKAN_HPP_NAMESPACE::FenceGetFdInfoKHR const & fenceGetFdInfoKHR ) const VULKAN_HPP_NOEXCEPT 4824 { 4825 std::size_t seed = 0; 4826 VULKAN_HPP_HASH_COMBINE( seed, fenceGetFdInfoKHR.sType ); 4827 VULKAN_HPP_HASH_COMBINE( seed, fenceGetFdInfoKHR.pNext ); 4828 VULKAN_HPP_HASH_COMBINE( seed, fenceGetFdInfoKHR.fence ); 4829 VULKAN_HPP_HASH_COMBINE( seed, fenceGetFdInfoKHR.handleType ); 4830 return seed; 4831 } 4832 }; 4833 4834 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 4835 template <> 4836 struct hash<VULKAN_HPP_NAMESPACE::FenceGetWin32HandleInfoKHR> 4837 { operator ()std::hash4838 std::size_t operator()( VULKAN_HPP_NAMESPACE::FenceGetWin32HandleInfoKHR const & fenceGetWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT 4839 { 4840 std::size_t seed = 0; 4841 VULKAN_HPP_HASH_COMBINE( seed, fenceGetWin32HandleInfoKHR.sType ); 4842 VULKAN_HPP_HASH_COMBINE( seed, fenceGetWin32HandleInfoKHR.pNext ); 4843 VULKAN_HPP_HASH_COMBINE( seed, fenceGetWin32HandleInfoKHR.fence ); 4844 VULKAN_HPP_HASH_COMBINE( seed, fenceGetWin32HandleInfoKHR.handleType ); 4845 return seed; 4846 } 4847 }; 4848 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 4849 4850 template <> 4851 struct hash<VULKAN_HPP_NAMESPACE::FilterCubicImageViewImageFormatPropertiesEXT> 4852 { operator ()std::hash4853 std::size_t operator()( VULKAN_HPP_NAMESPACE::FilterCubicImageViewImageFormatPropertiesEXT const & filterCubicImageViewImageFormatPropertiesEXT ) const 4854 VULKAN_HPP_NOEXCEPT 4855 { 4856 std::size_t seed = 0; 4857 VULKAN_HPP_HASH_COMBINE( seed, filterCubicImageViewImageFormatPropertiesEXT.sType ); 4858 VULKAN_HPP_HASH_COMBINE( seed, filterCubicImageViewImageFormatPropertiesEXT.pNext ); 4859 VULKAN_HPP_HASH_COMBINE( seed, filterCubicImageViewImageFormatPropertiesEXT.filterCubic ); 4860 VULKAN_HPP_HASH_COMBINE( seed, filterCubicImageViewImageFormatPropertiesEXT.filterCubicMinmax ); 4861 return seed; 4862 } 4863 }; 4864 4865 template <> 4866 struct hash<VULKAN_HPP_NAMESPACE::FormatProperties> 4867 { operator ()std::hash4868 std::size_t operator()( VULKAN_HPP_NAMESPACE::FormatProperties const & formatProperties ) const VULKAN_HPP_NOEXCEPT 4869 { 4870 std::size_t seed = 0; 4871 VULKAN_HPP_HASH_COMBINE( seed, formatProperties.linearTilingFeatures ); 4872 VULKAN_HPP_HASH_COMBINE( seed, formatProperties.optimalTilingFeatures ); 4873 VULKAN_HPP_HASH_COMBINE( seed, formatProperties.bufferFeatures ); 4874 return seed; 4875 } 4876 }; 4877 4878 template <> 4879 struct hash<VULKAN_HPP_NAMESPACE::FormatProperties2> 4880 { operator ()std::hash4881 std::size_t operator()( VULKAN_HPP_NAMESPACE::FormatProperties2 const & formatProperties2 ) const VULKAN_HPP_NOEXCEPT 4882 { 4883 std::size_t seed = 0; 4884 VULKAN_HPP_HASH_COMBINE( seed, formatProperties2.sType ); 4885 VULKAN_HPP_HASH_COMBINE( seed, formatProperties2.pNext ); 4886 VULKAN_HPP_HASH_COMBINE( seed, formatProperties2.formatProperties ); 4887 return seed; 4888 } 4889 }; 4890 4891 template <> 4892 struct hash<VULKAN_HPP_NAMESPACE::FormatProperties3> 4893 { operator ()std::hash4894 std::size_t operator()( VULKAN_HPP_NAMESPACE::FormatProperties3 const & formatProperties3 ) const VULKAN_HPP_NOEXCEPT 4895 { 4896 std::size_t seed = 0; 4897 VULKAN_HPP_HASH_COMBINE( seed, formatProperties3.sType ); 4898 VULKAN_HPP_HASH_COMBINE( seed, formatProperties3.pNext ); 4899 VULKAN_HPP_HASH_COMBINE( seed, formatProperties3.linearTilingFeatures ); 4900 VULKAN_HPP_HASH_COMBINE( seed, formatProperties3.optimalTilingFeatures ); 4901 VULKAN_HPP_HASH_COMBINE( seed, formatProperties3.bufferFeatures ); 4902 return seed; 4903 } 4904 }; 4905 4906 template <> 4907 struct hash<VULKAN_HPP_NAMESPACE::FragmentShadingRateAttachmentInfoKHR> 4908 { operator ()std::hash4909 std::size_t operator()( VULKAN_HPP_NAMESPACE::FragmentShadingRateAttachmentInfoKHR const & fragmentShadingRateAttachmentInfoKHR ) const VULKAN_HPP_NOEXCEPT 4910 { 4911 std::size_t seed = 0; 4912 VULKAN_HPP_HASH_COMBINE( seed, fragmentShadingRateAttachmentInfoKHR.sType ); 4913 VULKAN_HPP_HASH_COMBINE( seed, fragmentShadingRateAttachmentInfoKHR.pNext ); 4914 VULKAN_HPP_HASH_COMBINE( seed, fragmentShadingRateAttachmentInfoKHR.pFragmentShadingRateAttachment ); 4915 VULKAN_HPP_HASH_COMBINE( seed, fragmentShadingRateAttachmentInfoKHR.shadingRateAttachmentTexelSize ); 4916 return seed; 4917 } 4918 }; 4919 4920 template <> 4921 struct hash<VULKAN_HPP_NAMESPACE::FrameBoundaryEXT> 4922 { operator ()std::hash4923 std::size_t operator()( VULKAN_HPP_NAMESPACE::FrameBoundaryEXT const & frameBoundaryEXT ) const VULKAN_HPP_NOEXCEPT 4924 { 4925 std::size_t seed = 0; 4926 VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.sType ); 4927 VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.pNext ); 4928 VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.flags ); 4929 VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.frameID ); 4930 VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.imageCount ); 4931 VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.pImages ); 4932 VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.bufferCount ); 4933 VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.pBuffers ); 4934 VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.tagName ); 4935 VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.tagSize ); 4936 VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.pTag ); 4937 return seed; 4938 } 4939 }; 4940 4941 template <> 4942 struct hash<VULKAN_HPP_NAMESPACE::FramebufferAttachmentImageInfo> 4943 { operator ()std::hash4944 std::size_t operator()( VULKAN_HPP_NAMESPACE::FramebufferAttachmentImageInfo const & framebufferAttachmentImageInfo ) const VULKAN_HPP_NOEXCEPT 4945 { 4946 std::size_t seed = 0; 4947 VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentImageInfo.sType ); 4948 VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentImageInfo.pNext ); 4949 VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentImageInfo.flags ); 4950 VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentImageInfo.usage ); 4951 VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentImageInfo.width ); 4952 VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentImageInfo.height ); 4953 VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentImageInfo.layerCount ); 4954 VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentImageInfo.viewFormatCount ); 4955 VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentImageInfo.pViewFormats ); 4956 return seed; 4957 } 4958 }; 4959 4960 template <> 4961 struct hash<VULKAN_HPP_NAMESPACE::FramebufferAttachmentsCreateInfo> 4962 { operator ()std::hash4963 std::size_t operator()( VULKAN_HPP_NAMESPACE::FramebufferAttachmentsCreateInfo const & framebufferAttachmentsCreateInfo ) const VULKAN_HPP_NOEXCEPT 4964 { 4965 std::size_t seed = 0; 4966 VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentsCreateInfo.sType ); 4967 VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentsCreateInfo.pNext ); 4968 VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentsCreateInfo.attachmentImageInfoCount ); 4969 VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentsCreateInfo.pAttachmentImageInfos ); 4970 return seed; 4971 } 4972 }; 4973 4974 template <> 4975 struct hash<VULKAN_HPP_NAMESPACE::FramebufferCreateInfo> 4976 { operator ()std::hash4977 std::size_t operator()( VULKAN_HPP_NAMESPACE::FramebufferCreateInfo const & framebufferCreateInfo ) const VULKAN_HPP_NOEXCEPT 4978 { 4979 std::size_t seed = 0; 4980 VULKAN_HPP_HASH_COMBINE( seed, framebufferCreateInfo.sType ); 4981 VULKAN_HPP_HASH_COMBINE( seed, framebufferCreateInfo.pNext ); 4982 VULKAN_HPP_HASH_COMBINE( seed, framebufferCreateInfo.flags ); 4983 VULKAN_HPP_HASH_COMBINE( seed, framebufferCreateInfo.renderPass ); 4984 VULKAN_HPP_HASH_COMBINE( seed, framebufferCreateInfo.attachmentCount ); 4985 VULKAN_HPP_HASH_COMBINE( seed, framebufferCreateInfo.pAttachments ); 4986 VULKAN_HPP_HASH_COMBINE( seed, framebufferCreateInfo.width ); 4987 VULKAN_HPP_HASH_COMBINE( seed, framebufferCreateInfo.height ); 4988 VULKAN_HPP_HASH_COMBINE( seed, framebufferCreateInfo.layers ); 4989 return seed; 4990 } 4991 }; 4992 4993 template <> 4994 struct hash<VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV> 4995 { operator ()std::hash4996 std::size_t operator()( VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV const & framebufferMixedSamplesCombinationNV ) const VULKAN_HPP_NOEXCEPT 4997 { 4998 std::size_t seed = 0; 4999 VULKAN_HPP_HASH_COMBINE( seed, framebufferMixedSamplesCombinationNV.sType ); 5000 VULKAN_HPP_HASH_COMBINE( seed, framebufferMixedSamplesCombinationNV.pNext ); 5001 VULKAN_HPP_HASH_COMBINE( seed, framebufferMixedSamplesCombinationNV.coverageReductionMode ); 5002 VULKAN_HPP_HASH_COMBINE( seed, framebufferMixedSamplesCombinationNV.rasterizationSamples ); 5003 VULKAN_HPP_HASH_COMBINE( seed, framebufferMixedSamplesCombinationNV.depthStencilSamples ); 5004 VULKAN_HPP_HASH_COMBINE( seed, framebufferMixedSamplesCombinationNV.colorSamples ); 5005 return seed; 5006 } 5007 }; 5008 5009 template <> 5010 struct hash<VULKAN_HPP_NAMESPACE::IndirectCommandsStreamNV> 5011 { operator ()std::hash5012 std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectCommandsStreamNV const & indirectCommandsStreamNV ) const VULKAN_HPP_NOEXCEPT 5013 { 5014 std::size_t seed = 0; 5015 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsStreamNV.buffer ); 5016 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsStreamNV.offset ); 5017 return seed; 5018 } 5019 }; 5020 5021 template <> 5022 struct hash<VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV> 5023 { operator ()std::hash5024 std::size_t operator()( VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV const & generatedCommandsInfoNV ) const VULKAN_HPP_NOEXCEPT 5025 { 5026 std::size_t seed = 0; 5027 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.sType ); 5028 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.pNext ); 5029 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.pipelineBindPoint ); 5030 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.pipeline ); 5031 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.indirectCommandsLayout ); 5032 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.streamCount ); 5033 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.pStreams ); 5034 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.sequencesCount ); 5035 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.preprocessBuffer ); 5036 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.preprocessOffset ); 5037 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.preprocessSize ); 5038 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.sequencesCountBuffer ); 5039 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.sequencesCountOffset ); 5040 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.sequencesIndexBuffer ); 5041 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.sequencesIndexOffset ); 5042 return seed; 5043 } 5044 }; 5045 5046 template <> 5047 struct hash<VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV> 5048 { 5049 std::size_t operator ()std::hash5050 operator()( VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV const & generatedCommandsMemoryRequirementsInfoNV ) const VULKAN_HPP_NOEXCEPT 5051 { 5052 std::size_t seed = 0; 5053 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsMemoryRequirementsInfoNV.sType ); 5054 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsMemoryRequirementsInfoNV.pNext ); 5055 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsMemoryRequirementsInfoNV.pipelineBindPoint ); 5056 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsMemoryRequirementsInfoNV.pipeline ); 5057 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsMemoryRequirementsInfoNV.indirectCommandsLayout ); 5058 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsMemoryRequirementsInfoNV.maxSequencesCount ); 5059 return seed; 5060 } 5061 }; 5062 5063 template <> 5064 struct hash<VULKAN_HPP_NAMESPACE::LatencyTimingsFrameReportNV> 5065 { operator ()std::hash5066 std::size_t operator()( VULKAN_HPP_NAMESPACE::LatencyTimingsFrameReportNV const & latencyTimingsFrameReportNV ) const VULKAN_HPP_NOEXCEPT 5067 { 5068 std::size_t seed = 0; 5069 VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.sType ); 5070 VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.pNext ); 5071 VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.presentID ); 5072 VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.inputSampleTimeUs ); 5073 VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.simStartTimeUs ); 5074 VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.simEndTimeUs ); 5075 VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.renderSubmitStartTimeUs ); 5076 VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.renderSubmitEndTimeUs ); 5077 VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.presentStartTimeUs ); 5078 VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.presentEndTimeUs ); 5079 VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.driverStartTimeUs ); 5080 VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.driverEndTimeUs ); 5081 VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.osRenderQueueStartTimeUs ); 5082 VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.osRenderQueueEndTimeUs ); 5083 VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.gpuRenderStartTimeUs ); 5084 VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.gpuRenderEndTimeUs ); 5085 return seed; 5086 } 5087 }; 5088 5089 template <> 5090 struct hash<VULKAN_HPP_NAMESPACE::GetLatencyMarkerInfoNV> 5091 { operator ()std::hash5092 std::size_t operator()( VULKAN_HPP_NAMESPACE::GetLatencyMarkerInfoNV const & getLatencyMarkerInfoNV ) const VULKAN_HPP_NOEXCEPT 5093 { 5094 std::size_t seed = 0; 5095 VULKAN_HPP_HASH_COMBINE( seed, getLatencyMarkerInfoNV.sType ); 5096 VULKAN_HPP_HASH_COMBINE( seed, getLatencyMarkerInfoNV.pNext ); 5097 VULKAN_HPP_HASH_COMBINE( seed, getLatencyMarkerInfoNV.pTimings ); 5098 return seed; 5099 } 5100 }; 5101 5102 template <> 5103 struct hash<VULKAN_HPP_NAMESPACE::VertexInputBindingDescription> 5104 { operator ()std::hash5105 std::size_t operator()( VULKAN_HPP_NAMESPACE::VertexInputBindingDescription const & vertexInputBindingDescription ) const VULKAN_HPP_NOEXCEPT 5106 { 5107 std::size_t seed = 0; 5108 VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDescription.binding ); 5109 VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDescription.stride ); 5110 VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDescription.inputRate ); 5111 return seed; 5112 } 5113 }; 5114 5115 template <> 5116 struct hash<VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription> 5117 { operator ()std::hash5118 std::size_t operator()( VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription const & vertexInputAttributeDescription ) const VULKAN_HPP_NOEXCEPT 5119 { 5120 std::size_t seed = 0; 5121 VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription.location ); 5122 VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription.binding ); 5123 VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription.format ); 5124 VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription.offset ); 5125 return seed; 5126 } 5127 }; 5128 5129 template <> 5130 struct hash<VULKAN_HPP_NAMESPACE::PipelineVertexInputStateCreateInfo> 5131 { operator ()std::hash5132 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineVertexInputStateCreateInfo const & pipelineVertexInputStateCreateInfo ) const VULKAN_HPP_NOEXCEPT 5133 { 5134 std::size_t seed = 0; 5135 VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputStateCreateInfo.sType ); 5136 VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputStateCreateInfo.pNext ); 5137 VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputStateCreateInfo.flags ); 5138 VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputStateCreateInfo.vertexBindingDescriptionCount ); 5139 VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputStateCreateInfo.pVertexBindingDescriptions ); 5140 VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputStateCreateInfo.vertexAttributeDescriptionCount ); 5141 VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputStateCreateInfo.pVertexAttributeDescriptions ); 5142 return seed; 5143 } 5144 }; 5145 5146 template <> 5147 struct hash<VULKAN_HPP_NAMESPACE::PipelineInputAssemblyStateCreateInfo> 5148 { operator ()std::hash5149 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineInputAssemblyStateCreateInfo const & pipelineInputAssemblyStateCreateInfo ) const VULKAN_HPP_NOEXCEPT 5150 { 5151 std::size_t seed = 0; 5152 VULKAN_HPP_HASH_COMBINE( seed, pipelineInputAssemblyStateCreateInfo.sType ); 5153 VULKAN_HPP_HASH_COMBINE( seed, pipelineInputAssemblyStateCreateInfo.pNext ); 5154 VULKAN_HPP_HASH_COMBINE( seed, pipelineInputAssemblyStateCreateInfo.flags ); 5155 VULKAN_HPP_HASH_COMBINE( seed, pipelineInputAssemblyStateCreateInfo.topology ); 5156 VULKAN_HPP_HASH_COMBINE( seed, pipelineInputAssemblyStateCreateInfo.primitiveRestartEnable ); 5157 return seed; 5158 } 5159 }; 5160 5161 template <> 5162 struct hash<VULKAN_HPP_NAMESPACE::PipelineTessellationStateCreateInfo> 5163 { operator ()std::hash5164 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineTessellationStateCreateInfo const & pipelineTessellationStateCreateInfo ) const VULKAN_HPP_NOEXCEPT 5165 { 5166 std::size_t seed = 0; 5167 VULKAN_HPP_HASH_COMBINE( seed, pipelineTessellationStateCreateInfo.sType ); 5168 VULKAN_HPP_HASH_COMBINE( seed, pipelineTessellationStateCreateInfo.pNext ); 5169 VULKAN_HPP_HASH_COMBINE( seed, pipelineTessellationStateCreateInfo.flags ); 5170 VULKAN_HPP_HASH_COMBINE( seed, pipelineTessellationStateCreateInfo.patchControlPoints ); 5171 return seed; 5172 } 5173 }; 5174 5175 template <> 5176 struct hash<VULKAN_HPP_NAMESPACE::PipelineViewportStateCreateInfo> 5177 { operator ()std::hash5178 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineViewportStateCreateInfo const & pipelineViewportStateCreateInfo ) const VULKAN_HPP_NOEXCEPT 5179 { 5180 std::size_t seed = 0; 5181 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportStateCreateInfo.sType ); 5182 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportStateCreateInfo.pNext ); 5183 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportStateCreateInfo.flags ); 5184 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportStateCreateInfo.viewportCount ); 5185 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportStateCreateInfo.pViewports ); 5186 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportStateCreateInfo.scissorCount ); 5187 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportStateCreateInfo.pScissors ); 5188 return seed; 5189 } 5190 }; 5191 5192 template <> 5193 struct hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationStateCreateInfo> 5194 { operator ()std::hash5195 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationStateCreateInfo const & pipelineRasterizationStateCreateInfo ) const VULKAN_HPP_NOEXCEPT 5196 { 5197 std::size_t seed = 0; 5198 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.sType ); 5199 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.pNext ); 5200 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.flags ); 5201 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.depthClampEnable ); 5202 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.rasterizerDiscardEnable ); 5203 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.polygonMode ); 5204 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.cullMode ); 5205 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.frontFace ); 5206 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.depthBiasEnable ); 5207 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.depthBiasConstantFactor ); 5208 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.depthBiasClamp ); 5209 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.depthBiasSlopeFactor ); 5210 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.lineWidth ); 5211 return seed; 5212 } 5213 }; 5214 5215 template <> 5216 struct hash<VULKAN_HPP_NAMESPACE::PipelineMultisampleStateCreateInfo> 5217 { operator ()std::hash5218 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineMultisampleStateCreateInfo const & pipelineMultisampleStateCreateInfo ) const VULKAN_HPP_NOEXCEPT 5219 { 5220 std::size_t seed = 0; 5221 VULKAN_HPP_HASH_COMBINE( seed, pipelineMultisampleStateCreateInfo.sType ); 5222 VULKAN_HPP_HASH_COMBINE( seed, pipelineMultisampleStateCreateInfo.pNext ); 5223 VULKAN_HPP_HASH_COMBINE( seed, pipelineMultisampleStateCreateInfo.flags ); 5224 VULKAN_HPP_HASH_COMBINE( seed, pipelineMultisampleStateCreateInfo.rasterizationSamples ); 5225 VULKAN_HPP_HASH_COMBINE( seed, pipelineMultisampleStateCreateInfo.sampleShadingEnable ); 5226 VULKAN_HPP_HASH_COMBINE( seed, pipelineMultisampleStateCreateInfo.minSampleShading ); 5227 VULKAN_HPP_HASH_COMBINE( seed, pipelineMultisampleStateCreateInfo.pSampleMask ); 5228 VULKAN_HPP_HASH_COMBINE( seed, pipelineMultisampleStateCreateInfo.alphaToCoverageEnable ); 5229 VULKAN_HPP_HASH_COMBINE( seed, pipelineMultisampleStateCreateInfo.alphaToOneEnable ); 5230 return seed; 5231 } 5232 }; 5233 5234 template <> 5235 struct hash<VULKAN_HPP_NAMESPACE::StencilOpState> 5236 { operator ()std::hash5237 std::size_t operator()( VULKAN_HPP_NAMESPACE::StencilOpState const & stencilOpState ) const VULKAN_HPP_NOEXCEPT 5238 { 5239 std::size_t seed = 0; 5240 VULKAN_HPP_HASH_COMBINE( seed, stencilOpState.failOp ); 5241 VULKAN_HPP_HASH_COMBINE( seed, stencilOpState.passOp ); 5242 VULKAN_HPP_HASH_COMBINE( seed, stencilOpState.depthFailOp ); 5243 VULKAN_HPP_HASH_COMBINE( seed, stencilOpState.compareOp ); 5244 VULKAN_HPP_HASH_COMBINE( seed, stencilOpState.compareMask ); 5245 VULKAN_HPP_HASH_COMBINE( seed, stencilOpState.writeMask ); 5246 VULKAN_HPP_HASH_COMBINE( seed, stencilOpState.reference ); 5247 return seed; 5248 } 5249 }; 5250 5251 template <> 5252 struct hash<VULKAN_HPP_NAMESPACE::PipelineDepthStencilStateCreateInfo> 5253 { operator ()std::hash5254 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineDepthStencilStateCreateInfo const & pipelineDepthStencilStateCreateInfo ) const VULKAN_HPP_NOEXCEPT 5255 { 5256 std::size_t seed = 0; 5257 VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.sType ); 5258 VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.pNext ); 5259 VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.flags ); 5260 VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.depthTestEnable ); 5261 VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.depthWriteEnable ); 5262 VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.depthCompareOp ); 5263 VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.depthBoundsTestEnable ); 5264 VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.stencilTestEnable ); 5265 VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.front ); 5266 VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.back ); 5267 VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.minDepthBounds ); 5268 VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.maxDepthBounds ); 5269 return seed; 5270 } 5271 }; 5272 5273 template <> 5274 struct hash<VULKAN_HPP_NAMESPACE::PipelineColorBlendAttachmentState> 5275 { operator ()std::hash5276 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineColorBlendAttachmentState const & pipelineColorBlendAttachmentState ) const VULKAN_HPP_NOEXCEPT 5277 { 5278 std::size_t seed = 0; 5279 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAttachmentState.blendEnable ); 5280 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAttachmentState.srcColorBlendFactor ); 5281 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAttachmentState.dstColorBlendFactor ); 5282 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAttachmentState.colorBlendOp ); 5283 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAttachmentState.srcAlphaBlendFactor ); 5284 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAttachmentState.dstAlphaBlendFactor ); 5285 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAttachmentState.alphaBlendOp ); 5286 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAttachmentState.colorWriteMask ); 5287 return seed; 5288 } 5289 }; 5290 5291 template <> 5292 struct hash<VULKAN_HPP_NAMESPACE::PipelineColorBlendStateCreateInfo> 5293 { operator ()std::hash5294 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineColorBlendStateCreateInfo const & pipelineColorBlendStateCreateInfo ) const VULKAN_HPP_NOEXCEPT 5295 { 5296 std::size_t seed = 0; 5297 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendStateCreateInfo.sType ); 5298 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendStateCreateInfo.pNext ); 5299 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendStateCreateInfo.flags ); 5300 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendStateCreateInfo.logicOpEnable ); 5301 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendStateCreateInfo.logicOp ); 5302 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendStateCreateInfo.attachmentCount ); 5303 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendStateCreateInfo.pAttachments ); 5304 for ( size_t i = 0; i < 4; ++i ) 5305 { 5306 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendStateCreateInfo.blendConstants[i] ); 5307 } 5308 return seed; 5309 } 5310 }; 5311 5312 template <> 5313 struct hash<VULKAN_HPP_NAMESPACE::PipelineDynamicStateCreateInfo> 5314 { operator ()std::hash5315 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineDynamicStateCreateInfo const & pipelineDynamicStateCreateInfo ) const VULKAN_HPP_NOEXCEPT 5316 { 5317 std::size_t seed = 0; 5318 VULKAN_HPP_HASH_COMBINE( seed, pipelineDynamicStateCreateInfo.sType ); 5319 VULKAN_HPP_HASH_COMBINE( seed, pipelineDynamicStateCreateInfo.pNext ); 5320 VULKAN_HPP_HASH_COMBINE( seed, pipelineDynamicStateCreateInfo.flags ); 5321 VULKAN_HPP_HASH_COMBINE( seed, pipelineDynamicStateCreateInfo.dynamicStateCount ); 5322 VULKAN_HPP_HASH_COMBINE( seed, pipelineDynamicStateCreateInfo.pDynamicStates ); 5323 return seed; 5324 } 5325 }; 5326 5327 template <> 5328 struct hash<VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> 5329 { operator ()std::hash5330 std::size_t operator()( VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo const & graphicsPipelineCreateInfo ) const VULKAN_HPP_NOEXCEPT 5331 { 5332 std::size_t seed = 0; 5333 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.sType ); 5334 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pNext ); 5335 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.flags ); 5336 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.stageCount ); 5337 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pStages ); 5338 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pVertexInputState ); 5339 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pInputAssemblyState ); 5340 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pTessellationState ); 5341 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pViewportState ); 5342 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pRasterizationState ); 5343 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pMultisampleState ); 5344 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pDepthStencilState ); 5345 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pColorBlendState ); 5346 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pDynamicState ); 5347 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.layout ); 5348 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.renderPass ); 5349 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.subpass ); 5350 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.basePipelineHandle ); 5351 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.basePipelineIndex ); 5352 return seed; 5353 } 5354 }; 5355 5356 template <> 5357 struct hash<VULKAN_HPP_NAMESPACE::GraphicsPipelineLibraryCreateInfoEXT> 5358 { operator ()std::hash5359 std::size_t operator()( VULKAN_HPP_NAMESPACE::GraphicsPipelineLibraryCreateInfoEXT const & graphicsPipelineLibraryCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 5360 { 5361 std::size_t seed = 0; 5362 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineLibraryCreateInfoEXT.sType ); 5363 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineLibraryCreateInfoEXT.pNext ); 5364 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineLibraryCreateInfoEXT.flags ); 5365 return seed; 5366 } 5367 }; 5368 5369 template <> 5370 struct hash<VULKAN_HPP_NAMESPACE::GraphicsShaderGroupCreateInfoNV> 5371 { operator ()std::hash5372 std::size_t operator()( VULKAN_HPP_NAMESPACE::GraphicsShaderGroupCreateInfoNV const & graphicsShaderGroupCreateInfoNV ) const VULKAN_HPP_NOEXCEPT 5373 { 5374 std::size_t seed = 0; 5375 VULKAN_HPP_HASH_COMBINE( seed, graphicsShaderGroupCreateInfoNV.sType ); 5376 VULKAN_HPP_HASH_COMBINE( seed, graphicsShaderGroupCreateInfoNV.pNext ); 5377 VULKAN_HPP_HASH_COMBINE( seed, graphicsShaderGroupCreateInfoNV.stageCount ); 5378 VULKAN_HPP_HASH_COMBINE( seed, graphicsShaderGroupCreateInfoNV.pStages ); 5379 VULKAN_HPP_HASH_COMBINE( seed, graphicsShaderGroupCreateInfoNV.pVertexInputState ); 5380 VULKAN_HPP_HASH_COMBINE( seed, graphicsShaderGroupCreateInfoNV.pTessellationState ); 5381 return seed; 5382 } 5383 }; 5384 5385 template <> 5386 struct hash<VULKAN_HPP_NAMESPACE::GraphicsPipelineShaderGroupsCreateInfoNV> 5387 { 5388 std::size_t operator ()std::hash5389 operator()( VULKAN_HPP_NAMESPACE::GraphicsPipelineShaderGroupsCreateInfoNV const & graphicsPipelineShaderGroupsCreateInfoNV ) const VULKAN_HPP_NOEXCEPT 5390 { 5391 std::size_t seed = 0; 5392 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineShaderGroupsCreateInfoNV.sType ); 5393 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineShaderGroupsCreateInfoNV.pNext ); 5394 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineShaderGroupsCreateInfoNV.groupCount ); 5395 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineShaderGroupsCreateInfoNV.pGroups ); 5396 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineShaderGroupsCreateInfoNV.pipelineCount ); 5397 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineShaderGroupsCreateInfoNV.pPipelines ); 5398 return seed; 5399 } 5400 }; 5401 5402 template <> 5403 struct hash<VULKAN_HPP_NAMESPACE::XYColorEXT> 5404 { operator ()std::hash5405 std::size_t operator()( VULKAN_HPP_NAMESPACE::XYColorEXT const & xYColorEXT ) const VULKAN_HPP_NOEXCEPT 5406 { 5407 std::size_t seed = 0; 5408 VULKAN_HPP_HASH_COMBINE( seed, xYColorEXT.x ); 5409 VULKAN_HPP_HASH_COMBINE( seed, xYColorEXT.y ); 5410 return seed; 5411 } 5412 }; 5413 5414 template <> 5415 struct hash<VULKAN_HPP_NAMESPACE::HdrMetadataEXT> 5416 { operator ()std::hash5417 std::size_t operator()( VULKAN_HPP_NAMESPACE::HdrMetadataEXT const & hdrMetadataEXT ) const VULKAN_HPP_NOEXCEPT 5418 { 5419 std::size_t seed = 0; 5420 VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.sType ); 5421 VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.pNext ); 5422 VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.displayPrimaryRed ); 5423 VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.displayPrimaryGreen ); 5424 VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.displayPrimaryBlue ); 5425 VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.whitePoint ); 5426 VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.maxLuminance ); 5427 VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.minLuminance ); 5428 VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.maxContentLightLevel ); 5429 VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.maxFrameAverageLightLevel ); 5430 return seed; 5431 } 5432 }; 5433 5434 template <> 5435 struct hash<VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT> 5436 { operator ()std::hash5437 std::size_t operator()( VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT const & headlessSurfaceCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 5438 { 5439 std::size_t seed = 0; 5440 VULKAN_HPP_HASH_COMBINE( seed, headlessSurfaceCreateInfoEXT.sType ); 5441 VULKAN_HPP_HASH_COMBINE( seed, headlessSurfaceCreateInfoEXT.pNext ); 5442 VULKAN_HPP_HASH_COMBINE( seed, headlessSurfaceCreateInfoEXT.flags ); 5443 return seed; 5444 } 5445 }; 5446 5447 template <> 5448 struct hash<VULKAN_HPP_NAMESPACE::HostImageCopyDevicePerformanceQueryEXT> 5449 { 5450 std::size_t operator ()std::hash5451 operator()( VULKAN_HPP_NAMESPACE::HostImageCopyDevicePerformanceQueryEXT const & hostImageCopyDevicePerformanceQueryEXT ) const VULKAN_HPP_NOEXCEPT 5452 { 5453 std::size_t seed = 0; 5454 VULKAN_HPP_HASH_COMBINE( seed, hostImageCopyDevicePerformanceQueryEXT.sType ); 5455 VULKAN_HPP_HASH_COMBINE( seed, hostImageCopyDevicePerformanceQueryEXT.pNext ); 5456 VULKAN_HPP_HASH_COMBINE( seed, hostImageCopyDevicePerformanceQueryEXT.optimalDeviceAccess ); 5457 VULKAN_HPP_HASH_COMBINE( seed, hostImageCopyDevicePerformanceQueryEXT.identicalMemoryLayout ); 5458 return seed; 5459 } 5460 }; 5461 5462 template <> 5463 struct hash<VULKAN_HPP_NAMESPACE::HostImageLayoutTransitionInfoEXT> 5464 { operator ()std::hash5465 std::size_t operator()( VULKAN_HPP_NAMESPACE::HostImageLayoutTransitionInfoEXT const & hostImageLayoutTransitionInfoEXT ) const VULKAN_HPP_NOEXCEPT 5466 { 5467 std::size_t seed = 0; 5468 VULKAN_HPP_HASH_COMBINE( seed, hostImageLayoutTransitionInfoEXT.sType ); 5469 VULKAN_HPP_HASH_COMBINE( seed, hostImageLayoutTransitionInfoEXT.pNext ); 5470 VULKAN_HPP_HASH_COMBINE( seed, hostImageLayoutTransitionInfoEXT.image ); 5471 VULKAN_HPP_HASH_COMBINE( seed, hostImageLayoutTransitionInfoEXT.oldLayout ); 5472 VULKAN_HPP_HASH_COMBINE( seed, hostImageLayoutTransitionInfoEXT.newLayout ); 5473 VULKAN_HPP_HASH_COMBINE( seed, hostImageLayoutTransitionInfoEXT.subresourceRange ); 5474 return seed; 5475 } 5476 }; 5477 5478 # if defined( VK_USE_PLATFORM_IOS_MVK ) 5479 template <> 5480 struct hash<VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK> 5481 { operator ()std::hash5482 std::size_t operator()( VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK const & iOSSurfaceCreateInfoMVK ) const VULKAN_HPP_NOEXCEPT 5483 { 5484 std::size_t seed = 0; 5485 VULKAN_HPP_HASH_COMBINE( seed, iOSSurfaceCreateInfoMVK.sType ); 5486 VULKAN_HPP_HASH_COMBINE( seed, iOSSurfaceCreateInfoMVK.pNext ); 5487 VULKAN_HPP_HASH_COMBINE( seed, iOSSurfaceCreateInfoMVK.flags ); 5488 VULKAN_HPP_HASH_COMBINE( seed, iOSSurfaceCreateInfoMVK.pView ); 5489 return seed; 5490 } 5491 }; 5492 # endif /*VK_USE_PLATFORM_IOS_MVK*/ 5493 5494 template <> 5495 struct hash<VULKAN_HPP_NAMESPACE::ImageBlit> 5496 { operator ()std::hash5497 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageBlit const & imageBlit ) const VULKAN_HPP_NOEXCEPT 5498 { 5499 std::size_t seed = 0; 5500 VULKAN_HPP_HASH_COMBINE( seed, imageBlit.srcSubresource ); 5501 for ( size_t i = 0; i < 2; ++i ) 5502 { 5503 VULKAN_HPP_HASH_COMBINE( seed, imageBlit.srcOffsets[i] ); 5504 } 5505 VULKAN_HPP_HASH_COMBINE( seed, imageBlit.dstSubresource ); 5506 for ( size_t i = 0; i < 2; ++i ) 5507 { 5508 VULKAN_HPP_HASH_COMBINE( seed, imageBlit.dstOffsets[i] ); 5509 } 5510 return seed; 5511 } 5512 }; 5513 5514 template <> 5515 struct hash<VULKAN_HPP_NAMESPACE::ImageCaptureDescriptorDataInfoEXT> 5516 { operator ()std::hash5517 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageCaptureDescriptorDataInfoEXT const & imageCaptureDescriptorDataInfoEXT ) const VULKAN_HPP_NOEXCEPT 5518 { 5519 std::size_t seed = 0; 5520 VULKAN_HPP_HASH_COMBINE( seed, imageCaptureDescriptorDataInfoEXT.sType ); 5521 VULKAN_HPP_HASH_COMBINE( seed, imageCaptureDescriptorDataInfoEXT.pNext ); 5522 VULKAN_HPP_HASH_COMBINE( seed, imageCaptureDescriptorDataInfoEXT.image ); 5523 return seed; 5524 } 5525 }; 5526 5527 template <> 5528 struct hash<VULKAN_HPP_NAMESPACE::ImageCompressionControlEXT> 5529 { operator ()std::hash5530 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageCompressionControlEXT const & imageCompressionControlEXT ) const VULKAN_HPP_NOEXCEPT 5531 { 5532 std::size_t seed = 0; 5533 VULKAN_HPP_HASH_COMBINE( seed, imageCompressionControlEXT.sType ); 5534 VULKAN_HPP_HASH_COMBINE( seed, imageCompressionControlEXT.pNext ); 5535 VULKAN_HPP_HASH_COMBINE( seed, imageCompressionControlEXT.flags ); 5536 VULKAN_HPP_HASH_COMBINE( seed, imageCompressionControlEXT.compressionControlPlaneCount ); 5537 VULKAN_HPP_HASH_COMBINE( seed, imageCompressionControlEXT.pFixedRateFlags ); 5538 return seed; 5539 } 5540 }; 5541 5542 template <> 5543 struct hash<VULKAN_HPP_NAMESPACE::ImageCompressionPropertiesEXT> 5544 { operator ()std::hash5545 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageCompressionPropertiesEXT const & imageCompressionPropertiesEXT ) const VULKAN_HPP_NOEXCEPT 5546 { 5547 std::size_t seed = 0; 5548 VULKAN_HPP_HASH_COMBINE( seed, imageCompressionPropertiesEXT.sType ); 5549 VULKAN_HPP_HASH_COMBINE( seed, imageCompressionPropertiesEXT.pNext ); 5550 VULKAN_HPP_HASH_COMBINE( seed, imageCompressionPropertiesEXT.imageCompressionFlags ); 5551 VULKAN_HPP_HASH_COMBINE( seed, imageCompressionPropertiesEXT.imageCompressionFixedRateFlags ); 5552 return seed; 5553 } 5554 }; 5555 5556 # if defined( VK_USE_PLATFORM_FUCHSIA ) 5557 template <> 5558 struct hash<VULKAN_HPP_NAMESPACE::ImageFormatConstraintsInfoFUCHSIA> 5559 { operator ()std::hash5560 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageFormatConstraintsInfoFUCHSIA const & imageFormatConstraintsInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT 5561 { 5562 std::size_t seed = 0; 5563 VULKAN_HPP_HASH_COMBINE( seed, imageFormatConstraintsInfoFUCHSIA.sType ); 5564 VULKAN_HPP_HASH_COMBINE( seed, imageFormatConstraintsInfoFUCHSIA.pNext ); 5565 VULKAN_HPP_HASH_COMBINE( seed, imageFormatConstraintsInfoFUCHSIA.imageCreateInfo ); 5566 VULKAN_HPP_HASH_COMBINE( seed, imageFormatConstraintsInfoFUCHSIA.requiredFormatFeatures ); 5567 VULKAN_HPP_HASH_COMBINE( seed, imageFormatConstraintsInfoFUCHSIA.flags ); 5568 VULKAN_HPP_HASH_COMBINE( seed, imageFormatConstraintsInfoFUCHSIA.sysmemPixelFormat ); 5569 VULKAN_HPP_HASH_COMBINE( seed, imageFormatConstraintsInfoFUCHSIA.colorSpaceCount ); 5570 VULKAN_HPP_HASH_COMBINE( seed, imageFormatConstraintsInfoFUCHSIA.pColorSpaces ); 5571 return seed; 5572 } 5573 }; 5574 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 5575 5576 # if defined( VK_USE_PLATFORM_FUCHSIA ) 5577 template <> 5578 struct hash<VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFUCHSIA> 5579 { operator ()std::hash5580 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFUCHSIA const & imageConstraintsInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT 5581 { 5582 std::size_t seed = 0; 5583 VULKAN_HPP_HASH_COMBINE( seed, imageConstraintsInfoFUCHSIA.sType ); 5584 VULKAN_HPP_HASH_COMBINE( seed, imageConstraintsInfoFUCHSIA.pNext ); 5585 VULKAN_HPP_HASH_COMBINE( seed, imageConstraintsInfoFUCHSIA.formatConstraintsCount ); 5586 VULKAN_HPP_HASH_COMBINE( seed, imageConstraintsInfoFUCHSIA.pFormatConstraints ); 5587 VULKAN_HPP_HASH_COMBINE( seed, imageConstraintsInfoFUCHSIA.bufferCollectionConstraints ); 5588 VULKAN_HPP_HASH_COMBINE( seed, imageConstraintsInfoFUCHSIA.flags ); 5589 return seed; 5590 } 5591 }; 5592 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 5593 5594 template <> 5595 struct hash<VULKAN_HPP_NAMESPACE::ImageCopy> 5596 { operator ()std::hash5597 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageCopy const & imageCopy ) const VULKAN_HPP_NOEXCEPT 5598 { 5599 std::size_t seed = 0; 5600 VULKAN_HPP_HASH_COMBINE( seed, imageCopy.srcSubresource ); 5601 VULKAN_HPP_HASH_COMBINE( seed, imageCopy.srcOffset ); 5602 VULKAN_HPP_HASH_COMBINE( seed, imageCopy.dstSubresource ); 5603 VULKAN_HPP_HASH_COMBINE( seed, imageCopy.dstOffset ); 5604 VULKAN_HPP_HASH_COMBINE( seed, imageCopy.extent ); 5605 return seed; 5606 } 5607 }; 5608 5609 template <> 5610 struct hash<VULKAN_HPP_NAMESPACE::SubresourceLayout> 5611 { operator ()std::hash5612 std::size_t operator()( VULKAN_HPP_NAMESPACE::SubresourceLayout const & subresourceLayout ) const VULKAN_HPP_NOEXCEPT 5613 { 5614 std::size_t seed = 0; 5615 VULKAN_HPP_HASH_COMBINE( seed, subresourceLayout.offset ); 5616 VULKAN_HPP_HASH_COMBINE( seed, subresourceLayout.size ); 5617 VULKAN_HPP_HASH_COMBINE( seed, subresourceLayout.rowPitch ); 5618 VULKAN_HPP_HASH_COMBINE( seed, subresourceLayout.arrayPitch ); 5619 VULKAN_HPP_HASH_COMBINE( seed, subresourceLayout.depthPitch ); 5620 return seed; 5621 } 5622 }; 5623 5624 template <> 5625 struct hash<VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierExplicitCreateInfoEXT> 5626 { operator ()std::hash5627 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierExplicitCreateInfoEXT const & imageDrmFormatModifierExplicitCreateInfoEXT ) const 5628 VULKAN_HPP_NOEXCEPT 5629 { 5630 std::size_t seed = 0; 5631 VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierExplicitCreateInfoEXT.sType ); 5632 VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierExplicitCreateInfoEXT.pNext ); 5633 VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierExplicitCreateInfoEXT.drmFormatModifier ); 5634 VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierExplicitCreateInfoEXT.drmFormatModifierPlaneCount ); 5635 VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierExplicitCreateInfoEXT.pPlaneLayouts ); 5636 return seed; 5637 } 5638 }; 5639 5640 template <> 5641 struct hash<VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierListCreateInfoEXT> 5642 { 5643 std::size_t operator ()std::hash5644 operator()( VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierListCreateInfoEXT const & imageDrmFormatModifierListCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 5645 { 5646 std::size_t seed = 0; 5647 VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierListCreateInfoEXT.sType ); 5648 VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierListCreateInfoEXT.pNext ); 5649 VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierListCreateInfoEXT.drmFormatModifierCount ); 5650 VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierListCreateInfoEXT.pDrmFormatModifiers ); 5651 return seed; 5652 } 5653 }; 5654 5655 template <> 5656 struct hash<VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT> 5657 { operator ()std::hash5658 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT const & imageDrmFormatModifierPropertiesEXT ) const VULKAN_HPP_NOEXCEPT 5659 { 5660 std::size_t seed = 0; 5661 VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierPropertiesEXT.sType ); 5662 VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierPropertiesEXT.pNext ); 5663 VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierPropertiesEXT.drmFormatModifier ); 5664 return seed; 5665 } 5666 }; 5667 5668 template <> 5669 struct hash<VULKAN_HPP_NAMESPACE::ImageFormatListCreateInfo> 5670 { operator ()std::hash5671 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageFormatListCreateInfo const & imageFormatListCreateInfo ) const VULKAN_HPP_NOEXCEPT 5672 { 5673 std::size_t seed = 0; 5674 VULKAN_HPP_HASH_COMBINE( seed, imageFormatListCreateInfo.sType ); 5675 VULKAN_HPP_HASH_COMBINE( seed, imageFormatListCreateInfo.pNext ); 5676 VULKAN_HPP_HASH_COMBINE( seed, imageFormatListCreateInfo.viewFormatCount ); 5677 VULKAN_HPP_HASH_COMBINE( seed, imageFormatListCreateInfo.pViewFormats ); 5678 return seed; 5679 } 5680 }; 5681 5682 template <> 5683 struct hash<VULKAN_HPP_NAMESPACE::ImageFormatProperties2> 5684 { operator ()std::hash5685 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageFormatProperties2 const & imageFormatProperties2 ) const VULKAN_HPP_NOEXCEPT 5686 { 5687 std::size_t seed = 0; 5688 VULKAN_HPP_HASH_COMBINE( seed, imageFormatProperties2.sType ); 5689 VULKAN_HPP_HASH_COMBINE( seed, imageFormatProperties2.pNext ); 5690 VULKAN_HPP_HASH_COMBINE( seed, imageFormatProperties2.imageFormatProperties ); 5691 return seed; 5692 } 5693 }; 5694 5695 template <> 5696 struct hash<VULKAN_HPP_NAMESPACE::ImageMemoryBarrier> 5697 { operator ()std::hash5698 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageMemoryBarrier const & imageMemoryBarrier ) const VULKAN_HPP_NOEXCEPT 5699 { 5700 std::size_t seed = 0; 5701 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.sType ); 5702 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.pNext ); 5703 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.srcAccessMask ); 5704 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.dstAccessMask ); 5705 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.oldLayout ); 5706 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.newLayout ); 5707 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.srcQueueFamilyIndex ); 5708 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.dstQueueFamilyIndex ); 5709 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.image ); 5710 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.subresourceRange ); 5711 return seed; 5712 } 5713 }; 5714 5715 template <> 5716 struct hash<VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2> 5717 { operator ()std::hash5718 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 const & imageMemoryRequirementsInfo2 ) const VULKAN_HPP_NOEXCEPT 5719 { 5720 std::size_t seed = 0; 5721 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryRequirementsInfo2.sType ); 5722 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryRequirementsInfo2.pNext ); 5723 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryRequirementsInfo2.image ); 5724 return seed; 5725 } 5726 }; 5727 5728 # if defined( VK_USE_PLATFORM_FUCHSIA ) 5729 template <> 5730 struct hash<VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA> 5731 { operator ()std::hash5732 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA const & imagePipeSurfaceCreateInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT 5733 { 5734 std::size_t seed = 0; 5735 VULKAN_HPP_HASH_COMBINE( seed, imagePipeSurfaceCreateInfoFUCHSIA.sType ); 5736 VULKAN_HPP_HASH_COMBINE( seed, imagePipeSurfaceCreateInfoFUCHSIA.pNext ); 5737 VULKAN_HPP_HASH_COMBINE( seed, imagePipeSurfaceCreateInfoFUCHSIA.flags ); 5738 VULKAN_HPP_HASH_COMBINE( seed, imagePipeSurfaceCreateInfoFUCHSIA.imagePipeHandle ); 5739 return seed; 5740 } 5741 }; 5742 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 5743 5744 template <> 5745 struct hash<VULKAN_HPP_NAMESPACE::ImagePlaneMemoryRequirementsInfo> 5746 { operator ()std::hash5747 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImagePlaneMemoryRequirementsInfo const & imagePlaneMemoryRequirementsInfo ) const VULKAN_HPP_NOEXCEPT 5748 { 5749 std::size_t seed = 0; 5750 VULKAN_HPP_HASH_COMBINE( seed, imagePlaneMemoryRequirementsInfo.sType ); 5751 VULKAN_HPP_HASH_COMBINE( seed, imagePlaneMemoryRequirementsInfo.pNext ); 5752 VULKAN_HPP_HASH_COMBINE( seed, imagePlaneMemoryRequirementsInfo.planeAspect ); 5753 return seed; 5754 } 5755 }; 5756 5757 template <> 5758 struct hash<VULKAN_HPP_NAMESPACE::ImageResolve> 5759 { operator ()std::hash5760 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageResolve const & imageResolve ) const VULKAN_HPP_NOEXCEPT 5761 { 5762 std::size_t seed = 0; 5763 VULKAN_HPP_HASH_COMBINE( seed, imageResolve.srcSubresource ); 5764 VULKAN_HPP_HASH_COMBINE( seed, imageResolve.srcOffset ); 5765 VULKAN_HPP_HASH_COMBINE( seed, imageResolve.dstSubresource ); 5766 VULKAN_HPP_HASH_COMBINE( seed, imageResolve.dstOffset ); 5767 VULKAN_HPP_HASH_COMBINE( seed, imageResolve.extent ); 5768 return seed; 5769 } 5770 }; 5771 5772 template <> 5773 struct hash<VULKAN_HPP_NAMESPACE::ImageResolve2> 5774 { operator ()std::hash5775 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageResolve2 const & imageResolve2 ) const VULKAN_HPP_NOEXCEPT 5776 { 5777 std::size_t seed = 0; 5778 VULKAN_HPP_HASH_COMBINE( seed, imageResolve2.sType ); 5779 VULKAN_HPP_HASH_COMBINE( seed, imageResolve2.pNext ); 5780 VULKAN_HPP_HASH_COMBINE( seed, imageResolve2.srcSubresource ); 5781 VULKAN_HPP_HASH_COMBINE( seed, imageResolve2.srcOffset ); 5782 VULKAN_HPP_HASH_COMBINE( seed, imageResolve2.dstSubresource ); 5783 VULKAN_HPP_HASH_COMBINE( seed, imageResolve2.dstOffset ); 5784 VULKAN_HPP_HASH_COMBINE( seed, imageResolve2.extent ); 5785 return seed; 5786 } 5787 }; 5788 5789 template <> 5790 struct hash<VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2> 5791 { operator ()std::hash5792 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 const & imageSparseMemoryRequirementsInfo2 ) const VULKAN_HPP_NOEXCEPT 5793 { 5794 std::size_t seed = 0; 5795 VULKAN_HPP_HASH_COMBINE( seed, imageSparseMemoryRequirementsInfo2.sType ); 5796 VULKAN_HPP_HASH_COMBINE( seed, imageSparseMemoryRequirementsInfo2.pNext ); 5797 VULKAN_HPP_HASH_COMBINE( seed, imageSparseMemoryRequirementsInfo2.image ); 5798 return seed; 5799 } 5800 }; 5801 5802 template <> 5803 struct hash<VULKAN_HPP_NAMESPACE::ImageStencilUsageCreateInfo> 5804 { operator ()std::hash5805 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageStencilUsageCreateInfo const & imageStencilUsageCreateInfo ) const VULKAN_HPP_NOEXCEPT 5806 { 5807 std::size_t seed = 0; 5808 VULKAN_HPP_HASH_COMBINE( seed, imageStencilUsageCreateInfo.sType ); 5809 VULKAN_HPP_HASH_COMBINE( seed, imageStencilUsageCreateInfo.pNext ); 5810 VULKAN_HPP_HASH_COMBINE( seed, imageStencilUsageCreateInfo.stencilUsage ); 5811 return seed; 5812 } 5813 }; 5814 5815 template <> 5816 struct hash<VULKAN_HPP_NAMESPACE::ImageSwapchainCreateInfoKHR> 5817 { operator ()std::hash5818 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageSwapchainCreateInfoKHR const & imageSwapchainCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 5819 { 5820 std::size_t seed = 0; 5821 VULKAN_HPP_HASH_COMBINE( seed, imageSwapchainCreateInfoKHR.sType ); 5822 VULKAN_HPP_HASH_COMBINE( seed, imageSwapchainCreateInfoKHR.pNext ); 5823 VULKAN_HPP_HASH_COMBINE( seed, imageSwapchainCreateInfoKHR.swapchain ); 5824 return seed; 5825 } 5826 }; 5827 5828 template <> 5829 struct hash<VULKAN_HPP_NAMESPACE::ImageViewASTCDecodeModeEXT> 5830 { operator ()std::hash5831 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewASTCDecodeModeEXT const & imageViewASTCDecodeModeEXT ) const VULKAN_HPP_NOEXCEPT 5832 { 5833 std::size_t seed = 0; 5834 VULKAN_HPP_HASH_COMBINE( seed, imageViewASTCDecodeModeEXT.sType ); 5835 VULKAN_HPP_HASH_COMBINE( seed, imageViewASTCDecodeModeEXT.pNext ); 5836 VULKAN_HPP_HASH_COMBINE( seed, imageViewASTCDecodeModeEXT.decodeMode ); 5837 return seed; 5838 } 5839 }; 5840 5841 template <> 5842 struct hash<VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX> 5843 { operator ()std::hash5844 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX const & imageViewAddressPropertiesNVX ) const VULKAN_HPP_NOEXCEPT 5845 { 5846 std::size_t seed = 0; 5847 VULKAN_HPP_HASH_COMBINE( seed, imageViewAddressPropertiesNVX.sType ); 5848 VULKAN_HPP_HASH_COMBINE( seed, imageViewAddressPropertiesNVX.pNext ); 5849 VULKAN_HPP_HASH_COMBINE( seed, imageViewAddressPropertiesNVX.deviceAddress ); 5850 VULKAN_HPP_HASH_COMBINE( seed, imageViewAddressPropertiesNVX.size ); 5851 return seed; 5852 } 5853 }; 5854 5855 template <> 5856 struct hash<VULKAN_HPP_NAMESPACE::ImageViewCaptureDescriptorDataInfoEXT> 5857 { 5858 std::size_t operator ()std::hash5859 operator()( VULKAN_HPP_NAMESPACE::ImageViewCaptureDescriptorDataInfoEXT const & imageViewCaptureDescriptorDataInfoEXT ) const VULKAN_HPP_NOEXCEPT 5860 { 5861 std::size_t seed = 0; 5862 VULKAN_HPP_HASH_COMBINE( seed, imageViewCaptureDescriptorDataInfoEXT.sType ); 5863 VULKAN_HPP_HASH_COMBINE( seed, imageViewCaptureDescriptorDataInfoEXT.pNext ); 5864 VULKAN_HPP_HASH_COMBINE( seed, imageViewCaptureDescriptorDataInfoEXT.imageView ); 5865 return seed; 5866 } 5867 }; 5868 5869 template <> 5870 struct hash<VULKAN_HPP_NAMESPACE::ImageViewCreateInfo> 5871 { operator ()std::hash5872 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewCreateInfo const & imageViewCreateInfo ) const VULKAN_HPP_NOEXCEPT 5873 { 5874 std::size_t seed = 0; 5875 VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.sType ); 5876 VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.pNext ); 5877 VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.flags ); 5878 VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.image ); 5879 VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.viewType ); 5880 VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.format ); 5881 VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.components ); 5882 VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.subresourceRange ); 5883 return seed; 5884 } 5885 }; 5886 5887 template <> 5888 struct hash<VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX> 5889 { operator ()std::hash5890 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX const & imageViewHandleInfoNVX ) const VULKAN_HPP_NOEXCEPT 5891 { 5892 std::size_t seed = 0; 5893 VULKAN_HPP_HASH_COMBINE( seed, imageViewHandleInfoNVX.sType ); 5894 VULKAN_HPP_HASH_COMBINE( seed, imageViewHandleInfoNVX.pNext ); 5895 VULKAN_HPP_HASH_COMBINE( seed, imageViewHandleInfoNVX.imageView ); 5896 VULKAN_HPP_HASH_COMBINE( seed, imageViewHandleInfoNVX.descriptorType ); 5897 VULKAN_HPP_HASH_COMBINE( seed, imageViewHandleInfoNVX.sampler ); 5898 return seed; 5899 } 5900 }; 5901 5902 template <> 5903 struct hash<VULKAN_HPP_NAMESPACE::ImageViewMinLodCreateInfoEXT> 5904 { operator ()std::hash5905 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewMinLodCreateInfoEXT const & imageViewMinLodCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 5906 { 5907 std::size_t seed = 0; 5908 VULKAN_HPP_HASH_COMBINE( seed, imageViewMinLodCreateInfoEXT.sType ); 5909 VULKAN_HPP_HASH_COMBINE( seed, imageViewMinLodCreateInfoEXT.pNext ); 5910 VULKAN_HPP_HASH_COMBINE( seed, imageViewMinLodCreateInfoEXT.minLod ); 5911 return seed; 5912 } 5913 }; 5914 5915 template <> 5916 struct hash<VULKAN_HPP_NAMESPACE::ImageViewSampleWeightCreateInfoQCOM> 5917 { operator ()std::hash5918 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewSampleWeightCreateInfoQCOM const & imageViewSampleWeightCreateInfoQCOM ) const VULKAN_HPP_NOEXCEPT 5919 { 5920 std::size_t seed = 0; 5921 VULKAN_HPP_HASH_COMBINE( seed, imageViewSampleWeightCreateInfoQCOM.sType ); 5922 VULKAN_HPP_HASH_COMBINE( seed, imageViewSampleWeightCreateInfoQCOM.pNext ); 5923 VULKAN_HPP_HASH_COMBINE( seed, imageViewSampleWeightCreateInfoQCOM.filterCenter ); 5924 VULKAN_HPP_HASH_COMBINE( seed, imageViewSampleWeightCreateInfoQCOM.filterSize ); 5925 VULKAN_HPP_HASH_COMBINE( seed, imageViewSampleWeightCreateInfoQCOM.numPhases ); 5926 return seed; 5927 } 5928 }; 5929 5930 template <> 5931 struct hash<VULKAN_HPP_NAMESPACE::ImageViewSlicedCreateInfoEXT> 5932 { operator ()std::hash5933 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewSlicedCreateInfoEXT const & imageViewSlicedCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 5934 { 5935 std::size_t seed = 0; 5936 VULKAN_HPP_HASH_COMBINE( seed, imageViewSlicedCreateInfoEXT.sType ); 5937 VULKAN_HPP_HASH_COMBINE( seed, imageViewSlicedCreateInfoEXT.pNext ); 5938 VULKAN_HPP_HASH_COMBINE( seed, imageViewSlicedCreateInfoEXT.sliceOffset ); 5939 VULKAN_HPP_HASH_COMBINE( seed, imageViewSlicedCreateInfoEXT.sliceCount ); 5940 return seed; 5941 } 5942 }; 5943 5944 template <> 5945 struct hash<VULKAN_HPP_NAMESPACE::ImageViewUsageCreateInfo> 5946 { operator ()std::hash5947 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewUsageCreateInfo const & imageViewUsageCreateInfo ) const VULKAN_HPP_NOEXCEPT 5948 { 5949 std::size_t seed = 0; 5950 VULKAN_HPP_HASH_COMBINE( seed, imageViewUsageCreateInfo.sType ); 5951 VULKAN_HPP_HASH_COMBINE( seed, imageViewUsageCreateInfo.pNext ); 5952 VULKAN_HPP_HASH_COMBINE( seed, imageViewUsageCreateInfo.usage ); 5953 return seed; 5954 } 5955 }; 5956 5957 # if defined( VK_USE_PLATFORM_ANDROID_KHR ) 5958 template <> 5959 struct hash<VULKAN_HPP_NAMESPACE::ImportAndroidHardwareBufferInfoANDROID> 5960 { 5961 std::size_t operator ()std::hash5962 operator()( VULKAN_HPP_NAMESPACE::ImportAndroidHardwareBufferInfoANDROID const & importAndroidHardwareBufferInfoANDROID ) const VULKAN_HPP_NOEXCEPT 5963 { 5964 std::size_t seed = 0; 5965 VULKAN_HPP_HASH_COMBINE( seed, importAndroidHardwareBufferInfoANDROID.sType ); 5966 VULKAN_HPP_HASH_COMBINE( seed, importAndroidHardwareBufferInfoANDROID.pNext ); 5967 VULKAN_HPP_HASH_COMBINE( seed, importAndroidHardwareBufferInfoANDROID.buffer ); 5968 return seed; 5969 } 5970 }; 5971 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ 5972 5973 template <> 5974 struct hash<VULKAN_HPP_NAMESPACE::ImportFenceFdInfoKHR> 5975 { operator ()std::hash5976 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportFenceFdInfoKHR const & importFenceFdInfoKHR ) const VULKAN_HPP_NOEXCEPT 5977 { 5978 std::size_t seed = 0; 5979 VULKAN_HPP_HASH_COMBINE( seed, importFenceFdInfoKHR.sType ); 5980 VULKAN_HPP_HASH_COMBINE( seed, importFenceFdInfoKHR.pNext ); 5981 VULKAN_HPP_HASH_COMBINE( seed, importFenceFdInfoKHR.fence ); 5982 VULKAN_HPP_HASH_COMBINE( seed, importFenceFdInfoKHR.flags ); 5983 VULKAN_HPP_HASH_COMBINE( seed, importFenceFdInfoKHR.handleType ); 5984 VULKAN_HPP_HASH_COMBINE( seed, importFenceFdInfoKHR.fd ); 5985 return seed; 5986 } 5987 }; 5988 5989 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 5990 template <> 5991 struct hash<VULKAN_HPP_NAMESPACE::ImportFenceWin32HandleInfoKHR> 5992 { operator ()std::hash5993 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportFenceWin32HandleInfoKHR const & importFenceWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT 5994 { 5995 std::size_t seed = 0; 5996 VULKAN_HPP_HASH_COMBINE( seed, importFenceWin32HandleInfoKHR.sType ); 5997 VULKAN_HPP_HASH_COMBINE( seed, importFenceWin32HandleInfoKHR.pNext ); 5998 VULKAN_HPP_HASH_COMBINE( seed, importFenceWin32HandleInfoKHR.fence ); 5999 VULKAN_HPP_HASH_COMBINE( seed, importFenceWin32HandleInfoKHR.flags ); 6000 VULKAN_HPP_HASH_COMBINE( seed, importFenceWin32HandleInfoKHR.handleType ); 6001 VULKAN_HPP_HASH_COMBINE( seed, importFenceWin32HandleInfoKHR.handle ); 6002 VULKAN_HPP_HASH_COMBINE( seed, importFenceWin32HandleInfoKHR.name ); 6003 return seed; 6004 } 6005 }; 6006 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 6007 6008 # if defined( VK_USE_PLATFORM_FUCHSIA ) 6009 template <> 6010 struct hash<VULKAN_HPP_NAMESPACE::ImportMemoryBufferCollectionFUCHSIA> 6011 { operator ()std::hash6012 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMemoryBufferCollectionFUCHSIA const & importMemoryBufferCollectionFUCHSIA ) const VULKAN_HPP_NOEXCEPT 6013 { 6014 std::size_t seed = 0; 6015 VULKAN_HPP_HASH_COMBINE( seed, importMemoryBufferCollectionFUCHSIA.sType ); 6016 VULKAN_HPP_HASH_COMBINE( seed, importMemoryBufferCollectionFUCHSIA.pNext ); 6017 VULKAN_HPP_HASH_COMBINE( seed, importMemoryBufferCollectionFUCHSIA.collection ); 6018 VULKAN_HPP_HASH_COMBINE( seed, importMemoryBufferCollectionFUCHSIA.index ); 6019 return seed; 6020 } 6021 }; 6022 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 6023 6024 template <> 6025 struct hash<VULKAN_HPP_NAMESPACE::ImportMemoryFdInfoKHR> 6026 { operator ()std::hash6027 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMemoryFdInfoKHR const & importMemoryFdInfoKHR ) const VULKAN_HPP_NOEXCEPT 6028 { 6029 std::size_t seed = 0; 6030 VULKAN_HPP_HASH_COMBINE( seed, importMemoryFdInfoKHR.sType ); 6031 VULKAN_HPP_HASH_COMBINE( seed, importMemoryFdInfoKHR.pNext ); 6032 VULKAN_HPP_HASH_COMBINE( seed, importMemoryFdInfoKHR.handleType ); 6033 VULKAN_HPP_HASH_COMBINE( seed, importMemoryFdInfoKHR.fd ); 6034 return seed; 6035 } 6036 }; 6037 6038 template <> 6039 struct hash<VULKAN_HPP_NAMESPACE::ImportMemoryHostPointerInfoEXT> 6040 { operator ()std::hash6041 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMemoryHostPointerInfoEXT const & importMemoryHostPointerInfoEXT ) const VULKAN_HPP_NOEXCEPT 6042 { 6043 std::size_t seed = 0; 6044 VULKAN_HPP_HASH_COMBINE( seed, importMemoryHostPointerInfoEXT.sType ); 6045 VULKAN_HPP_HASH_COMBINE( seed, importMemoryHostPointerInfoEXT.pNext ); 6046 VULKAN_HPP_HASH_COMBINE( seed, importMemoryHostPointerInfoEXT.handleType ); 6047 VULKAN_HPP_HASH_COMBINE( seed, importMemoryHostPointerInfoEXT.pHostPointer ); 6048 return seed; 6049 } 6050 }; 6051 6052 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 6053 template <> 6054 struct hash<VULKAN_HPP_NAMESPACE::ImportMemoryWin32HandleInfoKHR> 6055 { operator ()std::hash6056 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMemoryWin32HandleInfoKHR const & importMemoryWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT 6057 { 6058 std::size_t seed = 0; 6059 VULKAN_HPP_HASH_COMBINE( seed, importMemoryWin32HandleInfoKHR.sType ); 6060 VULKAN_HPP_HASH_COMBINE( seed, importMemoryWin32HandleInfoKHR.pNext ); 6061 VULKAN_HPP_HASH_COMBINE( seed, importMemoryWin32HandleInfoKHR.handleType ); 6062 VULKAN_HPP_HASH_COMBINE( seed, importMemoryWin32HandleInfoKHR.handle ); 6063 VULKAN_HPP_HASH_COMBINE( seed, importMemoryWin32HandleInfoKHR.name ); 6064 return seed; 6065 } 6066 }; 6067 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 6068 6069 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 6070 template <> 6071 struct hash<VULKAN_HPP_NAMESPACE::ImportMemoryWin32HandleInfoNV> 6072 { operator ()std::hash6073 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMemoryWin32HandleInfoNV const & importMemoryWin32HandleInfoNV ) const VULKAN_HPP_NOEXCEPT 6074 { 6075 std::size_t seed = 0; 6076 VULKAN_HPP_HASH_COMBINE( seed, importMemoryWin32HandleInfoNV.sType ); 6077 VULKAN_HPP_HASH_COMBINE( seed, importMemoryWin32HandleInfoNV.pNext ); 6078 VULKAN_HPP_HASH_COMBINE( seed, importMemoryWin32HandleInfoNV.handleType ); 6079 VULKAN_HPP_HASH_COMBINE( seed, importMemoryWin32HandleInfoNV.handle ); 6080 return seed; 6081 } 6082 }; 6083 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 6084 6085 # if defined( VK_USE_PLATFORM_FUCHSIA ) 6086 template <> 6087 struct hash<VULKAN_HPP_NAMESPACE::ImportMemoryZirconHandleInfoFUCHSIA> 6088 { operator ()std::hash6089 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMemoryZirconHandleInfoFUCHSIA const & importMemoryZirconHandleInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT 6090 { 6091 std::size_t seed = 0; 6092 VULKAN_HPP_HASH_COMBINE( seed, importMemoryZirconHandleInfoFUCHSIA.sType ); 6093 VULKAN_HPP_HASH_COMBINE( seed, importMemoryZirconHandleInfoFUCHSIA.pNext ); 6094 VULKAN_HPP_HASH_COMBINE( seed, importMemoryZirconHandleInfoFUCHSIA.handleType ); 6095 VULKAN_HPP_HASH_COMBINE( seed, importMemoryZirconHandleInfoFUCHSIA.handle ); 6096 return seed; 6097 } 6098 }; 6099 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 6100 6101 # if defined( VK_USE_PLATFORM_METAL_EXT ) 6102 template <> 6103 struct hash<VULKAN_HPP_NAMESPACE::ImportMetalBufferInfoEXT> 6104 { operator ()std::hash6105 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMetalBufferInfoEXT const & importMetalBufferInfoEXT ) const VULKAN_HPP_NOEXCEPT 6106 { 6107 std::size_t seed = 0; 6108 VULKAN_HPP_HASH_COMBINE( seed, importMetalBufferInfoEXT.sType ); 6109 VULKAN_HPP_HASH_COMBINE( seed, importMetalBufferInfoEXT.pNext ); 6110 VULKAN_HPP_HASH_COMBINE( seed, importMetalBufferInfoEXT.mtlBuffer ); 6111 return seed; 6112 } 6113 }; 6114 # endif /*VK_USE_PLATFORM_METAL_EXT*/ 6115 6116 # if defined( VK_USE_PLATFORM_METAL_EXT ) 6117 template <> 6118 struct hash<VULKAN_HPP_NAMESPACE::ImportMetalIOSurfaceInfoEXT> 6119 { operator ()std::hash6120 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMetalIOSurfaceInfoEXT const & importMetalIOSurfaceInfoEXT ) const VULKAN_HPP_NOEXCEPT 6121 { 6122 std::size_t seed = 0; 6123 VULKAN_HPP_HASH_COMBINE( seed, importMetalIOSurfaceInfoEXT.sType ); 6124 VULKAN_HPP_HASH_COMBINE( seed, importMetalIOSurfaceInfoEXT.pNext ); 6125 VULKAN_HPP_HASH_COMBINE( seed, importMetalIOSurfaceInfoEXT.ioSurface ); 6126 return seed; 6127 } 6128 }; 6129 # endif /*VK_USE_PLATFORM_METAL_EXT*/ 6130 6131 # if defined( VK_USE_PLATFORM_METAL_EXT ) 6132 template <> 6133 struct hash<VULKAN_HPP_NAMESPACE::ImportMetalSharedEventInfoEXT> 6134 { operator ()std::hash6135 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMetalSharedEventInfoEXT const & importMetalSharedEventInfoEXT ) const VULKAN_HPP_NOEXCEPT 6136 { 6137 std::size_t seed = 0; 6138 VULKAN_HPP_HASH_COMBINE( seed, importMetalSharedEventInfoEXT.sType ); 6139 VULKAN_HPP_HASH_COMBINE( seed, importMetalSharedEventInfoEXT.pNext ); 6140 VULKAN_HPP_HASH_COMBINE( seed, importMetalSharedEventInfoEXT.mtlSharedEvent ); 6141 return seed; 6142 } 6143 }; 6144 # endif /*VK_USE_PLATFORM_METAL_EXT*/ 6145 6146 # if defined( VK_USE_PLATFORM_METAL_EXT ) 6147 template <> 6148 struct hash<VULKAN_HPP_NAMESPACE::ImportMetalTextureInfoEXT> 6149 { operator ()std::hash6150 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMetalTextureInfoEXT const & importMetalTextureInfoEXT ) const VULKAN_HPP_NOEXCEPT 6151 { 6152 std::size_t seed = 0; 6153 VULKAN_HPP_HASH_COMBINE( seed, importMetalTextureInfoEXT.sType ); 6154 VULKAN_HPP_HASH_COMBINE( seed, importMetalTextureInfoEXT.pNext ); 6155 VULKAN_HPP_HASH_COMBINE( seed, importMetalTextureInfoEXT.plane ); 6156 VULKAN_HPP_HASH_COMBINE( seed, importMetalTextureInfoEXT.mtlTexture ); 6157 return seed; 6158 } 6159 }; 6160 # endif /*VK_USE_PLATFORM_METAL_EXT*/ 6161 6162 # if defined( VK_USE_PLATFORM_SCREEN_QNX ) 6163 template <> 6164 struct hash<VULKAN_HPP_NAMESPACE::ImportScreenBufferInfoQNX> 6165 { operator ()std::hash6166 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportScreenBufferInfoQNX const & importScreenBufferInfoQNX ) const VULKAN_HPP_NOEXCEPT 6167 { 6168 std::size_t seed = 0; 6169 VULKAN_HPP_HASH_COMBINE( seed, importScreenBufferInfoQNX.sType ); 6170 VULKAN_HPP_HASH_COMBINE( seed, importScreenBufferInfoQNX.pNext ); 6171 VULKAN_HPP_HASH_COMBINE( seed, importScreenBufferInfoQNX.buffer ); 6172 return seed; 6173 } 6174 }; 6175 # endif /*VK_USE_PLATFORM_SCREEN_QNX*/ 6176 6177 template <> 6178 struct hash<VULKAN_HPP_NAMESPACE::ImportSemaphoreFdInfoKHR> 6179 { operator ()std::hash6180 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportSemaphoreFdInfoKHR const & importSemaphoreFdInfoKHR ) const VULKAN_HPP_NOEXCEPT 6181 { 6182 std::size_t seed = 0; 6183 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreFdInfoKHR.sType ); 6184 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreFdInfoKHR.pNext ); 6185 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreFdInfoKHR.semaphore ); 6186 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreFdInfoKHR.flags ); 6187 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreFdInfoKHR.handleType ); 6188 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreFdInfoKHR.fd ); 6189 return seed; 6190 } 6191 }; 6192 6193 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 6194 template <> 6195 struct hash<VULKAN_HPP_NAMESPACE::ImportSemaphoreWin32HandleInfoKHR> 6196 { operator ()std::hash6197 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportSemaphoreWin32HandleInfoKHR const & importSemaphoreWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT 6198 { 6199 std::size_t seed = 0; 6200 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreWin32HandleInfoKHR.sType ); 6201 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreWin32HandleInfoKHR.pNext ); 6202 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreWin32HandleInfoKHR.semaphore ); 6203 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreWin32HandleInfoKHR.flags ); 6204 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreWin32HandleInfoKHR.handleType ); 6205 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreWin32HandleInfoKHR.handle ); 6206 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreWin32HandleInfoKHR.name ); 6207 return seed; 6208 } 6209 }; 6210 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 6211 6212 # if defined( VK_USE_PLATFORM_FUCHSIA ) 6213 template <> 6214 struct hash<VULKAN_HPP_NAMESPACE::ImportSemaphoreZirconHandleInfoFUCHSIA> 6215 { 6216 std::size_t operator ()std::hash6217 operator()( VULKAN_HPP_NAMESPACE::ImportSemaphoreZirconHandleInfoFUCHSIA const & importSemaphoreZirconHandleInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT 6218 { 6219 std::size_t seed = 0; 6220 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreZirconHandleInfoFUCHSIA.sType ); 6221 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreZirconHandleInfoFUCHSIA.pNext ); 6222 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreZirconHandleInfoFUCHSIA.semaphore ); 6223 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreZirconHandleInfoFUCHSIA.flags ); 6224 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreZirconHandleInfoFUCHSIA.handleType ); 6225 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreZirconHandleInfoFUCHSIA.zirconHandle ); 6226 return seed; 6227 } 6228 }; 6229 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 6230 6231 template <> 6232 struct hash<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutTokenNV> 6233 { operator ()std::hash6234 std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutTokenNV const & indirectCommandsLayoutTokenNV ) const VULKAN_HPP_NOEXCEPT 6235 { 6236 std::size_t seed = 0; 6237 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.sType ); 6238 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.pNext ); 6239 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.tokenType ); 6240 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.stream ); 6241 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.offset ); 6242 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.vertexBindingUnit ); 6243 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.vertexDynamicStride ); 6244 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.pushconstantPipelineLayout ); 6245 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.pushconstantShaderStageFlags ); 6246 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.pushconstantOffset ); 6247 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.pushconstantSize ); 6248 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.indirectStateFlags ); 6249 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.indexTypeCount ); 6250 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.pIndexTypes ); 6251 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.pIndexTypeValues ); 6252 return seed; 6253 } 6254 }; 6255 6256 template <> 6257 struct hash<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV> 6258 { operator ()std::hash6259 std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV const & indirectCommandsLayoutCreateInfoNV ) const VULKAN_HPP_NOEXCEPT 6260 { 6261 std::size_t seed = 0; 6262 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoNV.sType ); 6263 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoNV.pNext ); 6264 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoNV.flags ); 6265 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoNV.pipelineBindPoint ); 6266 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoNV.tokenCount ); 6267 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoNV.pTokens ); 6268 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoNV.streamCount ); 6269 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoNV.pStreamStrides ); 6270 return seed; 6271 } 6272 }; 6273 6274 template <> 6275 struct hash<VULKAN_HPP_NAMESPACE::InitializePerformanceApiInfoINTEL> 6276 { operator ()std::hash6277 std::size_t operator()( VULKAN_HPP_NAMESPACE::InitializePerformanceApiInfoINTEL const & initializePerformanceApiInfoINTEL ) const VULKAN_HPP_NOEXCEPT 6278 { 6279 std::size_t seed = 0; 6280 VULKAN_HPP_HASH_COMBINE( seed, initializePerformanceApiInfoINTEL.sType ); 6281 VULKAN_HPP_HASH_COMBINE( seed, initializePerformanceApiInfoINTEL.pNext ); 6282 VULKAN_HPP_HASH_COMBINE( seed, initializePerformanceApiInfoINTEL.pUserData ); 6283 return seed; 6284 } 6285 }; 6286 6287 template <> 6288 struct hash<VULKAN_HPP_NAMESPACE::InputAttachmentAspectReference> 6289 { operator ()std::hash6290 std::size_t operator()( VULKAN_HPP_NAMESPACE::InputAttachmentAspectReference const & inputAttachmentAspectReference ) const VULKAN_HPP_NOEXCEPT 6291 { 6292 std::size_t seed = 0; 6293 VULKAN_HPP_HASH_COMBINE( seed, inputAttachmentAspectReference.subpass ); 6294 VULKAN_HPP_HASH_COMBINE( seed, inputAttachmentAspectReference.inputAttachmentIndex ); 6295 VULKAN_HPP_HASH_COMBINE( seed, inputAttachmentAspectReference.aspectMask ); 6296 return seed; 6297 } 6298 }; 6299 6300 template <> 6301 struct hash<VULKAN_HPP_NAMESPACE::InstanceCreateInfo> 6302 { operator ()std::hash6303 std::size_t operator()( VULKAN_HPP_NAMESPACE::InstanceCreateInfo const & instanceCreateInfo ) const VULKAN_HPP_NOEXCEPT 6304 { 6305 std::size_t seed = 0; 6306 VULKAN_HPP_HASH_COMBINE( seed, instanceCreateInfo.sType ); 6307 VULKAN_HPP_HASH_COMBINE( seed, instanceCreateInfo.pNext ); 6308 VULKAN_HPP_HASH_COMBINE( seed, instanceCreateInfo.flags ); 6309 VULKAN_HPP_HASH_COMBINE( seed, instanceCreateInfo.pApplicationInfo ); 6310 VULKAN_HPP_HASH_COMBINE( seed, instanceCreateInfo.enabledLayerCount ); 6311 for ( size_t i = 0; i < instanceCreateInfo.enabledLayerCount; ++i ) 6312 { 6313 for ( const char * p = instanceCreateInfo.ppEnabledLayerNames[i]; *p != '\0'; ++p ) 6314 { 6315 VULKAN_HPP_HASH_COMBINE( seed, *p ); 6316 } 6317 } 6318 VULKAN_HPP_HASH_COMBINE( seed, instanceCreateInfo.enabledExtensionCount ); 6319 for ( size_t i = 0; i < instanceCreateInfo.enabledExtensionCount; ++i ) 6320 { 6321 for ( const char * p = instanceCreateInfo.ppEnabledExtensionNames[i]; *p != '\0'; ++p ) 6322 { 6323 VULKAN_HPP_HASH_COMBINE( seed, *p ); 6324 } 6325 } 6326 return seed; 6327 } 6328 }; 6329 6330 template <> 6331 struct hash<VULKAN_HPP_NAMESPACE::LatencySleepInfoNV> 6332 { operator ()std::hash6333 std::size_t operator()( VULKAN_HPP_NAMESPACE::LatencySleepInfoNV const & latencySleepInfoNV ) const VULKAN_HPP_NOEXCEPT 6334 { 6335 std::size_t seed = 0; 6336 VULKAN_HPP_HASH_COMBINE( seed, latencySleepInfoNV.sType ); 6337 VULKAN_HPP_HASH_COMBINE( seed, latencySleepInfoNV.pNext ); 6338 VULKAN_HPP_HASH_COMBINE( seed, latencySleepInfoNV.signalSemaphore ); 6339 VULKAN_HPP_HASH_COMBINE( seed, latencySleepInfoNV.value ); 6340 return seed; 6341 } 6342 }; 6343 6344 template <> 6345 struct hash<VULKAN_HPP_NAMESPACE::LatencySleepModeInfoNV> 6346 { operator ()std::hash6347 std::size_t operator()( VULKAN_HPP_NAMESPACE::LatencySleepModeInfoNV const & latencySleepModeInfoNV ) const VULKAN_HPP_NOEXCEPT 6348 { 6349 std::size_t seed = 0; 6350 VULKAN_HPP_HASH_COMBINE( seed, latencySleepModeInfoNV.sType ); 6351 VULKAN_HPP_HASH_COMBINE( seed, latencySleepModeInfoNV.pNext ); 6352 VULKAN_HPP_HASH_COMBINE( seed, latencySleepModeInfoNV.lowLatencyMode ); 6353 VULKAN_HPP_HASH_COMBINE( seed, latencySleepModeInfoNV.lowLatencyBoost ); 6354 VULKAN_HPP_HASH_COMBINE( seed, latencySleepModeInfoNV.minimumIntervalUs ); 6355 return seed; 6356 } 6357 }; 6358 6359 template <> 6360 struct hash<VULKAN_HPP_NAMESPACE::LatencySubmissionPresentIdNV> 6361 { operator ()std::hash6362 std::size_t operator()( VULKAN_HPP_NAMESPACE::LatencySubmissionPresentIdNV const & latencySubmissionPresentIdNV ) const VULKAN_HPP_NOEXCEPT 6363 { 6364 std::size_t seed = 0; 6365 VULKAN_HPP_HASH_COMBINE( seed, latencySubmissionPresentIdNV.sType ); 6366 VULKAN_HPP_HASH_COMBINE( seed, latencySubmissionPresentIdNV.pNext ); 6367 VULKAN_HPP_HASH_COMBINE( seed, latencySubmissionPresentIdNV.presentID ); 6368 return seed; 6369 } 6370 }; 6371 6372 template <> 6373 struct hash<VULKAN_HPP_NAMESPACE::LatencySurfaceCapabilitiesNV> 6374 { operator ()std::hash6375 std::size_t operator()( VULKAN_HPP_NAMESPACE::LatencySurfaceCapabilitiesNV const & latencySurfaceCapabilitiesNV ) const VULKAN_HPP_NOEXCEPT 6376 { 6377 std::size_t seed = 0; 6378 VULKAN_HPP_HASH_COMBINE( seed, latencySurfaceCapabilitiesNV.sType ); 6379 VULKAN_HPP_HASH_COMBINE( seed, latencySurfaceCapabilitiesNV.pNext ); 6380 VULKAN_HPP_HASH_COMBINE( seed, latencySurfaceCapabilitiesNV.presentModeCount ); 6381 VULKAN_HPP_HASH_COMBINE( seed, latencySurfaceCapabilitiesNV.pPresentModes ); 6382 return seed; 6383 } 6384 }; 6385 6386 template <> 6387 struct hash<VULKAN_HPP_NAMESPACE::LayerProperties> 6388 { operator ()std::hash6389 std::size_t operator()( VULKAN_HPP_NAMESPACE::LayerProperties const & layerProperties ) const VULKAN_HPP_NOEXCEPT 6390 { 6391 std::size_t seed = 0; 6392 for ( size_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i ) 6393 { 6394 VULKAN_HPP_HASH_COMBINE( seed, layerProperties.layerName[i] ); 6395 } 6396 VULKAN_HPP_HASH_COMBINE( seed, layerProperties.specVersion ); 6397 VULKAN_HPP_HASH_COMBINE( seed, layerProperties.implementationVersion ); 6398 for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) 6399 { 6400 VULKAN_HPP_HASH_COMBINE( seed, layerProperties.description[i] ); 6401 } 6402 return seed; 6403 } 6404 }; 6405 6406 # if defined( VK_USE_PLATFORM_MACOS_MVK ) 6407 template <> 6408 struct hash<VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK> 6409 { operator ()std::hash6410 std::size_t operator()( VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK const & macOSSurfaceCreateInfoMVK ) const VULKAN_HPP_NOEXCEPT 6411 { 6412 std::size_t seed = 0; 6413 VULKAN_HPP_HASH_COMBINE( seed, macOSSurfaceCreateInfoMVK.sType ); 6414 VULKAN_HPP_HASH_COMBINE( seed, macOSSurfaceCreateInfoMVK.pNext ); 6415 VULKAN_HPP_HASH_COMBINE( seed, macOSSurfaceCreateInfoMVK.flags ); 6416 VULKAN_HPP_HASH_COMBINE( seed, macOSSurfaceCreateInfoMVK.pView ); 6417 return seed; 6418 } 6419 }; 6420 # endif /*VK_USE_PLATFORM_MACOS_MVK*/ 6421 6422 template <> 6423 struct hash<VULKAN_HPP_NAMESPACE::MappedMemoryRange> 6424 { operator ()std::hash6425 std::size_t operator()( VULKAN_HPP_NAMESPACE::MappedMemoryRange const & mappedMemoryRange ) const VULKAN_HPP_NOEXCEPT 6426 { 6427 std::size_t seed = 0; 6428 VULKAN_HPP_HASH_COMBINE( seed, mappedMemoryRange.sType ); 6429 VULKAN_HPP_HASH_COMBINE( seed, mappedMemoryRange.pNext ); 6430 VULKAN_HPP_HASH_COMBINE( seed, mappedMemoryRange.memory ); 6431 VULKAN_HPP_HASH_COMBINE( seed, mappedMemoryRange.offset ); 6432 VULKAN_HPP_HASH_COMBINE( seed, mappedMemoryRange.size ); 6433 return seed; 6434 } 6435 }; 6436 6437 template <> 6438 struct hash<VULKAN_HPP_NAMESPACE::MemoryAllocateFlagsInfo> 6439 { operator ()std::hash6440 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryAllocateFlagsInfo const & memoryAllocateFlagsInfo ) const VULKAN_HPP_NOEXCEPT 6441 { 6442 std::size_t seed = 0; 6443 VULKAN_HPP_HASH_COMBINE( seed, memoryAllocateFlagsInfo.sType ); 6444 VULKAN_HPP_HASH_COMBINE( seed, memoryAllocateFlagsInfo.pNext ); 6445 VULKAN_HPP_HASH_COMBINE( seed, memoryAllocateFlagsInfo.flags ); 6446 VULKAN_HPP_HASH_COMBINE( seed, memoryAllocateFlagsInfo.deviceMask ); 6447 return seed; 6448 } 6449 }; 6450 6451 template <> 6452 struct hash<VULKAN_HPP_NAMESPACE::MemoryAllocateInfo> 6453 { operator ()std::hash6454 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryAllocateInfo const & memoryAllocateInfo ) const VULKAN_HPP_NOEXCEPT 6455 { 6456 std::size_t seed = 0; 6457 VULKAN_HPP_HASH_COMBINE( seed, memoryAllocateInfo.sType ); 6458 VULKAN_HPP_HASH_COMBINE( seed, memoryAllocateInfo.pNext ); 6459 VULKAN_HPP_HASH_COMBINE( seed, memoryAllocateInfo.allocationSize ); 6460 VULKAN_HPP_HASH_COMBINE( seed, memoryAllocateInfo.memoryTypeIndex ); 6461 return seed; 6462 } 6463 }; 6464 6465 template <> 6466 struct hash<VULKAN_HPP_NAMESPACE::MemoryBarrier> 6467 { operator ()std::hash6468 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryBarrier const & memoryBarrier ) const VULKAN_HPP_NOEXCEPT 6469 { 6470 std::size_t seed = 0; 6471 VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier.sType ); 6472 VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier.pNext ); 6473 VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier.srcAccessMask ); 6474 VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier.dstAccessMask ); 6475 return seed; 6476 } 6477 }; 6478 6479 template <> 6480 struct hash<VULKAN_HPP_NAMESPACE::MemoryDedicatedAllocateInfo> 6481 { operator ()std::hash6482 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryDedicatedAllocateInfo const & memoryDedicatedAllocateInfo ) const VULKAN_HPP_NOEXCEPT 6483 { 6484 std::size_t seed = 0; 6485 VULKAN_HPP_HASH_COMBINE( seed, memoryDedicatedAllocateInfo.sType ); 6486 VULKAN_HPP_HASH_COMBINE( seed, memoryDedicatedAllocateInfo.pNext ); 6487 VULKAN_HPP_HASH_COMBINE( seed, memoryDedicatedAllocateInfo.image ); 6488 VULKAN_HPP_HASH_COMBINE( seed, memoryDedicatedAllocateInfo.buffer ); 6489 return seed; 6490 } 6491 }; 6492 6493 template <> 6494 struct hash<VULKAN_HPP_NAMESPACE::MemoryDedicatedRequirements> 6495 { operator ()std::hash6496 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryDedicatedRequirements const & memoryDedicatedRequirements ) const VULKAN_HPP_NOEXCEPT 6497 { 6498 std::size_t seed = 0; 6499 VULKAN_HPP_HASH_COMBINE( seed, memoryDedicatedRequirements.sType ); 6500 VULKAN_HPP_HASH_COMBINE( seed, memoryDedicatedRequirements.pNext ); 6501 VULKAN_HPP_HASH_COMBINE( seed, memoryDedicatedRequirements.prefersDedicatedAllocation ); 6502 VULKAN_HPP_HASH_COMBINE( seed, memoryDedicatedRequirements.requiresDedicatedAllocation ); 6503 return seed; 6504 } 6505 }; 6506 6507 template <> 6508 struct hash<VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR> 6509 { operator ()std::hash6510 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR const & memoryFdPropertiesKHR ) const VULKAN_HPP_NOEXCEPT 6511 { 6512 std::size_t seed = 0; 6513 VULKAN_HPP_HASH_COMBINE( seed, memoryFdPropertiesKHR.sType ); 6514 VULKAN_HPP_HASH_COMBINE( seed, memoryFdPropertiesKHR.pNext ); 6515 VULKAN_HPP_HASH_COMBINE( seed, memoryFdPropertiesKHR.memoryTypeBits ); 6516 return seed; 6517 } 6518 }; 6519 6520 # if defined( VK_USE_PLATFORM_ANDROID_KHR ) 6521 template <> 6522 struct hash<VULKAN_HPP_NAMESPACE::MemoryGetAndroidHardwareBufferInfoANDROID> 6523 { 6524 std::size_t operator ()std::hash6525 operator()( VULKAN_HPP_NAMESPACE::MemoryGetAndroidHardwareBufferInfoANDROID const & memoryGetAndroidHardwareBufferInfoANDROID ) const VULKAN_HPP_NOEXCEPT 6526 { 6527 std::size_t seed = 0; 6528 VULKAN_HPP_HASH_COMBINE( seed, memoryGetAndroidHardwareBufferInfoANDROID.sType ); 6529 VULKAN_HPP_HASH_COMBINE( seed, memoryGetAndroidHardwareBufferInfoANDROID.pNext ); 6530 VULKAN_HPP_HASH_COMBINE( seed, memoryGetAndroidHardwareBufferInfoANDROID.memory ); 6531 return seed; 6532 } 6533 }; 6534 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ 6535 6536 template <> 6537 struct hash<VULKAN_HPP_NAMESPACE::MemoryGetFdInfoKHR> 6538 { operator ()std::hash6539 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryGetFdInfoKHR const & memoryGetFdInfoKHR ) const VULKAN_HPP_NOEXCEPT 6540 { 6541 std::size_t seed = 0; 6542 VULKAN_HPP_HASH_COMBINE( seed, memoryGetFdInfoKHR.sType ); 6543 VULKAN_HPP_HASH_COMBINE( seed, memoryGetFdInfoKHR.pNext ); 6544 VULKAN_HPP_HASH_COMBINE( seed, memoryGetFdInfoKHR.memory ); 6545 VULKAN_HPP_HASH_COMBINE( seed, memoryGetFdInfoKHR.handleType ); 6546 return seed; 6547 } 6548 }; 6549 6550 template <> 6551 struct hash<VULKAN_HPP_NAMESPACE::MemoryGetRemoteAddressInfoNV> 6552 { operator ()std::hash6553 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryGetRemoteAddressInfoNV const & memoryGetRemoteAddressInfoNV ) const VULKAN_HPP_NOEXCEPT 6554 { 6555 std::size_t seed = 0; 6556 VULKAN_HPP_HASH_COMBINE( seed, memoryGetRemoteAddressInfoNV.sType ); 6557 VULKAN_HPP_HASH_COMBINE( seed, memoryGetRemoteAddressInfoNV.pNext ); 6558 VULKAN_HPP_HASH_COMBINE( seed, memoryGetRemoteAddressInfoNV.memory ); 6559 VULKAN_HPP_HASH_COMBINE( seed, memoryGetRemoteAddressInfoNV.handleType ); 6560 return seed; 6561 } 6562 }; 6563 6564 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 6565 template <> 6566 struct hash<VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR> 6567 { operator ()std::hash6568 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR const & memoryGetWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT 6569 { 6570 std::size_t seed = 0; 6571 VULKAN_HPP_HASH_COMBINE( seed, memoryGetWin32HandleInfoKHR.sType ); 6572 VULKAN_HPP_HASH_COMBINE( seed, memoryGetWin32HandleInfoKHR.pNext ); 6573 VULKAN_HPP_HASH_COMBINE( seed, memoryGetWin32HandleInfoKHR.memory ); 6574 VULKAN_HPP_HASH_COMBINE( seed, memoryGetWin32HandleInfoKHR.handleType ); 6575 return seed; 6576 } 6577 }; 6578 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 6579 6580 # if defined( VK_USE_PLATFORM_FUCHSIA ) 6581 template <> 6582 struct hash<VULKAN_HPP_NAMESPACE::MemoryGetZirconHandleInfoFUCHSIA> 6583 { operator ()std::hash6584 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryGetZirconHandleInfoFUCHSIA const & memoryGetZirconHandleInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT 6585 { 6586 std::size_t seed = 0; 6587 VULKAN_HPP_HASH_COMBINE( seed, memoryGetZirconHandleInfoFUCHSIA.sType ); 6588 VULKAN_HPP_HASH_COMBINE( seed, memoryGetZirconHandleInfoFUCHSIA.pNext ); 6589 VULKAN_HPP_HASH_COMBINE( seed, memoryGetZirconHandleInfoFUCHSIA.memory ); 6590 VULKAN_HPP_HASH_COMBINE( seed, memoryGetZirconHandleInfoFUCHSIA.handleType ); 6591 return seed; 6592 } 6593 }; 6594 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 6595 6596 template <> 6597 struct hash<VULKAN_HPP_NAMESPACE::MemoryHeap> 6598 { operator ()std::hash6599 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryHeap const & memoryHeap ) const VULKAN_HPP_NOEXCEPT 6600 { 6601 std::size_t seed = 0; 6602 VULKAN_HPP_HASH_COMBINE( seed, memoryHeap.size ); 6603 VULKAN_HPP_HASH_COMBINE( seed, memoryHeap.flags ); 6604 return seed; 6605 } 6606 }; 6607 6608 template <> 6609 struct hash<VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT> 6610 { operator ()std::hash6611 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT const & memoryHostPointerPropertiesEXT ) const VULKAN_HPP_NOEXCEPT 6612 { 6613 std::size_t seed = 0; 6614 VULKAN_HPP_HASH_COMBINE( seed, memoryHostPointerPropertiesEXT.sType ); 6615 VULKAN_HPP_HASH_COMBINE( seed, memoryHostPointerPropertiesEXT.pNext ); 6616 VULKAN_HPP_HASH_COMBINE( seed, memoryHostPointerPropertiesEXT.memoryTypeBits ); 6617 return seed; 6618 } 6619 }; 6620 6621 template <> 6622 struct hash<VULKAN_HPP_NAMESPACE::MemoryMapInfoKHR> 6623 { operator ()std::hash6624 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryMapInfoKHR const & memoryMapInfoKHR ) const VULKAN_HPP_NOEXCEPT 6625 { 6626 std::size_t seed = 0; 6627 VULKAN_HPP_HASH_COMBINE( seed, memoryMapInfoKHR.sType ); 6628 VULKAN_HPP_HASH_COMBINE( seed, memoryMapInfoKHR.pNext ); 6629 VULKAN_HPP_HASH_COMBINE( seed, memoryMapInfoKHR.flags ); 6630 VULKAN_HPP_HASH_COMBINE( seed, memoryMapInfoKHR.memory ); 6631 VULKAN_HPP_HASH_COMBINE( seed, memoryMapInfoKHR.offset ); 6632 VULKAN_HPP_HASH_COMBINE( seed, memoryMapInfoKHR.size ); 6633 return seed; 6634 } 6635 }; 6636 6637 template <> 6638 struct hash<VULKAN_HPP_NAMESPACE::MemoryOpaqueCaptureAddressAllocateInfo> 6639 { 6640 std::size_t operator ()std::hash6641 operator()( VULKAN_HPP_NAMESPACE::MemoryOpaqueCaptureAddressAllocateInfo const & memoryOpaqueCaptureAddressAllocateInfo ) const VULKAN_HPP_NOEXCEPT 6642 { 6643 std::size_t seed = 0; 6644 VULKAN_HPP_HASH_COMBINE( seed, memoryOpaqueCaptureAddressAllocateInfo.sType ); 6645 VULKAN_HPP_HASH_COMBINE( seed, memoryOpaqueCaptureAddressAllocateInfo.pNext ); 6646 VULKAN_HPP_HASH_COMBINE( seed, memoryOpaqueCaptureAddressAllocateInfo.opaqueCaptureAddress ); 6647 return seed; 6648 } 6649 }; 6650 6651 template <> 6652 struct hash<VULKAN_HPP_NAMESPACE::MemoryPriorityAllocateInfoEXT> 6653 { operator ()std::hash6654 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryPriorityAllocateInfoEXT const & memoryPriorityAllocateInfoEXT ) const VULKAN_HPP_NOEXCEPT 6655 { 6656 std::size_t seed = 0; 6657 VULKAN_HPP_HASH_COMBINE( seed, memoryPriorityAllocateInfoEXT.sType ); 6658 VULKAN_HPP_HASH_COMBINE( seed, memoryPriorityAllocateInfoEXT.pNext ); 6659 VULKAN_HPP_HASH_COMBINE( seed, memoryPriorityAllocateInfoEXT.priority ); 6660 return seed; 6661 } 6662 }; 6663 6664 template <> 6665 struct hash<VULKAN_HPP_NAMESPACE::MemoryRequirements> 6666 { operator ()std::hash6667 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryRequirements const & memoryRequirements ) const VULKAN_HPP_NOEXCEPT 6668 { 6669 std::size_t seed = 0; 6670 VULKAN_HPP_HASH_COMBINE( seed, memoryRequirements.size ); 6671 VULKAN_HPP_HASH_COMBINE( seed, memoryRequirements.alignment ); 6672 VULKAN_HPP_HASH_COMBINE( seed, memoryRequirements.memoryTypeBits ); 6673 return seed; 6674 } 6675 }; 6676 6677 template <> 6678 struct hash<VULKAN_HPP_NAMESPACE::MemoryRequirements2> 6679 { operator ()std::hash6680 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryRequirements2 const & memoryRequirements2 ) const VULKAN_HPP_NOEXCEPT 6681 { 6682 std::size_t seed = 0; 6683 VULKAN_HPP_HASH_COMBINE( seed, memoryRequirements2.sType ); 6684 VULKAN_HPP_HASH_COMBINE( seed, memoryRequirements2.pNext ); 6685 VULKAN_HPP_HASH_COMBINE( seed, memoryRequirements2.memoryRequirements ); 6686 return seed; 6687 } 6688 }; 6689 6690 template <> 6691 struct hash<VULKAN_HPP_NAMESPACE::MemoryType> 6692 { operator ()std::hash6693 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryType const & memoryType ) const VULKAN_HPP_NOEXCEPT 6694 { 6695 std::size_t seed = 0; 6696 VULKAN_HPP_HASH_COMBINE( seed, memoryType.propertyFlags ); 6697 VULKAN_HPP_HASH_COMBINE( seed, memoryType.heapIndex ); 6698 return seed; 6699 } 6700 }; 6701 6702 template <> 6703 struct hash<VULKAN_HPP_NAMESPACE::MemoryUnmapInfoKHR> 6704 { operator ()std::hash6705 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryUnmapInfoKHR const & memoryUnmapInfoKHR ) const VULKAN_HPP_NOEXCEPT 6706 { 6707 std::size_t seed = 0; 6708 VULKAN_HPP_HASH_COMBINE( seed, memoryUnmapInfoKHR.sType ); 6709 VULKAN_HPP_HASH_COMBINE( seed, memoryUnmapInfoKHR.pNext ); 6710 VULKAN_HPP_HASH_COMBINE( seed, memoryUnmapInfoKHR.flags ); 6711 VULKAN_HPP_HASH_COMBINE( seed, memoryUnmapInfoKHR.memory ); 6712 return seed; 6713 } 6714 }; 6715 6716 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 6717 template <> 6718 struct hash<VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR> 6719 { operator ()std::hash6720 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR const & memoryWin32HandlePropertiesKHR ) const VULKAN_HPP_NOEXCEPT 6721 { 6722 std::size_t seed = 0; 6723 VULKAN_HPP_HASH_COMBINE( seed, memoryWin32HandlePropertiesKHR.sType ); 6724 VULKAN_HPP_HASH_COMBINE( seed, memoryWin32HandlePropertiesKHR.pNext ); 6725 VULKAN_HPP_HASH_COMBINE( seed, memoryWin32HandlePropertiesKHR.memoryTypeBits ); 6726 return seed; 6727 } 6728 }; 6729 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 6730 6731 # if defined( VK_USE_PLATFORM_FUCHSIA ) 6732 template <> 6733 struct hash<VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA> 6734 { operator ()std::hash6735 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA const & memoryZirconHandlePropertiesFUCHSIA ) const VULKAN_HPP_NOEXCEPT 6736 { 6737 std::size_t seed = 0; 6738 VULKAN_HPP_HASH_COMBINE( seed, memoryZirconHandlePropertiesFUCHSIA.sType ); 6739 VULKAN_HPP_HASH_COMBINE( seed, memoryZirconHandlePropertiesFUCHSIA.pNext ); 6740 VULKAN_HPP_HASH_COMBINE( seed, memoryZirconHandlePropertiesFUCHSIA.memoryTypeBits ); 6741 return seed; 6742 } 6743 }; 6744 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 6745 6746 # if defined( VK_USE_PLATFORM_METAL_EXT ) 6747 template <> 6748 struct hash<VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT> 6749 { operator ()std::hash6750 std::size_t operator()( VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT const & metalSurfaceCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 6751 { 6752 std::size_t seed = 0; 6753 VULKAN_HPP_HASH_COMBINE( seed, metalSurfaceCreateInfoEXT.sType ); 6754 VULKAN_HPP_HASH_COMBINE( seed, metalSurfaceCreateInfoEXT.pNext ); 6755 VULKAN_HPP_HASH_COMBINE( seed, metalSurfaceCreateInfoEXT.flags ); 6756 VULKAN_HPP_HASH_COMBINE( seed, metalSurfaceCreateInfoEXT.pLayer ); 6757 return seed; 6758 } 6759 }; 6760 # endif /*VK_USE_PLATFORM_METAL_EXT*/ 6761 6762 template <> 6763 struct hash<VULKAN_HPP_NAMESPACE::MicromapBuildSizesInfoEXT> 6764 { operator ()std::hash6765 std::size_t operator()( VULKAN_HPP_NAMESPACE::MicromapBuildSizesInfoEXT const & micromapBuildSizesInfoEXT ) const VULKAN_HPP_NOEXCEPT 6766 { 6767 std::size_t seed = 0; 6768 VULKAN_HPP_HASH_COMBINE( seed, micromapBuildSizesInfoEXT.sType ); 6769 VULKAN_HPP_HASH_COMBINE( seed, micromapBuildSizesInfoEXT.pNext ); 6770 VULKAN_HPP_HASH_COMBINE( seed, micromapBuildSizesInfoEXT.micromapSize ); 6771 VULKAN_HPP_HASH_COMBINE( seed, micromapBuildSizesInfoEXT.buildScratchSize ); 6772 VULKAN_HPP_HASH_COMBINE( seed, micromapBuildSizesInfoEXT.discardable ); 6773 return seed; 6774 } 6775 }; 6776 6777 template <> 6778 struct hash<VULKAN_HPP_NAMESPACE::MicromapCreateInfoEXT> 6779 { operator ()std::hash6780 std::size_t operator()( VULKAN_HPP_NAMESPACE::MicromapCreateInfoEXT const & micromapCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 6781 { 6782 std::size_t seed = 0; 6783 VULKAN_HPP_HASH_COMBINE( seed, micromapCreateInfoEXT.sType ); 6784 VULKAN_HPP_HASH_COMBINE( seed, micromapCreateInfoEXT.pNext ); 6785 VULKAN_HPP_HASH_COMBINE( seed, micromapCreateInfoEXT.createFlags ); 6786 VULKAN_HPP_HASH_COMBINE( seed, micromapCreateInfoEXT.buffer ); 6787 VULKAN_HPP_HASH_COMBINE( seed, micromapCreateInfoEXT.offset ); 6788 VULKAN_HPP_HASH_COMBINE( seed, micromapCreateInfoEXT.size ); 6789 VULKAN_HPP_HASH_COMBINE( seed, micromapCreateInfoEXT.type ); 6790 VULKAN_HPP_HASH_COMBINE( seed, micromapCreateInfoEXT.deviceAddress ); 6791 return seed; 6792 } 6793 }; 6794 6795 template <> 6796 struct hash<VULKAN_HPP_NAMESPACE::MicromapTriangleEXT> 6797 { operator ()std::hash6798 std::size_t operator()( VULKAN_HPP_NAMESPACE::MicromapTriangleEXT const & micromapTriangleEXT ) const VULKAN_HPP_NOEXCEPT 6799 { 6800 std::size_t seed = 0; 6801 VULKAN_HPP_HASH_COMBINE( seed, micromapTriangleEXT.dataOffset ); 6802 VULKAN_HPP_HASH_COMBINE( seed, micromapTriangleEXT.subdivisionLevel ); 6803 VULKAN_HPP_HASH_COMBINE( seed, micromapTriangleEXT.format ); 6804 return seed; 6805 } 6806 }; 6807 6808 template <> 6809 struct hash<VULKAN_HPP_NAMESPACE::MicromapVersionInfoEXT> 6810 { operator ()std::hash6811 std::size_t operator()( VULKAN_HPP_NAMESPACE::MicromapVersionInfoEXT const & micromapVersionInfoEXT ) const VULKAN_HPP_NOEXCEPT 6812 { 6813 std::size_t seed = 0; 6814 VULKAN_HPP_HASH_COMBINE( seed, micromapVersionInfoEXT.sType ); 6815 VULKAN_HPP_HASH_COMBINE( seed, micromapVersionInfoEXT.pNext ); 6816 VULKAN_HPP_HASH_COMBINE( seed, micromapVersionInfoEXT.pVersionData ); 6817 return seed; 6818 } 6819 }; 6820 6821 template <> 6822 struct hash<VULKAN_HPP_NAMESPACE::MultiDrawIndexedInfoEXT> 6823 { operator ()std::hash6824 std::size_t operator()( VULKAN_HPP_NAMESPACE::MultiDrawIndexedInfoEXT const & multiDrawIndexedInfoEXT ) const VULKAN_HPP_NOEXCEPT 6825 { 6826 std::size_t seed = 0; 6827 VULKAN_HPP_HASH_COMBINE( seed, multiDrawIndexedInfoEXT.firstIndex ); 6828 VULKAN_HPP_HASH_COMBINE( seed, multiDrawIndexedInfoEXT.indexCount ); 6829 VULKAN_HPP_HASH_COMBINE( seed, multiDrawIndexedInfoEXT.vertexOffset ); 6830 return seed; 6831 } 6832 }; 6833 6834 template <> 6835 struct hash<VULKAN_HPP_NAMESPACE::MultiDrawInfoEXT> 6836 { operator ()std::hash6837 std::size_t operator()( VULKAN_HPP_NAMESPACE::MultiDrawInfoEXT const & multiDrawInfoEXT ) const VULKAN_HPP_NOEXCEPT 6838 { 6839 std::size_t seed = 0; 6840 VULKAN_HPP_HASH_COMBINE( seed, multiDrawInfoEXT.firstVertex ); 6841 VULKAN_HPP_HASH_COMBINE( seed, multiDrawInfoEXT.vertexCount ); 6842 return seed; 6843 } 6844 }; 6845 6846 template <> 6847 struct hash<VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT> 6848 { operator ()std::hash6849 std::size_t operator()( VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT const & multisamplePropertiesEXT ) const VULKAN_HPP_NOEXCEPT 6850 { 6851 std::size_t seed = 0; 6852 VULKAN_HPP_HASH_COMBINE( seed, multisamplePropertiesEXT.sType ); 6853 VULKAN_HPP_HASH_COMBINE( seed, multisamplePropertiesEXT.pNext ); 6854 VULKAN_HPP_HASH_COMBINE( seed, multisamplePropertiesEXT.maxSampleLocationGridSize ); 6855 return seed; 6856 } 6857 }; 6858 6859 template <> 6860 struct hash<VULKAN_HPP_NAMESPACE::MultisampledRenderToSingleSampledInfoEXT> 6861 { 6862 std::size_t operator ()std::hash6863 operator()( VULKAN_HPP_NAMESPACE::MultisampledRenderToSingleSampledInfoEXT const & multisampledRenderToSingleSampledInfoEXT ) const VULKAN_HPP_NOEXCEPT 6864 { 6865 std::size_t seed = 0; 6866 VULKAN_HPP_HASH_COMBINE( seed, multisampledRenderToSingleSampledInfoEXT.sType ); 6867 VULKAN_HPP_HASH_COMBINE( seed, multisampledRenderToSingleSampledInfoEXT.pNext ); 6868 VULKAN_HPP_HASH_COMBINE( seed, multisampledRenderToSingleSampledInfoEXT.multisampledRenderToSingleSampledEnable ); 6869 VULKAN_HPP_HASH_COMBINE( seed, multisampledRenderToSingleSampledInfoEXT.rasterizationSamples ); 6870 return seed; 6871 } 6872 }; 6873 6874 template <> 6875 struct hash<VULKAN_HPP_NAMESPACE::MultiviewPerViewAttributesInfoNVX> 6876 { operator ()std::hash6877 std::size_t operator()( VULKAN_HPP_NAMESPACE::MultiviewPerViewAttributesInfoNVX const & multiviewPerViewAttributesInfoNVX ) const VULKAN_HPP_NOEXCEPT 6878 { 6879 std::size_t seed = 0; 6880 VULKAN_HPP_HASH_COMBINE( seed, multiviewPerViewAttributesInfoNVX.sType ); 6881 VULKAN_HPP_HASH_COMBINE( seed, multiviewPerViewAttributesInfoNVX.pNext ); 6882 VULKAN_HPP_HASH_COMBINE( seed, multiviewPerViewAttributesInfoNVX.perViewAttributes ); 6883 VULKAN_HPP_HASH_COMBINE( seed, multiviewPerViewAttributesInfoNVX.perViewAttributesPositionXOnly ); 6884 return seed; 6885 } 6886 }; 6887 6888 template <> 6889 struct hash<VULKAN_HPP_NAMESPACE::MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM> 6890 { 6891 std::size_t operator ()std::hash6892 operator()( VULKAN_HPP_NAMESPACE::MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM const & multiviewPerViewRenderAreasRenderPassBeginInfoQCOM ) const 6893 VULKAN_HPP_NOEXCEPT 6894 { 6895 std::size_t seed = 0; 6896 VULKAN_HPP_HASH_COMBINE( seed, multiviewPerViewRenderAreasRenderPassBeginInfoQCOM.sType ); 6897 VULKAN_HPP_HASH_COMBINE( seed, multiviewPerViewRenderAreasRenderPassBeginInfoQCOM.pNext ); 6898 VULKAN_HPP_HASH_COMBINE( seed, multiviewPerViewRenderAreasRenderPassBeginInfoQCOM.perViewRenderAreaCount ); 6899 VULKAN_HPP_HASH_COMBINE( seed, multiviewPerViewRenderAreasRenderPassBeginInfoQCOM.pPerViewRenderAreas ); 6900 return seed; 6901 } 6902 }; 6903 6904 template <> 6905 struct hash<VULKAN_HPP_NAMESPACE::MutableDescriptorTypeListEXT> 6906 { operator ()std::hash6907 std::size_t operator()( VULKAN_HPP_NAMESPACE::MutableDescriptorTypeListEXT const & mutableDescriptorTypeListEXT ) const VULKAN_HPP_NOEXCEPT 6908 { 6909 std::size_t seed = 0; 6910 VULKAN_HPP_HASH_COMBINE( seed, mutableDescriptorTypeListEXT.descriptorTypeCount ); 6911 VULKAN_HPP_HASH_COMBINE( seed, mutableDescriptorTypeListEXT.pDescriptorTypes ); 6912 return seed; 6913 } 6914 }; 6915 6916 template <> 6917 struct hash<VULKAN_HPP_NAMESPACE::MutableDescriptorTypeCreateInfoEXT> 6918 { operator ()std::hash6919 std::size_t operator()( VULKAN_HPP_NAMESPACE::MutableDescriptorTypeCreateInfoEXT const & mutableDescriptorTypeCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 6920 { 6921 std::size_t seed = 0; 6922 VULKAN_HPP_HASH_COMBINE( seed, mutableDescriptorTypeCreateInfoEXT.sType ); 6923 VULKAN_HPP_HASH_COMBINE( seed, mutableDescriptorTypeCreateInfoEXT.pNext ); 6924 VULKAN_HPP_HASH_COMBINE( seed, mutableDescriptorTypeCreateInfoEXT.mutableDescriptorTypeListCount ); 6925 VULKAN_HPP_HASH_COMBINE( seed, mutableDescriptorTypeCreateInfoEXT.pMutableDescriptorTypeLists ); 6926 return seed; 6927 } 6928 }; 6929 6930 template <> 6931 struct hash<VULKAN_HPP_NAMESPACE::OpaqueCaptureDescriptorDataCreateInfoEXT> 6932 { 6933 std::size_t operator ()std::hash6934 operator()( VULKAN_HPP_NAMESPACE::OpaqueCaptureDescriptorDataCreateInfoEXT const & opaqueCaptureDescriptorDataCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 6935 { 6936 std::size_t seed = 0; 6937 VULKAN_HPP_HASH_COMBINE( seed, opaqueCaptureDescriptorDataCreateInfoEXT.sType ); 6938 VULKAN_HPP_HASH_COMBINE( seed, opaqueCaptureDescriptorDataCreateInfoEXT.pNext ); 6939 VULKAN_HPP_HASH_COMBINE( seed, opaqueCaptureDescriptorDataCreateInfoEXT.opaqueCaptureDescriptorData ); 6940 return seed; 6941 } 6942 }; 6943 6944 template <> 6945 struct hash<VULKAN_HPP_NAMESPACE::OpticalFlowExecuteInfoNV> 6946 { operator ()std::hash6947 std::size_t operator()( VULKAN_HPP_NAMESPACE::OpticalFlowExecuteInfoNV const & opticalFlowExecuteInfoNV ) const VULKAN_HPP_NOEXCEPT 6948 { 6949 std::size_t seed = 0; 6950 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowExecuteInfoNV.sType ); 6951 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowExecuteInfoNV.pNext ); 6952 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowExecuteInfoNV.flags ); 6953 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowExecuteInfoNV.regionCount ); 6954 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowExecuteInfoNV.pRegions ); 6955 return seed; 6956 } 6957 }; 6958 6959 template <> 6960 struct hash<VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatInfoNV> 6961 { operator ()std::hash6962 std::size_t operator()( VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatInfoNV const & opticalFlowImageFormatInfoNV ) const VULKAN_HPP_NOEXCEPT 6963 { 6964 std::size_t seed = 0; 6965 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowImageFormatInfoNV.sType ); 6966 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowImageFormatInfoNV.pNext ); 6967 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowImageFormatInfoNV.usage ); 6968 return seed; 6969 } 6970 }; 6971 6972 template <> 6973 struct hash<VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV> 6974 { operator ()std::hash6975 std::size_t operator()( VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV const & opticalFlowImageFormatPropertiesNV ) const VULKAN_HPP_NOEXCEPT 6976 { 6977 std::size_t seed = 0; 6978 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowImageFormatPropertiesNV.sType ); 6979 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowImageFormatPropertiesNV.pNext ); 6980 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowImageFormatPropertiesNV.format ); 6981 return seed; 6982 } 6983 }; 6984 6985 template <> 6986 struct hash<VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreateInfoNV> 6987 { operator ()std::hash6988 std::size_t operator()( VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreateInfoNV const & opticalFlowSessionCreateInfoNV ) const VULKAN_HPP_NOEXCEPT 6989 { 6990 std::size_t seed = 0; 6991 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.sType ); 6992 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.pNext ); 6993 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.width ); 6994 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.height ); 6995 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.imageFormat ); 6996 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.flowVectorFormat ); 6997 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.costFormat ); 6998 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.outputGridSize ); 6999 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.hintGridSize ); 7000 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.performanceLevel ); 7001 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.flags ); 7002 return seed; 7003 } 7004 }; 7005 7006 template <> 7007 struct hash<VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreatePrivateDataInfoNV> 7008 { 7009 std::size_t operator ()std::hash7010 operator()( VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreatePrivateDataInfoNV const & opticalFlowSessionCreatePrivateDataInfoNV ) const VULKAN_HPP_NOEXCEPT 7011 { 7012 std::size_t seed = 0; 7013 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreatePrivateDataInfoNV.sType ); 7014 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreatePrivateDataInfoNV.pNext ); 7015 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreatePrivateDataInfoNV.id ); 7016 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreatePrivateDataInfoNV.size ); 7017 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreatePrivateDataInfoNV.pPrivateData ); 7018 return seed; 7019 } 7020 }; 7021 7022 template <> 7023 struct hash<VULKAN_HPP_NAMESPACE::OutOfBandQueueTypeInfoNV> 7024 { operator ()std::hash7025 std::size_t operator()( VULKAN_HPP_NAMESPACE::OutOfBandQueueTypeInfoNV const & outOfBandQueueTypeInfoNV ) const VULKAN_HPP_NOEXCEPT 7026 { 7027 std::size_t seed = 0; 7028 VULKAN_HPP_HASH_COMBINE( seed, outOfBandQueueTypeInfoNV.sType ); 7029 VULKAN_HPP_HASH_COMBINE( seed, outOfBandQueueTypeInfoNV.pNext ); 7030 VULKAN_HPP_HASH_COMBINE( seed, outOfBandQueueTypeInfoNV.queueType ); 7031 return seed; 7032 } 7033 }; 7034 7035 template <> 7036 struct hash<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE> 7037 { operator ()std::hash7038 std::size_t operator()( VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE const & pastPresentationTimingGOOGLE ) const VULKAN_HPP_NOEXCEPT 7039 { 7040 std::size_t seed = 0; 7041 VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingGOOGLE.presentID ); 7042 VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingGOOGLE.desiredPresentTime ); 7043 VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingGOOGLE.actualPresentTime ); 7044 VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingGOOGLE.earliestPresentTime ); 7045 VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingGOOGLE.presentMargin ); 7046 return seed; 7047 } 7048 }; 7049 7050 template <> 7051 struct hash<VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL> 7052 { 7053 std::size_t operator ()std::hash7054 operator()( VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL const & performanceConfigurationAcquireInfoINTEL ) const VULKAN_HPP_NOEXCEPT 7055 { 7056 std::size_t seed = 0; 7057 VULKAN_HPP_HASH_COMBINE( seed, performanceConfigurationAcquireInfoINTEL.sType ); 7058 VULKAN_HPP_HASH_COMBINE( seed, performanceConfigurationAcquireInfoINTEL.pNext ); 7059 VULKAN_HPP_HASH_COMBINE( seed, performanceConfigurationAcquireInfoINTEL.type ); 7060 return seed; 7061 } 7062 }; 7063 7064 template <> 7065 struct hash<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR> 7066 { operator ()std::hash7067 std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR const & performanceCounterDescriptionKHR ) const VULKAN_HPP_NOEXCEPT 7068 { 7069 std::size_t seed = 0; 7070 VULKAN_HPP_HASH_COMBINE( seed, performanceCounterDescriptionKHR.sType ); 7071 VULKAN_HPP_HASH_COMBINE( seed, performanceCounterDescriptionKHR.pNext ); 7072 VULKAN_HPP_HASH_COMBINE( seed, performanceCounterDescriptionKHR.flags ); 7073 for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) 7074 { 7075 VULKAN_HPP_HASH_COMBINE( seed, performanceCounterDescriptionKHR.name[i] ); 7076 } 7077 for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) 7078 { 7079 VULKAN_HPP_HASH_COMBINE( seed, performanceCounterDescriptionKHR.category[i] ); 7080 } 7081 for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) 7082 { 7083 VULKAN_HPP_HASH_COMBINE( seed, performanceCounterDescriptionKHR.description[i] ); 7084 } 7085 return seed; 7086 } 7087 }; 7088 7089 template <> 7090 struct hash<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR> 7091 { operator ()std::hash7092 std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceCounterKHR const & performanceCounterKHR ) const VULKAN_HPP_NOEXCEPT 7093 { 7094 std::size_t seed = 0; 7095 VULKAN_HPP_HASH_COMBINE( seed, performanceCounterKHR.sType ); 7096 VULKAN_HPP_HASH_COMBINE( seed, performanceCounterKHR.pNext ); 7097 VULKAN_HPP_HASH_COMBINE( seed, performanceCounterKHR.unit ); 7098 VULKAN_HPP_HASH_COMBINE( seed, performanceCounterKHR.scope ); 7099 VULKAN_HPP_HASH_COMBINE( seed, performanceCounterKHR.storage ); 7100 for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) 7101 { 7102 VULKAN_HPP_HASH_COMBINE( seed, performanceCounterKHR.uuid[i] ); 7103 } 7104 return seed; 7105 } 7106 }; 7107 7108 template <> 7109 struct hash<VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL> 7110 { operator ()std::hash7111 std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL const & performanceMarkerInfoINTEL ) const VULKAN_HPP_NOEXCEPT 7112 { 7113 std::size_t seed = 0; 7114 VULKAN_HPP_HASH_COMBINE( seed, performanceMarkerInfoINTEL.sType ); 7115 VULKAN_HPP_HASH_COMBINE( seed, performanceMarkerInfoINTEL.pNext ); 7116 VULKAN_HPP_HASH_COMBINE( seed, performanceMarkerInfoINTEL.marker ); 7117 return seed; 7118 } 7119 }; 7120 7121 template <> 7122 struct hash<VULKAN_HPP_NAMESPACE::PerformanceOverrideInfoINTEL> 7123 { operator ()std::hash7124 std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceOverrideInfoINTEL const & performanceOverrideInfoINTEL ) const VULKAN_HPP_NOEXCEPT 7125 { 7126 std::size_t seed = 0; 7127 VULKAN_HPP_HASH_COMBINE( seed, performanceOverrideInfoINTEL.sType ); 7128 VULKAN_HPP_HASH_COMBINE( seed, performanceOverrideInfoINTEL.pNext ); 7129 VULKAN_HPP_HASH_COMBINE( seed, performanceOverrideInfoINTEL.type ); 7130 VULKAN_HPP_HASH_COMBINE( seed, performanceOverrideInfoINTEL.enable ); 7131 VULKAN_HPP_HASH_COMBINE( seed, performanceOverrideInfoINTEL.parameter ); 7132 return seed; 7133 } 7134 }; 7135 7136 template <> 7137 struct hash<VULKAN_HPP_NAMESPACE::PerformanceQuerySubmitInfoKHR> 7138 { operator ()std::hash7139 std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceQuerySubmitInfoKHR const & performanceQuerySubmitInfoKHR ) const VULKAN_HPP_NOEXCEPT 7140 { 7141 std::size_t seed = 0; 7142 VULKAN_HPP_HASH_COMBINE( seed, performanceQuerySubmitInfoKHR.sType ); 7143 VULKAN_HPP_HASH_COMBINE( seed, performanceQuerySubmitInfoKHR.pNext ); 7144 VULKAN_HPP_HASH_COMBINE( seed, performanceQuerySubmitInfoKHR.counterPassIndex ); 7145 return seed; 7146 } 7147 }; 7148 7149 template <> 7150 struct hash<VULKAN_HPP_NAMESPACE::PerformanceStreamMarkerInfoINTEL> 7151 { operator ()std::hash7152 std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceStreamMarkerInfoINTEL const & performanceStreamMarkerInfoINTEL ) const VULKAN_HPP_NOEXCEPT 7153 { 7154 std::size_t seed = 0; 7155 VULKAN_HPP_HASH_COMBINE( seed, performanceStreamMarkerInfoINTEL.sType ); 7156 VULKAN_HPP_HASH_COMBINE( seed, performanceStreamMarkerInfoINTEL.pNext ); 7157 VULKAN_HPP_HASH_COMBINE( seed, performanceStreamMarkerInfoINTEL.marker ); 7158 return seed; 7159 } 7160 }; 7161 7162 template <> 7163 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevice16BitStorageFeatures> 7164 { operator ()std::hash7165 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevice16BitStorageFeatures const & physicalDevice16BitStorageFeatures ) const VULKAN_HPP_NOEXCEPT 7166 { 7167 std::size_t seed = 0; 7168 VULKAN_HPP_HASH_COMBINE( seed, physicalDevice16BitStorageFeatures.sType ); 7169 VULKAN_HPP_HASH_COMBINE( seed, physicalDevice16BitStorageFeatures.pNext ); 7170 VULKAN_HPP_HASH_COMBINE( seed, physicalDevice16BitStorageFeatures.storageBuffer16BitAccess ); 7171 VULKAN_HPP_HASH_COMBINE( seed, physicalDevice16BitStorageFeatures.uniformAndStorageBuffer16BitAccess ); 7172 VULKAN_HPP_HASH_COMBINE( seed, physicalDevice16BitStorageFeatures.storagePushConstant16 ); 7173 VULKAN_HPP_HASH_COMBINE( seed, physicalDevice16BitStorageFeatures.storageInputOutput16 ); 7174 return seed; 7175 } 7176 }; 7177 7178 template <> 7179 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevice4444FormatsFeaturesEXT> 7180 { operator ()std::hash7181 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevice4444FormatsFeaturesEXT const & physicalDevice4444FormatsFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 7182 { 7183 std::size_t seed = 0; 7184 VULKAN_HPP_HASH_COMBINE( seed, physicalDevice4444FormatsFeaturesEXT.sType ); 7185 VULKAN_HPP_HASH_COMBINE( seed, physicalDevice4444FormatsFeaturesEXT.pNext ); 7186 VULKAN_HPP_HASH_COMBINE( seed, physicalDevice4444FormatsFeaturesEXT.formatA4R4G4B4 ); 7187 VULKAN_HPP_HASH_COMBINE( seed, physicalDevice4444FormatsFeaturesEXT.formatA4B4G4R4 ); 7188 return seed; 7189 } 7190 }; 7191 7192 template <> 7193 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevice8BitStorageFeatures> 7194 { operator ()std::hash7195 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevice8BitStorageFeatures const & physicalDevice8BitStorageFeatures ) const VULKAN_HPP_NOEXCEPT 7196 { 7197 std::size_t seed = 0; 7198 VULKAN_HPP_HASH_COMBINE( seed, physicalDevice8BitStorageFeatures.sType ); 7199 VULKAN_HPP_HASH_COMBINE( seed, physicalDevice8BitStorageFeatures.pNext ); 7200 VULKAN_HPP_HASH_COMBINE( seed, physicalDevice8BitStorageFeatures.storageBuffer8BitAccess ); 7201 VULKAN_HPP_HASH_COMBINE( seed, physicalDevice8BitStorageFeatures.uniformAndStorageBuffer8BitAccess ); 7202 VULKAN_HPP_HASH_COMBINE( seed, physicalDevice8BitStorageFeatures.storagePushConstant8 ); 7203 return seed; 7204 } 7205 }; 7206 7207 template <> 7208 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceASTCDecodeFeaturesEXT> 7209 { operator ()std::hash7210 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceASTCDecodeFeaturesEXT const & physicalDeviceASTCDecodeFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 7211 { 7212 std::size_t seed = 0; 7213 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceASTCDecodeFeaturesEXT.sType ); 7214 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceASTCDecodeFeaturesEXT.pNext ); 7215 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceASTCDecodeFeaturesEXT.decodeModeSharedExponent ); 7216 return seed; 7217 } 7218 }; 7219 7220 template <> 7221 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceAccelerationStructureFeaturesKHR> 7222 { operator ()std::hash7223 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceAccelerationStructureFeaturesKHR const & physicalDeviceAccelerationStructureFeaturesKHR ) const 7224 VULKAN_HPP_NOEXCEPT 7225 { 7226 std::size_t seed = 0; 7227 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructureFeaturesKHR.sType ); 7228 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructureFeaturesKHR.pNext ); 7229 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructureFeaturesKHR.accelerationStructure ); 7230 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructureFeaturesKHR.accelerationStructureCaptureReplay ); 7231 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructureFeaturesKHR.accelerationStructureIndirectBuild ); 7232 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructureFeaturesKHR.accelerationStructureHostCommands ); 7233 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructureFeaturesKHR.descriptorBindingAccelerationStructureUpdateAfterBind ); 7234 return seed; 7235 } 7236 }; 7237 7238 template <> 7239 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceAccelerationStructurePropertiesKHR> 7240 { operator ()std::hash7241 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceAccelerationStructurePropertiesKHR const & physicalDeviceAccelerationStructurePropertiesKHR ) 7242 const VULKAN_HPP_NOEXCEPT 7243 { 7244 std::size_t seed = 0; 7245 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.sType ); 7246 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.pNext ); 7247 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.maxGeometryCount ); 7248 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.maxInstanceCount ); 7249 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.maxPrimitiveCount ); 7250 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.maxPerStageDescriptorAccelerationStructures ); 7251 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.maxPerStageDescriptorUpdateAfterBindAccelerationStructures ); 7252 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.maxDescriptorSetAccelerationStructures ); 7253 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.maxDescriptorSetUpdateAfterBindAccelerationStructures ); 7254 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.minAccelerationStructureScratchOffsetAlignment ); 7255 return seed; 7256 } 7257 }; 7258 7259 template <> 7260 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceAddressBindingReportFeaturesEXT> 7261 { operator ()std::hash7262 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceAddressBindingReportFeaturesEXT const & physicalDeviceAddressBindingReportFeaturesEXT ) const 7263 VULKAN_HPP_NOEXCEPT 7264 { 7265 std::size_t seed = 0; 7266 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAddressBindingReportFeaturesEXT.sType ); 7267 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAddressBindingReportFeaturesEXT.pNext ); 7268 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAddressBindingReportFeaturesEXT.reportAddressBinding ); 7269 return seed; 7270 } 7271 }; 7272 7273 template <> 7274 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceAmigoProfilingFeaturesSEC> 7275 { 7276 std::size_t operator ()std::hash7277 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceAmigoProfilingFeaturesSEC const & physicalDeviceAmigoProfilingFeaturesSEC ) const VULKAN_HPP_NOEXCEPT 7278 { 7279 std::size_t seed = 0; 7280 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAmigoProfilingFeaturesSEC.sType ); 7281 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAmigoProfilingFeaturesSEC.pNext ); 7282 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAmigoProfilingFeaturesSEC.amigoProfiling ); 7283 return seed; 7284 } 7285 }; 7286 7287 template <> 7288 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT> 7289 { operator ()std::hash7290 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT const & 7291 physicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 7292 { 7293 std::size_t seed = 0; 7294 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT.sType ); 7295 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT.pNext ); 7296 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT.attachmentFeedbackLoopDynamicState ); 7297 return seed; 7298 } 7299 }; 7300 7301 template <> 7302 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT> 7303 { operator ()std::hash7304 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT const & 7305 physicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 7306 { 7307 std::size_t seed = 0; 7308 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT.sType ); 7309 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT.pNext ); 7310 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT.attachmentFeedbackLoopLayout ); 7311 return seed; 7312 } 7313 }; 7314 7315 template <> 7316 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceBlendOperationAdvancedFeaturesEXT> 7317 { operator ()std::hash7318 std::size_t operator()( 7319 VULKAN_HPP_NAMESPACE::PhysicalDeviceBlendOperationAdvancedFeaturesEXT const & physicalDeviceBlendOperationAdvancedFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 7320 { 7321 std::size_t seed = 0; 7322 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedFeaturesEXT.sType ); 7323 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedFeaturesEXT.pNext ); 7324 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedFeaturesEXT.advancedBlendCoherentOperations ); 7325 return seed; 7326 } 7327 }; 7328 7329 template <> 7330 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceBlendOperationAdvancedPropertiesEXT> 7331 { operator ()std::hash7332 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceBlendOperationAdvancedPropertiesEXT const & physicalDeviceBlendOperationAdvancedPropertiesEXT ) 7333 const VULKAN_HPP_NOEXCEPT 7334 { 7335 std::size_t seed = 0; 7336 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.sType ); 7337 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.pNext ); 7338 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendMaxColorAttachments ); 7339 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendIndependentBlend ); 7340 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendNonPremultipliedSrcColor ); 7341 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendNonPremultipliedDstColor ); 7342 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendCorrelatedOverlap ); 7343 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendAllOperations ); 7344 return seed; 7345 } 7346 }; 7347 7348 template <> 7349 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceBorderColorSwizzleFeaturesEXT> 7350 { operator ()std::hash7351 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceBorderColorSwizzleFeaturesEXT const & physicalDeviceBorderColorSwizzleFeaturesEXT ) const 7352 VULKAN_HPP_NOEXCEPT 7353 { 7354 std::size_t seed = 0; 7355 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBorderColorSwizzleFeaturesEXT.sType ); 7356 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBorderColorSwizzleFeaturesEXT.pNext ); 7357 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBorderColorSwizzleFeaturesEXT.borderColorSwizzle ); 7358 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBorderColorSwizzleFeaturesEXT.borderColorSwizzleFromImage ); 7359 return seed; 7360 } 7361 }; 7362 7363 template <> 7364 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceBufferDeviceAddressFeatures> 7365 { 7366 std::size_t operator ()std::hash7367 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceBufferDeviceAddressFeatures const & physicalDeviceBufferDeviceAddressFeatures ) const VULKAN_HPP_NOEXCEPT 7368 { 7369 std::size_t seed = 0; 7370 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeatures.sType ); 7371 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeatures.pNext ); 7372 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeatures.bufferDeviceAddress ); 7373 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeatures.bufferDeviceAddressCaptureReplay ); 7374 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeatures.bufferDeviceAddressMultiDevice ); 7375 return seed; 7376 } 7377 }; 7378 7379 template <> 7380 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceBufferDeviceAddressFeaturesEXT> 7381 { operator ()std::hash7382 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceBufferDeviceAddressFeaturesEXT const & physicalDeviceBufferDeviceAddressFeaturesEXT ) const 7383 VULKAN_HPP_NOEXCEPT 7384 { 7385 std::size_t seed = 0; 7386 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeaturesEXT.sType ); 7387 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeaturesEXT.pNext ); 7388 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeaturesEXT.bufferDeviceAddress ); 7389 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeaturesEXT.bufferDeviceAddressCaptureReplay ); 7390 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeaturesEXT.bufferDeviceAddressMultiDevice ); 7391 return seed; 7392 } 7393 }; 7394 7395 template <> 7396 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterCullingShaderFeaturesHUAWEI> 7397 { operator ()std::hash7398 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterCullingShaderFeaturesHUAWEI const & physicalDeviceClusterCullingShaderFeaturesHUAWEI ) 7399 const VULKAN_HPP_NOEXCEPT 7400 { 7401 std::size_t seed = 0; 7402 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderFeaturesHUAWEI.sType ); 7403 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderFeaturesHUAWEI.pNext ); 7404 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderFeaturesHUAWEI.clustercullingShader ); 7405 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderFeaturesHUAWEI.multiviewClusterCullingShader ); 7406 return seed; 7407 } 7408 }; 7409 7410 template <> 7411 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterCullingShaderPropertiesHUAWEI> 7412 { 7413 std::size_t operator ()std::hash7414 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterCullingShaderPropertiesHUAWEI const & physicalDeviceClusterCullingShaderPropertiesHUAWEI ) const 7415 VULKAN_HPP_NOEXCEPT 7416 { 7417 std::size_t seed = 0; 7418 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderPropertiesHUAWEI.sType ); 7419 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderPropertiesHUAWEI.pNext ); 7420 for ( size_t i = 0; i < 3; ++i ) 7421 { 7422 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderPropertiesHUAWEI.maxWorkGroupCount[i] ); 7423 } 7424 for ( size_t i = 0; i < 3; ++i ) 7425 { 7426 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderPropertiesHUAWEI.maxWorkGroupSize[i] ); 7427 } 7428 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderPropertiesHUAWEI.maxOutputClusterCount ); 7429 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderPropertiesHUAWEI.indirectBufferOffsetAlignment ); 7430 return seed; 7431 } 7432 }; 7433 7434 template <> 7435 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCoherentMemoryFeaturesAMD> 7436 { 7437 std::size_t operator ()std::hash7438 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCoherentMemoryFeaturesAMD const & physicalDeviceCoherentMemoryFeaturesAMD ) const VULKAN_HPP_NOEXCEPT 7439 { 7440 std::size_t seed = 0; 7441 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCoherentMemoryFeaturesAMD.sType ); 7442 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCoherentMemoryFeaturesAMD.pNext ); 7443 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCoherentMemoryFeaturesAMD.deviceCoherentMemory ); 7444 return seed; 7445 } 7446 }; 7447 7448 template <> 7449 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceColorWriteEnableFeaturesEXT> 7450 { 7451 std::size_t operator ()std::hash7452 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceColorWriteEnableFeaturesEXT const & physicalDeviceColorWriteEnableFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 7453 { 7454 std::size_t seed = 0; 7455 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceColorWriteEnableFeaturesEXT.sType ); 7456 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceColorWriteEnableFeaturesEXT.pNext ); 7457 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceColorWriteEnableFeaturesEXT.colorWriteEnable ); 7458 return seed; 7459 } 7460 }; 7461 7462 template <> 7463 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceComputeShaderDerivativesFeaturesNV> 7464 { operator ()std::hash7465 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceComputeShaderDerivativesFeaturesNV const & physicalDeviceComputeShaderDerivativesFeaturesNV ) 7466 const VULKAN_HPP_NOEXCEPT 7467 { 7468 std::size_t seed = 0; 7469 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceComputeShaderDerivativesFeaturesNV.sType ); 7470 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceComputeShaderDerivativesFeaturesNV.pNext ); 7471 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceComputeShaderDerivativesFeaturesNV.computeDerivativeGroupQuads ); 7472 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceComputeShaderDerivativesFeaturesNV.computeDerivativeGroupLinear ); 7473 return seed; 7474 } 7475 }; 7476 7477 template <> 7478 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceConditionalRenderingFeaturesEXT> 7479 { operator ()std::hash7480 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceConditionalRenderingFeaturesEXT const & physicalDeviceConditionalRenderingFeaturesEXT ) const 7481 VULKAN_HPP_NOEXCEPT 7482 { 7483 std::size_t seed = 0; 7484 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConditionalRenderingFeaturesEXT.sType ); 7485 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConditionalRenderingFeaturesEXT.pNext ); 7486 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConditionalRenderingFeaturesEXT.conditionalRendering ); 7487 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConditionalRenderingFeaturesEXT.inheritedConditionalRendering ); 7488 return seed; 7489 } 7490 }; 7491 7492 template <> 7493 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceConservativeRasterizationPropertiesEXT> 7494 { operator ()std::hash7495 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceConservativeRasterizationPropertiesEXT const & 7496 physicalDeviceConservativeRasterizationPropertiesEXT ) const VULKAN_HPP_NOEXCEPT 7497 { 7498 std::size_t seed = 0; 7499 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.sType ); 7500 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.pNext ); 7501 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.primitiveOverestimationSize ); 7502 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.maxExtraPrimitiveOverestimationSize ); 7503 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.extraPrimitiveOverestimationSizeGranularity ); 7504 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.primitiveUnderestimation ); 7505 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.conservativePointAndLineRasterization ); 7506 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.degenerateTrianglesRasterized ); 7507 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.degenerateLinesRasterized ); 7508 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.fullyCoveredFragmentShaderInputVariable ); 7509 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.conservativeRasterizationPostDepthCoverage ); 7510 return seed; 7511 } 7512 }; 7513 7514 template <> 7515 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixFeaturesKHR> 7516 { operator ()std::hash7517 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixFeaturesKHR const & physicalDeviceCooperativeMatrixFeaturesKHR ) const 7518 VULKAN_HPP_NOEXCEPT 7519 { 7520 std::size_t seed = 0; 7521 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixFeaturesKHR.sType ); 7522 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixFeaturesKHR.pNext ); 7523 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixFeaturesKHR.cooperativeMatrix ); 7524 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixFeaturesKHR.cooperativeMatrixRobustBufferAccess ); 7525 return seed; 7526 } 7527 }; 7528 7529 template <> 7530 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixFeaturesNV> 7531 { 7532 std::size_t operator ()std::hash7533 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixFeaturesNV const & physicalDeviceCooperativeMatrixFeaturesNV ) const VULKAN_HPP_NOEXCEPT 7534 { 7535 std::size_t seed = 0; 7536 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixFeaturesNV.sType ); 7537 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixFeaturesNV.pNext ); 7538 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixFeaturesNV.cooperativeMatrix ); 7539 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixFeaturesNV.cooperativeMatrixRobustBufferAccess ); 7540 return seed; 7541 } 7542 }; 7543 7544 template <> 7545 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixPropertiesKHR> 7546 { operator ()std::hash7547 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixPropertiesKHR const & physicalDeviceCooperativeMatrixPropertiesKHR ) const 7548 VULKAN_HPP_NOEXCEPT 7549 { 7550 std::size_t seed = 0; 7551 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixPropertiesKHR.sType ); 7552 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixPropertiesKHR.pNext ); 7553 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixPropertiesKHR.cooperativeMatrixSupportedStages ); 7554 return seed; 7555 } 7556 }; 7557 7558 template <> 7559 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixPropertiesNV> 7560 { operator ()std::hash7561 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixPropertiesNV const & physicalDeviceCooperativeMatrixPropertiesNV ) const 7562 VULKAN_HPP_NOEXCEPT 7563 { 7564 std::size_t seed = 0; 7565 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixPropertiesNV.sType ); 7566 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixPropertiesNV.pNext ); 7567 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixPropertiesNV.cooperativeMatrixSupportedStages ); 7568 return seed; 7569 } 7570 }; 7571 7572 template <> 7573 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectFeaturesNV> 7574 { operator ()std::hash7575 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectFeaturesNV const & physicalDeviceCopyMemoryIndirectFeaturesNV ) const 7576 VULKAN_HPP_NOEXCEPT 7577 { 7578 std::size_t seed = 0; 7579 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCopyMemoryIndirectFeaturesNV.sType ); 7580 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCopyMemoryIndirectFeaturesNV.pNext ); 7581 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCopyMemoryIndirectFeaturesNV.indirectCopy ); 7582 return seed; 7583 } 7584 }; 7585 7586 template <> 7587 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectPropertiesNV> 7588 { operator ()std::hash7589 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectPropertiesNV const & physicalDeviceCopyMemoryIndirectPropertiesNV ) const 7590 VULKAN_HPP_NOEXCEPT 7591 { 7592 std::size_t seed = 0; 7593 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCopyMemoryIndirectPropertiesNV.sType ); 7594 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCopyMemoryIndirectPropertiesNV.pNext ); 7595 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCopyMemoryIndirectPropertiesNV.supportedQueues ); 7596 return seed; 7597 } 7598 }; 7599 7600 template <> 7601 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCornerSampledImageFeaturesNV> 7602 { operator ()std::hash7603 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCornerSampledImageFeaturesNV const & physicalDeviceCornerSampledImageFeaturesNV ) const 7604 VULKAN_HPP_NOEXCEPT 7605 { 7606 std::size_t seed = 0; 7607 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCornerSampledImageFeaturesNV.sType ); 7608 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCornerSampledImageFeaturesNV.pNext ); 7609 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCornerSampledImageFeaturesNV.cornerSampledImage ); 7610 return seed; 7611 } 7612 }; 7613 7614 template <> 7615 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCoverageReductionModeFeaturesNV> 7616 { operator ()std::hash7617 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCoverageReductionModeFeaturesNV const & physicalDeviceCoverageReductionModeFeaturesNV ) const 7618 VULKAN_HPP_NOEXCEPT 7619 { 7620 std::size_t seed = 0; 7621 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCoverageReductionModeFeaturesNV.sType ); 7622 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCoverageReductionModeFeaturesNV.pNext ); 7623 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCoverageReductionModeFeaturesNV.coverageReductionMode ); 7624 return seed; 7625 } 7626 }; 7627 7628 template <> 7629 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCubicClampFeaturesQCOM> 7630 { operator ()std::hash7631 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCubicClampFeaturesQCOM const & physicalDeviceCubicClampFeaturesQCOM ) const VULKAN_HPP_NOEXCEPT 7632 { 7633 std::size_t seed = 0; 7634 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCubicClampFeaturesQCOM.sType ); 7635 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCubicClampFeaturesQCOM.pNext ); 7636 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCubicClampFeaturesQCOM.cubicRangeClamp ); 7637 return seed; 7638 } 7639 }; 7640 7641 template <> 7642 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCubicWeightsFeaturesQCOM> 7643 { 7644 std::size_t operator ()std::hash7645 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCubicWeightsFeaturesQCOM const & physicalDeviceCubicWeightsFeaturesQCOM ) const VULKAN_HPP_NOEXCEPT 7646 { 7647 std::size_t seed = 0; 7648 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCubicWeightsFeaturesQCOM.sType ); 7649 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCubicWeightsFeaturesQCOM.pNext ); 7650 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCubicWeightsFeaturesQCOM.selectableCubicWeights ); 7651 return seed; 7652 } 7653 }; 7654 7655 template <> 7656 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomBorderColorFeaturesEXT> 7657 { operator ()std::hash7658 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomBorderColorFeaturesEXT const & physicalDeviceCustomBorderColorFeaturesEXT ) const 7659 VULKAN_HPP_NOEXCEPT 7660 { 7661 std::size_t seed = 0; 7662 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCustomBorderColorFeaturesEXT.sType ); 7663 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCustomBorderColorFeaturesEXT.pNext ); 7664 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCustomBorderColorFeaturesEXT.customBorderColors ); 7665 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCustomBorderColorFeaturesEXT.customBorderColorWithoutFormat ); 7666 return seed; 7667 } 7668 }; 7669 7670 template <> 7671 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomBorderColorPropertiesEXT> 7672 { operator ()std::hash7673 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomBorderColorPropertiesEXT const & physicalDeviceCustomBorderColorPropertiesEXT ) const 7674 VULKAN_HPP_NOEXCEPT 7675 { 7676 std::size_t seed = 0; 7677 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCustomBorderColorPropertiesEXT.sType ); 7678 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCustomBorderColorPropertiesEXT.pNext ); 7679 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCustomBorderColorPropertiesEXT.maxCustomBorderColorSamplers ); 7680 return seed; 7681 } 7682 }; 7683 7684 template <> 7685 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV> 7686 { operator ()std::hash7687 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const & 7688 physicalDeviceDedicatedAllocationImageAliasingFeaturesNV ) const VULKAN_HPP_NOEXCEPT 7689 { 7690 std::size_t seed = 0; 7691 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDedicatedAllocationImageAliasingFeaturesNV.sType ); 7692 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDedicatedAllocationImageAliasingFeaturesNV.pNext ); 7693 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDedicatedAllocationImageAliasingFeaturesNV.dedicatedAllocationImageAliasing ); 7694 return seed; 7695 } 7696 }; 7697 7698 template <> 7699 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthBiasControlFeaturesEXT> 7700 { 7701 std::size_t operator ()std::hash7702 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthBiasControlFeaturesEXT const & physicalDeviceDepthBiasControlFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 7703 { 7704 std::size_t seed = 0; 7705 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthBiasControlFeaturesEXT.sType ); 7706 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthBiasControlFeaturesEXT.pNext ); 7707 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthBiasControlFeaturesEXT.depthBiasControl ); 7708 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthBiasControlFeaturesEXT.leastRepresentableValueForceUnormRepresentation ); 7709 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthBiasControlFeaturesEXT.floatRepresentation ); 7710 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthBiasControlFeaturesEXT.depthBiasExact ); 7711 return seed; 7712 } 7713 }; 7714 7715 template <> 7716 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClampZeroOneFeaturesEXT> 7717 { operator ()std::hash7718 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClampZeroOneFeaturesEXT const & physicalDeviceDepthClampZeroOneFeaturesEXT ) const 7719 VULKAN_HPP_NOEXCEPT 7720 { 7721 std::size_t seed = 0; 7722 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClampZeroOneFeaturesEXT.sType ); 7723 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClampZeroOneFeaturesEXT.pNext ); 7724 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClampZeroOneFeaturesEXT.depthClampZeroOne ); 7725 return seed; 7726 } 7727 }; 7728 7729 template <> 7730 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClipControlFeaturesEXT> 7731 { 7732 std::size_t operator ()std::hash7733 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClipControlFeaturesEXT const & physicalDeviceDepthClipControlFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 7734 { 7735 std::size_t seed = 0; 7736 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClipControlFeaturesEXT.sType ); 7737 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClipControlFeaturesEXT.pNext ); 7738 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClipControlFeaturesEXT.depthClipControl ); 7739 return seed; 7740 } 7741 }; 7742 7743 template <> 7744 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClipEnableFeaturesEXT> 7745 { 7746 std::size_t operator ()std::hash7747 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClipEnableFeaturesEXT const & physicalDeviceDepthClipEnableFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 7748 { 7749 std::size_t seed = 0; 7750 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClipEnableFeaturesEXT.sType ); 7751 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClipEnableFeaturesEXT.pNext ); 7752 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClipEnableFeaturesEXT.depthClipEnable ); 7753 return seed; 7754 } 7755 }; 7756 7757 template <> 7758 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthStencilResolveProperties> 7759 { operator ()std::hash7760 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthStencilResolveProperties const & physicalDeviceDepthStencilResolveProperties ) const 7761 VULKAN_HPP_NOEXCEPT 7762 { 7763 std::size_t seed = 0; 7764 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthStencilResolveProperties.sType ); 7765 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthStencilResolveProperties.pNext ); 7766 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthStencilResolveProperties.supportedDepthResolveModes ); 7767 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthStencilResolveProperties.supportedStencilResolveModes ); 7768 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthStencilResolveProperties.independentResolveNone ); 7769 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthStencilResolveProperties.independentResolve ); 7770 return seed; 7771 } 7772 }; 7773 7774 template <> 7775 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT> 7776 { operator ()std::hash7777 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT const & 7778 physicalDeviceDescriptorBufferDensityMapPropertiesEXT ) const VULKAN_HPP_NOEXCEPT 7779 { 7780 std::size_t seed = 0; 7781 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferDensityMapPropertiesEXT.sType ); 7782 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferDensityMapPropertiesEXT.pNext ); 7783 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferDensityMapPropertiesEXT.combinedImageSamplerDensityMapDescriptorSize ); 7784 return seed; 7785 } 7786 }; 7787 7788 template <> 7789 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferFeaturesEXT> 7790 { 7791 std::size_t operator ()std::hash7792 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferFeaturesEXT const & physicalDeviceDescriptorBufferFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 7793 { 7794 std::size_t seed = 0; 7795 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferFeaturesEXT.sType ); 7796 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferFeaturesEXT.pNext ); 7797 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferFeaturesEXT.descriptorBuffer ); 7798 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferFeaturesEXT.descriptorBufferCaptureReplay ); 7799 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferFeaturesEXT.descriptorBufferImageLayoutIgnored ); 7800 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferFeaturesEXT.descriptorBufferPushDescriptors ); 7801 return seed; 7802 } 7803 }; 7804 7805 template <> 7806 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferPropertiesEXT> 7807 { operator ()std::hash7808 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferPropertiesEXT const & physicalDeviceDescriptorBufferPropertiesEXT ) const 7809 VULKAN_HPP_NOEXCEPT 7810 { 7811 std::size_t seed = 0; 7812 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.sType ); 7813 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.pNext ); 7814 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.combinedImageSamplerDescriptorSingleArray ); 7815 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.bufferlessPushDescriptors ); 7816 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.allowSamplerImageViewPostSubmitCreation ); 7817 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.descriptorBufferOffsetAlignment ); 7818 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.maxDescriptorBufferBindings ); 7819 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.maxResourceDescriptorBufferBindings ); 7820 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.maxSamplerDescriptorBufferBindings ); 7821 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.maxEmbeddedImmutableSamplerBindings ); 7822 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.maxEmbeddedImmutableSamplers ); 7823 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.bufferCaptureReplayDescriptorDataSize ); 7824 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.imageCaptureReplayDescriptorDataSize ); 7825 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.imageViewCaptureReplayDescriptorDataSize ); 7826 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.samplerCaptureReplayDescriptorDataSize ); 7827 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.accelerationStructureCaptureReplayDescriptorDataSize ); 7828 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.samplerDescriptorSize ); 7829 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.combinedImageSamplerDescriptorSize ); 7830 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.sampledImageDescriptorSize ); 7831 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.storageImageDescriptorSize ); 7832 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.uniformTexelBufferDescriptorSize ); 7833 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.robustUniformTexelBufferDescriptorSize ); 7834 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.storageTexelBufferDescriptorSize ); 7835 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.robustStorageTexelBufferDescriptorSize ); 7836 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.uniformBufferDescriptorSize ); 7837 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.robustUniformBufferDescriptorSize ); 7838 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.storageBufferDescriptorSize ); 7839 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.robustStorageBufferDescriptorSize ); 7840 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.inputAttachmentDescriptorSize ); 7841 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.accelerationStructureDescriptorSize ); 7842 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.maxSamplerDescriptorBufferRange ); 7843 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.maxResourceDescriptorBufferRange ); 7844 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.samplerDescriptorBufferAddressSpaceSize ); 7845 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.resourceDescriptorBufferAddressSpaceSize ); 7846 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.descriptorBufferAddressSpaceSize ); 7847 return seed; 7848 } 7849 }; 7850 7851 template <> 7852 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorIndexingFeatures> 7853 { 7854 std::size_t operator ()std::hash7855 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorIndexingFeatures const & physicalDeviceDescriptorIndexingFeatures ) const VULKAN_HPP_NOEXCEPT 7856 { 7857 std::size_t seed = 0; 7858 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.sType ); 7859 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.pNext ); 7860 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderInputAttachmentArrayDynamicIndexing ); 7861 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderUniformTexelBufferArrayDynamicIndexing ); 7862 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderStorageTexelBufferArrayDynamicIndexing ); 7863 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderUniformBufferArrayNonUniformIndexing ); 7864 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderSampledImageArrayNonUniformIndexing ); 7865 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderStorageBufferArrayNonUniformIndexing ); 7866 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderStorageImageArrayNonUniformIndexing ); 7867 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderInputAttachmentArrayNonUniformIndexing ); 7868 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderUniformTexelBufferArrayNonUniformIndexing ); 7869 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderStorageTexelBufferArrayNonUniformIndexing ); 7870 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingUniformBufferUpdateAfterBind ); 7871 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingSampledImageUpdateAfterBind ); 7872 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingStorageImageUpdateAfterBind ); 7873 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingStorageBufferUpdateAfterBind ); 7874 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingUniformTexelBufferUpdateAfterBind ); 7875 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingStorageTexelBufferUpdateAfterBind ); 7876 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingUpdateUnusedWhilePending ); 7877 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingPartiallyBound ); 7878 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingVariableDescriptorCount ); 7879 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.runtimeDescriptorArray ); 7880 return seed; 7881 } 7882 }; 7883 7884 template <> 7885 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorIndexingProperties> 7886 { operator ()std::hash7887 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorIndexingProperties const & physicalDeviceDescriptorIndexingProperties ) const 7888 VULKAN_HPP_NOEXCEPT 7889 { 7890 std::size_t seed = 0; 7891 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.sType ); 7892 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.pNext ); 7893 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxUpdateAfterBindDescriptorsInAllPools ); 7894 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.shaderUniformBufferArrayNonUniformIndexingNative ); 7895 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.shaderSampledImageArrayNonUniformIndexingNative ); 7896 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.shaderStorageBufferArrayNonUniformIndexingNative ); 7897 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.shaderStorageImageArrayNonUniformIndexingNative ); 7898 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.shaderInputAttachmentArrayNonUniformIndexingNative ); 7899 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.robustBufferAccessUpdateAfterBind ); 7900 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.quadDivergentImplicitLod ); 7901 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindSamplers ); 7902 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindUniformBuffers ); 7903 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindStorageBuffers ); 7904 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindSampledImages ); 7905 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindStorageImages ); 7906 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindInputAttachments ); 7907 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxPerStageUpdateAfterBindResources ); 7908 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindSamplers ); 7909 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindUniformBuffers ); 7910 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic ); 7911 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindStorageBuffers ); 7912 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic ); 7913 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindSampledImages ); 7914 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindStorageImages ); 7915 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindInputAttachments ); 7916 return seed; 7917 } 7918 }; 7919 7920 template <> 7921 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorPoolOverallocationFeaturesNV> 7922 { operator ()std::hash7923 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorPoolOverallocationFeaturesNV const & 7924 physicalDeviceDescriptorPoolOverallocationFeaturesNV ) const VULKAN_HPP_NOEXCEPT 7925 { 7926 std::size_t seed = 0; 7927 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorPoolOverallocationFeaturesNV.sType ); 7928 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorPoolOverallocationFeaturesNV.pNext ); 7929 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorPoolOverallocationFeaturesNV.descriptorPoolOverallocation ); 7930 return seed; 7931 } 7932 }; 7933 7934 template <> 7935 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE> 7936 { 7937 std::size_t operator ()std::hash7938 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE const & physicalDeviceDescriptorSetHostMappingFeaturesVALVE ) const 7939 VULKAN_HPP_NOEXCEPT 7940 { 7941 std::size_t seed = 0; 7942 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorSetHostMappingFeaturesVALVE.sType ); 7943 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorSetHostMappingFeaturesVALVE.pNext ); 7944 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorSetHostMappingFeaturesVALVE.descriptorSetHostMapping ); 7945 return seed; 7946 } 7947 }; 7948 7949 template <> 7950 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV> 7951 { operator ()std::hash7952 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV const & 7953 physicalDeviceDeviceGeneratedCommandsComputeFeaturesNV ) const VULKAN_HPP_NOEXCEPT 7954 { 7955 std::size_t seed = 0; 7956 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsComputeFeaturesNV.sType ); 7957 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsComputeFeaturesNV.pNext ); 7958 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsComputeFeaturesNV.deviceGeneratedCompute ); 7959 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsComputeFeaturesNV.deviceGeneratedComputePipelines ); 7960 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsComputeFeaturesNV.deviceGeneratedComputeCaptureReplay ); 7961 return seed; 7962 } 7963 }; 7964 7965 template <> 7966 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsFeaturesNV> 7967 { operator ()std::hash7968 std::size_t operator()( 7969 VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsFeaturesNV const & physicalDeviceDeviceGeneratedCommandsFeaturesNV ) const VULKAN_HPP_NOEXCEPT 7970 { 7971 std::size_t seed = 0; 7972 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsFeaturesNV.sType ); 7973 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsFeaturesNV.pNext ); 7974 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsFeaturesNV.deviceGeneratedCommands ); 7975 return seed; 7976 } 7977 }; 7978 7979 template <> 7980 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsPropertiesNV> 7981 { operator ()std::hash7982 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsPropertiesNV const & physicalDeviceDeviceGeneratedCommandsPropertiesNV ) 7983 const VULKAN_HPP_NOEXCEPT 7984 { 7985 std::size_t seed = 0; 7986 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.sType ); 7987 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.pNext ); 7988 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxGraphicsShaderGroupCount ); 7989 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxIndirectSequenceCount ); 7990 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxIndirectCommandsTokenCount ); 7991 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxIndirectCommandsStreamCount ); 7992 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxIndirectCommandsTokenOffset ); 7993 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxIndirectCommandsStreamStride ); 7994 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.minSequencesCountBufferOffsetAlignment ); 7995 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.minSequencesIndexBufferOffsetAlignment ); 7996 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.minIndirectCommandsBufferOffsetAlignment ); 7997 return seed; 7998 } 7999 }; 8000 8001 template <> 8002 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceMemoryReportFeaturesEXT> 8003 { operator ()std::hash8004 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceMemoryReportFeaturesEXT const & physicalDeviceDeviceMemoryReportFeaturesEXT ) const 8005 VULKAN_HPP_NOEXCEPT 8006 { 8007 std::size_t seed = 0; 8008 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceMemoryReportFeaturesEXT.sType ); 8009 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceMemoryReportFeaturesEXT.pNext ); 8010 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceMemoryReportFeaturesEXT.deviceMemoryReport ); 8011 return seed; 8012 } 8013 }; 8014 8015 template <> 8016 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDiagnosticsConfigFeaturesNV> 8017 { 8018 std::size_t operator ()std::hash8019 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDiagnosticsConfigFeaturesNV const & physicalDeviceDiagnosticsConfigFeaturesNV ) const VULKAN_HPP_NOEXCEPT 8020 { 8021 std::size_t seed = 0; 8022 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDiagnosticsConfigFeaturesNV.sType ); 8023 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDiagnosticsConfigFeaturesNV.pNext ); 8024 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDiagnosticsConfigFeaturesNV.diagnosticsConfig ); 8025 return seed; 8026 } 8027 }; 8028 8029 template <> 8030 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDiscardRectanglePropertiesEXT> 8031 { operator ()std::hash8032 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDiscardRectanglePropertiesEXT const & physicalDeviceDiscardRectanglePropertiesEXT ) const 8033 VULKAN_HPP_NOEXCEPT 8034 { 8035 std::size_t seed = 0; 8036 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDiscardRectanglePropertiesEXT.sType ); 8037 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDiscardRectanglePropertiesEXT.pNext ); 8038 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDiscardRectanglePropertiesEXT.maxDiscardRectangles ); 8039 return seed; 8040 } 8041 }; 8042 8043 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 8044 template <> 8045 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDisplacementMicromapFeaturesNV> 8046 { operator ()std::hash8047 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDisplacementMicromapFeaturesNV const & physicalDeviceDisplacementMicromapFeaturesNV ) const 8048 VULKAN_HPP_NOEXCEPT 8049 { 8050 std::size_t seed = 0; 8051 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDisplacementMicromapFeaturesNV.sType ); 8052 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDisplacementMicromapFeaturesNV.pNext ); 8053 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDisplacementMicromapFeaturesNV.displacementMicromap ); 8054 return seed; 8055 } 8056 }; 8057 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 8058 8059 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 8060 template <> 8061 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDisplacementMicromapPropertiesNV> 8062 { operator ()std::hash8063 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDisplacementMicromapPropertiesNV const & physicalDeviceDisplacementMicromapPropertiesNV ) const 8064 VULKAN_HPP_NOEXCEPT 8065 { 8066 std::size_t seed = 0; 8067 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDisplacementMicromapPropertiesNV.sType ); 8068 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDisplacementMicromapPropertiesNV.pNext ); 8069 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDisplacementMicromapPropertiesNV.maxDisplacementMicromapSubdivisionLevel ); 8070 return seed; 8071 } 8072 }; 8073 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 8074 8075 template <> 8076 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDriverProperties> 8077 { operator ()std::hash8078 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDriverProperties const & physicalDeviceDriverProperties ) const VULKAN_HPP_NOEXCEPT 8079 { 8080 std::size_t seed = 0; 8081 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDriverProperties.sType ); 8082 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDriverProperties.pNext ); 8083 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDriverProperties.driverID ); 8084 for ( size_t i = 0; i < VK_MAX_DRIVER_NAME_SIZE; ++i ) 8085 { 8086 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDriverProperties.driverName[i] ); 8087 } 8088 for ( size_t i = 0; i < VK_MAX_DRIVER_INFO_SIZE; ++i ) 8089 { 8090 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDriverProperties.driverInfo[i] ); 8091 } 8092 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDriverProperties.conformanceVersion ); 8093 return seed; 8094 } 8095 }; 8096 8097 template <> 8098 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDrmPropertiesEXT> 8099 { operator ()std::hash8100 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDrmPropertiesEXT const & physicalDeviceDrmPropertiesEXT ) const VULKAN_HPP_NOEXCEPT 8101 { 8102 std::size_t seed = 0; 8103 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDrmPropertiesEXT.sType ); 8104 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDrmPropertiesEXT.pNext ); 8105 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDrmPropertiesEXT.hasPrimary ); 8106 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDrmPropertiesEXT.hasRender ); 8107 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDrmPropertiesEXT.primaryMajor ); 8108 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDrmPropertiesEXT.primaryMinor ); 8109 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDrmPropertiesEXT.renderMajor ); 8110 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDrmPropertiesEXT.renderMinor ); 8111 return seed; 8112 } 8113 }; 8114 8115 template <> 8116 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingFeatures> 8117 { 8118 std::size_t operator ()std::hash8119 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingFeatures const & physicalDeviceDynamicRenderingFeatures ) const VULKAN_HPP_NOEXCEPT 8120 { 8121 std::size_t seed = 0; 8122 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDynamicRenderingFeatures.sType ); 8123 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDynamicRenderingFeatures.pNext ); 8124 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDynamicRenderingFeatures.dynamicRendering ); 8125 return seed; 8126 } 8127 }; 8128 8129 template <> 8130 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT> 8131 { operator ()std::hash8132 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT const & 8133 physicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 8134 { 8135 std::size_t seed = 0; 8136 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT.sType ); 8137 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT.pNext ); 8138 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT.dynamicRenderingUnusedAttachments ); 8139 return seed; 8140 } 8141 }; 8142 8143 template <> 8144 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExclusiveScissorFeaturesNV> 8145 { 8146 std::size_t operator ()std::hash8147 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExclusiveScissorFeaturesNV const & physicalDeviceExclusiveScissorFeaturesNV ) const VULKAN_HPP_NOEXCEPT 8148 { 8149 std::size_t seed = 0; 8150 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExclusiveScissorFeaturesNV.sType ); 8151 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExclusiveScissorFeaturesNV.pNext ); 8152 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExclusiveScissorFeaturesNV.exclusiveScissor ); 8153 return seed; 8154 } 8155 }; 8156 8157 template <> 8158 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState2FeaturesEXT> 8159 { operator ()std::hash8160 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState2FeaturesEXT const & physicalDeviceExtendedDynamicState2FeaturesEXT ) const 8161 VULKAN_HPP_NOEXCEPT 8162 { 8163 std::size_t seed = 0; 8164 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState2FeaturesEXT.sType ); 8165 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState2FeaturesEXT.pNext ); 8166 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState2FeaturesEXT.extendedDynamicState2 ); 8167 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState2FeaturesEXT.extendedDynamicState2LogicOp ); 8168 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState2FeaturesEXT.extendedDynamicState2PatchControlPoints ); 8169 return seed; 8170 } 8171 }; 8172 8173 template <> 8174 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState3FeaturesEXT> 8175 { operator ()std::hash8176 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState3FeaturesEXT const & physicalDeviceExtendedDynamicState3FeaturesEXT ) const 8177 VULKAN_HPP_NOEXCEPT 8178 { 8179 std::size_t seed = 0; 8180 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.sType ); 8181 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.pNext ); 8182 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3TessellationDomainOrigin ); 8183 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3DepthClampEnable ); 8184 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3PolygonMode ); 8185 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3RasterizationSamples ); 8186 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3SampleMask ); 8187 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3AlphaToCoverageEnable ); 8188 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3AlphaToOneEnable ); 8189 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3LogicOpEnable ); 8190 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ColorBlendEnable ); 8191 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ColorBlendEquation ); 8192 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ColorWriteMask ); 8193 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3RasterizationStream ); 8194 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ConservativeRasterizationMode ); 8195 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ExtraPrimitiveOverestimationSize ); 8196 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3DepthClipEnable ); 8197 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3SampleLocationsEnable ); 8198 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ColorBlendAdvanced ); 8199 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ProvokingVertexMode ); 8200 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3LineRasterizationMode ); 8201 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3LineStippleEnable ); 8202 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3DepthClipNegativeOneToOne ); 8203 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ViewportWScalingEnable ); 8204 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ViewportSwizzle ); 8205 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3CoverageToColorEnable ); 8206 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3CoverageToColorLocation ); 8207 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3CoverageModulationMode ); 8208 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3CoverageModulationTableEnable ); 8209 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3CoverageModulationTable ); 8210 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3CoverageReductionMode ); 8211 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3RepresentativeFragmentTestEnable ); 8212 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ShadingRateImageEnable ); 8213 return seed; 8214 } 8215 }; 8216 8217 template <> 8218 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState3PropertiesEXT> 8219 { operator ()std::hash8220 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState3PropertiesEXT const & physicalDeviceExtendedDynamicState3PropertiesEXT ) 8221 const VULKAN_HPP_NOEXCEPT 8222 { 8223 std::size_t seed = 0; 8224 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3PropertiesEXT.sType ); 8225 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3PropertiesEXT.pNext ); 8226 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3PropertiesEXT.dynamicPrimitiveTopologyUnrestricted ); 8227 return seed; 8228 } 8229 }; 8230 8231 template <> 8232 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicStateFeaturesEXT> 8233 { operator ()std::hash8234 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicStateFeaturesEXT const & physicalDeviceExtendedDynamicStateFeaturesEXT ) const 8235 VULKAN_HPP_NOEXCEPT 8236 { 8237 std::size_t seed = 0; 8238 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicStateFeaturesEXT.sType ); 8239 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicStateFeaturesEXT.pNext ); 8240 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicStateFeaturesEXT.extendedDynamicState ); 8241 return seed; 8242 } 8243 }; 8244 8245 template <> 8246 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo> 8247 { operator ()std::hash8248 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo const & physicalDeviceExternalBufferInfo ) const VULKAN_HPP_NOEXCEPT 8249 { 8250 std::size_t seed = 0; 8251 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalBufferInfo.sType ); 8252 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalBufferInfo.pNext ); 8253 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalBufferInfo.flags ); 8254 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalBufferInfo.usage ); 8255 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalBufferInfo.handleType ); 8256 return seed; 8257 } 8258 }; 8259 8260 template <> 8261 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo> 8262 { operator ()std::hash8263 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo const & physicalDeviceExternalFenceInfo ) const VULKAN_HPP_NOEXCEPT 8264 { 8265 std::size_t seed = 0; 8266 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFenceInfo.sType ); 8267 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFenceInfo.pNext ); 8268 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFenceInfo.handleType ); 8269 return seed; 8270 } 8271 }; 8272 8273 # if defined( VK_USE_PLATFORM_ANDROID_KHR ) 8274 template <> 8275 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFormatResolveFeaturesANDROID> 8276 { 8277 std::size_t operator ()std::hash8278 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFormatResolveFeaturesANDROID const & physicalDeviceExternalFormatResolveFeaturesANDROID ) const 8279 VULKAN_HPP_NOEXCEPT 8280 { 8281 std::size_t seed = 0; 8282 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFormatResolveFeaturesANDROID.sType ); 8283 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFormatResolveFeaturesANDROID.pNext ); 8284 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFormatResolveFeaturesANDROID.externalFormatResolve ); 8285 return seed; 8286 } 8287 }; 8288 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ 8289 8290 # if defined( VK_USE_PLATFORM_ANDROID_KHR ) 8291 template <> 8292 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFormatResolvePropertiesANDROID> 8293 { operator ()std::hash8294 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFormatResolvePropertiesANDROID const & 8295 physicalDeviceExternalFormatResolvePropertiesANDROID ) const VULKAN_HPP_NOEXCEPT 8296 { 8297 std::size_t seed = 0; 8298 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFormatResolvePropertiesANDROID.sType ); 8299 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFormatResolvePropertiesANDROID.pNext ); 8300 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFormatResolvePropertiesANDROID.nullColorAttachmentWithExternalFormatResolve ); 8301 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFormatResolvePropertiesANDROID.externalFormatResolveChromaOffsetX ); 8302 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFormatResolvePropertiesANDROID.externalFormatResolveChromaOffsetY ); 8303 return seed; 8304 } 8305 }; 8306 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ 8307 8308 template <> 8309 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalImageFormatInfo> 8310 { 8311 std::size_t operator ()std::hash8312 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalImageFormatInfo const & physicalDeviceExternalImageFormatInfo ) const VULKAN_HPP_NOEXCEPT 8313 { 8314 std::size_t seed = 0; 8315 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalImageFormatInfo.sType ); 8316 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalImageFormatInfo.pNext ); 8317 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalImageFormatInfo.handleType ); 8318 return seed; 8319 } 8320 }; 8321 8322 template <> 8323 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryHostPropertiesEXT> 8324 { operator ()std::hash8325 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryHostPropertiesEXT const & physicalDeviceExternalMemoryHostPropertiesEXT ) const 8326 VULKAN_HPP_NOEXCEPT 8327 { 8328 std::size_t seed = 0; 8329 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalMemoryHostPropertiesEXT.sType ); 8330 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalMemoryHostPropertiesEXT.pNext ); 8331 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalMemoryHostPropertiesEXT.minImportedHostPointerAlignment ); 8332 return seed; 8333 } 8334 }; 8335 8336 template <> 8337 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryRDMAFeaturesNV> 8338 { operator ()std::hash8339 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryRDMAFeaturesNV const & physicalDeviceExternalMemoryRDMAFeaturesNV ) const 8340 VULKAN_HPP_NOEXCEPT 8341 { 8342 std::size_t seed = 0; 8343 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalMemoryRDMAFeaturesNV.sType ); 8344 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalMemoryRDMAFeaturesNV.pNext ); 8345 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalMemoryRDMAFeaturesNV.externalMemoryRDMA ); 8346 return seed; 8347 } 8348 }; 8349 8350 # if defined( VK_USE_PLATFORM_SCREEN_QNX ) 8351 template <> 8352 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX> 8353 { 8354 std::size_t operator ()std::hash8355 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX const & physicalDeviceExternalMemoryScreenBufferFeaturesQNX ) const 8356 VULKAN_HPP_NOEXCEPT 8357 { 8358 std::size_t seed = 0; 8359 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalMemoryScreenBufferFeaturesQNX.sType ); 8360 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalMemoryScreenBufferFeaturesQNX.pNext ); 8361 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalMemoryScreenBufferFeaturesQNX.screenBufferImport ); 8362 return seed; 8363 } 8364 }; 8365 # endif /*VK_USE_PLATFORM_SCREEN_QNX*/ 8366 8367 template <> 8368 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo> 8369 { operator ()std::hash8370 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo const & physicalDeviceExternalSemaphoreInfo ) const VULKAN_HPP_NOEXCEPT 8371 { 8372 std::size_t seed = 0; 8373 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalSemaphoreInfo.sType ); 8374 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalSemaphoreInfo.pNext ); 8375 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalSemaphoreInfo.handleType ); 8376 return seed; 8377 } 8378 }; 8379 8380 template <> 8381 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFaultFeaturesEXT> 8382 { operator ()std::hash8383 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFaultFeaturesEXT const & physicalDeviceFaultFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 8384 { 8385 std::size_t seed = 0; 8386 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFaultFeaturesEXT.sType ); 8387 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFaultFeaturesEXT.pNext ); 8388 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFaultFeaturesEXT.deviceFault ); 8389 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFaultFeaturesEXT.deviceFaultVendorBinary ); 8390 return seed; 8391 } 8392 }; 8393 8394 template <> 8395 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2> 8396 { operator ()std::hash8397 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 const & physicalDeviceFeatures2 ) const VULKAN_HPP_NOEXCEPT 8398 { 8399 std::size_t seed = 0; 8400 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures2.sType ); 8401 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures2.pNext ); 8402 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures2.features ); 8403 return seed; 8404 } 8405 }; 8406 8407 template <> 8408 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFloatControlsProperties> 8409 { 8410 std::size_t operator ()std::hash8411 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFloatControlsProperties const & physicalDeviceFloatControlsProperties ) const VULKAN_HPP_NOEXCEPT 8412 { 8413 std::size_t seed = 0; 8414 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.sType ); 8415 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.pNext ); 8416 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.denormBehaviorIndependence ); 8417 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.roundingModeIndependence ); 8418 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderSignedZeroInfNanPreserveFloat16 ); 8419 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderSignedZeroInfNanPreserveFloat32 ); 8420 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderSignedZeroInfNanPreserveFloat64 ); 8421 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderDenormPreserveFloat16 ); 8422 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderDenormPreserveFloat32 ); 8423 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderDenormPreserveFloat64 ); 8424 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderDenormFlushToZeroFloat16 ); 8425 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderDenormFlushToZeroFloat32 ); 8426 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderDenormFlushToZeroFloat64 ); 8427 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTEFloat16 ); 8428 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTEFloat32 ); 8429 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTEFloat64 ); 8430 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTZFloat16 ); 8431 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTZFloat32 ); 8432 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTZFloat64 ); 8433 return seed; 8434 } 8435 }; 8436 8437 template <> 8438 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMap2FeaturesEXT> 8439 { operator ()std::hash8440 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMap2FeaturesEXT const & physicalDeviceFragmentDensityMap2FeaturesEXT ) const 8441 VULKAN_HPP_NOEXCEPT 8442 { 8443 std::size_t seed = 0; 8444 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMap2FeaturesEXT.sType ); 8445 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMap2FeaturesEXT.pNext ); 8446 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMap2FeaturesEXT.fragmentDensityMapDeferred ); 8447 return seed; 8448 } 8449 }; 8450 8451 template <> 8452 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMap2PropertiesEXT> 8453 { operator ()std::hash8454 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMap2PropertiesEXT const & physicalDeviceFragmentDensityMap2PropertiesEXT ) const 8455 VULKAN_HPP_NOEXCEPT 8456 { 8457 std::size_t seed = 0; 8458 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMap2PropertiesEXT.sType ); 8459 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMap2PropertiesEXT.pNext ); 8460 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMap2PropertiesEXT.subsampledLoads ); 8461 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMap2PropertiesEXT.subsampledCoarseReconstructionEarlyAccess ); 8462 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMap2PropertiesEXT.maxSubsampledArrayLayers ); 8463 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMap2PropertiesEXT.maxDescriptorSetSubsampledSamplers ); 8464 return seed; 8465 } 8466 }; 8467 8468 template <> 8469 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapFeaturesEXT> 8470 { operator ()std::hash8471 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapFeaturesEXT const & physicalDeviceFragmentDensityMapFeaturesEXT ) const 8472 VULKAN_HPP_NOEXCEPT 8473 { 8474 std::size_t seed = 0; 8475 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapFeaturesEXT.sType ); 8476 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapFeaturesEXT.pNext ); 8477 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapFeaturesEXT.fragmentDensityMap ); 8478 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapFeaturesEXT.fragmentDensityMapDynamic ); 8479 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapFeaturesEXT.fragmentDensityMapNonSubsampledImages ); 8480 return seed; 8481 } 8482 }; 8483 8484 template <> 8485 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM> 8486 { 8487 std::size_t operator ()std::hash8488 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM const & physicalDeviceFragmentDensityMapOffsetFeaturesQCOM ) const 8489 VULKAN_HPP_NOEXCEPT 8490 { 8491 std::size_t seed = 0; 8492 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetFeaturesQCOM.sType ); 8493 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetFeaturesQCOM.pNext ); 8494 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetFeaturesQCOM.fragmentDensityMapOffset ); 8495 return seed; 8496 } 8497 }; 8498 8499 template <> 8500 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM> 8501 { operator ()std::hash8502 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM const & 8503 physicalDeviceFragmentDensityMapOffsetPropertiesQCOM ) const VULKAN_HPP_NOEXCEPT 8504 { 8505 std::size_t seed = 0; 8506 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetPropertiesQCOM.sType ); 8507 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetPropertiesQCOM.pNext ); 8508 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetPropertiesQCOM.fragmentDensityOffsetGranularity ); 8509 return seed; 8510 } 8511 }; 8512 8513 template <> 8514 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapPropertiesEXT> 8515 { operator ()std::hash8516 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapPropertiesEXT const & physicalDeviceFragmentDensityMapPropertiesEXT ) const 8517 VULKAN_HPP_NOEXCEPT 8518 { 8519 std::size_t seed = 0; 8520 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapPropertiesEXT.sType ); 8521 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapPropertiesEXT.pNext ); 8522 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapPropertiesEXT.minFragmentDensityTexelSize ); 8523 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapPropertiesEXT.maxFragmentDensityTexelSize ); 8524 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapPropertiesEXT.fragmentDensityInvocations ); 8525 return seed; 8526 } 8527 }; 8528 8529 template <> 8530 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderBarycentricFeaturesKHR> 8531 { 8532 std::size_t operator ()std::hash8533 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderBarycentricFeaturesKHR const & physicalDeviceFragmentShaderBarycentricFeaturesKHR ) const 8534 VULKAN_HPP_NOEXCEPT 8535 { 8536 std::size_t seed = 0; 8537 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderBarycentricFeaturesKHR.sType ); 8538 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderBarycentricFeaturesKHR.pNext ); 8539 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderBarycentricFeaturesKHR.fragmentShaderBarycentric ); 8540 return seed; 8541 } 8542 }; 8543 8544 template <> 8545 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderBarycentricPropertiesKHR> 8546 { operator ()std::hash8547 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderBarycentricPropertiesKHR const & 8548 physicalDeviceFragmentShaderBarycentricPropertiesKHR ) const VULKAN_HPP_NOEXCEPT 8549 { 8550 std::size_t seed = 0; 8551 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderBarycentricPropertiesKHR.sType ); 8552 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderBarycentricPropertiesKHR.pNext ); 8553 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderBarycentricPropertiesKHR.triStripVertexOrderIndependentOfProvokingVertex ); 8554 return seed; 8555 } 8556 }; 8557 8558 template <> 8559 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderInterlockFeaturesEXT> 8560 { operator ()std::hash8561 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderInterlockFeaturesEXT const & physicalDeviceFragmentShaderInterlockFeaturesEXT ) 8562 const VULKAN_HPP_NOEXCEPT 8563 { 8564 std::size_t seed = 0; 8565 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderInterlockFeaturesEXT.sType ); 8566 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderInterlockFeaturesEXT.pNext ); 8567 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderInterlockFeaturesEXT.fragmentShaderSampleInterlock ); 8568 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderInterlockFeaturesEXT.fragmentShaderPixelInterlock ); 8569 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderInterlockFeaturesEXT.fragmentShaderShadingRateInterlock ); 8570 return seed; 8571 } 8572 }; 8573 8574 template <> 8575 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateEnumsFeaturesNV> 8576 { operator ()std::hash8577 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateEnumsFeaturesNV const & physicalDeviceFragmentShadingRateEnumsFeaturesNV ) 8578 const VULKAN_HPP_NOEXCEPT 8579 { 8580 std::size_t seed = 0; 8581 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateEnumsFeaturesNV.sType ); 8582 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateEnumsFeaturesNV.pNext ); 8583 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateEnumsFeaturesNV.fragmentShadingRateEnums ); 8584 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateEnumsFeaturesNV.supersampleFragmentShadingRates ); 8585 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateEnumsFeaturesNV.noInvocationFragmentShadingRates ); 8586 return seed; 8587 } 8588 }; 8589 8590 template <> 8591 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateEnumsPropertiesNV> 8592 { 8593 std::size_t operator ()std::hash8594 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateEnumsPropertiesNV const & physicalDeviceFragmentShadingRateEnumsPropertiesNV ) const 8595 VULKAN_HPP_NOEXCEPT 8596 { 8597 std::size_t seed = 0; 8598 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateEnumsPropertiesNV.sType ); 8599 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateEnumsPropertiesNV.pNext ); 8600 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateEnumsPropertiesNV.maxFragmentShadingRateInvocationCount ); 8601 return seed; 8602 } 8603 }; 8604 8605 template <> 8606 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateFeaturesKHR> 8607 { operator ()std::hash8608 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateFeaturesKHR const & physicalDeviceFragmentShadingRateFeaturesKHR ) const 8609 VULKAN_HPP_NOEXCEPT 8610 { 8611 std::size_t seed = 0; 8612 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateFeaturesKHR.sType ); 8613 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateFeaturesKHR.pNext ); 8614 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateFeaturesKHR.pipelineFragmentShadingRate ); 8615 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateFeaturesKHR.primitiveFragmentShadingRate ); 8616 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateFeaturesKHR.attachmentFragmentShadingRate ); 8617 return seed; 8618 } 8619 }; 8620 8621 template <> 8622 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR> 8623 { operator ()std::hash8624 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR const & physicalDeviceFragmentShadingRateKHR ) const VULKAN_HPP_NOEXCEPT 8625 { 8626 std::size_t seed = 0; 8627 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateKHR.sType ); 8628 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateKHR.pNext ); 8629 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateKHR.sampleCounts ); 8630 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateKHR.fragmentSize ); 8631 return seed; 8632 } 8633 }; 8634 8635 template <> 8636 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRatePropertiesKHR> 8637 { operator ()std::hash8638 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRatePropertiesKHR const & physicalDeviceFragmentShadingRatePropertiesKHR ) const 8639 VULKAN_HPP_NOEXCEPT 8640 { 8641 std::size_t seed = 0; 8642 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.sType ); 8643 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.pNext ); 8644 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.minFragmentShadingRateAttachmentTexelSize ); 8645 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentShadingRateAttachmentTexelSize ); 8646 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentShadingRateAttachmentTexelSizeAspectRatio ); 8647 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.primitiveFragmentShadingRateWithMultipleViewports ); 8648 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.layeredShadingRateAttachments ); 8649 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateNonTrivialCombinerOps ); 8650 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentSize ); 8651 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentSizeAspectRatio ); 8652 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentShadingRateCoverageSamples ); 8653 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentShadingRateRasterizationSamples ); 8654 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithShaderDepthStencilWrites ); 8655 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithSampleMask ); 8656 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithShaderSampleMask ); 8657 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithConservativeRasterization ); 8658 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithFragmentShaderInterlock ); 8659 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithCustomSampleLocations ); 8660 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateStrictMultiplyCombiner ); 8661 return seed; 8662 } 8663 }; 8664 8665 template <> 8666 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFrameBoundaryFeaturesEXT> 8667 { 8668 std::size_t operator ()std::hash8669 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFrameBoundaryFeaturesEXT const & physicalDeviceFrameBoundaryFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 8670 { 8671 std::size_t seed = 0; 8672 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFrameBoundaryFeaturesEXT.sType ); 8673 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFrameBoundaryFeaturesEXT.pNext ); 8674 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFrameBoundaryFeaturesEXT.frameBoundary ); 8675 return seed; 8676 } 8677 }; 8678 8679 template <> 8680 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceGlobalPriorityQueryFeaturesKHR> 8681 { operator ()std::hash8682 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceGlobalPriorityQueryFeaturesKHR const & physicalDeviceGlobalPriorityQueryFeaturesKHR ) const 8683 VULKAN_HPP_NOEXCEPT 8684 { 8685 std::size_t seed = 0; 8686 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGlobalPriorityQueryFeaturesKHR.sType ); 8687 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGlobalPriorityQueryFeaturesKHR.pNext ); 8688 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGlobalPriorityQueryFeaturesKHR.globalPriorityQuery ); 8689 return seed; 8690 } 8691 }; 8692 8693 template <> 8694 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT> 8695 { operator ()std::hash8696 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT const & physicalDeviceGraphicsPipelineLibraryFeaturesEXT ) 8697 const VULKAN_HPP_NOEXCEPT 8698 { 8699 std::size_t seed = 0; 8700 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGraphicsPipelineLibraryFeaturesEXT.sType ); 8701 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGraphicsPipelineLibraryFeaturesEXT.pNext ); 8702 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGraphicsPipelineLibraryFeaturesEXT.graphicsPipelineLibrary ); 8703 return seed; 8704 } 8705 }; 8706 8707 template <> 8708 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT> 8709 { 8710 std::size_t operator ()std::hash8711 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT const & physicalDeviceGraphicsPipelineLibraryPropertiesEXT ) const 8712 VULKAN_HPP_NOEXCEPT 8713 { 8714 std::size_t seed = 0; 8715 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGraphicsPipelineLibraryPropertiesEXT.sType ); 8716 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGraphicsPipelineLibraryPropertiesEXT.pNext ); 8717 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGraphicsPipelineLibraryPropertiesEXT.graphicsPipelineLibraryFastLinking ); 8718 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGraphicsPipelineLibraryPropertiesEXT.graphicsPipelineLibraryIndependentInterpolationDecoration ); 8719 return seed; 8720 } 8721 }; 8722 8723 template <> 8724 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties> 8725 { operator ()std::hash8726 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties const & physicalDeviceGroupProperties ) const VULKAN_HPP_NOEXCEPT 8727 { 8728 std::size_t seed = 0; 8729 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGroupProperties.sType ); 8730 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGroupProperties.pNext ); 8731 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGroupProperties.physicalDeviceCount ); 8732 for ( size_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; ++i ) 8733 { 8734 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGroupProperties.physicalDevices[i] ); 8735 } 8736 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGroupProperties.subsetAllocation ); 8737 return seed; 8738 } 8739 }; 8740 8741 template <> 8742 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceHostImageCopyFeaturesEXT> 8743 { 8744 std::size_t operator ()std::hash8745 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceHostImageCopyFeaturesEXT const & physicalDeviceHostImageCopyFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 8746 { 8747 std::size_t seed = 0; 8748 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyFeaturesEXT.sType ); 8749 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyFeaturesEXT.pNext ); 8750 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyFeaturesEXT.hostImageCopy ); 8751 return seed; 8752 } 8753 }; 8754 8755 template <> 8756 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceHostImageCopyPropertiesEXT> 8757 { 8758 std::size_t operator ()std::hash8759 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceHostImageCopyPropertiesEXT const & physicalDeviceHostImageCopyPropertiesEXT ) const VULKAN_HPP_NOEXCEPT 8760 { 8761 std::size_t seed = 0; 8762 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyPropertiesEXT.sType ); 8763 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyPropertiesEXT.pNext ); 8764 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyPropertiesEXT.copySrcLayoutCount ); 8765 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyPropertiesEXT.pCopySrcLayouts ); 8766 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyPropertiesEXT.copyDstLayoutCount ); 8767 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyPropertiesEXT.pCopyDstLayouts ); 8768 for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) 8769 { 8770 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyPropertiesEXT.optimalTilingLayoutUUID[i] ); 8771 } 8772 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyPropertiesEXT.identicalMemoryTypeRequirements ); 8773 return seed; 8774 } 8775 }; 8776 8777 template <> 8778 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceHostQueryResetFeatures> 8779 { operator ()std::hash8780 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceHostQueryResetFeatures const & physicalDeviceHostQueryResetFeatures ) const VULKAN_HPP_NOEXCEPT 8781 { 8782 std::size_t seed = 0; 8783 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostQueryResetFeatures.sType ); 8784 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostQueryResetFeatures.pNext ); 8785 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostQueryResetFeatures.hostQueryReset ); 8786 return seed; 8787 } 8788 }; 8789 8790 template <> 8791 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceIDProperties> 8792 { operator ()std::hash8793 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceIDProperties const & physicalDeviceIDProperties ) const VULKAN_HPP_NOEXCEPT 8794 { 8795 std::size_t seed = 0; 8796 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIDProperties.sType ); 8797 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIDProperties.pNext ); 8798 for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) 8799 { 8800 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIDProperties.deviceUUID[i] ); 8801 } 8802 for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) 8803 { 8804 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIDProperties.driverUUID[i] ); 8805 } 8806 for ( size_t i = 0; i < VK_LUID_SIZE; ++i ) 8807 { 8808 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIDProperties.deviceLUID[i] ); 8809 } 8810 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIDProperties.deviceNodeMask ); 8811 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIDProperties.deviceLUIDValid ); 8812 return seed; 8813 } 8814 }; 8815 8816 template <> 8817 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImage2DViewOf3DFeaturesEXT> 8818 { 8819 std::size_t operator ()std::hash8820 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImage2DViewOf3DFeaturesEXT const & physicalDeviceImage2DViewOf3DFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 8821 { 8822 std::size_t seed = 0; 8823 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImage2DViewOf3DFeaturesEXT.sType ); 8824 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImage2DViewOf3DFeaturesEXT.pNext ); 8825 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImage2DViewOf3DFeaturesEXT.image2DViewOf3D ); 8826 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImage2DViewOf3DFeaturesEXT.sampler2DViewOf3D ); 8827 return seed; 8828 } 8829 }; 8830 8831 template <> 8832 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageCompressionControlFeaturesEXT> 8833 { operator ()std::hash8834 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageCompressionControlFeaturesEXT const & physicalDeviceImageCompressionControlFeaturesEXT ) 8835 const VULKAN_HPP_NOEXCEPT 8836 { 8837 std::size_t seed = 0; 8838 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageCompressionControlFeaturesEXT.sType ); 8839 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageCompressionControlFeaturesEXT.pNext ); 8840 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageCompressionControlFeaturesEXT.imageCompressionControl ); 8841 return seed; 8842 } 8843 }; 8844 8845 template <> 8846 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT> 8847 { operator ()std::hash8848 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT const & 8849 physicalDeviceImageCompressionControlSwapchainFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 8850 { 8851 std::size_t seed = 0; 8852 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageCompressionControlSwapchainFeaturesEXT.sType ); 8853 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageCompressionControlSwapchainFeaturesEXT.pNext ); 8854 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageCompressionControlSwapchainFeaturesEXT.imageCompressionControlSwapchain ); 8855 return seed; 8856 } 8857 }; 8858 8859 template <> 8860 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageDrmFormatModifierInfoEXT> 8861 { operator ()std::hash8862 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageDrmFormatModifierInfoEXT const & physicalDeviceImageDrmFormatModifierInfoEXT ) const 8863 VULKAN_HPP_NOEXCEPT 8864 { 8865 std::size_t seed = 0; 8866 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageDrmFormatModifierInfoEXT.sType ); 8867 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageDrmFormatModifierInfoEXT.pNext ); 8868 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageDrmFormatModifierInfoEXT.drmFormatModifier ); 8869 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageDrmFormatModifierInfoEXT.sharingMode ); 8870 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageDrmFormatModifierInfoEXT.queueFamilyIndexCount ); 8871 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageDrmFormatModifierInfoEXT.pQueueFamilyIndices ); 8872 return seed; 8873 } 8874 }; 8875 8876 template <> 8877 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2> 8878 { operator ()std::hash8879 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 const & physicalDeviceImageFormatInfo2 ) const VULKAN_HPP_NOEXCEPT 8880 { 8881 std::size_t seed = 0; 8882 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageFormatInfo2.sType ); 8883 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageFormatInfo2.pNext ); 8884 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageFormatInfo2.format ); 8885 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageFormatInfo2.type ); 8886 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageFormatInfo2.tiling ); 8887 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageFormatInfo2.usage ); 8888 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageFormatInfo2.flags ); 8889 return seed; 8890 } 8891 }; 8892 8893 template <> 8894 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessing2FeaturesQCOM> 8895 { operator ()std::hash8896 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessing2FeaturesQCOM const & physicalDeviceImageProcessing2FeaturesQCOM ) const 8897 VULKAN_HPP_NOEXCEPT 8898 { 8899 std::size_t seed = 0; 8900 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessing2FeaturesQCOM.sType ); 8901 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessing2FeaturesQCOM.pNext ); 8902 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessing2FeaturesQCOM.textureBlockMatch2 ); 8903 return seed; 8904 } 8905 }; 8906 8907 template <> 8908 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessing2PropertiesQCOM> 8909 { operator ()std::hash8910 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessing2PropertiesQCOM const & physicalDeviceImageProcessing2PropertiesQCOM ) const 8911 VULKAN_HPP_NOEXCEPT 8912 { 8913 std::size_t seed = 0; 8914 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessing2PropertiesQCOM.sType ); 8915 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessing2PropertiesQCOM.pNext ); 8916 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessing2PropertiesQCOM.maxBlockMatchWindow ); 8917 return seed; 8918 } 8919 }; 8920 8921 template <> 8922 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessingFeaturesQCOM> 8923 { 8924 std::size_t operator ()std::hash8925 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessingFeaturesQCOM const & physicalDeviceImageProcessingFeaturesQCOM ) const VULKAN_HPP_NOEXCEPT 8926 { 8927 std::size_t seed = 0; 8928 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingFeaturesQCOM.sType ); 8929 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingFeaturesQCOM.pNext ); 8930 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingFeaturesQCOM.textureSampleWeighted ); 8931 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingFeaturesQCOM.textureBoxFilter ); 8932 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingFeaturesQCOM.textureBlockMatch ); 8933 return seed; 8934 } 8935 }; 8936 8937 template <> 8938 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessingPropertiesQCOM> 8939 { operator ()std::hash8940 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessingPropertiesQCOM const & physicalDeviceImageProcessingPropertiesQCOM ) const 8941 VULKAN_HPP_NOEXCEPT 8942 { 8943 std::size_t seed = 0; 8944 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingPropertiesQCOM.sType ); 8945 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingPropertiesQCOM.pNext ); 8946 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingPropertiesQCOM.maxWeightFilterPhases ); 8947 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingPropertiesQCOM.maxWeightFilterDimension ); 8948 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingPropertiesQCOM.maxBlockMatchRegion ); 8949 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingPropertiesQCOM.maxBoxFilterBlockSize ); 8950 return seed; 8951 } 8952 }; 8953 8954 template <> 8955 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageRobustnessFeatures> 8956 { 8957 std::size_t operator ()std::hash8958 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageRobustnessFeatures const & physicalDeviceImageRobustnessFeatures ) const VULKAN_HPP_NOEXCEPT 8959 { 8960 std::size_t seed = 0; 8961 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageRobustnessFeatures.sType ); 8962 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageRobustnessFeatures.pNext ); 8963 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageRobustnessFeatures.robustImageAccess ); 8964 return seed; 8965 } 8966 }; 8967 8968 template <> 8969 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageSlicedViewOf3DFeaturesEXT> 8970 { operator ()std::hash8971 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageSlicedViewOf3DFeaturesEXT const & physicalDeviceImageSlicedViewOf3DFeaturesEXT ) const 8972 VULKAN_HPP_NOEXCEPT 8973 { 8974 std::size_t seed = 0; 8975 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageSlicedViewOf3DFeaturesEXT.sType ); 8976 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageSlicedViewOf3DFeaturesEXT.pNext ); 8977 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageSlicedViewOf3DFeaturesEXT.imageSlicedViewOf3D ); 8978 return seed; 8979 } 8980 }; 8981 8982 template <> 8983 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageViewImageFormatInfoEXT> 8984 { 8985 std::size_t operator ()std::hash8986 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageViewImageFormatInfoEXT const & physicalDeviceImageViewImageFormatInfoEXT ) const VULKAN_HPP_NOEXCEPT 8987 { 8988 std::size_t seed = 0; 8989 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageViewImageFormatInfoEXT.sType ); 8990 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageViewImageFormatInfoEXT.pNext ); 8991 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageViewImageFormatInfoEXT.imageViewType ); 8992 return seed; 8993 } 8994 }; 8995 8996 template <> 8997 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageViewMinLodFeaturesEXT> 8998 { 8999 std::size_t operator ()std::hash9000 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageViewMinLodFeaturesEXT const & physicalDeviceImageViewMinLodFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 9001 { 9002 std::size_t seed = 0; 9003 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageViewMinLodFeaturesEXT.sType ); 9004 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageViewMinLodFeaturesEXT.pNext ); 9005 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageViewMinLodFeaturesEXT.minLod ); 9006 return seed; 9007 } 9008 }; 9009 9010 template <> 9011 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImagelessFramebufferFeatures> 9012 { operator ()std::hash9013 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImagelessFramebufferFeatures const & physicalDeviceImagelessFramebufferFeatures ) const 9014 VULKAN_HPP_NOEXCEPT 9015 { 9016 std::size_t seed = 0; 9017 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImagelessFramebufferFeatures.sType ); 9018 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImagelessFramebufferFeatures.pNext ); 9019 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImagelessFramebufferFeatures.imagelessFramebuffer ); 9020 return seed; 9021 } 9022 }; 9023 9024 template <> 9025 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceIndexTypeUint8FeaturesEXT> 9026 { 9027 std::size_t operator ()std::hash9028 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceIndexTypeUint8FeaturesEXT const & physicalDeviceIndexTypeUint8FeaturesEXT ) const VULKAN_HPP_NOEXCEPT 9029 { 9030 std::size_t seed = 0; 9031 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIndexTypeUint8FeaturesEXT.sType ); 9032 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIndexTypeUint8FeaturesEXT.pNext ); 9033 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIndexTypeUint8FeaturesEXT.indexTypeUint8 ); 9034 return seed; 9035 } 9036 }; 9037 9038 template <> 9039 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceInheritedViewportScissorFeaturesNV> 9040 { operator ()std::hash9041 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceInheritedViewportScissorFeaturesNV const & physicalDeviceInheritedViewportScissorFeaturesNV ) 9042 const VULKAN_HPP_NOEXCEPT 9043 { 9044 std::size_t seed = 0; 9045 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInheritedViewportScissorFeaturesNV.sType ); 9046 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInheritedViewportScissorFeaturesNV.pNext ); 9047 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInheritedViewportScissorFeaturesNV.inheritedViewportScissor2D ); 9048 return seed; 9049 } 9050 }; 9051 9052 template <> 9053 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceInlineUniformBlockFeatures> 9054 { 9055 std::size_t operator ()std::hash9056 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceInlineUniformBlockFeatures const & physicalDeviceInlineUniformBlockFeatures ) const VULKAN_HPP_NOEXCEPT 9057 { 9058 std::size_t seed = 0; 9059 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockFeatures.sType ); 9060 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockFeatures.pNext ); 9061 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockFeatures.inlineUniformBlock ); 9062 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockFeatures.descriptorBindingInlineUniformBlockUpdateAfterBind ); 9063 return seed; 9064 } 9065 }; 9066 9067 template <> 9068 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceInlineUniformBlockProperties> 9069 { operator ()std::hash9070 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceInlineUniformBlockProperties const & physicalDeviceInlineUniformBlockProperties ) const 9071 VULKAN_HPP_NOEXCEPT 9072 { 9073 std::size_t seed = 0; 9074 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockProperties.sType ); 9075 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockProperties.pNext ); 9076 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockProperties.maxInlineUniformBlockSize ); 9077 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockProperties.maxPerStageDescriptorInlineUniformBlocks ); 9078 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockProperties.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks ); 9079 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockProperties.maxDescriptorSetInlineUniformBlocks ); 9080 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockProperties.maxDescriptorSetUpdateAfterBindInlineUniformBlocks ); 9081 return seed; 9082 } 9083 }; 9084 9085 template <> 9086 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceInvocationMaskFeaturesHUAWEI> 9087 { operator ()std::hash9088 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceInvocationMaskFeaturesHUAWEI const & physicalDeviceInvocationMaskFeaturesHUAWEI ) const 9089 VULKAN_HPP_NOEXCEPT 9090 { 9091 std::size_t seed = 0; 9092 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInvocationMaskFeaturesHUAWEI.sType ); 9093 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInvocationMaskFeaturesHUAWEI.pNext ); 9094 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInvocationMaskFeaturesHUAWEI.invocationMask ); 9095 return seed; 9096 } 9097 }; 9098 9099 template <> 9100 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredDriverPropertiesMSFT> 9101 { 9102 std::size_t operator ()std::hash9103 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredDriverPropertiesMSFT const & physicalDeviceLayeredDriverPropertiesMSFT ) const VULKAN_HPP_NOEXCEPT 9104 { 9105 std::size_t seed = 0; 9106 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredDriverPropertiesMSFT.sType ); 9107 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredDriverPropertiesMSFT.pNext ); 9108 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredDriverPropertiesMSFT.underlyingAPI ); 9109 return seed; 9110 } 9111 }; 9112 9113 template <> 9114 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLegacyDitheringFeaturesEXT> 9115 { 9116 std::size_t operator ()std::hash9117 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLegacyDitheringFeaturesEXT const & physicalDeviceLegacyDitheringFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 9118 { 9119 std::size_t seed = 0; 9120 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyDitheringFeaturesEXT.sType ); 9121 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyDitheringFeaturesEXT.pNext ); 9122 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyDitheringFeaturesEXT.legacyDithering ); 9123 return seed; 9124 } 9125 }; 9126 9127 template <> 9128 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLimits> 9129 { operator ()std::hash9130 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLimits const & physicalDeviceLimits ) const VULKAN_HPP_NOEXCEPT 9131 { 9132 std::size_t seed = 0; 9133 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxImageDimension1D ); 9134 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxImageDimension2D ); 9135 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxImageDimension3D ); 9136 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxImageDimensionCube ); 9137 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxImageArrayLayers ); 9138 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTexelBufferElements ); 9139 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxUniformBufferRange ); 9140 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxStorageBufferRange ); 9141 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxPushConstantsSize ); 9142 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxMemoryAllocationCount ); 9143 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxSamplerAllocationCount ); 9144 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.bufferImageGranularity ); 9145 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.sparseAddressSpaceSize ); 9146 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxBoundDescriptorSets ); 9147 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxPerStageDescriptorSamplers ); 9148 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxPerStageDescriptorUniformBuffers ); 9149 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxPerStageDescriptorStorageBuffers ); 9150 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxPerStageDescriptorSampledImages ); 9151 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxPerStageDescriptorStorageImages ); 9152 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxPerStageDescriptorInputAttachments ); 9153 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxPerStageResources ); 9154 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDescriptorSetSamplers ); 9155 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDescriptorSetUniformBuffers ); 9156 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDescriptorSetUniformBuffersDynamic ); 9157 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDescriptorSetStorageBuffers ); 9158 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDescriptorSetStorageBuffersDynamic ); 9159 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDescriptorSetSampledImages ); 9160 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDescriptorSetStorageImages ); 9161 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDescriptorSetInputAttachments ); 9162 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxVertexInputAttributes ); 9163 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxVertexInputBindings ); 9164 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxVertexInputAttributeOffset ); 9165 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxVertexInputBindingStride ); 9166 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxVertexOutputComponents ); 9167 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTessellationGenerationLevel ); 9168 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTessellationPatchSize ); 9169 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTessellationControlPerVertexInputComponents ); 9170 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTessellationControlPerVertexOutputComponents ); 9171 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTessellationControlPerPatchOutputComponents ); 9172 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTessellationControlTotalOutputComponents ); 9173 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTessellationEvaluationInputComponents ); 9174 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTessellationEvaluationOutputComponents ); 9175 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxGeometryShaderInvocations ); 9176 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxGeometryInputComponents ); 9177 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxGeometryOutputComponents ); 9178 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxGeometryOutputVertices ); 9179 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxGeometryTotalOutputComponents ); 9180 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxFragmentInputComponents ); 9181 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxFragmentOutputAttachments ); 9182 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxFragmentDualSrcAttachments ); 9183 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxFragmentCombinedOutputResources ); 9184 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxComputeSharedMemorySize ); 9185 for ( size_t i = 0; i < 3; ++i ) 9186 { 9187 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxComputeWorkGroupCount[i] ); 9188 } 9189 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxComputeWorkGroupInvocations ); 9190 for ( size_t i = 0; i < 3; ++i ) 9191 { 9192 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxComputeWorkGroupSize[i] ); 9193 } 9194 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.subPixelPrecisionBits ); 9195 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.subTexelPrecisionBits ); 9196 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.mipmapPrecisionBits ); 9197 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDrawIndexedIndexValue ); 9198 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDrawIndirectCount ); 9199 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxSamplerLodBias ); 9200 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxSamplerAnisotropy ); 9201 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxViewports ); 9202 for ( size_t i = 0; i < 2; ++i ) 9203 { 9204 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxViewportDimensions[i] ); 9205 } 9206 for ( size_t i = 0; i < 2; ++i ) 9207 { 9208 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.viewportBoundsRange[i] ); 9209 } 9210 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.viewportSubPixelBits ); 9211 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.minMemoryMapAlignment ); 9212 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.minTexelBufferOffsetAlignment ); 9213 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.minUniformBufferOffsetAlignment ); 9214 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.minStorageBufferOffsetAlignment ); 9215 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.minTexelOffset ); 9216 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTexelOffset ); 9217 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.minTexelGatherOffset ); 9218 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTexelGatherOffset ); 9219 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.minInterpolationOffset ); 9220 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxInterpolationOffset ); 9221 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.subPixelInterpolationOffsetBits ); 9222 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxFramebufferWidth ); 9223 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxFramebufferHeight ); 9224 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxFramebufferLayers ); 9225 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.framebufferColorSampleCounts ); 9226 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.framebufferDepthSampleCounts ); 9227 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.framebufferStencilSampleCounts ); 9228 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.framebufferNoAttachmentsSampleCounts ); 9229 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxColorAttachments ); 9230 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.sampledImageColorSampleCounts ); 9231 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.sampledImageIntegerSampleCounts ); 9232 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.sampledImageDepthSampleCounts ); 9233 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.sampledImageStencilSampleCounts ); 9234 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.storageImageSampleCounts ); 9235 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxSampleMaskWords ); 9236 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.timestampComputeAndGraphics ); 9237 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.timestampPeriod ); 9238 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxClipDistances ); 9239 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxCullDistances ); 9240 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxCombinedClipAndCullDistances ); 9241 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.discreteQueuePriorities ); 9242 for ( size_t i = 0; i < 2; ++i ) 9243 { 9244 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.pointSizeRange[i] ); 9245 } 9246 for ( size_t i = 0; i < 2; ++i ) 9247 { 9248 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.lineWidthRange[i] ); 9249 } 9250 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.pointSizeGranularity ); 9251 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.lineWidthGranularity ); 9252 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.strictLines ); 9253 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.standardSampleLocations ); 9254 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.optimalBufferCopyOffsetAlignment ); 9255 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.optimalBufferCopyRowPitchAlignment ); 9256 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.nonCoherentAtomSize ); 9257 return seed; 9258 } 9259 }; 9260 9261 template <> 9262 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationFeaturesEXT> 9263 { operator ()std::hash9264 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationFeaturesEXT const & physicalDeviceLineRasterizationFeaturesEXT ) const 9265 VULKAN_HPP_NOEXCEPT 9266 { 9267 std::size_t seed = 0; 9268 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeaturesEXT.sType ); 9269 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeaturesEXT.pNext ); 9270 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeaturesEXT.rectangularLines ); 9271 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeaturesEXT.bresenhamLines ); 9272 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeaturesEXT.smoothLines ); 9273 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeaturesEXT.stippledRectangularLines ); 9274 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeaturesEXT.stippledBresenhamLines ); 9275 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeaturesEXT.stippledSmoothLines ); 9276 return seed; 9277 } 9278 }; 9279 9280 template <> 9281 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationPropertiesEXT> 9282 { operator ()std::hash9283 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationPropertiesEXT const & physicalDeviceLineRasterizationPropertiesEXT ) const 9284 VULKAN_HPP_NOEXCEPT 9285 { 9286 std::size_t seed = 0; 9287 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationPropertiesEXT.sType ); 9288 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationPropertiesEXT.pNext ); 9289 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationPropertiesEXT.lineSubPixelPrecisionBits ); 9290 return seed; 9291 } 9292 }; 9293 9294 template <> 9295 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLinearColorAttachmentFeaturesNV> 9296 { operator ()std::hash9297 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLinearColorAttachmentFeaturesNV const & physicalDeviceLinearColorAttachmentFeaturesNV ) const 9298 VULKAN_HPP_NOEXCEPT 9299 { 9300 std::size_t seed = 0; 9301 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLinearColorAttachmentFeaturesNV.sType ); 9302 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLinearColorAttachmentFeaturesNV.pNext ); 9303 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLinearColorAttachmentFeaturesNV.linearColorAttachment ); 9304 return seed; 9305 } 9306 }; 9307 9308 template <> 9309 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance3Properties> 9310 { operator ()std::hash9311 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance3Properties const & physicalDeviceMaintenance3Properties ) const VULKAN_HPP_NOEXCEPT 9312 { 9313 std::size_t seed = 0; 9314 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance3Properties.sType ); 9315 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance3Properties.pNext ); 9316 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance3Properties.maxPerSetDescriptors ); 9317 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance3Properties.maxMemoryAllocationSize ); 9318 return seed; 9319 } 9320 }; 9321 9322 template <> 9323 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance4Features> 9324 { operator ()std::hash9325 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance4Features const & physicalDeviceMaintenance4Features ) const VULKAN_HPP_NOEXCEPT 9326 { 9327 std::size_t seed = 0; 9328 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance4Features.sType ); 9329 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance4Features.pNext ); 9330 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance4Features.maintenance4 ); 9331 return seed; 9332 } 9333 }; 9334 9335 template <> 9336 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance4Properties> 9337 { operator ()std::hash9338 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance4Properties const & physicalDeviceMaintenance4Properties ) const VULKAN_HPP_NOEXCEPT 9339 { 9340 std::size_t seed = 0; 9341 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance4Properties.sType ); 9342 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance4Properties.pNext ); 9343 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance4Properties.maxBufferSize ); 9344 return seed; 9345 } 9346 }; 9347 9348 template <> 9349 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance5FeaturesKHR> 9350 { 9351 std::size_t operator ()std::hash9352 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance5FeaturesKHR const & physicalDeviceMaintenance5FeaturesKHR ) const VULKAN_HPP_NOEXCEPT 9353 { 9354 std::size_t seed = 0; 9355 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5FeaturesKHR.sType ); 9356 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5FeaturesKHR.pNext ); 9357 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5FeaturesKHR.maintenance5 ); 9358 return seed; 9359 } 9360 }; 9361 9362 template <> 9363 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance5PropertiesKHR> 9364 { 9365 std::size_t operator ()std::hash9366 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance5PropertiesKHR const & physicalDeviceMaintenance5PropertiesKHR ) const VULKAN_HPP_NOEXCEPT 9367 { 9368 std::size_t seed = 0; 9369 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5PropertiesKHR.sType ); 9370 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5PropertiesKHR.pNext ); 9371 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5PropertiesKHR.earlyFragmentMultisampleCoverageAfterSampleCounting ); 9372 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5PropertiesKHR.earlyFragmentSampleMaskTestBeforeSampleCounting ); 9373 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5PropertiesKHR.depthStencilSwizzleOneSupport ); 9374 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5PropertiesKHR.polygonModePointSize ); 9375 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5PropertiesKHR.nonStrictSinglePixelWideLinesUseParallelogram ); 9376 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5PropertiesKHR.nonStrictWideLinesUseParallelogram ); 9377 return seed; 9378 } 9379 }; 9380 9381 template <> 9382 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryBudgetPropertiesEXT> 9383 { 9384 std::size_t operator ()std::hash9385 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryBudgetPropertiesEXT const & physicalDeviceMemoryBudgetPropertiesEXT ) const VULKAN_HPP_NOEXCEPT 9386 { 9387 std::size_t seed = 0; 9388 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryBudgetPropertiesEXT.sType ); 9389 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryBudgetPropertiesEXT.pNext ); 9390 for ( size_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i ) 9391 { 9392 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryBudgetPropertiesEXT.heapBudget[i] ); 9393 } 9394 for ( size_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i ) 9395 { 9396 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryBudgetPropertiesEXT.heapUsage[i] ); 9397 } 9398 return seed; 9399 } 9400 }; 9401 9402 template <> 9403 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryDecompressionFeaturesNV> 9404 { operator ()std::hash9405 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryDecompressionFeaturesNV const & physicalDeviceMemoryDecompressionFeaturesNV ) const 9406 VULKAN_HPP_NOEXCEPT 9407 { 9408 std::size_t seed = 0; 9409 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionFeaturesNV.sType ); 9410 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionFeaturesNV.pNext ); 9411 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionFeaturesNV.memoryDecompression ); 9412 return seed; 9413 } 9414 }; 9415 9416 template <> 9417 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryDecompressionPropertiesNV> 9418 { operator ()std::hash9419 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryDecompressionPropertiesNV const & physicalDeviceMemoryDecompressionPropertiesNV ) const 9420 VULKAN_HPP_NOEXCEPT 9421 { 9422 std::size_t seed = 0; 9423 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionPropertiesNV.sType ); 9424 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionPropertiesNV.pNext ); 9425 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionPropertiesNV.decompressionMethods ); 9426 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionPropertiesNV.maxDecompressionIndirectCount ); 9427 return seed; 9428 } 9429 }; 9430 9431 template <> 9432 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryPriorityFeaturesEXT> 9433 { 9434 std::size_t operator ()std::hash9435 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryPriorityFeaturesEXT const & physicalDeviceMemoryPriorityFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 9436 { 9437 std::size_t seed = 0; 9438 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryPriorityFeaturesEXT.sType ); 9439 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryPriorityFeaturesEXT.pNext ); 9440 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryPriorityFeaturesEXT.memoryPriority ); 9441 return seed; 9442 } 9443 }; 9444 9445 template <> 9446 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties> 9447 { operator ()std::hash9448 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties const & physicalDeviceMemoryProperties ) const VULKAN_HPP_NOEXCEPT 9449 { 9450 std::size_t seed = 0; 9451 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryProperties.memoryTypeCount ); 9452 for ( size_t i = 0; i < VK_MAX_MEMORY_TYPES; ++i ) 9453 { 9454 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryProperties.memoryTypes[i] ); 9455 } 9456 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryProperties.memoryHeapCount ); 9457 for ( size_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i ) 9458 { 9459 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryProperties.memoryHeaps[i] ); 9460 } 9461 return seed; 9462 } 9463 }; 9464 9465 template <> 9466 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2> 9467 { operator ()std::hash9468 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 const & physicalDeviceMemoryProperties2 ) const VULKAN_HPP_NOEXCEPT 9469 { 9470 std::size_t seed = 0; 9471 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryProperties2.sType ); 9472 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryProperties2.pNext ); 9473 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryProperties2.memoryProperties ); 9474 return seed; 9475 } 9476 }; 9477 9478 template <> 9479 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderFeaturesEXT> 9480 { operator ()std::hash9481 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderFeaturesEXT const & physicalDeviceMeshShaderFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 9482 { 9483 std::size_t seed = 0; 9484 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesEXT.sType ); 9485 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesEXT.pNext ); 9486 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesEXT.taskShader ); 9487 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesEXT.meshShader ); 9488 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesEXT.multiviewMeshShader ); 9489 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesEXT.primitiveFragmentShadingRateMeshShader ); 9490 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesEXT.meshShaderQueries ); 9491 return seed; 9492 } 9493 }; 9494 9495 template <> 9496 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderFeaturesNV> 9497 { operator ()std::hash9498 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderFeaturesNV const & physicalDeviceMeshShaderFeaturesNV ) const VULKAN_HPP_NOEXCEPT 9499 { 9500 std::size_t seed = 0; 9501 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesNV.sType ); 9502 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesNV.pNext ); 9503 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesNV.taskShader ); 9504 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesNV.meshShader ); 9505 return seed; 9506 } 9507 }; 9508 9509 template <> 9510 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderPropertiesEXT> 9511 { 9512 std::size_t operator ()std::hash9513 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderPropertiesEXT const & physicalDeviceMeshShaderPropertiesEXT ) const VULKAN_HPP_NOEXCEPT 9514 { 9515 std::size_t seed = 0; 9516 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.sType ); 9517 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.pNext ); 9518 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxTaskWorkGroupTotalCount ); 9519 for ( size_t i = 0; i < 3; ++i ) 9520 { 9521 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxTaskWorkGroupCount[i] ); 9522 } 9523 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxTaskWorkGroupInvocations ); 9524 for ( size_t i = 0; i < 3; ++i ) 9525 { 9526 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxTaskWorkGroupSize[i] ); 9527 } 9528 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxTaskPayloadSize ); 9529 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxTaskSharedMemorySize ); 9530 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxTaskPayloadAndSharedMemorySize ); 9531 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshWorkGroupTotalCount ); 9532 for ( size_t i = 0; i < 3; ++i ) 9533 { 9534 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshWorkGroupCount[i] ); 9535 } 9536 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshWorkGroupInvocations ); 9537 for ( size_t i = 0; i < 3; ++i ) 9538 { 9539 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshWorkGroupSize[i] ); 9540 } 9541 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshSharedMemorySize ); 9542 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshPayloadAndSharedMemorySize ); 9543 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshOutputMemorySize ); 9544 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshPayloadAndOutputMemorySize ); 9545 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshOutputComponents ); 9546 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshOutputVertices ); 9547 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshOutputPrimitives ); 9548 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshOutputLayers ); 9549 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshMultiviewViewCount ); 9550 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.meshOutputPerVertexGranularity ); 9551 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.meshOutputPerPrimitiveGranularity ); 9552 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxPreferredTaskWorkGroupInvocations ); 9553 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxPreferredMeshWorkGroupInvocations ); 9554 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.prefersLocalInvocationVertexOutput ); 9555 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.prefersLocalInvocationPrimitiveOutput ); 9556 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.prefersCompactVertexOutput ); 9557 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.prefersCompactPrimitiveOutput ); 9558 return seed; 9559 } 9560 }; 9561 9562 template <> 9563 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderPropertiesNV> 9564 { operator ()std::hash9565 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderPropertiesNV const & physicalDeviceMeshShaderPropertiesNV ) const VULKAN_HPP_NOEXCEPT 9566 { 9567 std::size_t seed = 0; 9568 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.sType ); 9569 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.pNext ); 9570 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxDrawMeshTasksCount ); 9571 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxTaskWorkGroupInvocations ); 9572 for ( size_t i = 0; i < 3; ++i ) 9573 { 9574 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxTaskWorkGroupSize[i] ); 9575 } 9576 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxTaskTotalMemorySize ); 9577 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxTaskOutputCount ); 9578 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxMeshWorkGroupInvocations ); 9579 for ( size_t i = 0; i < 3; ++i ) 9580 { 9581 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxMeshWorkGroupSize[i] ); 9582 } 9583 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxMeshTotalMemorySize ); 9584 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxMeshOutputVertices ); 9585 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxMeshOutputPrimitives ); 9586 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxMeshMultiviewViewCount ); 9587 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.meshOutputPerVertexGranularity ); 9588 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.meshOutputPerPrimitiveGranularity ); 9589 return seed; 9590 } 9591 }; 9592 9593 template <> 9594 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiDrawFeaturesEXT> 9595 { operator ()std::hash9596 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiDrawFeaturesEXT const & physicalDeviceMultiDrawFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 9597 { 9598 std::size_t seed = 0; 9599 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiDrawFeaturesEXT.sType ); 9600 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiDrawFeaturesEXT.pNext ); 9601 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiDrawFeaturesEXT.multiDraw ); 9602 return seed; 9603 } 9604 }; 9605 9606 template <> 9607 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiDrawPropertiesEXT> 9608 { operator ()std::hash9609 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiDrawPropertiesEXT const & physicalDeviceMultiDrawPropertiesEXT ) const VULKAN_HPP_NOEXCEPT 9610 { 9611 std::size_t seed = 0; 9612 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiDrawPropertiesEXT.sType ); 9613 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiDrawPropertiesEXT.pNext ); 9614 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiDrawPropertiesEXT.maxMultiDrawCount ); 9615 return seed; 9616 } 9617 }; 9618 9619 template <> 9620 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT> 9621 { operator ()std::hash9622 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT const & 9623 physicalDeviceMultisampledRenderToSingleSampledFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 9624 { 9625 std::size_t seed = 0; 9626 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultisampledRenderToSingleSampledFeaturesEXT.sType ); 9627 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultisampledRenderToSingleSampledFeaturesEXT.pNext ); 9628 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultisampledRenderToSingleSampledFeaturesEXT.multisampledRenderToSingleSampled ); 9629 return seed; 9630 } 9631 }; 9632 9633 template <> 9634 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewFeatures> 9635 { operator ()std::hash9636 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewFeatures const & physicalDeviceMultiviewFeatures ) const VULKAN_HPP_NOEXCEPT 9637 { 9638 std::size_t seed = 0; 9639 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewFeatures.sType ); 9640 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewFeatures.pNext ); 9641 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewFeatures.multiview ); 9642 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewFeatures.multiviewGeometryShader ); 9643 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewFeatures.multiviewTessellationShader ); 9644 return seed; 9645 } 9646 }; 9647 9648 template <> 9649 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX> 9650 { operator ()std::hash9651 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const & 9652 physicalDeviceMultiviewPerViewAttributesPropertiesNVX ) const VULKAN_HPP_NOEXCEPT 9653 { 9654 std::size_t seed = 0; 9655 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewAttributesPropertiesNVX.sType ); 9656 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewAttributesPropertiesNVX.pNext ); 9657 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewAttributesPropertiesNVX.perViewPositionAllComponents ); 9658 return seed; 9659 } 9660 }; 9661 9662 template <> 9663 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM> 9664 { operator ()std::hash9665 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM const & 9666 physicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM ) const VULKAN_HPP_NOEXCEPT 9667 { 9668 std::size_t seed = 0; 9669 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM.sType ); 9670 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM.pNext ); 9671 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM.multiviewPerViewRenderAreas ); 9672 return seed; 9673 } 9674 }; 9675 9676 template <> 9677 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM> 9678 { 9679 std::size_t operator ()std::hash9680 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM const & physicalDeviceMultiviewPerViewViewportsFeaturesQCOM ) const 9681 VULKAN_HPP_NOEXCEPT 9682 { 9683 std::size_t seed = 0; 9684 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewViewportsFeaturesQCOM.sType ); 9685 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewViewportsFeaturesQCOM.pNext ); 9686 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewViewportsFeaturesQCOM.multiviewPerViewViewports ); 9687 return seed; 9688 } 9689 }; 9690 9691 template <> 9692 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewProperties> 9693 { operator ()std::hash9694 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewProperties const & physicalDeviceMultiviewProperties ) const VULKAN_HPP_NOEXCEPT 9695 { 9696 std::size_t seed = 0; 9697 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewProperties.sType ); 9698 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewProperties.pNext ); 9699 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewProperties.maxMultiviewViewCount ); 9700 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewProperties.maxMultiviewInstanceIndex ); 9701 return seed; 9702 } 9703 }; 9704 9705 template <> 9706 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMutableDescriptorTypeFeaturesEXT> 9707 { operator ()std::hash9708 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMutableDescriptorTypeFeaturesEXT const & physicalDeviceMutableDescriptorTypeFeaturesEXT ) const 9709 VULKAN_HPP_NOEXCEPT 9710 { 9711 std::size_t seed = 0; 9712 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMutableDescriptorTypeFeaturesEXT.sType ); 9713 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMutableDescriptorTypeFeaturesEXT.pNext ); 9714 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMutableDescriptorTypeFeaturesEXT.mutableDescriptorType ); 9715 return seed; 9716 } 9717 }; 9718 9719 template <> 9720 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceNonSeamlessCubeMapFeaturesEXT> 9721 { operator ()std::hash9722 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceNonSeamlessCubeMapFeaturesEXT const & physicalDeviceNonSeamlessCubeMapFeaturesEXT ) const 9723 VULKAN_HPP_NOEXCEPT 9724 { 9725 std::size_t seed = 0; 9726 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNonSeamlessCubeMapFeaturesEXT.sType ); 9727 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNonSeamlessCubeMapFeaturesEXT.pNext ); 9728 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNonSeamlessCubeMapFeaturesEXT.nonSeamlessCubeMap ); 9729 return seed; 9730 } 9731 }; 9732 9733 template <> 9734 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceOpacityMicromapFeaturesEXT> 9735 { 9736 std::size_t operator ()std::hash9737 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceOpacityMicromapFeaturesEXT const & physicalDeviceOpacityMicromapFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 9738 { 9739 std::size_t seed = 0; 9740 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapFeaturesEXT.sType ); 9741 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapFeaturesEXT.pNext ); 9742 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapFeaturesEXT.micromap ); 9743 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapFeaturesEXT.micromapCaptureReplay ); 9744 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapFeaturesEXT.micromapHostCommands ); 9745 return seed; 9746 } 9747 }; 9748 9749 template <> 9750 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceOpacityMicromapPropertiesEXT> 9751 { operator ()std::hash9752 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceOpacityMicromapPropertiesEXT const & physicalDeviceOpacityMicromapPropertiesEXT ) const 9753 VULKAN_HPP_NOEXCEPT 9754 { 9755 std::size_t seed = 0; 9756 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapPropertiesEXT.sType ); 9757 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapPropertiesEXT.pNext ); 9758 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapPropertiesEXT.maxOpacity2StateSubdivisionLevel ); 9759 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapPropertiesEXT.maxOpacity4StateSubdivisionLevel ); 9760 return seed; 9761 } 9762 }; 9763 9764 template <> 9765 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceOpticalFlowFeaturesNV> 9766 { operator ()std::hash9767 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceOpticalFlowFeaturesNV const & physicalDeviceOpticalFlowFeaturesNV ) const VULKAN_HPP_NOEXCEPT 9768 { 9769 std::size_t seed = 0; 9770 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowFeaturesNV.sType ); 9771 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowFeaturesNV.pNext ); 9772 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowFeaturesNV.opticalFlow ); 9773 return seed; 9774 } 9775 }; 9776 9777 template <> 9778 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceOpticalFlowPropertiesNV> 9779 { 9780 std::size_t operator ()std::hash9781 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceOpticalFlowPropertiesNV const & physicalDeviceOpticalFlowPropertiesNV ) const VULKAN_HPP_NOEXCEPT 9782 { 9783 std::size_t seed = 0; 9784 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.sType ); 9785 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.pNext ); 9786 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.supportedOutputGridSizes ); 9787 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.supportedHintGridSizes ); 9788 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.hintSupported ); 9789 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.costSupported ); 9790 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.bidirectionalFlowSupported ); 9791 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.globalFlowSupported ); 9792 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.minWidth ); 9793 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.minHeight ); 9794 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.maxWidth ); 9795 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.maxHeight ); 9796 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.maxNumRegionsOfInterest ); 9797 return seed; 9798 } 9799 }; 9800 9801 template <> 9802 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePCIBusInfoPropertiesEXT> 9803 { 9804 std::size_t operator ()std::hash9805 operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePCIBusInfoPropertiesEXT const & physicalDevicePCIBusInfoPropertiesEXT ) const VULKAN_HPP_NOEXCEPT 9806 { 9807 std::size_t seed = 0; 9808 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePCIBusInfoPropertiesEXT.sType ); 9809 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePCIBusInfoPropertiesEXT.pNext ); 9810 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePCIBusInfoPropertiesEXT.pciDomain ); 9811 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePCIBusInfoPropertiesEXT.pciBus ); 9812 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePCIBusInfoPropertiesEXT.pciDevice ); 9813 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePCIBusInfoPropertiesEXT.pciFunction ); 9814 return seed; 9815 } 9816 }; 9817 9818 template <> 9819 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT> 9820 { 9821 std::size_t operator ()std::hash9822 operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT const & physicalDevicePageableDeviceLocalMemoryFeaturesEXT ) const 9823 VULKAN_HPP_NOEXCEPT 9824 { 9825 std::size_t seed = 0; 9826 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePageableDeviceLocalMemoryFeaturesEXT.sType ); 9827 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePageableDeviceLocalMemoryFeaturesEXT.pNext ); 9828 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePageableDeviceLocalMemoryFeaturesEXT.pageableDeviceLocalMemory ); 9829 return seed; 9830 } 9831 }; 9832 9833 template <> 9834 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceQueryFeaturesKHR> 9835 { 9836 std::size_t operator ()std::hash9837 operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceQueryFeaturesKHR const & physicalDevicePerformanceQueryFeaturesKHR ) const VULKAN_HPP_NOEXCEPT 9838 { 9839 std::size_t seed = 0; 9840 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceQueryFeaturesKHR.sType ); 9841 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceQueryFeaturesKHR.pNext ); 9842 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceQueryFeaturesKHR.performanceCounterQueryPools ); 9843 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceQueryFeaturesKHR.performanceCounterMultipleQueryPools ); 9844 return seed; 9845 } 9846 }; 9847 9848 template <> 9849 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceQueryPropertiesKHR> 9850 { operator ()std::hash9851 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceQueryPropertiesKHR const & physicalDevicePerformanceQueryPropertiesKHR ) const 9852 VULKAN_HPP_NOEXCEPT 9853 { 9854 std::size_t seed = 0; 9855 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceQueryPropertiesKHR.sType ); 9856 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceQueryPropertiesKHR.pNext ); 9857 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceQueryPropertiesKHR.allowCommandBufferQueryCopies ); 9858 return seed; 9859 } 9860 }; 9861 9862 template <> 9863 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineCreationCacheControlFeatures> 9864 { 9865 std::size_t operator ()std::hash9866 operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineCreationCacheControlFeatures const & physicalDevicePipelineCreationCacheControlFeatures ) const 9867 VULKAN_HPP_NOEXCEPT 9868 { 9869 std::size_t seed = 0; 9870 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineCreationCacheControlFeatures.sType ); 9871 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineCreationCacheControlFeatures.pNext ); 9872 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineCreationCacheControlFeatures.pipelineCreationCacheControl ); 9873 return seed; 9874 } 9875 }; 9876 9877 template <> 9878 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR> 9879 { operator ()std::hash9880 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR const & 9881 physicalDevicePipelineExecutablePropertiesFeaturesKHR ) const VULKAN_HPP_NOEXCEPT 9882 { 9883 std::size_t seed = 0; 9884 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineExecutablePropertiesFeaturesKHR.sType ); 9885 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineExecutablePropertiesFeaturesKHR.pNext ); 9886 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineExecutablePropertiesFeaturesKHR.pipelineExecutableInfo ); 9887 return seed; 9888 } 9889 }; 9890 9891 template <> 9892 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT> 9893 { operator ()std::hash9894 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT const & 9895 physicalDevicePipelineLibraryGroupHandlesFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 9896 { 9897 std::size_t seed = 0; 9898 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineLibraryGroupHandlesFeaturesEXT.sType ); 9899 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineLibraryGroupHandlesFeaturesEXT.pNext ); 9900 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineLibraryGroupHandlesFeaturesEXT.pipelineLibraryGroupHandles ); 9901 return seed; 9902 } 9903 }; 9904 9905 template <> 9906 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelinePropertiesFeaturesEXT> 9907 { operator ()std::hash9908 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelinePropertiesFeaturesEXT const & physicalDevicePipelinePropertiesFeaturesEXT ) const 9909 VULKAN_HPP_NOEXCEPT 9910 { 9911 std::size_t seed = 0; 9912 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelinePropertiesFeaturesEXT.sType ); 9913 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelinePropertiesFeaturesEXT.pNext ); 9914 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelinePropertiesFeaturesEXT.pipelinePropertiesIdentifier ); 9915 return seed; 9916 } 9917 }; 9918 9919 template <> 9920 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineProtectedAccessFeaturesEXT> 9921 { operator ()std::hash9922 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineProtectedAccessFeaturesEXT const & physicalDevicePipelineProtectedAccessFeaturesEXT ) 9923 const VULKAN_HPP_NOEXCEPT 9924 { 9925 std::size_t seed = 0; 9926 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineProtectedAccessFeaturesEXT.sType ); 9927 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineProtectedAccessFeaturesEXT.pNext ); 9928 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineProtectedAccessFeaturesEXT.pipelineProtectedAccess ); 9929 return seed; 9930 } 9931 }; 9932 9933 template <> 9934 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineRobustnessFeaturesEXT> 9935 { operator ()std::hash9936 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineRobustnessFeaturesEXT const & physicalDevicePipelineRobustnessFeaturesEXT ) const 9937 VULKAN_HPP_NOEXCEPT 9938 { 9939 std::size_t seed = 0; 9940 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineRobustnessFeaturesEXT.sType ); 9941 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineRobustnessFeaturesEXT.pNext ); 9942 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineRobustnessFeaturesEXT.pipelineRobustness ); 9943 return seed; 9944 } 9945 }; 9946 9947 template <> 9948 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineRobustnessPropertiesEXT> 9949 { operator ()std::hash9950 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineRobustnessPropertiesEXT const & physicalDevicePipelineRobustnessPropertiesEXT ) const 9951 VULKAN_HPP_NOEXCEPT 9952 { 9953 std::size_t seed = 0; 9954 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineRobustnessPropertiesEXT.sType ); 9955 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineRobustnessPropertiesEXT.pNext ); 9956 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineRobustnessPropertiesEXT.defaultRobustnessStorageBuffers ); 9957 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineRobustnessPropertiesEXT.defaultRobustnessUniformBuffers ); 9958 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineRobustnessPropertiesEXT.defaultRobustnessVertexInputs ); 9959 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineRobustnessPropertiesEXT.defaultRobustnessImages ); 9960 return seed; 9961 } 9962 }; 9963 9964 template <> 9965 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePointClippingProperties> 9966 { 9967 std::size_t operator ()std::hash9968 operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePointClippingProperties const & physicalDevicePointClippingProperties ) const VULKAN_HPP_NOEXCEPT 9969 { 9970 std::size_t seed = 0; 9971 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePointClippingProperties.sType ); 9972 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePointClippingProperties.pNext ); 9973 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePointClippingProperties.pointClippingBehavior ); 9974 return seed; 9975 } 9976 }; 9977 9978 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 9979 template <> 9980 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePortabilitySubsetFeaturesKHR> 9981 { operator ()std::hash9982 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePortabilitySubsetFeaturesKHR const & physicalDevicePortabilitySubsetFeaturesKHR ) const 9983 VULKAN_HPP_NOEXCEPT 9984 { 9985 std::size_t seed = 0; 9986 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.sType ); 9987 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.pNext ); 9988 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.constantAlphaColorBlendFactors ); 9989 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.events ); 9990 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.imageViewFormatReinterpretation ); 9991 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.imageViewFormatSwizzle ); 9992 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.imageView2DOn3DImage ); 9993 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.multisampleArrayImage ); 9994 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.mutableComparisonSamplers ); 9995 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.pointPolygons ); 9996 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.samplerMipLodBias ); 9997 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.separateStencilMaskRef ); 9998 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.shaderSampleRateInterpolationFunctions ); 9999 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.tessellationIsolines ); 10000 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.tessellationPointMode ); 10001 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.triangleFans ); 10002 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.vertexAttributeAccessBeyondStride ); 10003 return seed; 10004 } 10005 }; 10006 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 10007 10008 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 10009 template <> 10010 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePortabilitySubsetPropertiesKHR> 10011 { operator ()std::hash10012 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePortabilitySubsetPropertiesKHR const & physicalDevicePortabilitySubsetPropertiesKHR ) const 10013 VULKAN_HPP_NOEXCEPT 10014 { 10015 std::size_t seed = 0; 10016 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetPropertiesKHR.sType ); 10017 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetPropertiesKHR.pNext ); 10018 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetPropertiesKHR.minVertexInputBindingStrideAlignment ); 10019 return seed; 10020 } 10021 }; 10022 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 10023 10024 template <> 10025 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePresentBarrierFeaturesNV> 10026 { 10027 std::size_t operator ()std::hash10028 operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePresentBarrierFeaturesNV const & physicalDevicePresentBarrierFeaturesNV ) const VULKAN_HPP_NOEXCEPT 10029 { 10030 std::size_t seed = 0; 10031 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentBarrierFeaturesNV.sType ); 10032 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentBarrierFeaturesNV.pNext ); 10033 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentBarrierFeaturesNV.presentBarrier ); 10034 return seed; 10035 } 10036 }; 10037 10038 template <> 10039 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePresentIdFeaturesKHR> 10040 { operator ()std::hash10041 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePresentIdFeaturesKHR const & physicalDevicePresentIdFeaturesKHR ) const VULKAN_HPP_NOEXCEPT 10042 { 10043 std::size_t seed = 0; 10044 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentIdFeaturesKHR.sType ); 10045 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentIdFeaturesKHR.pNext ); 10046 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentIdFeaturesKHR.presentId ); 10047 return seed; 10048 } 10049 }; 10050 10051 template <> 10052 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePresentWaitFeaturesKHR> 10053 { operator ()std::hash10054 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePresentWaitFeaturesKHR const & physicalDevicePresentWaitFeaturesKHR ) const VULKAN_HPP_NOEXCEPT 10055 { 10056 std::size_t seed = 0; 10057 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentWaitFeaturesKHR.sType ); 10058 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentWaitFeaturesKHR.pNext ); 10059 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentWaitFeaturesKHR.presentWait ); 10060 return seed; 10061 } 10062 }; 10063 10064 template <> 10065 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT> 10066 { operator ()std::hash10067 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT const & 10068 physicalDevicePrimitiveTopologyListRestartFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 10069 { 10070 std::size_t seed = 0; 10071 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrimitiveTopologyListRestartFeaturesEXT.sType ); 10072 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrimitiveTopologyListRestartFeaturesEXT.pNext ); 10073 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrimitiveTopologyListRestartFeaturesEXT.primitiveTopologyListRestart ); 10074 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrimitiveTopologyListRestartFeaturesEXT.primitiveTopologyPatchListRestart ); 10075 return seed; 10076 } 10077 }; 10078 10079 template <> 10080 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT> 10081 { operator ()std::hash10082 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT const & physicalDevicePrimitivesGeneratedQueryFeaturesEXT ) 10083 const VULKAN_HPP_NOEXCEPT 10084 { 10085 std::size_t seed = 0; 10086 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrimitivesGeneratedQueryFeaturesEXT.sType ); 10087 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrimitivesGeneratedQueryFeaturesEXT.pNext ); 10088 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrimitivesGeneratedQueryFeaturesEXT.primitivesGeneratedQuery ); 10089 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrimitivesGeneratedQueryFeaturesEXT.primitivesGeneratedQueryWithRasterizerDiscard ); 10090 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrimitivesGeneratedQueryFeaturesEXT.primitivesGeneratedQueryWithNonZeroStreams ); 10091 return seed; 10092 } 10093 }; 10094 10095 template <> 10096 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePrivateDataFeatures> 10097 { operator ()std::hash10098 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePrivateDataFeatures const & physicalDevicePrivateDataFeatures ) const VULKAN_HPP_NOEXCEPT 10099 { 10100 std::size_t seed = 0; 10101 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrivateDataFeatures.sType ); 10102 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrivateDataFeatures.pNext ); 10103 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrivateDataFeatures.privateData ); 10104 return seed; 10105 } 10106 }; 10107 10108 template <> 10109 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseProperties> 10110 { operator ()std::hash10111 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseProperties const & physicalDeviceSparseProperties ) const VULKAN_HPP_NOEXCEPT 10112 { 10113 std::size_t seed = 0; 10114 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseProperties.residencyStandard2DBlockShape ); 10115 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseProperties.residencyStandard2DMultisampleBlockShape ); 10116 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseProperties.residencyStandard3DBlockShape ); 10117 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseProperties.residencyAlignedMipSize ); 10118 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseProperties.residencyNonResidentStrict ); 10119 return seed; 10120 } 10121 }; 10122 10123 template <> 10124 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties> 10125 { operator ()std::hash10126 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties const & physicalDeviceProperties ) const VULKAN_HPP_NOEXCEPT 10127 { 10128 std::size_t seed = 0; 10129 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.apiVersion ); 10130 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.driverVersion ); 10131 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.vendorID ); 10132 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.deviceID ); 10133 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.deviceType ); 10134 for ( size_t i = 0; i < VK_MAX_PHYSICAL_DEVICE_NAME_SIZE; ++i ) 10135 { 10136 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.deviceName[i] ); 10137 } 10138 for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) 10139 { 10140 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.pipelineCacheUUID[i] ); 10141 } 10142 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.limits ); 10143 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.sparseProperties ); 10144 return seed; 10145 } 10146 }; 10147 10148 template <> 10149 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2> 10150 { operator ()std::hash10151 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 const & physicalDeviceProperties2 ) const VULKAN_HPP_NOEXCEPT 10152 { 10153 std::size_t seed = 0; 10154 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties2.sType ); 10155 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties2.pNext ); 10156 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties2.properties ); 10157 return seed; 10158 } 10159 }; 10160 10161 template <> 10162 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceProtectedMemoryFeatures> 10163 { 10164 std::size_t operator ()std::hash10165 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProtectedMemoryFeatures const & physicalDeviceProtectedMemoryFeatures ) const VULKAN_HPP_NOEXCEPT 10166 { 10167 std::size_t seed = 0; 10168 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProtectedMemoryFeatures.sType ); 10169 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProtectedMemoryFeatures.pNext ); 10170 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProtectedMemoryFeatures.protectedMemory ); 10171 return seed; 10172 } 10173 }; 10174 10175 template <> 10176 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceProtectedMemoryProperties> 10177 { 10178 std::size_t operator ()std::hash10179 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProtectedMemoryProperties const & physicalDeviceProtectedMemoryProperties ) const VULKAN_HPP_NOEXCEPT 10180 { 10181 std::size_t seed = 0; 10182 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProtectedMemoryProperties.sType ); 10183 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProtectedMemoryProperties.pNext ); 10184 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProtectedMemoryProperties.protectedNoFault ); 10185 return seed; 10186 } 10187 }; 10188 10189 template <> 10190 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceProvokingVertexFeaturesEXT> 10191 { 10192 std::size_t operator ()std::hash10193 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProvokingVertexFeaturesEXT const & physicalDeviceProvokingVertexFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 10194 { 10195 std::size_t seed = 0; 10196 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProvokingVertexFeaturesEXT.sType ); 10197 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProvokingVertexFeaturesEXT.pNext ); 10198 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProvokingVertexFeaturesEXT.provokingVertexLast ); 10199 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProvokingVertexFeaturesEXT.transformFeedbackPreservesProvokingVertex ); 10200 return seed; 10201 } 10202 }; 10203 10204 template <> 10205 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceProvokingVertexPropertiesEXT> 10206 { operator ()std::hash10207 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProvokingVertexPropertiesEXT const & physicalDeviceProvokingVertexPropertiesEXT ) const 10208 VULKAN_HPP_NOEXCEPT 10209 { 10210 std::size_t seed = 0; 10211 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProvokingVertexPropertiesEXT.sType ); 10212 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProvokingVertexPropertiesEXT.pNext ); 10213 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProvokingVertexPropertiesEXT.provokingVertexModePerPipeline ); 10214 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProvokingVertexPropertiesEXT.transformFeedbackPreservesTriangleFanProvokingVertex ); 10215 return seed; 10216 } 10217 }; 10218 10219 template <> 10220 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePushDescriptorPropertiesKHR> 10221 { 10222 std::size_t operator ()std::hash10223 operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePushDescriptorPropertiesKHR const & physicalDevicePushDescriptorPropertiesKHR ) const VULKAN_HPP_NOEXCEPT 10224 { 10225 std::size_t seed = 0; 10226 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePushDescriptorPropertiesKHR.sType ); 10227 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePushDescriptorPropertiesKHR.pNext ); 10228 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePushDescriptorPropertiesKHR.maxPushDescriptors ); 10229 return seed; 10230 } 10231 }; 10232 10233 template <> 10234 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRGBA10X6FormatsFeaturesEXT> 10235 { 10236 std::size_t operator ()std::hash10237 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRGBA10X6FormatsFeaturesEXT const & physicalDeviceRGBA10X6FormatsFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 10238 { 10239 std::size_t seed = 0; 10240 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRGBA10X6FormatsFeaturesEXT.sType ); 10241 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRGBA10X6FormatsFeaturesEXT.pNext ); 10242 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRGBA10X6FormatsFeaturesEXT.formatRgba10x6WithoutYCbCrSampler ); 10243 return seed; 10244 } 10245 }; 10246 10247 template <> 10248 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT> 10249 { operator ()std::hash10250 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT const & 10251 physicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 10252 { 10253 std::size_t seed = 0; 10254 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT.sType ); 10255 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT.pNext ); 10256 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT.rasterizationOrderColorAttachmentAccess ); 10257 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT.rasterizationOrderDepthAttachmentAccess ); 10258 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT.rasterizationOrderStencilAttachmentAccess ); 10259 return seed; 10260 } 10261 }; 10262 10263 template <> 10264 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayQueryFeaturesKHR> 10265 { operator ()std::hash10266 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayQueryFeaturesKHR const & physicalDeviceRayQueryFeaturesKHR ) const VULKAN_HPP_NOEXCEPT 10267 { 10268 std::size_t seed = 0; 10269 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayQueryFeaturesKHR.sType ); 10270 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayQueryFeaturesKHR.pNext ); 10271 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayQueryFeaturesKHR.rayQuery ); 10272 return seed; 10273 } 10274 }; 10275 10276 template <> 10277 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderFeaturesNV> 10278 { 10279 std::size_t operator ()std::hash10280 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderFeaturesNV const & physicalDeviceRayTracingInvocationReorderFeaturesNV ) const 10281 VULKAN_HPP_NOEXCEPT 10282 { 10283 std::size_t seed = 0; 10284 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderFeaturesNV.sType ); 10285 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderFeaturesNV.pNext ); 10286 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderFeaturesNV.rayTracingInvocationReorder ); 10287 return seed; 10288 } 10289 }; 10290 10291 template <> 10292 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderPropertiesNV> 10293 { operator ()std::hash10294 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderPropertiesNV const & 10295 physicalDeviceRayTracingInvocationReorderPropertiesNV ) const VULKAN_HPP_NOEXCEPT 10296 { 10297 std::size_t seed = 0; 10298 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderPropertiesNV.sType ); 10299 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderPropertiesNV.pNext ); 10300 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderPropertiesNV.rayTracingInvocationReorderReorderingHint ); 10301 return seed; 10302 } 10303 }; 10304 10305 template <> 10306 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingMaintenance1FeaturesKHR> 10307 { operator ()std::hash10308 std::size_t operator()( 10309 VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingMaintenance1FeaturesKHR const & physicalDeviceRayTracingMaintenance1FeaturesKHR ) const VULKAN_HPP_NOEXCEPT 10310 { 10311 std::size_t seed = 0; 10312 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingMaintenance1FeaturesKHR.sType ); 10313 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingMaintenance1FeaturesKHR.pNext ); 10314 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingMaintenance1FeaturesKHR.rayTracingMaintenance1 ); 10315 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingMaintenance1FeaturesKHR.rayTracingPipelineTraceRaysIndirect2 ); 10316 return seed; 10317 } 10318 }; 10319 10320 template <> 10321 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingMotionBlurFeaturesNV> 10322 { operator ()std::hash10323 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingMotionBlurFeaturesNV const & physicalDeviceRayTracingMotionBlurFeaturesNV ) const 10324 VULKAN_HPP_NOEXCEPT 10325 { 10326 std::size_t seed = 0; 10327 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingMotionBlurFeaturesNV.sType ); 10328 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingMotionBlurFeaturesNV.pNext ); 10329 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingMotionBlurFeaturesNV.rayTracingMotionBlur ); 10330 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingMotionBlurFeaturesNV.rayTracingMotionBlurPipelineTraceRaysIndirect ); 10331 return seed; 10332 } 10333 }; 10334 10335 template <> 10336 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPipelineFeaturesKHR> 10337 { operator ()std::hash10338 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPipelineFeaturesKHR const & physicalDeviceRayTracingPipelineFeaturesKHR ) const 10339 VULKAN_HPP_NOEXCEPT 10340 { 10341 std::size_t seed = 0; 10342 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelineFeaturesKHR.sType ); 10343 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelineFeaturesKHR.pNext ); 10344 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelineFeaturesKHR.rayTracingPipeline ); 10345 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelineFeaturesKHR.rayTracingPipelineShaderGroupHandleCaptureReplay ); 10346 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelineFeaturesKHR.rayTracingPipelineShaderGroupHandleCaptureReplayMixed ); 10347 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelineFeaturesKHR.rayTracingPipelineTraceRaysIndirect ); 10348 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelineFeaturesKHR.rayTraversalPrimitiveCulling ); 10349 return seed; 10350 } 10351 }; 10352 10353 template <> 10354 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPipelinePropertiesKHR> 10355 { operator ()std::hash10356 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPipelinePropertiesKHR const & physicalDeviceRayTracingPipelinePropertiesKHR ) const 10357 VULKAN_HPP_NOEXCEPT 10358 { 10359 std::size_t seed = 0; 10360 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.sType ); 10361 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.pNext ); 10362 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.shaderGroupHandleSize ); 10363 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.maxRayRecursionDepth ); 10364 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.maxShaderGroupStride ); 10365 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.shaderGroupBaseAlignment ); 10366 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.shaderGroupHandleCaptureReplaySize ); 10367 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.maxRayDispatchInvocationCount ); 10368 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.shaderGroupHandleAlignment ); 10369 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.maxRayHitAttributeSize ); 10370 return seed; 10371 } 10372 }; 10373 10374 template <> 10375 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPositionFetchFeaturesKHR> 10376 { operator ()std::hash10377 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPositionFetchFeaturesKHR const & physicalDeviceRayTracingPositionFetchFeaturesKHR ) 10378 const VULKAN_HPP_NOEXCEPT 10379 { 10380 std::size_t seed = 0; 10381 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPositionFetchFeaturesKHR.sType ); 10382 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPositionFetchFeaturesKHR.pNext ); 10383 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPositionFetchFeaturesKHR.rayTracingPositionFetch ); 10384 return seed; 10385 } 10386 }; 10387 10388 template <> 10389 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPropertiesNV> 10390 { operator ()std::hash10391 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPropertiesNV const & physicalDeviceRayTracingPropertiesNV ) const VULKAN_HPP_NOEXCEPT 10392 { 10393 std::size_t seed = 0; 10394 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.sType ); 10395 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.pNext ); 10396 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.shaderGroupHandleSize ); 10397 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.maxRecursionDepth ); 10398 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.maxShaderGroupStride ); 10399 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.shaderGroupBaseAlignment ); 10400 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.maxGeometryCount ); 10401 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.maxInstanceCount ); 10402 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.maxTriangleCount ); 10403 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.maxDescriptorSetAccelerationStructures ); 10404 return seed; 10405 } 10406 }; 10407 10408 template <> 10409 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRepresentativeFragmentTestFeaturesNV> 10410 { 10411 std::size_t operator ()std::hash10412 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRepresentativeFragmentTestFeaturesNV const & physicalDeviceRepresentativeFragmentTestFeaturesNV ) const 10413 VULKAN_HPP_NOEXCEPT 10414 { 10415 std::size_t seed = 0; 10416 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRepresentativeFragmentTestFeaturesNV.sType ); 10417 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRepresentativeFragmentTestFeaturesNV.pNext ); 10418 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRepresentativeFragmentTestFeaturesNV.representativeFragmentTest ); 10419 return seed; 10420 } 10421 }; 10422 10423 template <> 10424 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2FeaturesEXT> 10425 { operator ()std::hash10426 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2FeaturesEXT const & physicalDeviceRobustness2FeaturesEXT ) const VULKAN_HPP_NOEXCEPT 10427 { 10428 std::size_t seed = 0; 10429 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2FeaturesEXT.sType ); 10430 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2FeaturesEXT.pNext ); 10431 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2FeaturesEXT.robustBufferAccess2 ); 10432 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2FeaturesEXT.robustImageAccess2 ); 10433 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2FeaturesEXT.nullDescriptor ); 10434 return seed; 10435 } 10436 }; 10437 10438 template <> 10439 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2PropertiesEXT> 10440 { 10441 std::size_t operator ()std::hash10442 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2PropertiesEXT const & physicalDeviceRobustness2PropertiesEXT ) const VULKAN_HPP_NOEXCEPT 10443 { 10444 std::size_t seed = 0; 10445 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2PropertiesEXT.sType ); 10446 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2PropertiesEXT.pNext ); 10447 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2PropertiesEXT.robustStorageBufferAccessSizeAlignment ); 10448 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2PropertiesEXT.robustUniformBufferAccessSizeAlignment ); 10449 return seed; 10450 } 10451 }; 10452 10453 template <> 10454 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSampleLocationsPropertiesEXT> 10455 { operator ()std::hash10456 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSampleLocationsPropertiesEXT const & physicalDeviceSampleLocationsPropertiesEXT ) const 10457 VULKAN_HPP_NOEXCEPT 10458 { 10459 std::size_t seed = 0; 10460 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSampleLocationsPropertiesEXT.sType ); 10461 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSampleLocationsPropertiesEXT.pNext ); 10462 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSampleLocationsPropertiesEXT.sampleLocationSampleCounts ); 10463 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSampleLocationsPropertiesEXT.maxSampleLocationGridSize ); 10464 for ( size_t i = 0; i < 2; ++i ) 10465 { 10466 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSampleLocationsPropertiesEXT.sampleLocationCoordinateRange[i] ); 10467 } 10468 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSampleLocationsPropertiesEXT.sampleLocationSubPixelBits ); 10469 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSampleLocationsPropertiesEXT.variableSampleLocations ); 10470 return seed; 10471 } 10472 }; 10473 10474 template <> 10475 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSamplerFilterMinmaxProperties> 10476 { operator ()std::hash10477 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSamplerFilterMinmaxProperties const & physicalDeviceSamplerFilterMinmaxProperties ) const 10478 VULKAN_HPP_NOEXCEPT 10479 { 10480 std::size_t seed = 0; 10481 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSamplerFilterMinmaxProperties.sType ); 10482 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSamplerFilterMinmaxProperties.pNext ); 10483 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSamplerFilterMinmaxProperties.filterMinmaxSingleComponentFormats ); 10484 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSamplerFilterMinmaxProperties.filterMinmaxImageComponentMapping ); 10485 return seed; 10486 } 10487 }; 10488 10489 template <> 10490 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSamplerYcbcrConversionFeatures> 10491 { operator ()std::hash10492 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSamplerYcbcrConversionFeatures const & physicalDeviceSamplerYcbcrConversionFeatures ) const 10493 VULKAN_HPP_NOEXCEPT 10494 { 10495 std::size_t seed = 0; 10496 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSamplerYcbcrConversionFeatures.sType ); 10497 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSamplerYcbcrConversionFeatures.pNext ); 10498 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSamplerYcbcrConversionFeatures.samplerYcbcrConversion ); 10499 return seed; 10500 } 10501 }; 10502 10503 template <> 10504 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceScalarBlockLayoutFeatures> 10505 { 10506 std::size_t operator ()std::hash10507 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceScalarBlockLayoutFeatures const & physicalDeviceScalarBlockLayoutFeatures ) const VULKAN_HPP_NOEXCEPT 10508 { 10509 std::size_t seed = 0; 10510 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceScalarBlockLayoutFeatures.sType ); 10511 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceScalarBlockLayoutFeatures.pNext ); 10512 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceScalarBlockLayoutFeatures.scalarBlockLayout ); 10513 return seed; 10514 } 10515 }; 10516 10517 template <> 10518 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSeparateDepthStencilLayoutsFeatures> 10519 { operator ()std::hash10520 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSeparateDepthStencilLayoutsFeatures const & physicalDeviceSeparateDepthStencilLayoutsFeatures ) 10521 const VULKAN_HPP_NOEXCEPT 10522 { 10523 std::size_t seed = 0; 10524 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSeparateDepthStencilLayoutsFeatures.sType ); 10525 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSeparateDepthStencilLayoutsFeatures.pNext ); 10526 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSeparateDepthStencilLayoutsFeatures.separateDepthStencilLayouts ); 10527 return seed; 10528 } 10529 }; 10530 10531 template <> 10532 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloat2FeaturesEXT> 10533 { operator ()std::hash10534 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloat2FeaturesEXT const & physicalDeviceShaderAtomicFloat2FeaturesEXT ) const 10535 VULKAN_HPP_NOEXCEPT 10536 { 10537 std::size_t seed = 0; 10538 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.sType ); 10539 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.pNext ); 10540 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderBufferFloat16Atomics ); 10541 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderBufferFloat16AtomicAdd ); 10542 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderBufferFloat16AtomicMinMax ); 10543 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderBufferFloat32AtomicMinMax ); 10544 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderBufferFloat64AtomicMinMax ); 10545 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderSharedFloat16Atomics ); 10546 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderSharedFloat16AtomicAdd ); 10547 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderSharedFloat16AtomicMinMax ); 10548 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderSharedFloat32AtomicMinMax ); 10549 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderSharedFloat64AtomicMinMax ); 10550 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderImageFloat32AtomicMinMax ); 10551 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.sparseImageFloat32AtomicMinMax ); 10552 return seed; 10553 } 10554 }; 10555 10556 template <> 10557 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloatFeaturesEXT> 10558 { operator ()std::hash10559 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloatFeaturesEXT const & physicalDeviceShaderAtomicFloatFeaturesEXT ) const 10560 VULKAN_HPP_NOEXCEPT 10561 { 10562 std::size_t seed = 0; 10563 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.sType ); 10564 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.pNext ); 10565 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderBufferFloat32Atomics ); 10566 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderBufferFloat32AtomicAdd ); 10567 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderBufferFloat64Atomics ); 10568 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderBufferFloat64AtomicAdd ); 10569 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderSharedFloat32Atomics ); 10570 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderSharedFloat32AtomicAdd ); 10571 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderSharedFloat64Atomics ); 10572 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderSharedFloat64AtomicAdd ); 10573 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderImageFloat32Atomics ); 10574 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderImageFloat32AtomicAdd ); 10575 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.sparseImageFloat32Atomics ); 10576 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.sparseImageFloat32AtomicAdd ); 10577 return seed; 10578 } 10579 }; 10580 10581 template <> 10582 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicInt64Features> 10583 { 10584 std::size_t operator ()std::hash10585 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicInt64Features const & physicalDeviceShaderAtomicInt64Features ) const VULKAN_HPP_NOEXCEPT 10586 { 10587 std::size_t seed = 0; 10588 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicInt64Features.sType ); 10589 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicInt64Features.pNext ); 10590 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicInt64Features.shaderBufferInt64Atomics ); 10591 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicInt64Features.shaderSharedInt64Atomics ); 10592 return seed; 10593 } 10594 }; 10595 10596 template <> 10597 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderClockFeaturesKHR> 10598 { operator ()std::hash10599 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderClockFeaturesKHR const & physicalDeviceShaderClockFeaturesKHR ) const VULKAN_HPP_NOEXCEPT 10600 { 10601 std::size_t seed = 0; 10602 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderClockFeaturesKHR.sType ); 10603 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderClockFeaturesKHR.pNext ); 10604 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderClockFeaturesKHR.shaderSubgroupClock ); 10605 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderClockFeaturesKHR.shaderDeviceClock ); 10606 return seed; 10607 } 10608 }; 10609 10610 template <> 10611 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCoreBuiltinsFeaturesARM> 10612 { operator ()std::hash10613 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCoreBuiltinsFeaturesARM const & physicalDeviceShaderCoreBuiltinsFeaturesARM ) const 10614 VULKAN_HPP_NOEXCEPT 10615 { 10616 std::size_t seed = 0; 10617 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreBuiltinsFeaturesARM.sType ); 10618 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreBuiltinsFeaturesARM.pNext ); 10619 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreBuiltinsFeaturesARM.shaderCoreBuiltins ); 10620 return seed; 10621 } 10622 }; 10623 10624 template <> 10625 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCoreBuiltinsPropertiesARM> 10626 { operator ()std::hash10627 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCoreBuiltinsPropertiesARM const & physicalDeviceShaderCoreBuiltinsPropertiesARM ) const 10628 VULKAN_HPP_NOEXCEPT 10629 { 10630 std::size_t seed = 0; 10631 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreBuiltinsPropertiesARM.sType ); 10632 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreBuiltinsPropertiesARM.pNext ); 10633 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreBuiltinsPropertiesARM.shaderCoreMask ); 10634 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreBuiltinsPropertiesARM.shaderCoreCount ); 10635 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreBuiltinsPropertiesARM.shaderWarpsPerCore ); 10636 return seed; 10637 } 10638 }; 10639 10640 template <> 10641 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCoreProperties2AMD> 10642 { 10643 std::size_t operator ()std::hash10644 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCoreProperties2AMD const & physicalDeviceShaderCoreProperties2AMD ) const VULKAN_HPP_NOEXCEPT 10645 { 10646 std::size_t seed = 0; 10647 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreProperties2AMD.sType ); 10648 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreProperties2AMD.pNext ); 10649 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreProperties2AMD.shaderCoreFeatures ); 10650 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreProperties2AMD.activeComputeUnitCount ); 10651 return seed; 10652 } 10653 }; 10654 10655 template <> 10656 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCorePropertiesAMD> 10657 { 10658 std::size_t operator ()std::hash10659 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCorePropertiesAMD const & physicalDeviceShaderCorePropertiesAMD ) const VULKAN_HPP_NOEXCEPT 10660 { 10661 std::size_t seed = 0; 10662 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.sType ); 10663 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.pNext ); 10664 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.shaderEngineCount ); 10665 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.shaderArraysPerEngineCount ); 10666 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.computeUnitsPerShaderArray ); 10667 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.simdPerComputeUnit ); 10668 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.wavefrontsPerSimd ); 10669 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.wavefrontSize ); 10670 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.sgprsPerSimd ); 10671 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.minSgprAllocation ); 10672 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.maxSgprAllocation ); 10673 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.sgprAllocationGranularity ); 10674 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.vgprsPerSimd ); 10675 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.minVgprAllocation ); 10676 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.maxVgprAllocation ); 10677 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.vgprAllocationGranularity ); 10678 return seed; 10679 } 10680 }; 10681 10682 template <> 10683 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCorePropertiesARM> 10684 { 10685 std::size_t operator ()std::hash10686 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCorePropertiesARM const & physicalDeviceShaderCorePropertiesARM ) const VULKAN_HPP_NOEXCEPT 10687 { 10688 std::size_t seed = 0; 10689 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesARM.sType ); 10690 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesARM.pNext ); 10691 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesARM.pixelRate ); 10692 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesARM.texelRate ); 10693 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesARM.fmaRate ); 10694 return seed; 10695 } 10696 }; 10697 10698 template <> 10699 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderDemoteToHelperInvocationFeatures> 10700 { operator ()std::hash10701 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderDemoteToHelperInvocationFeatures const & 10702 physicalDeviceShaderDemoteToHelperInvocationFeatures ) const VULKAN_HPP_NOEXCEPT 10703 { 10704 std::size_t seed = 0; 10705 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderDemoteToHelperInvocationFeatures.sType ); 10706 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderDemoteToHelperInvocationFeatures.pNext ); 10707 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderDemoteToHelperInvocationFeatures.shaderDemoteToHelperInvocation ); 10708 return seed; 10709 } 10710 }; 10711 10712 template <> 10713 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderDrawParametersFeatures> 10714 { operator ()std::hash10715 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderDrawParametersFeatures const & physicalDeviceShaderDrawParametersFeatures ) const 10716 VULKAN_HPP_NOEXCEPT 10717 { 10718 std::size_t seed = 0; 10719 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderDrawParametersFeatures.sType ); 10720 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderDrawParametersFeatures.pNext ); 10721 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderDrawParametersFeatures.shaderDrawParameters ); 10722 return seed; 10723 } 10724 }; 10725 10726 template <> 10727 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD> 10728 { operator ()std::hash10729 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD const & 10730 physicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD ) const VULKAN_HPP_NOEXCEPT 10731 { 10732 std::size_t seed = 0; 10733 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD.sType ); 10734 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD.pNext ); 10735 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD.shaderEarlyAndLateFragmentTests ); 10736 return seed; 10737 } 10738 }; 10739 10740 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 10741 template <> 10742 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderEnqueueFeaturesAMDX> 10743 { 10744 std::size_t operator ()std::hash10745 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderEnqueueFeaturesAMDX const & physicalDeviceShaderEnqueueFeaturesAMDX ) const VULKAN_HPP_NOEXCEPT 10746 { 10747 std::size_t seed = 0; 10748 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueueFeaturesAMDX.sType ); 10749 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueueFeaturesAMDX.pNext ); 10750 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueueFeaturesAMDX.shaderEnqueue ); 10751 return seed; 10752 } 10753 }; 10754 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 10755 10756 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 10757 template <> 10758 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderEnqueuePropertiesAMDX> 10759 { 10760 std::size_t operator ()std::hash10761 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderEnqueuePropertiesAMDX const & physicalDeviceShaderEnqueuePropertiesAMDX ) const VULKAN_HPP_NOEXCEPT 10762 { 10763 std::size_t seed = 0; 10764 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueuePropertiesAMDX.sType ); 10765 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueuePropertiesAMDX.pNext ); 10766 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueuePropertiesAMDX.maxExecutionGraphDepth ); 10767 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueuePropertiesAMDX.maxExecutionGraphShaderOutputNodes ); 10768 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueuePropertiesAMDX.maxExecutionGraphShaderPayloadSize ); 10769 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueuePropertiesAMDX.maxExecutionGraphShaderPayloadCount ); 10770 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueuePropertiesAMDX.executionGraphDispatchAddressAlignment ); 10771 return seed; 10772 } 10773 }; 10774 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 10775 10776 template <> 10777 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFloat16Int8Features> 10778 { 10779 std::size_t operator ()std::hash10780 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFloat16Int8Features const & physicalDeviceShaderFloat16Int8Features ) const VULKAN_HPP_NOEXCEPT 10781 { 10782 std::size_t seed = 0; 10783 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFloat16Int8Features.sType ); 10784 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFloat16Int8Features.pNext ); 10785 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFloat16Int8Features.shaderFloat16 ); 10786 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFloat16Int8Features.shaderInt8 ); 10787 return seed; 10788 } 10789 }; 10790 10791 template <> 10792 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderImageAtomicInt64FeaturesEXT> 10793 { operator ()std::hash10794 std::size_t operator()( 10795 VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderImageAtomicInt64FeaturesEXT const & physicalDeviceShaderImageAtomicInt64FeaturesEXT ) const VULKAN_HPP_NOEXCEPT 10796 { 10797 std::size_t seed = 0; 10798 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderImageAtomicInt64FeaturesEXT.sType ); 10799 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderImageAtomicInt64FeaturesEXT.pNext ); 10800 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderImageAtomicInt64FeaturesEXT.shaderImageInt64Atomics ); 10801 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderImageAtomicInt64FeaturesEXT.sparseImageInt64Atomics ); 10802 return seed; 10803 } 10804 }; 10805 10806 template <> 10807 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderImageFootprintFeaturesNV> 10808 { operator ()std::hash10809 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderImageFootprintFeaturesNV const & physicalDeviceShaderImageFootprintFeaturesNV ) const 10810 VULKAN_HPP_NOEXCEPT 10811 { 10812 std::size_t seed = 0; 10813 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderImageFootprintFeaturesNV.sType ); 10814 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderImageFootprintFeaturesNV.pNext ); 10815 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderImageFootprintFeaturesNV.imageFootprint ); 10816 return seed; 10817 } 10818 }; 10819 10820 template <> 10821 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerDotProductFeatures> 10822 { operator ()std::hash10823 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerDotProductFeatures const & physicalDeviceShaderIntegerDotProductFeatures ) const 10824 VULKAN_HPP_NOEXCEPT 10825 { 10826 std::size_t seed = 0; 10827 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductFeatures.sType ); 10828 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductFeatures.pNext ); 10829 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductFeatures.shaderIntegerDotProduct ); 10830 return seed; 10831 } 10832 }; 10833 10834 template <> 10835 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerDotProductProperties> 10836 { operator ()std::hash10837 std::size_t operator()( 10838 VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerDotProductProperties const & physicalDeviceShaderIntegerDotProductProperties ) const VULKAN_HPP_NOEXCEPT 10839 { 10840 std::size_t seed = 0; 10841 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.sType ); 10842 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.pNext ); 10843 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct8BitUnsignedAccelerated ); 10844 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct8BitSignedAccelerated ); 10845 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct8BitMixedSignednessAccelerated ); 10846 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct4x8BitPackedUnsignedAccelerated ); 10847 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct4x8BitPackedSignedAccelerated ); 10848 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct4x8BitPackedMixedSignednessAccelerated ); 10849 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct16BitUnsignedAccelerated ); 10850 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct16BitSignedAccelerated ); 10851 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct16BitMixedSignednessAccelerated ); 10852 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct32BitUnsignedAccelerated ); 10853 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct32BitSignedAccelerated ); 10854 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct32BitMixedSignednessAccelerated ); 10855 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct64BitUnsignedAccelerated ); 10856 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct64BitSignedAccelerated ); 10857 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct64BitMixedSignednessAccelerated ); 10858 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating8BitUnsignedAccelerated ); 10859 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating8BitSignedAccelerated ); 10860 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated ); 10861 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated ); 10862 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated ); 10863 VULKAN_HPP_HASH_COMBINE( seed, 10864 physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated ); 10865 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating16BitUnsignedAccelerated ); 10866 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating16BitSignedAccelerated ); 10867 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated ); 10868 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating32BitUnsignedAccelerated ); 10869 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating32BitSignedAccelerated ); 10870 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated ); 10871 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating64BitUnsignedAccelerated ); 10872 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating64BitSignedAccelerated ); 10873 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated ); 10874 return seed; 10875 } 10876 }; 10877 10878 template <> 10879 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL> 10880 { 10881 std::size_t operator ()std::hash10882 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const & physicalDeviceShaderIntegerFunctions2FeaturesINTEL ) const 10883 VULKAN_HPP_NOEXCEPT 10884 { 10885 std::size_t seed = 0; 10886 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerFunctions2FeaturesINTEL.sType ); 10887 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerFunctions2FeaturesINTEL.pNext ); 10888 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerFunctions2FeaturesINTEL.shaderIntegerFunctions2 ); 10889 return seed; 10890 } 10891 }; 10892 10893 template <> 10894 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderModuleIdentifierFeaturesEXT> 10895 { operator ()std::hash10896 std::size_t operator()( 10897 VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderModuleIdentifierFeaturesEXT const & physicalDeviceShaderModuleIdentifierFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 10898 { 10899 std::size_t seed = 0; 10900 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderModuleIdentifierFeaturesEXT.sType ); 10901 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderModuleIdentifierFeaturesEXT.pNext ); 10902 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderModuleIdentifierFeaturesEXT.shaderModuleIdentifier ); 10903 return seed; 10904 } 10905 }; 10906 10907 template <> 10908 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderModuleIdentifierPropertiesEXT> 10909 { operator ()std::hash10910 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderModuleIdentifierPropertiesEXT const & physicalDeviceShaderModuleIdentifierPropertiesEXT ) 10911 const VULKAN_HPP_NOEXCEPT 10912 { 10913 std::size_t seed = 0; 10914 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderModuleIdentifierPropertiesEXT.sType ); 10915 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderModuleIdentifierPropertiesEXT.pNext ); 10916 for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) 10917 { 10918 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderModuleIdentifierPropertiesEXT.shaderModuleIdentifierAlgorithmUUID[i] ); 10919 } 10920 return seed; 10921 } 10922 }; 10923 10924 template <> 10925 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderObjectFeaturesEXT> 10926 { 10927 std::size_t operator ()std::hash10928 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderObjectFeaturesEXT const & physicalDeviceShaderObjectFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 10929 { 10930 std::size_t seed = 0; 10931 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderObjectFeaturesEXT.sType ); 10932 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderObjectFeaturesEXT.pNext ); 10933 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderObjectFeaturesEXT.shaderObject ); 10934 return seed; 10935 } 10936 }; 10937 10938 template <> 10939 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderObjectPropertiesEXT> 10940 { 10941 std::size_t operator ()std::hash10942 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderObjectPropertiesEXT const & physicalDeviceShaderObjectPropertiesEXT ) const VULKAN_HPP_NOEXCEPT 10943 { 10944 std::size_t seed = 0; 10945 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderObjectPropertiesEXT.sType ); 10946 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderObjectPropertiesEXT.pNext ); 10947 for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) 10948 { 10949 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderObjectPropertiesEXT.shaderBinaryUUID[i] ); 10950 } 10951 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderObjectPropertiesEXT.shaderBinaryVersion ); 10952 return seed; 10953 } 10954 }; 10955 10956 template <> 10957 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSMBuiltinsFeaturesNV> 10958 { 10959 std::size_t operator ()std::hash10960 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSMBuiltinsFeaturesNV const & physicalDeviceShaderSMBuiltinsFeaturesNV ) const VULKAN_HPP_NOEXCEPT 10961 { 10962 std::size_t seed = 0; 10963 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSMBuiltinsFeaturesNV.sType ); 10964 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSMBuiltinsFeaturesNV.pNext ); 10965 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSMBuiltinsFeaturesNV.shaderSMBuiltins ); 10966 return seed; 10967 } 10968 }; 10969 10970 template <> 10971 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSMBuiltinsPropertiesNV> 10972 { operator ()std::hash10973 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSMBuiltinsPropertiesNV const & physicalDeviceShaderSMBuiltinsPropertiesNV ) const 10974 VULKAN_HPP_NOEXCEPT 10975 { 10976 std::size_t seed = 0; 10977 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSMBuiltinsPropertiesNV.sType ); 10978 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSMBuiltinsPropertiesNV.pNext ); 10979 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSMBuiltinsPropertiesNV.shaderSMCount ); 10980 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSMBuiltinsPropertiesNV.shaderWarpsPerSM ); 10981 return seed; 10982 } 10983 }; 10984 10985 template <> 10986 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupExtendedTypesFeatures> 10987 { operator ()std::hash10988 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupExtendedTypesFeatures const & physicalDeviceShaderSubgroupExtendedTypesFeatures ) 10989 const VULKAN_HPP_NOEXCEPT 10990 { 10991 std::size_t seed = 0; 10992 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupExtendedTypesFeatures.sType ); 10993 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupExtendedTypesFeatures.pNext ); 10994 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupExtendedTypesFeatures.shaderSubgroupExtendedTypes ); 10995 return seed; 10996 } 10997 }; 10998 10999 template <> 11000 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR> 11001 { operator ()std::hash11002 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR const & 11003 physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR ) const VULKAN_HPP_NOEXCEPT 11004 { 11005 std::size_t seed = 0; 11006 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR.sType ); 11007 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR.pNext ); 11008 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR.shaderSubgroupUniformControlFlow ); 11009 return seed; 11010 } 11011 }; 11012 11013 template <> 11014 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderTerminateInvocationFeatures> 11015 { operator ()std::hash11016 std::size_t operator()( 11017 VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderTerminateInvocationFeatures const & physicalDeviceShaderTerminateInvocationFeatures ) const VULKAN_HPP_NOEXCEPT 11018 { 11019 std::size_t seed = 0; 11020 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTerminateInvocationFeatures.sType ); 11021 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTerminateInvocationFeatures.pNext ); 11022 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTerminateInvocationFeatures.shaderTerminateInvocation ); 11023 return seed; 11024 } 11025 }; 11026 11027 template <> 11028 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderTileImageFeaturesEXT> 11029 { 11030 std::size_t operator ()std::hash11031 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderTileImageFeaturesEXT const & physicalDeviceShaderTileImageFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 11032 { 11033 std::size_t seed = 0; 11034 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImageFeaturesEXT.sType ); 11035 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImageFeaturesEXT.pNext ); 11036 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImageFeaturesEXT.shaderTileImageColorReadAccess ); 11037 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImageFeaturesEXT.shaderTileImageDepthReadAccess ); 11038 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImageFeaturesEXT.shaderTileImageStencilReadAccess ); 11039 return seed; 11040 } 11041 }; 11042 11043 template <> 11044 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderTileImagePropertiesEXT> 11045 { operator ()std::hash11046 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderTileImagePropertiesEXT const & physicalDeviceShaderTileImagePropertiesEXT ) const 11047 VULKAN_HPP_NOEXCEPT 11048 { 11049 std::size_t seed = 0; 11050 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImagePropertiesEXT.sType ); 11051 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImagePropertiesEXT.pNext ); 11052 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImagePropertiesEXT.shaderTileImageCoherentReadAccelerated ); 11053 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImagePropertiesEXT.shaderTileImageReadSampleFromPixelRateInvocation ); 11054 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImagePropertiesEXT.shaderTileImageReadFromHelperInvocation ); 11055 return seed; 11056 } 11057 }; 11058 11059 template <> 11060 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShadingRateImageFeaturesNV> 11061 { 11062 std::size_t operator ()std::hash11063 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShadingRateImageFeaturesNV const & physicalDeviceShadingRateImageFeaturesNV ) const VULKAN_HPP_NOEXCEPT 11064 { 11065 std::size_t seed = 0; 11066 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShadingRateImageFeaturesNV.sType ); 11067 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShadingRateImageFeaturesNV.pNext ); 11068 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShadingRateImageFeaturesNV.shadingRateImage ); 11069 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShadingRateImageFeaturesNV.shadingRateCoarseSampleOrder ); 11070 return seed; 11071 } 11072 }; 11073 11074 template <> 11075 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShadingRateImagePropertiesNV> 11076 { operator ()std::hash11077 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShadingRateImagePropertiesNV const & physicalDeviceShadingRateImagePropertiesNV ) const 11078 VULKAN_HPP_NOEXCEPT 11079 { 11080 std::size_t seed = 0; 11081 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShadingRateImagePropertiesNV.sType ); 11082 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShadingRateImagePropertiesNV.pNext ); 11083 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShadingRateImagePropertiesNV.shadingRateTexelSize ); 11084 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShadingRateImagePropertiesNV.shadingRatePaletteSize ); 11085 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShadingRateImagePropertiesNV.shadingRateMaxCoarseSamples ); 11086 return seed; 11087 } 11088 }; 11089 11090 template <> 11091 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2> 11092 { operator ()std::hash11093 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 const & physicalDeviceSparseImageFormatInfo2 ) const VULKAN_HPP_NOEXCEPT 11094 { 11095 std::size_t seed = 0; 11096 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseImageFormatInfo2.sType ); 11097 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseImageFormatInfo2.pNext ); 11098 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseImageFormatInfo2.format ); 11099 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseImageFormatInfo2.type ); 11100 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseImageFormatInfo2.samples ); 11101 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseImageFormatInfo2.usage ); 11102 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseImageFormatInfo2.tiling ); 11103 return seed; 11104 } 11105 }; 11106 11107 template <> 11108 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupProperties> 11109 { operator ()std::hash11110 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupProperties const & physicalDeviceSubgroupProperties ) const VULKAN_HPP_NOEXCEPT 11111 { 11112 std::size_t seed = 0; 11113 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupProperties.sType ); 11114 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupProperties.pNext ); 11115 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupProperties.subgroupSize ); 11116 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupProperties.supportedStages ); 11117 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupProperties.supportedOperations ); 11118 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupProperties.quadOperationsInAllStages ); 11119 return seed; 11120 } 11121 }; 11122 11123 template <> 11124 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupSizeControlFeatures> 11125 { 11126 std::size_t operator ()std::hash11127 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupSizeControlFeatures const & physicalDeviceSubgroupSizeControlFeatures ) const VULKAN_HPP_NOEXCEPT 11128 { 11129 std::size_t seed = 0; 11130 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlFeatures.sType ); 11131 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlFeatures.pNext ); 11132 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlFeatures.subgroupSizeControl ); 11133 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlFeatures.computeFullSubgroups ); 11134 return seed; 11135 } 11136 }; 11137 11138 template <> 11139 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupSizeControlProperties> 11140 { operator ()std::hash11141 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupSizeControlProperties const & physicalDeviceSubgroupSizeControlProperties ) const 11142 VULKAN_HPP_NOEXCEPT 11143 { 11144 std::size_t seed = 0; 11145 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlProperties.sType ); 11146 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlProperties.pNext ); 11147 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlProperties.minSubgroupSize ); 11148 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlProperties.maxSubgroupSize ); 11149 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlProperties.maxComputeWorkgroupSubgroups ); 11150 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlProperties.requiredSubgroupSizeStages ); 11151 return seed; 11152 } 11153 }; 11154 11155 template <> 11156 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassMergeFeedbackFeaturesEXT> 11157 { operator ()std::hash11158 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassMergeFeedbackFeaturesEXT const & physicalDeviceSubpassMergeFeedbackFeaturesEXT ) const 11159 VULKAN_HPP_NOEXCEPT 11160 { 11161 std::size_t seed = 0; 11162 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubpassMergeFeedbackFeaturesEXT.sType ); 11163 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubpassMergeFeedbackFeaturesEXT.pNext ); 11164 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubpassMergeFeedbackFeaturesEXT.subpassMergeFeedback ); 11165 return seed; 11166 } 11167 }; 11168 11169 template <> 11170 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassShadingFeaturesHUAWEI> 11171 { operator ()std::hash11172 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassShadingFeaturesHUAWEI const & physicalDeviceSubpassShadingFeaturesHUAWEI ) const 11173 VULKAN_HPP_NOEXCEPT 11174 { 11175 std::size_t seed = 0; 11176 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubpassShadingFeaturesHUAWEI.sType ); 11177 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubpassShadingFeaturesHUAWEI.pNext ); 11178 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubpassShadingFeaturesHUAWEI.subpassShading ); 11179 return seed; 11180 } 11181 }; 11182 11183 template <> 11184 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassShadingPropertiesHUAWEI> 11185 { operator ()std::hash11186 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassShadingPropertiesHUAWEI const & physicalDeviceSubpassShadingPropertiesHUAWEI ) const 11187 VULKAN_HPP_NOEXCEPT 11188 { 11189 std::size_t seed = 0; 11190 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubpassShadingPropertiesHUAWEI.sType ); 11191 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubpassShadingPropertiesHUAWEI.pNext ); 11192 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubpassShadingPropertiesHUAWEI.maxSubpassShadingWorkgroupSizeAspectRatio ); 11193 return seed; 11194 } 11195 }; 11196 11197 template <> 11198 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR> 11199 { operator ()std::hash11200 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR const & physicalDeviceSurfaceInfo2KHR ) const VULKAN_HPP_NOEXCEPT 11201 { 11202 std::size_t seed = 0; 11203 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSurfaceInfo2KHR.sType ); 11204 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSurfaceInfo2KHR.pNext ); 11205 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSurfaceInfo2KHR.surface ); 11206 return seed; 11207 } 11208 }; 11209 11210 template <> 11211 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSwapchainMaintenance1FeaturesEXT> 11212 { operator ()std::hash11213 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSwapchainMaintenance1FeaturesEXT const & physicalDeviceSwapchainMaintenance1FeaturesEXT ) const 11214 VULKAN_HPP_NOEXCEPT 11215 { 11216 std::size_t seed = 0; 11217 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSwapchainMaintenance1FeaturesEXT.sType ); 11218 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSwapchainMaintenance1FeaturesEXT.pNext ); 11219 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSwapchainMaintenance1FeaturesEXT.swapchainMaintenance1 ); 11220 return seed; 11221 } 11222 }; 11223 11224 template <> 11225 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSynchronization2Features> 11226 { 11227 std::size_t operator ()std::hash11228 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSynchronization2Features const & physicalDeviceSynchronization2Features ) const VULKAN_HPP_NOEXCEPT 11229 { 11230 std::size_t seed = 0; 11231 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSynchronization2Features.sType ); 11232 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSynchronization2Features.pNext ); 11233 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSynchronization2Features.synchronization2 ); 11234 return seed; 11235 } 11236 }; 11237 11238 template <> 11239 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTexelBufferAlignmentFeaturesEXT> 11240 { operator ()std::hash11241 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTexelBufferAlignmentFeaturesEXT const & physicalDeviceTexelBufferAlignmentFeaturesEXT ) const 11242 VULKAN_HPP_NOEXCEPT 11243 { 11244 std::size_t seed = 0; 11245 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTexelBufferAlignmentFeaturesEXT.sType ); 11246 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTexelBufferAlignmentFeaturesEXT.pNext ); 11247 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTexelBufferAlignmentFeaturesEXT.texelBufferAlignment ); 11248 return seed; 11249 } 11250 }; 11251 11252 template <> 11253 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTexelBufferAlignmentProperties> 11254 { operator ()std::hash11255 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTexelBufferAlignmentProperties const & physicalDeviceTexelBufferAlignmentProperties ) const 11256 VULKAN_HPP_NOEXCEPT 11257 { 11258 std::size_t seed = 0; 11259 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTexelBufferAlignmentProperties.sType ); 11260 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTexelBufferAlignmentProperties.pNext ); 11261 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTexelBufferAlignmentProperties.storageTexelBufferOffsetAlignmentBytes ); 11262 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTexelBufferAlignmentProperties.storageTexelBufferOffsetSingleTexelAlignment ); 11263 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTexelBufferAlignmentProperties.uniformTexelBufferOffsetAlignmentBytes ); 11264 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTexelBufferAlignmentProperties.uniformTexelBufferOffsetSingleTexelAlignment ); 11265 return seed; 11266 } 11267 }; 11268 11269 template <> 11270 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTextureCompressionASTCHDRFeatures> 11271 { operator ()std::hash11272 std::size_t operator()( 11273 VULKAN_HPP_NAMESPACE::PhysicalDeviceTextureCompressionASTCHDRFeatures const & physicalDeviceTextureCompressionASTCHDRFeatures ) const VULKAN_HPP_NOEXCEPT 11274 { 11275 std::size_t seed = 0; 11276 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTextureCompressionASTCHDRFeatures.sType ); 11277 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTextureCompressionASTCHDRFeatures.pNext ); 11278 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTextureCompressionASTCHDRFeatures.textureCompressionASTC_HDR ); 11279 return seed; 11280 } 11281 }; 11282 11283 template <> 11284 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTilePropertiesFeaturesQCOM> 11285 { 11286 std::size_t operator ()std::hash11287 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTilePropertiesFeaturesQCOM const & physicalDeviceTilePropertiesFeaturesQCOM ) const VULKAN_HPP_NOEXCEPT 11288 { 11289 std::size_t seed = 0; 11290 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTilePropertiesFeaturesQCOM.sType ); 11291 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTilePropertiesFeaturesQCOM.pNext ); 11292 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTilePropertiesFeaturesQCOM.tileProperties ); 11293 return seed; 11294 } 11295 }; 11296 11297 template <> 11298 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTimelineSemaphoreFeatures> 11299 { 11300 std::size_t operator ()std::hash11301 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTimelineSemaphoreFeatures const & physicalDeviceTimelineSemaphoreFeatures ) const VULKAN_HPP_NOEXCEPT 11302 { 11303 std::size_t seed = 0; 11304 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTimelineSemaphoreFeatures.sType ); 11305 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTimelineSemaphoreFeatures.pNext ); 11306 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTimelineSemaphoreFeatures.timelineSemaphore ); 11307 return seed; 11308 } 11309 }; 11310 11311 template <> 11312 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTimelineSemaphoreProperties> 11313 { 11314 std::size_t operator ()std::hash11315 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTimelineSemaphoreProperties const & physicalDeviceTimelineSemaphoreProperties ) const VULKAN_HPP_NOEXCEPT 11316 { 11317 std::size_t seed = 0; 11318 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTimelineSemaphoreProperties.sType ); 11319 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTimelineSemaphoreProperties.pNext ); 11320 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTimelineSemaphoreProperties.maxTimelineSemaphoreValueDifference ); 11321 return seed; 11322 } 11323 }; 11324 11325 template <> 11326 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties> 11327 { operator ()std::hash11328 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties const & physicalDeviceToolProperties ) const VULKAN_HPP_NOEXCEPT 11329 { 11330 std::size_t seed = 0; 11331 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceToolProperties.sType ); 11332 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceToolProperties.pNext ); 11333 for ( size_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i ) 11334 { 11335 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceToolProperties.name[i] ); 11336 } 11337 for ( size_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i ) 11338 { 11339 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceToolProperties.version[i] ); 11340 } 11341 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceToolProperties.purposes ); 11342 for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) 11343 { 11344 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceToolProperties.description[i] ); 11345 } 11346 for ( size_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i ) 11347 { 11348 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceToolProperties.layer[i] ); 11349 } 11350 return seed; 11351 } 11352 }; 11353 11354 template <> 11355 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTransformFeedbackFeaturesEXT> 11356 { operator ()std::hash11357 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTransformFeedbackFeaturesEXT const & physicalDeviceTransformFeedbackFeaturesEXT ) const 11358 VULKAN_HPP_NOEXCEPT 11359 { 11360 std::size_t seed = 0; 11361 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackFeaturesEXT.sType ); 11362 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackFeaturesEXT.pNext ); 11363 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackFeaturesEXT.transformFeedback ); 11364 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackFeaturesEXT.geometryStreams ); 11365 return seed; 11366 } 11367 }; 11368 11369 template <> 11370 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTransformFeedbackPropertiesEXT> 11371 { operator ()std::hash11372 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTransformFeedbackPropertiesEXT const & physicalDeviceTransformFeedbackPropertiesEXT ) const 11373 VULKAN_HPP_NOEXCEPT 11374 { 11375 std::size_t seed = 0; 11376 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.sType ); 11377 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.pNext ); 11378 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackStreams ); 11379 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackBuffers ); 11380 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackBufferSize ); 11381 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackStreamDataSize ); 11382 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackBufferDataSize ); 11383 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackBufferDataStride ); 11384 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.transformFeedbackQueries ); 11385 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.transformFeedbackStreamsLinesTriangles ); 11386 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.transformFeedbackRasterizationStreamSelect ); 11387 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.transformFeedbackDraw ); 11388 return seed; 11389 } 11390 }; 11391 11392 template <> 11393 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceUniformBufferStandardLayoutFeatures> 11394 { operator ()std::hash11395 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceUniformBufferStandardLayoutFeatures const & physicalDeviceUniformBufferStandardLayoutFeatures ) 11396 const VULKAN_HPP_NOEXCEPT 11397 { 11398 std::size_t seed = 0; 11399 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceUniformBufferStandardLayoutFeatures.sType ); 11400 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceUniformBufferStandardLayoutFeatures.pNext ); 11401 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceUniformBufferStandardLayoutFeatures.uniformBufferStandardLayout ); 11402 return seed; 11403 } 11404 }; 11405 11406 template <> 11407 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVariablePointersFeatures> 11408 { 11409 std::size_t operator ()std::hash11410 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVariablePointersFeatures const & physicalDeviceVariablePointersFeatures ) const VULKAN_HPP_NOEXCEPT 11411 { 11412 std::size_t seed = 0; 11413 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVariablePointersFeatures.sType ); 11414 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVariablePointersFeatures.pNext ); 11415 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVariablePointersFeatures.variablePointersStorageBuffer ); 11416 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVariablePointersFeatures.variablePointers ); 11417 return seed; 11418 } 11419 }; 11420 11421 template <> 11422 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorFeaturesEXT> 11423 { operator ()std::hash11424 std::size_t operator()( 11425 VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorFeaturesEXT const & physicalDeviceVertexAttributeDivisorFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 11426 { 11427 std::size_t seed = 0; 11428 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorFeaturesEXT.sType ); 11429 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorFeaturesEXT.pNext ); 11430 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorFeaturesEXT.vertexAttributeInstanceRateDivisor ); 11431 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorFeaturesEXT.vertexAttributeInstanceRateZeroDivisor ); 11432 return seed; 11433 } 11434 }; 11435 11436 template <> 11437 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorPropertiesEXT> 11438 { operator ()std::hash11439 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorPropertiesEXT const & physicalDeviceVertexAttributeDivisorPropertiesEXT ) 11440 const VULKAN_HPP_NOEXCEPT 11441 { 11442 std::size_t seed = 0; 11443 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorPropertiesEXT.sType ); 11444 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorPropertiesEXT.pNext ); 11445 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorPropertiesEXT.maxVertexAttribDivisor ); 11446 return seed; 11447 } 11448 }; 11449 11450 template <> 11451 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexInputDynamicStateFeaturesEXT> 11452 { operator ()std::hash11453 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexInputDynamicStateFeaturesEXT const & physicalDeviceVertexInputDynamicStateFeaturesEXT ) 11454 const VULKAN_HPP_NOEXCEPT 11455 { 11456 std::size_t seed = 0; 11457 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexInputDynamicStateFeaturesEXT.sType ); 11458 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexInputDynamicStateFeaturesEXT.pNext ); 11459 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexInputDynamicStateFeaturesEXT.vertexInputDynamicState ); 11460 return seed; 11461 } 11462 }; 11463 11464 template <> 11465 struct hash<VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR> 11466 { operator ()std::hash11467 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR const & videoProfileInfoKHR ) const VULKAN_HPP_NOEXCEPT 11468 { 11469 std::size_t seed = 0; 11470 VULKAN_HPP_HASH_COMBINE( seed, videoProfileInfoKHR.sType ); 11471 VULKAN_HPP_HASH_COMBINE( seed, videoProfileInfoKHR.pNext ); 11472 VULKAN_HPP_HASH_COMBINE( seed, videoProfileInfoKHR.videoCodecOperation ); 11473 VULKAN_HPP_HASH_COMBINE( seed, videoProfileInfoKHR.chromaSubsampling ); 11474 VULKAN_HPP_HASH_COMBINE( seed, videoProfileInfoKHR.lumaBitDepth ); 11475 VULKAN_HPP_HASH_COMBINE( seed, videoProfileInfoKHR.chromaBitDepth ); 11476 return seed; 11477 } 11478 }; 11479 11480 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 11481 template <> 11482 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeQualityLevelInfoKHR> 11483 { operator ()std::hash11484 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeQualityLevelInfoKHR const & physicalDeviceVideoEncodeQualityLevelInfoKHR ) const 11485 VULKAN_HPP_NOEXCEPT 11486 { 11487 std::size_t seed = 0; 11488 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoEncodeQualityLevelInfoKHR.sType ); 11489 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoEncodeQualityLevelInfoKHR.pNext ); 11490 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoEncodeQualityLevelInfoKHR.pVideoProfile ); 11491 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoEncodeQualityLevelInfoKHR.qualityLevel ); 11492 return seed; 11493 } 11494 }; 11495 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 11496 11497 template <> 11498 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR> 11499 { operator ()std::hash11500 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR const & physicalDeviceVideoFormatInfoKHR ) const VULKAN_HPP_NOEXCEPT 11501 { 11502 std::size_t seed = 0; 11503 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoFormatInfoKHR.sType ); 11504 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoFormatInfoKHR.pNext ); 11505 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoFormatInfoKHR.imageUsage ); 11506 return seed; 11507 } 11508 }; 11509 11510 template <> 11511 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan11Features> 11512 { operator ()std::hash11513 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan11Features const & physicalDeviceVulkan11Features ) const VULKAN_HPP_NOEXCEPT 11514 { 11515 std::size_t seed = 0; 11516 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.sType ); 11517 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.pNext ); 11518 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.storageBuffer16BitAccess ); 11519 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.uniformAndStorageBuffer16BitAccess ); 11520 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.storagePushConstant16 ); 11521 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.storageInputOutput16 ); 11522 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.multiview ); 11523 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.multiviewGeometryShader ); 11524 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.multiviewTessellationShader ); 11525 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.variablePointersStorageBuffer ); 11526 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.variablePointers ); 11527 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.protectedMemory ); 11528 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.samplerYcbcrConversion ); 11529 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.shaderDrawParameters ); 11530 return seed; 11531 } 11532 }; 11533 11534 template <> 11535 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan11Properties> 11536 { operator ()std::hash11537 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan11Properties const & physicalDeviceVulkan11Properties ) const VULKAN_HPP_NOEXCEPT 11538 { 11539 std::size_t seed = 0; 11540 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.sType ); 11541 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.pNext ); 11542 for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) 11543 { 11544 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.deviceUUID[i] ); 11545 } 11546 for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) 11547 { 11548 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.driverUUID[i] ); 11549 } 11550 for ( size_t i = 0; i < VK_LUID_SIZE; ++i ) 11551 { 11552 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.deviceLUID[i] ); 11553 } 11554 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.deviceNodeMask ); 11555 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.deviceLUIDValid ); 11556 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.subgroupSize ); 11557 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.subgroupSupportedStages ); 11558 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.subgroupSupportedOperations ); 11559 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.subgroupQuadOperationsInAllStages ); 11560 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.pointClippingBehavior ); 11561 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.maxMultiviewViewCount ); 11562 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.maxMultiviewInstanceIndex ); 11563 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.protectedNoFault ); 11564 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.maxPerSetDescriptors ); 11565 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.maxMemoryAllocationSize ); 11566 return seed; 11567 } 11568 }; 11569 11570 template <> 11571 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan12Features> 11572 { operator ()std::hash11573 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan12Features const & physicalDeviceVulkan12Features ) const VULKAN_HPP_NOEXCEPT 11574 { 11575 std::size_t seed = 0; 11576 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.sType ); 11577 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.pNext ); 11578 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.samplerMirrorClampToEdge ); 11579 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.drawIndirectCount ); 11580 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.storageBuffer8BitAccess ); 11581 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.uniformAndStorageBuffer8BitAccess ); 11582 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.storagePushConstant8 ); 11583 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderBufferInt64Atomics ); 11584 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderSharedInt64Atomics ); 11585 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderFloat16 ); 11586 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderInt8 ); 11587 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorIndexing ); 11588 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderInputAttachmentArrayDynamicIndexing ); 11589 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderUniformTexelBufferArrayDynamicIndexing ); 11590 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderStorageTexelBufferArrayDynamicIndexing ); 11591 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderUniformBufferArrayNonUniformIndexing ); 11592 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderSampledImageArrayNonUniformIndexing ); 11593 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderStorageBufferArrayNonUniformIndexing ); 11594 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderStorageImageArrayNonUniformIndexing ); 11595 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderInputAttachmentArrayNonUniformIndexing ); 11596 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderUniformTexelBufferArrayNonUniformIndexing ); 11597 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderStorageTexelBufferArrayNonUniformIndexing ); 11598 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorBindingUniformBufferUpdateAfterBind ); 11599 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorBindingSampledImageUpdateAfterBind ); 11600 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorBindingStorageImageUpdateAfterBind ); 11601 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorBindingStorageBufferUpdateAfterBind ); 11602 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorBindingUniformTexelBufferUpdateAfterBind ); 11603 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorBindingStorageTexelBufferUpdateAfterBind ); 11604 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorBindingUpdateUnusedWhilePending ); 11605 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorBindingPartiallyBound ); 11606 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorBindingVariableDescriptorCount ); 11607 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.runtimeDescriptorArray ); 11608 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.samplerFilterMinmax ); 11609 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.scalarBlockLayout ); 11610 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.imagelessFramebuffer ); 11611 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.uniformBufferStandardLayout ); 11612 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderSubgroupExtendedTypes ); 11613 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.separateDepthStencilLayouts ); 11614 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.hostQueryReset ); 11615 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.timelineSemaphore ); 11616 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.bufferDeviceAddress ); 11617 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.bufferDeviceAddressCaptureReplay ); 11618 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.bufferDeviceAddressMultiDevice ); 11619 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.vulkanMemoryModel ); 11620 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.vulkanMemoryModelDeviceScope ); 11621 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.vulkanMemoryModelAvailabilityVisibilityChains ); 11622 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderOutputViewportIndex ); 11623 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderOutputLayer ); 11624 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.subgroupBroadcastDynamicId ); 11625 return seed; 11626 } 11627 }; 11628 11629 template <> 11630 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan12Properties> 11631 { operator ()std::hash11632 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan12Properties const & physicalDeviceVulkan12Properties ) const VULKAN_HPP_NOEXCEPT 11633 { 11634 std::size_t seed = 0; 11635 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.sType ); 11636 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.pNext ); 11637 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.driverID ); 11638 for ( size_t i = 0; i < VK_MAX_DRIVER_NAME_SIZE; ++i ) 11639 { 11640 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.driverName[i] ); 11641 } 11642 for ( size_t i = 0; i < VK_MAX_DRIVER_INFO_SIZE; ++i ) 11643 { 11644 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.driverInfo[i] ); 11645 } 11646 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.conformanceVersion ); 11647 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.denormBehaviorIndependence ); 11648 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.roundingModeIndependence ); 11649 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderSignedZeroInfNanPreserveFloat16 ); 11650 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderSignedZeroInfNanPreserveFloat32 ); 11651 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderSignedZeroInfNanPreserveFloat64 ); 11652 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderDenormPreserveFloat16 ); 11653 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderDenormPreserveFloat32 ); 11654 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderDenormPreserveFloat64 ); 11655 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderDenormFlushToZeroFloat16 ); 11656 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderDenormFlushToZeroFloat32 ); 11657 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderDenormFlushToZeroFloat64 ); 11658 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTEFloat16 ); 11659 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTEFloat32 ); 11660 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTEFloat64 ); 11661 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTZFloat16 ); 11662 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTZFloat32 ); 11663 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTZFloat64 ); 11664 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxUpdateAfterBindDescriptorsInAllPools ); 11665 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderUniformBufferArrayNonUniformIndexingNative ); 11666 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderSampledImageArrayNonUniformIndexingNative ); 11667 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderStorageBufferArrayNonUniformIndexingNative ); 11668 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderStorageImageArrayNonUniformIndexingNative ); 11669 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderInputAttachmentArrayNonUniformIndexingNative ); 11670 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.robustBufferAccessUpdateAfterBind ); 11671 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.quadDivergentImplicitLod ); 11672 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindSamplers ); 11673 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindUniformBuffers ); 11674 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindStorageBuffers ); 11675 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindSampledImages ); 11676 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindStorageImages ); 11677 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindInputAttachments ); 11678 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxPerStageUpdateAfterBindResources ); 11679 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindSamplers ); 11680 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindUniformBuffers ); 11681 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic ); 11682 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindStorageBuffers ); 11683 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic ); 11684 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindSampledImages ); 11685 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindStorageImages ); 11686 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindInputAttachments ); 11687 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.supportedDepthResolveModes ); 11688 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.supportedStencilResolveModes ); 11689 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.independentResolveNone ); 11690 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.independentResolve ); 11691 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.filterMinmaxSingleComponentFormats ); 11692 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.filterMinmaxImageComponentMapping ); 11693 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxTimelineSemaphoreValueDifference ); 11694 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.framebufferIntegerColorSampleCounts ); 11695 return seed; 11696 } 11697 }; 11698 11699 template <> 11700 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan13Features> 11701 { operator ()std::hash11702 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan13Features const & physicalDeviceVulkan13Features ) const VULKAN_HPP_NOEXCEPT 11703 { 11704 std::size_t seed = 0; 11705 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.sType ); 11706 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.pNext ); 11707 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.robustImageAccess ); 11708 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.inlineUniformBlock ); 11709 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.descriptorBindingInlineUniformBlockUpdateAfterBind ); 11710 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.pipelineCreationCacheControl ); 11711 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.privateData ); 11712 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.shaderDemoteToHelperInvocation ); 11713 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.shaderTerminateInvocation ); 11714 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.subgroupSizeControl ); 11715 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.computeFullSubgroups ); 11716 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.synchronization2 ); 11717 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.textureCompressionASTC_HDR ); 11718 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.shaderZeroInitializeWorkgroupMemory ); 11719 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.dynamicRendering ); 11720 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.shaderIntegerDotProduct ); 11721 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.maintenance4 ); 11722 return seed; 11723 } 11724 }; 11725 11726 template <> 11727 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan13Properties> 11728 { operator ()std::hash11729 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan13Properties const & physicalDeviceVulkan13Properties ) const VULKAN_HPP_NOEXCEPT 11730 { 11731 std::size_t seed = 0; 11732 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.sType ); 11733 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.pNext ); 11734 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.minSubgroupSize ); 11735 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.maxSubgroupSize ); 11736 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.maxComputeWorkgroupSubgroups ); 11737 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.requiredSubgroupSizeStages ); 11738 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.maxInlineUniformBlockSize ); 11739 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.maxPerStageDescriptorInlineUniformBlocks ); 11740 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks ); 11741 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.maxDescriptorSetInlineUniformBlocks ); 11742 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.maxDescriptorSetUpdateAfterBindInlineUniformBlocks ); 11743 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.maxInlineUniformTotalSize ); 11744 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct8BitUnsignedAccelerated ); 11745 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct8BitSignedAccelerated ); 11746 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct8BitMixedSignednessAccelerated ); 11747 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct4x8BitPackedUnsignedAccelerated ); 11748 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct4x8BitPackedSignedAccelerated ); 11749 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct4x8BitPackedMixedSignednessAccelerated ); 11750 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct16BitUnsignedAccelerated ); 11751 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct16BitSignedAccelerated ); 11752 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct16BitMixedSignednessAccelerated ); 11753 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct32BitUnsignedAccelerated ); 11754 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct32BitSignedAccelerated ); 11755 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct32BitMixedSignednessAccelerated ); 11756 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct64BitUnsignedAccelerated ); 11757 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct64BitSignedAccelerated ); 11758 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct64BitMixedSignednessAccelerated ); 11759 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating8BitUnsignedAccelerated ); 11760 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating8BitSignedAccelerated ); 11761 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated ); 11762 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated ); 11763 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated ); 11764 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated ); 11765 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating16BitUnsignedAccelerated ); 11766 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating16BitSignedAccelerated ); 11767 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated ); 11768 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating32BitUnsignedAccelerated ); 11769 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating32BitSignedAccelerated ); 11770 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated ); 11771 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating64BitUnsignedAccelerated ); 11772 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating64BitSignedAccelerated ); 11773 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated ); 11774 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.storageTexelBufferOffsetAlignmentBytes ); 11775 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.storageTexelBufferOffsetSingleTexelAlignment ); 11776 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.uniformTexelBufferOffsetAlignmentBytes ); 11777 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.uniformTexelBufferOffsetSingleTexelAlignment ); 11778 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.maxBufferSize ); 11779 return seed; 11780 } 11781 }; 11782 11783 template <> 11784 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkanMemoryModelFeatures> 11785 { 11786 std::size_t operator ()std::hash11787 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkanMemoryModelFeatures const & physicalDeviceVulkanMemoryModelFeatures ) const VULKAN_HPP_NOEXCEPT 11788 { 11789 std::size_t seed = 0; 11790 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkanMemoryModelFeatures.sType ); 11791 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkanMemoryModelFeatures.pNext ); 11792 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkanMemoryModelFeatures.vulkanMemoryModel ); 11793 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkanMemoryModelFeatures.vulkanMemoryModelDeviceScope ); 11794 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkanMemoryModelFeatures.vulkanMemoryModelAvailabilityVisibilityChains ); 11795 return seed; 11796 } 11797 }; 11798 11799 template <> 11800 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR> 11801 { operator ()std::hash11802 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR const & 11803 physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR ) const VULKAN_HPP_NOEXCEPT 11804 { 11805 std::size_t seed = 0; 11806 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.sType ); 11807 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.pNext ); 11808 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.workgroupMemoryExplicitLayout ); 11809 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.workgroupMemoryExplicitLayoutScalarBlockLayout ); 11810 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.workgroupMemoryExplicitLayout8BitAccess ); 11811 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.workgroupMemoryExplicitLayout16BitAccess ); 11812 return seed; 11813 } 11814 }; 11815 11816 template <> 11817 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT> 11818 { operator ()std::hash11819 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT const & physicalDeviceYcbcr2Plane444FormatsFeaturesEXT ) const 11820 VULKAN_HPP_NOEXCEPT 11821 { 11822 std::size_t seed = 0; 11823 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceYcbcr2Plane444FormatsFeaturesEXT.sType ); 11824 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceYcbcr2Plane444FormatsFeaturesEXT.pNext ); 11825 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceYcbcr2Plane444FormatsFeaturesEXT.ycbcr2plane444Formats ); 11826 return seed; 11827 } 11828 }; 11829 11830 template <> 11831 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcrDegammaFeaturesQCOM> 11832 { 11833 std::size_t operator ()std::hash11834 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcrDegammaFeaturesQCOM const & physicalDeviceYcbcrDegammaFeaturesQCOM ) const VULKAN_HPP_NOEXCEPT 11835 { 11836 std::size_t seed = 0; 11837 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceYcbcrDegammaFeaturesQCOM.sType ); 11838 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceYcbcrDegammaFeaturesQCOM.pNext ); 11839 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceYcbcrDegammaFeaturesQCOM.ycbcrDegamma ); 11840 return seed; 11841 } 11842 }; 11843 11844 template <> 11845 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcrImageArraysFeaturesEXT> 11846 { 11847 std::size_t operator ()std::hash11848 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcrImageArraysFeaturesEXT const & physicalDeviceYcbcrImageArraysFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 11849 { 11850 std::size_t seed = 0; 11851 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceYcbcrImageArraysFeaturesEXT.sType ); 11852 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceYcbcrImageArraysFeaturesEXT.pNext ); 11853 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceYcbcrImageArraysFeaturesEXT.ycbcrImageArrays ); 11854 return seed; 11855 } 11856 }; 11857 11858 template <> 11859 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures> 11860 { 11861 std::size_t operator ()std::hash11862 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures const & physicalDeviceZeroInitializeWorkgroupMemoryFeatures ) const 11863 VULKAN_HPP_NOEXCEPT 11864 { 11865 std::size_t seed = 0; 11866 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceZeroInitializeWorkgroupMemoryFeatures.sType ); 11867 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceZeroInitializeWorkgroupMemoryFeatures.pNext ); 11868 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceZeroInitializeWorkgroupMemoryFeatures.shaderZeroInitializeWorkgroupMemory ); 11869 return seed; 11870 } 11871 }; 11872 11873 template <> 11874 struct hash<VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo> 11875 { operator ()std::hash11876 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo const & pipelineCacheCreateInfo ) const VULKAN_HPP_NOEXCEPT 11877 { 11878 std::size_t seed = 0; 11879 VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheCreateInfo.sType ); 11880 VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheCreateInfo.pNext ); 11881 VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheCreateInfo.flags ); 11882 VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheCreateInfo.initialDataSize ); 11883 VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheCreateInfo.pInitialData ); 11884 return seed; 11885 } 11886 }; 11887 11888 template <> 11889 struct hash<VULKAN_HPP_NAMESPACE::PipelineCacheHeaderVersionOne> 11890 { operator ()std::hash11891 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCacheHeaderVersionOne const & pipelineCacheHeaderVersionOne ) const VULKAN_HPP_NOEXCEPT 11892 { 11893 std::size_t seed = 0; 11894 VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheHeaderVersionOne.headerSize ); 11895 VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheHeaderVersionOne.headerVersion ); 11896 VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheHeaderVersionOne.vendorID ); 11897 VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheHeaderVersionOne.deviceID ); 11898 for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) 11899 { 11900 VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheHeaderVersionOne.pipelineCacheUUID[i] ); 11901 } 11902 return seed; 11903 } 11904 }; 11905 11906 template <> 11907 struct hash<VULKAN_HPP_NAMESPACE::PipelineColorBlendAdvancedStateCreateInfoEXT> 11908 { operator ()std::hash11909 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineColorBlendAdvancedStateCreateInfoEXT const & pipelineColorBlendAdvancedStateCreateInfoEXT ) const 11910 VULKAN_HPP_NOEXCEPT 11911 { 11912 std::size_t seed = 0; 11913 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAdvancedStateCreateInfoEXT.sType ); 11914 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAdvancedStateCreateInfoEXT.pNext ); 11915 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAdvancedStateCreateInfoEXT.srcPremultiplied ); 11916 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAdvancedStateCreateInfoEXT.dstPremultiplied ); 11917 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAdvancedStateCreateInfoEXT.blendOverlap ); 11918 return seed; 11919 } 11920 }; 11921 11922 template <> 11923 struct hash<VULKAN_HPP_NAMESPACE::PipelineColorWriteCreateInfoEXT> 11924 { operator ()std::hash11925 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineColorWriteCreateInfoEXT const & pipelineColorWriteCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 11926 { 11927 std::size_t seed = 0; 11928 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorWriteCreateInfoEXT.sType ); 11929 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorWriteCreateInfoEXT.pNext ); 11930 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorWriteCreateInfoEXT.attachmentCount ); 11931 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorWriteCreateInfoEXT.pColorWriteEnables ); 11932 return seed; 11933 } 11934 }; 11935 11936 template <> 11937 struct hash<VULKAN_HPP_NAMESPACE::PipelineCompilerControlCreateInfoAMD> 11938 { operator ()std::hash11939 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCompilerControlCreateInfoAMD const & pipelineCompilerControlCreateInfoAMD ) const VULKAN_HPP_NOEXCEPT 11940 { 11941 std::size_t seed = 0; 11942 VULKAN_HPP_HASH_COMBINE( seed, pipelineCompilerControlCreateInfoAMD.sType ); 11943 VULKAN_HPP_HASH_COMBINE( seed, pipelineCompilerControlCreateInfoAMD.pNext ); 11944 VULKAN_HPP_HASH_COMBINE( seed, pipelineCompilerControlCreateInfoAMD.compilerControlFlags ); 11945 return seed; 11946 } 11947 }; 11948 11949 template <> 11950 struct hash<VULKAN_HPP_NAMESPACE::PipelineCoverageModulationStateCreateInfoNV> 11951 { operator ()std::hash11952 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCoverageModulationStateCreateInfoNV const & pipelineCoverageModulationStateCreateInfoNV ) const 11953 VULKAN_HPP_NOEXCEPT 11954 { 11955 std::size_t seed = 0; 11956 VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageModulationStateCreateInfoNV.sType ); 11957 VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageModulationStateCreateInfoNV.pNext ); 11958 VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageModulationStateCreateInfoNV.flags ); 11959 VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageModulationStateCreateInfoNV.coverageModulationMode ); 11960 VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageModulationStateCreateInfoNV.coverageModulationTableEnable ); 11961 VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageModulationStateCreateInfoNV.coverageModulationTableCount ); 11962 VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageModulationStateCreateInfoNV.pCoverageModulationTable ); 11963 return seed; 11964 } 11965 }; 11966 11967 template <> 11968 struct hash<VULKAN_HPP_NAMESPACE::PipelineCoverageReductionStateCreateInfoNV> 11969 { operator ()std::hash11970 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCoverageReductionStateCreateInfoNV const & pipelineCoverageReductionStateCreateInfoNV ) const 11971 VULKAN_HPP_NOEXCEPT 11972 { 11973 std::size_t seed = 0; 11974 VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageReductionStateCreateInfoNV.sType ); 11975 VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageReductionStateCreateInfoNV.pNext ); 11976 VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageReductionStateCreateInfoNV.flags ); 11977 VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageReductionStateCreateInfoNV.coverageReductionMode ); 11978 return seed; 11979 } 11980 }; 11981 11982 template <> 11983 struct hash<VULKAN_HPP_NAMESPACE::PipelineCoverageToColorStateCreateInfoNV> 11984 { 11985 std::size_t operator ()std::hash11986 operator()( VULKAN_HPP_NAMESPACE::PipelineCoverageToColorStateCreateInfoNV const & pipelineCoverageToColorStateCreateInfoNV ) const VULKAN_HPP_NOEXCEPT 11987 { 11988 std::size_t seed = 0; 11989 VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageToColorStateCreateInfoNV.sType ); 11990 VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageToColorStateCreateInfoNV.pNext ); 11991 VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageToColorStateCreateInfoNV.flags ); 11992 VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageToColorStateCreateInfoNV.coverageToColorEnable ); 11993 VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageToColorStateCreateInfoNV.coverageToColorLocation ); 11994 return seed; 11995 } 11996 }; 11997 11998 template <> 11999 struct hash<VULKAN_HPP_NAMESPACE::PipelineCreateFlags2CreateInfoKHR> 12000 { operator ()std::hash12001 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCreateFlags2CreateInfoKHR const & pipelineCreateFlags2CreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 12002 { 12003 std::size_t seed = 0; 12004 VULKAN_HPP_HASH_COMBINE( seed, pipelineCreateFlags2CreateInfoKHR.sType ); 12005 VULKAN_HPP_HASH_COMBINE( seed, pipelineCreateFlags2CreateInfoKHR.pNext ); 12006 VULKAN_HPP_HASH_COMBINE( seed, pipelineCreateFlags2CreateInfoKHR.flags ); 12007 return seed; 12008 } 12009 }; 12010 12011 template <> 12012 struct hash<VULKAN_HPP_NAMESPACE::PipelineCreationFeedback> 12013 { operator ()std::hash12014 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCreationFeedback const & pipelineCreationFeedback ) const VULKAN_HPP_NOEXCEPT 12015 { 12016 std::size_t seed = 0; 12017 VULKAN_HPP_HASH_COMBINE( seed, pipelineCreationFeedback.flags ); 12018 VULKAN_HPP_HASH_COMBINE( seed, pipelineCreationFeedback.duration ); 12019 return seed; 12020 } 12021 }; 12022 12023 template <> 12024 struct hash<VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackCreateInfo> 12025 { operator ()std::hash12026 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackCreateInfo const & pipelineCreationFeedbackCreateInfo ) const VULKAN_HPP_NOEXCEPT 12027 { 12028 std::size_t seed = 0; 12029 VULKAN_HPP_HASH_COMBINE( seed, pipelineCreationFeedbackCreateInfo.sType ); 12030 VULKAN_HPP_HASH_COMBINE( seed, pipelineCreationFeedbackCreateInfo.pNext ); 12031 VULKAN_HPP_HASH_COMBINE( seed, pipelineCreationFeedbackCreateInfo.pPipelineCreationFeedback ); 12032 VULKAN_HPP_HASH_COMBINE( seed, pipelineCreationFeedbackCreateInfo.pipelineStageCreationFeedbackCount ); 12033 VULKAN_HPP_HASH_COMBINE( seed, pipelineCreationFeedbackCreateInfo.pPipelineStageCreationFeedbacks ); 12034 return seed; 12035 } 12036 }; 12037 12038 template <> 12039 struct hash<VULKAN_HPP_NAMESPACE::PipelineDiscardRectangleStateCreateInfoEXT> 12040 { operator ()std::hash12041 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineDiscardRectangleStateCreateInfoEXT const & pipelineDiscardRectangleStateCreateInfoEXT ) const 12042 VULKAN_HPP_NOEXCEPT 12043 { 12044 std::size_t seed = 0; 12045 VULKAN_HPP_HASH_COMBINE( seed, pipelineDiscardRectangleStateCreateInfoEXT.sType ); 12046 VULKAN_HPP_HASH_COMBINE( seed, pipelineDiscardRectangleStateCreateInfoEXT.pNext ); 12047 VULKAN_HPP_HASH_COMBINE( seed, pipelineDiscardRectangleStateCreateInfoEXT.flags ); 12048 VULKAN_HPP_HASH_COMBINE( seed, pipelineDiscardRectangleStateCreateInfoEXT.discardRectangleMode ); 12049 VULKAN_HPP_HASH_COMBINE( seed, pipelineDiscardRectangleStateCreateInfoEXT.discardRectangleCount ); 12050 VULKAN_HPP_HASH_COMBINE( seed, pipelineDiscardRectangleStateCreateInfoEXT.pDiscardRectangles ); 12051 return seed; 12052 } 12053 }; 12054 12055 template <> 12056 struct hash<VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR> 12057 { operator ()std::hash12058 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR const & pipelineExecutableInfoKHR ) const VULKAN_HPP_NOEXCEPT 12059 { 12060 std::size_t seed = 0; 12061 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInfoKHR.sType ); 12062 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInfoKHR.pNext ); 12063 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInfoKHR.pipeline ); 12064 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInfoKHR.executableIndex ); 12065 return seed; 12066 } 12067 }; 12068 12069 template <> 12070 struct hash<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR> 12071 { operator ()std::hash12072 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR const & pipelineExecutableInternalRepresentationKHR ) const 12073 VULKAN_HPP_NOEXCEPT 12074 { 12075 std::size_t seed = 0; 12076 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInternalRepresentationKHR.sType ); 12077 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInternalRepresentationKHR.pNext ); 12078 for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) 12079 { 12080 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInternalRepresentationKHR.name[i] ); 12081 } 12082 for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) 12083 { 12084 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInternalRepresentationKHR.description[i] ); 12085 } 12086 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInternalRepresentationKHR.isText ); 12087 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInternalRepresentationKHR.dataSize ); 12088 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInternalRepresentationKHR.pData ); 12089 return seed; 12090 } 12091 }; 12092 12093 template <> 12094 struct hash<VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR> 12095 { operator ()std::hash12096 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR const & pipelineExecutablePropertiesKHR ) const VULKAN_HPP_NOEXCEPT 12097 { 12098 std::size_t seed = 0; 12099 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutablePropertiesKHR.sType ); 12100 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutablePropertiesKHR.pNext ); 12101 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutablePropertiesKHR.stages ); 12102 for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) 12103 { 12104 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutablePropertiesKHR.name[i] ); 12105 } 12106 for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) 12107 { 12108 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutablePropertiesKHR.description[i] ); 12109 } 12110 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutablePropertiesKHR.subgroupSize ); 12111 return seed; 12112 } 12113 }; 12114 12115 template <> 12116 struct hash<VULKAN_HPP_NAMESPACE::PipelineFragmentShadingRateEnumStateCreateInfoNV> 12117 { operator ()std::hash12118 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineFragmentShadingRateEnumStateCreateInfoNV const & pipelineFragmentShadingRateEnumStateCreateInfoNV ) 12119 const VULKAN_HPP_NOEXCEPT 12120 { 12121 std::size_t seed = 0; 12122 VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentShadingRateEnumStateCreateInfoNV.sType ); 12123 VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentShadingRateEnumStateCreateInfoNV.pNext ); 12124 VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentShadingRateEnumStateCreateInfoNV.shadingRateType ); 12125 VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentShadingRateEnumStateCreateInfoNV.shadingRate ); 12126 for ( size_t i = 0; i < 2; ++i ) 12127 { 12128 VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentShadingRateEnumStateCreateInfoNV.combinerOps[i] ); 12129 } 12130 return seed; 12131 } 12132 }; 12133 12134 template <> 12135 struct hash<VULKAN_HPP_NAMESPACE::PipelineFragmentShadingRateStateCreateInfoKHR> 12136 { operator ()std::hash12137 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineFragmentShadingRateStateCreateInfoKHR const & pipelineFragmentShadingRateStateCreateInfoKHR ) const 12138 VULKAN_HPP_NOEXCEPT 12139 { 12140 std::size_t seed = 0; 12141 VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentShadingRateStateCreateInfoKHR.sType ); 12142 VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentShadingRateStateCreateInfoKHR.pNext ); 12143 VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentShadingRateStateCreateInfoKHR.fragmentSize ); 12144 for ( size_t i = 0; i < 2; ++i ) 12145 { 12146 VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentShadingRateStateCreateInfoKHR.combinerOps[i] ); 12147 } 12148 return seed; 12149 } 12150 }; 12151 12152 template <> 12153 struct hash<VULKAN_HPP_NAMESPACE::PipelineIndirectDeviceAddressInfoNV> 12154 { operator ()std::hash12155 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineIndirectDeviceAddressInfoNV const & pipelineIndirectDeviceAddressInfoNV ) const VULKAN_HPP_NOEXCEPT 12156 { 12157 std::size_t seed = 0; 12158 VULKAN_HPP_HASH_COMBINE( seed, pipelineIndirectDeviceAddressInfoNV.sType ); 12159 VULKAN_HPP_HASH_COMBINE( seed, pipelineIndirectDeviceAddressInfoNV.pNext ); 12160 VULKAN_HPP_HASH_COMBINE( seed, pipelineIndirectDeviceAddressInfoNV.pipelineBindPoint ); 12161 VULKAN_HPP_HASH_COMBINE( seed, pipelineIndirectDeviceAddressInfoNV.pipeline ); 12162 return seed; 12163 } 12164 }; 12165 12166 template <> 12167 struct hash<VULKAN_HPP_NAMESPACE::PipelineInfoKHR> 12168 { operator ()std::hash12169 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineInfoKHR const & pipelineInfoKHR ) const VULKAN_HPP_NOEXCEPT 12170 { 12171 std::size_t seed = 0; 12172 VULKAN_HPP_HASH_COMBINE( seed, pipelineInfoKHR.sType ); 12173 VULKAN_HPP_HASH_COMBINE( seed, pipelineInfoKHR.pNext ); 12174 VULKAN_HPP_HASH_COMBINE( seed, pipelineInfoKHR.pipeline ); 12175 return seed; 12176 } 12177 }; 12178 12179 template <> 12180 struct hash<VULKAN_HPP_NAMESPACE::PushConstantRange> 12181 { operator ()std::hash12182 std::size_t operator()( VULKAN_HPP_NAMESPACE::PushConstantRange const & pushConstantRange ) const VULKAN_HPP_NOEXCEPT 12183 { 12184 std::size_t seed = 0; 12185 VULKAN_HPP_HASH_COMBINE( seed, pushConstantRange.stageFlags ); 12186 VULKAN_HPP_HASH_COMBINE( seed, pushConstantRange.offset ); 12187 VULKAN_HPP_HASH_COMBINE( seed, pushConstantRange.size ); 12188 return seed; 12189 } 12190 }; 12191 12192 template <> 12193 struct hash<VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo> 12194 { operator ()std::hash12195 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo const & pipelineLayoutCreateInfo ) const VULKAN_HPP_NOEXCEPT 12196 { 12197 std::size_t seed = 0; 12198 VULKAN_HPP_HASH_COMBINE( seed, pipelineLayoutCreateInfo.sType ); 12199 VULKAN_HPP_HASH_COMBINE( seed, pipelineLayoutCreateInfo.pNext ); 12200 VULKAN_HPP_HASH_COMBINE( seed, pipelineLayoutCreateInfo.flags ); 12201 VULKAN_HPP_HASH_COMBINE( seed, pipelineLayoutCreateInfo.setLayoutCount ); 12202 VULKAN_HPP_HASH_COMBINE( seed, pipelineLayoutCreateInfo.pSetLayouts ); 12203 VULKAN_HPP_HASH_COMBINE( seed, pipelineLayoutCreateInfo.pushConstantRangeCount ); 12204 VULKAN_HPP_HASH_COMBINE( seed, pipelineLayoutCreateInfo.pPushConstantRanges ); 12205 return seed; 12206 } 12207 }; 12208 12209 template <> 12210 struct hash<VULKAN_HPP_NAMESPACE::PipelinePropertiesIdentifierEXT> 12211 { operator ()std::hash12212 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelinePropertiesIdentifierEXT const & pipelinePropertiesIdentifierEXT ) const VULKAN_HPP_NOEXCEPT 12213 { 12214 std::size_t seed = 0; 12215 VULKAN_HPP_HASH_COMBINE( seed, pipelinePropertiesIdentifierEXT.sType ); 12216 VULKAN_HPP_HASH_COMBINE( seed, pipelinePropertiesIdentifierEXT.pNext ); 12217 for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) 12218 { 12219 VULKAN_HPP_HASH_COMBINE( seed, pipelinePropertiesIdentifierEXT.pipelineIdentifier[i] ); 12220 } 12221 return seed; 12222 } 12223 }; 12224 12225 template <> 12226 struct hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationConservativeStateCreateInfoEXT> 12227 { 12228 std::size_t operator ()std::hash12229 operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationConservativeStateCreateInfoEXT const & pipelineRasterizationConservativeStateCreateInfoEXT ) const 12230 VULKAN_HPP_NOEXCEPT 12231 { 12232 std::size_t seed = 0; 12233 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationConservativeStateCreateInfoEXT.sType ); 12234 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationConservativeStateCreateInfoEXT.pNext ); 12235 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationConservativeStateCreateInfoEXT.flags ); 12236 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationConservativeStateCreateInfoEXT.conservativeRasterizationMode ); 12237 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationConservativeStateCreateInfoEXT.extraPrimitiveOverestimationSize ); 12238 return seed; 12239 } 12240 }; 12241 12242 template <> 12243 struct hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationDepthClipStateCreateInfoEXT> 12244 { operator ()std::hash12245 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationDepthClipStateCreateInfoEXT const & pipelineRasterizationDepthClipStateCreateInfoEXT ) 12246 const VULKAN_HPP_NOEXCEPT 12247 { 12248 std::size_t seed = 0; 12249 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationDepthClipStateCreateInfoEXT.sType ); 12250 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationDepthClipStateCreateInfoEXT.pNext ); 12251 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationDepthClipStateCreateInfoEXT.flags ); 12252 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationDepthClipStateCreateInfoEXT.depthClipEnable ); 12253 return seed; 12254 } 12255 }; 12256 12257 template <> 12258 struct hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationLineStateCreateInfoEXT> 12259 { operator ()std::hash12260 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationLineStateCreateInfoEXT const & pipelineRasterizationLineStateCreateInfoEXT ) const 12261 VULKAN_HPP_NOEXCEPT 12262 { 12263 std::size_t seed = 0; 12264 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfoEXT.sType ); 12265 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfoEXT.pNext ); 12266 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfoEXT.lineRasterizationMode ); 12267 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfoEXT.stippledLineEnable ); 12268 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfoEXT.lineStippleFactor ); 12269 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfoEXT.lineStipplePattern ); 12270 return seed; 12271 } 12272 }; 12273 12274 template <> 12275 struct hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationProvokingVertexStateCreateInfoEXT> 12276 { operator ()std::hash12277 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationProvokingVertexStateCreateInfoEXT const & 12278 pipelineRasterizationProvokingVertexStateCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 12279 { 12280 std::size_t seed = 0; 12281 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationProvokingVertexStateCreateInfoEXT.sType ); 12282 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationProvokingVertexStateCreateInfoEXT.pNext ); 12283 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationProvokingVertexStateCreateInfoEXT.provokingVertexMode ); 12284 return seed; 12285 } 12286 }; 12287 12288 template <> 12289 struct hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationStateRasterizationOrderAMD> 12290 { operator ()std::hash12291 std::size_t operator()( 12292 VULKAN_HPP_NAMESPACE::PipelineRasterizationStateRasterizationOrderAMD const & pipelineRasterizationStateRasterizationOrderAMD ) const VULKAN_HPP_NOEXCEPT 12293 { 12294 std::size_t seed = 0; 12295 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateRasterizationOrderAMD.sType ); 12296 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateRasterizationOrderAMD.pNext ); 12297 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateRasterizationOrderAMD.rasterizationOrder ); 12298 return seed; 12299 } 12300 }; 12301 12302 template <> 12303 struct hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationStateStreamCreateInfoEXT> 12304 { operator ()std::hash12305 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationStateStreamCreateInfoEXT const & pipelineRasterizationStateStreamCreateInfoEXT ) const 12306 VULKAN_HPP_NOEXCEPT 12307 { 12308 std::size_t seed = 0; 12309 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateStreamCreateInfoEXT.sType ); 12310 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateStreamCreateInfoEXT.pNext ); 12311 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateStreamCreateInfoEXT.flags ); 12312 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateStreamCreateInfoEXT.rasterizationStream ); 12313 return seed; 12314 } 12315 }; 12316 12317 template <> 12318 struct hash<VULKAN_HPP_NAMESPACE::PipelineRenderingCreateInfo> 12319 { operator ()std::hash12320 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRenderingCreateInfo const & pipelineRenderingCreateInfo ) const VULKAN_HPP_NOEXCEPT 12321 { 12322 std::size_t seed = 0; 12323 VULKAN_HPP_HASH_COMBINE( seed, pipelineRenderingCreateInfo.sType ); 12324 VULKAN_HPP_HASH_COMBINE( seed, pipelineRenderingCreateInfo.pNext ); 12325 VULKAN_HPP_HASH_COMBINE( seed, pipelineRenderingCreateInfo.viewMask ); 12326 VULKAN_HPP_HASH_COMBINE( seed, pipelineRenderingCreateInfo.colorAttachmentCount ); 12327 VULKAN_HPP_HASH_COMBINE( seed, pipelineRenderingCreateInfo.pColorAttachmentFormats ); 12328 VULKAN_HPP_HASH_COMBINE( seed, pipelineRenderingCreateInfo.depthAttachmentFormat ); 12329 VULKAN_HPP_HASH_COMBINE( seed, pipelineRenderingCreateInfo.stencilAttachmentFormat ); 12330 return seed; 12331 } 12332 }; 12333 12334 template <> 12335 struct hash<VULKAN_HPP_NAMESPACE::PipelineRepresentativeFragmentTestStateCreateInfoNV> 12336 { 12337 std::size_t operator ()std::hash12338 operator()( VULKAN_HPP_NAMESPACE::PipelineRepresentativeFragmentTestStateCreateInfoNV const & pipelineRepresentativeFragmentTestStateCreateInfoNV ) const 12339 VULKAN_HPP_NOEXCEPT 12340 { 12341 std::size_t seed = 0; 12342 VULKAN_HPP_HASH_COMBINE( seed, pipelineRepresentativeFragmentTestStateCreateInfoNV.sType ); 12343 VULKAN_HPP_HASH_COMBINE( seed, pipelineRepresentativeFragmentTestStateCreateInfoNV.pNext ); 12344 VULKAN_HPP_HASH_COMBINE( seed, pipelineRepresentativeFragmentTestStateCreateInfoNV.representativeFragmentTestEnable ); 12345 return seed; 12346 } 12347 }; 12348 12349 template <> 12350 struct hash<VULKAN_HPP_NAMESPACE::PipelineRobustnessCreateInfoEXT> 12351 { operator ()std::hash12352 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRobustnessCreateInfoEXT const & pipelineRobustnessCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 12353 { 12354 std::size_t seed = 0; 12355 VULKAN_HPP_HASH_COMBINE( seed, pipelineRobustnessCreateInfoEXT.sType ); 12356 VULKAN_HPP_HASH_COMBINE( seed, pipelineRobustnessCreateInfoEXT.pNext ); 12357 VULKAN_HPP_HASH_COMBINE( seed, pipelineRobustnessCreateInfoEXT.storageBuffers ); 12358 VULKAN_HPP_HASH_COMBINE( seed, pipelineRobustnessCreateInfoEXT.uniformBuffers ); 12359 VULKAN_HPP_HASH_COMBINE( seed, pipelineRobustnessCreateInfoEXT.vertexInputs ); 12360 VULKAN_HPP_HASH_COMBINE( seed, pipelineRobustnessCreateInfoEXT.images ); 12361 return seed; 12362 } 12363 }; 12364 12365 template <> 12366 struct hash<VULKAN_HPP_NAMESPACE::PipelineSampleLocationsStateCreateInfoEXT> 12367 { 12368 std::size_t operator ()std::hash12369 operator()( VULKAN_HPP_NAMESPACE::PipelineSampleLocationsStateCreateInfoEXT const & pipelineSampleLocationsStateCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 12370 { 12371 std::size_t seed = 0; 12372 VULKAN_HPP_HASH_COMBINE( seed, pipelineSampleLocationsStateCreateInfoEXT.sType ); 12373 VULKAN_HPP_HASH_COMBINE( seed, pipelineSampleLocationsStateCreateInfoEXT.pNext ); 12374 VULKAN_HPP_HASH_COMBINE( seed, pipelineSampleLocationsStateCreateInfoEXT.sampleLocationsEnable ); 12375 VULKAN_HPP_HASH_COMBINE( seed, pipelineSampleLocationsStateCreateInfoEXT.sampleLocationsInfo ); 12376 return seed; 12377 } 12378 }; 12379 12380 template <> 12381 struct hash<VULKAN_HPP_NAMESPACE::PipelineShaderStageModuleIdentifierCreateInfoEXT> 12382 { operator ()std::hash12383 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineShaderStageModuleIdentifierCreateInfoEXT const & pipelineShaderStageModuleIdentifierCreateInfoEXT ) 12384 const VULKAN_HPP_NOEXCEPT 12385 { 12386 std::size_t seed = 0; 12387 VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageModuleIdentifierCreateInfoEXT.sType ); 12388 VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageModuleIdentifierCreateInfoEXT.pNext ); 12389 VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageModuleIdentifierCreateInfoEXT.identifierSize ); 12390 VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageModuleIdentifierCreateInfoEXT.pIdentifier ); 12391 return seed; 12392 } 12393 }; 12394 12395 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 12396 template <> 12397 struct hash<VULKAN_HPP_NAMESPACE::PipelineShaderStageNodeCreateInfoAMDX> 12398 { 12399 std::size_t operator ()std::hash12400 operator()( VULKAN_HPP_NAMESPACE::PipelineShaderStageNodeCreateInfoAMDX const & pipelineShaderStageNodeCreateInfoAMDX ) const VULKAN_HPP_NOEXCEPT 12401 { 12402 std::size_t seed = 0; 12403 VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageNodeCreateInfoAMDX.sType ); 12404 VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageNodeCreateInfoAMDX.pNext ); 12405 for ( const char * p = pipelineShaderStageNodeCreateInfoAMDX.pName; *p != '\0'; ++p ) 12406 { 12407 VULKAN_HPP_HASH_COMBINE( seed, *p ); 12408 } 12409 VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageNodeCreateInfoAMDX.index ); 12410 return seed; 12411 } 12412 }; 12413 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 12414 12415 template <> 12416 struct hash<VULKAN_HPP_NAMESPACE::PipelineShaderStageRequiredSubgroupSizeCreateInfo> 12417 { operator ()std::hash12418 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineShaderStageRequiredSubgroupSizeCreateInfo const & pipelineShaderStageRequiredSubgroupSizeCreateInfo ) 12419 const VULKAN_HPP_NOEXCEPT 12420 { 12421 std::size_t seed = 0; 12422 VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageRequiredSubgroupSizeCreateInfo.sType ); 12423 VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageRequiredSubgroupSizeCreateInfo.pNext ); 12424 VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageRequiredSubgroupSizeCreateInfo.requiredSubgroupSize ); 12425 return seed; 12426 } 12427 }; 12428 12429 template <> 12430 struct hash<VULKAN_HPP_NAMESPACE::PipelineTessellationDomainOriginStateCreateInfo> 12431 { operator ()std::hash12432 std::size_t operator()( 12433 VULKAN_HPP_NAMESPACE::PipelineTessellationDomainOriginStateCreateInfo const & pipelineTessellationDomainOriginStateCreateInfo ) const VULKAN_HPP_NOEXCEPT 12434 { 12435 std::size_t seed = 0; 12436 VULKAN_HPP_HASH_COMBINE( seed, pipelineTessellationDomainOriginStateCreateInfo.sType ); 12437 VULKAN_HPP_HASH_COMBINE( seed, pipelineTessellationDomainOriginStateCreateInfo.pNext ); 12438 VULKAN_HPP_HASH_COMBINE( seed, pipelineTessellationDomainOriginStateCreateInfo.domainOrigin ); 12439 return seed; 12440 } 12441 }; 12442 12443 template <> 12444 struct hash<VULKAN_HPP_NAMESPACE::VertexInputBindingDivisorDescriptionEXT> 12445 { 12446 std::size_t operator ()std::hash12447 operator()( VULKAN_HPP_NAMESPACE::VertexInputBindingDivisorDescriptionEXT const & vertexInputBindingDivisorDescriptionEXT ) const VULKAN_HPP_NOEXCEPT 12448 { 12449 std::size_t seed = 0; 12450 VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDivisorDescriptionEXT.binding ); 12451 VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDivisorDescriptionEXT.divisor ); 12452 return seed; 12453 } 12454 }; 12455 12456 template <> 12457 struct hash<VULKAN_HPP_NAMESPACE::PipelineVertexInputDivisorStateCreateInfoEXT> 12458 { operator ()std::hash12459 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineVertexInputDivisorStateCreateInfoEXT const & pipelineVertexInputDivisorStateCreateInfoEXT ) const 12460 VULKAN_HPP_NOEXCEPT 12461 { 12462 std::size_t seed = 0; 12463 VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputDivisorStateCreateInfoEXT.sType ); 12464 VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputDivisorStateCreateInfoEXT.pNext ); 12465 VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputDivisorStateCreateInfoEXT.vertexBindingDivisorCount ); 12466 VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputDivisorStateCreateInfoEXT.pVertexBindingDivisors ); 12467 return seed; 12468 } 12469 }; 12470 12471 template <> 12472 struct hash<VULKAN_HPP_NAMESPACE::PipelineViewportCoarseSampleOrderStateCreateInfoNV> 12473 { 12474 std::size_t operator ()std::hash12475 operator()( VULKAN_HPP_NAMESPACE::PipelineViewportCoarseSampleOrderStateCreateInfoNV const & pipelineViewportCoarseSampleOrderStateCreateInfoNV ) const 12476 VULKAN_HPP_NOEXCEPT 12477 { 12478 std::size_t seed = 0; 12479 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportCoarseSampleOrderStateCreateInfoNV.sType ); 12480 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportCoarseSampleOrderStateCreateInfoNV.pNext ); 12481 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportCoarseSampleOrderStateCreateInfoNV.sampleOrderType ); 12482 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportCoarseSampleOrderStateCreateInfoNV.customSampleOrderCount ); 12483 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportCoarseSampleOrderStateCreateInfoNV.pCustomSampleOrders ); 12484 return seed; 12485 } 12486 }; 12487 12488 template <> 12489 struct hash<VULKAN_HPP_NAMESPACE::PipelineViewportDepthClipControlCreateInfoEXT> 12490 { operator ()std::hash12491 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineViewportDepthClipControlCreateInfoEXT const & pipelineViewportDepthClipControlCreateInfoEXT ) const 12492 VULKAN_HPP_NOEXCEPT 12493 { 12494 std::size_t seed = 0; 12495 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportDepthClipControlCreateInfoEXT.sType ); 12496 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportDepthClipControlCreateInfoEXT.pNext ); 12497 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportDepthClipControlCreateInfoEXT.negativeOneToOne ); 12498 return seed; 12499 } 12500 }; 12501 12502 template <> 12503 struct hash<VULKAN_HPP_NAMESPACE::PipelineViewportExclusiveScissorStateCreateInfoNV> 12504 { operator ()std::hash12505 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineViewportExclusiveScissorStateCreateInfoNV const & pipelineViewportExclusiveScissorStateCreateInfoNV ) 12506 const VULKAN_HPP_NOEXCEPT 12507 { 12508 std::size_t seed = 0; 12509 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportExclusiveScissorStateCreateInfoNV.sType ); 12510 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportExclusiveScissorStateCreateInfoNV.pNext ); 12511 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportExclusiveScissorStateCreateInfoNV.exclusiveScissorCount ); 12512 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportExclusiveScissorStateCreateInfoNV.pExclusiveScissors ); 12513 return seed; 12514 } 12515 }; 12516 12517 template <> 12518 struct hash<VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV> 12519 { operator ()std::hash12520 std::size_t operator()( VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV const & shadingRatePaletteNV ) const VULKAN_HPP_NOEXCEPT 12521 { 12522 std::size_t seed = 0; 12523 VULKAN_HPP_HASH_COMBINE( seed, shadingRatePaletteNV.shadingRatePaletteEntryCount ); 12524 VULKAN_HPP_HASH_COMBINE( seed, shadingRatePaletteNV.pShadingRatePaletteEntries ); 12525 return seed; 12526 } 12527 }; 12528 12529 template <> 12530 struct hash<VULKAN_HPP_NAMESPACE::PipelineViewportShadingRateImageStateCreateInfoNV> 12531 { operator ()std::hash12532 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineViewportShadingRateImageStateCreateInfoNV const & pipelineViewportShadingRateImageStateCreateInfoNV ) 12533 const VULKAN_HPP_NOEXCEPT 12534 { 12535 std::size_t seed = 0; 12536 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportShadingRateImageStateCreateInfoNV.sType ); 12537 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportShadingRateImageStateCreateInfoNV.pNext ); 12538 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportShadingRateImageStateCreateInfoNV.shadingRateImageEnable ); 12539 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportShadingRateImageStateCreateInfoNV.viewportCount ); 12540 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportShadingRateImageStateCreateInfoNV.pShadingRatePalettes ); 12541 return seed; 12542 } 12543 }; 12544 12545 template <> 12546 struct hash<VULKAN_HPP_NAMESPACE::ViewportSwizzleNV> 12547 { operator ()std::hash12548 std::size_t operator()( VULKAN_HPP_NAMESPACE::ViewportSwizzleNV const & viewportSwizzleNV ) const VULKAN_HPP_NOEXCEPT 12549 { 12550 std::size_t seed = 0; 12551 VULKAN_HPP_HASH_COMBINE( seed, viewportSwizzleNV.x ); 12552 VULKAN_HPP_HASH_COMBINE( seed, viewportSwizzleNV.y ); 12553 VULKAN_HPP_HASH_COMBINE( seed, viewportSwizzleNV.z ); 12554 VULKAN_HPP_HASH_COMBINE( seed, viewportSwizzleNV.w ); 12555 return seed; 12556 } 12557 }; 12558 12559 template <> 12560 struct hash<VULKAN_HPP_NAMESPACE::PipelineViewportSwizzleStateCreateInfoNV> 12561 { 12562 std::size_t operator ()std::hash12563 operator()( VULKAN_HPP_NAMESPACE::PipelineViewportSwizzleStateCreateInfoNV const & pipelineViewportSwizzleStateCreateInfoNV ) const VULKAN_HPP_NOEXCEPT 12564 { 12565 std::size_t seed = 0; 12566 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportSwizzleStateCreateInfoNV.sType ); 12567 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportSwizzleStateCreateInfoNV.pNext ); 12568 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportSwizzleStateCreateInfoNV.flags ); 12569 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportSwizzleStateCreateInfoNV.viewportCount ); 12570 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportSwizzleStateCreateInfoNV.pViewportSwizzles ); 12571 return seed; 12572 } 12573 }; 12574 12575 template <> 12576 struct hash<VULKAN_HPP_NAMESPACE::ViewportWScalingNV> 12577 { operator ()std::hash12578 std::size_t operator()( VULKAN_HPP_NAMESPACE::ViewportWScalingNV const & viewportWScalingNV ) const VULKAN_HPP_NOEXCEPT 12579 { 12580 std::size_t seed = 0; 12581 VULKAN_HPP_HASH_COMBINE( seed, viewportWScalingNV.xcoeff ); 12582 VULKAN_HPP_HASH_COMBINE( seed, viewportWScalingNV.ycoeff ); 12583 return seed; 12584 } 12585 }; 12586 12587 template <> 12588 struct hash<VULKAN_HPP_NAMESPACE::PipelineViewportWScalingStateCreateInfoNV> 12589 { 12590 std::size_t operator ()std::hash12591 operator()( VULKAN_HPP_NAMESPACE::PipelineViewportWScalingStateCreateInfoNV const & pipelineViewportWScalingStateCreateInfoNV ) const VULKAN_HPP_NOEXCEPT 12592 { 12593 std::size_t seed = 0; 12594 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportWScalingStateCreateInfoNV.sType ); 12595 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportWScalingStateCreateInfoNV.pNext ); 12596 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportWScalingStateCreateInfoNV.viewportWScalingEnable ); 12597 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportWScalingStateCreateInfoNV.viewportCount ); 12598 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportWScalingStateCreateInfoNV.pViewportWScalings ); 12599 return seed; 12600 } 12601 }; 12602 12603 # if defined( VK_USE_PLATFORM_GGP ) 12604 template <> 12605 struct hash<VULKAN_HPP_NAMESPACE::PresentFrameTokenGGP> 12606 { operator ()std::hash12607 std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentFrameTokenGGP const & presentFrameTokenGGP ) const VULKAN_HPP_NOEXCEPT 12608 { 12609 std::size_t seed = 0; 12610 VULKAN_HPP_HASH_COMBINE( seed, presentFrameTokenGGP.sType ); 12611 VULKAN_HPP_HASH_COMBINE( seed, presentFrameTokenGGP.pNext ); 12612 VULKAN_HPP_HASH_COMBINE( seed, presentFrameTokenGGP.frameToken ); 12613 return seed; 12614 } 12615 }; 12616 # endif /*VK_USE_PLATFORM_GGP*/ 12617 12618 template <> 12619 struct hash<VULKAN_HPP_NAMESPACE::PresentIdKHR> 12620 { operator ()std::hash12621 std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentIdKHR const & presentIdKHR ) const VULKAN_HPP_NOEXCEPT 12622 { 12623 std::size_t seed = 0; 12624 VULKAN_HPP_HASH_COMBINE( seed, presentIdKHR.sType ); 12625 VULKAN_HPP_HASH_COMBINE( seed, presentIdKHR.pNext ); 12626 VULKAN_HPP_HASH_COMBINE( seed, presentIdKHR.swapchainCount ); 12627 VULKAN_HPP_HASH_COMBINE( seed, presentIdKHR.pPresentIds ); 12628 return seed; 12629 } 12630 }; 12631 12632 template <> 12633 struct hash<VULKAN_HPP_NAMESPACE::PresentInfoKHR> 12634 { operator ()std::hash12635 std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentInfoKHR const & presentInfoKHR ) const VULKAN_HPP_NOEXCEPT 12636 { 12637 std::size_t seed = 0; 12638 VULKAN_HPP_HASH_COMBINE( seed, presentInfoKHR.sType ); 12639 VULKAN_HPP_HASH_COMBINE( seed, presentInfoKHR.pNext ); 12640 VULKAN_HPP_HASH_COMBINE( seed, presentInfoKHR.waitSemaphoreCount ); 12641 VULKAN_HPP_HASH_COMBINE( seed, presentInfoKHR.pWaitSemaphores ); 12642 VULKAN_HPP_HASH_COMBINE( seed, presentInfoKHR.swapchainCount ); 12643 VULKAN_HPP_HASH_COMBINE( seed, presentInfoKHR.pSwapchains ); 12644 VULKAN_HPP_HASH_COMBINE( seed, presentInfoKHR.pImageIndices ); 12645 VULKAN_HPP_HASH_COMBINE( seed, presentInfoKHR.pResults ); 12646 return seed; 12647 } 12648 }; 12649 12650 template <> 12651 struct hash<VULKAN_HPP_NAMESPACE::RectLayerKHR> 12652 { operator ()std::hash12653 std::size_t operator()( VULKAN_HPP_NAMESPACE::RectLayerKHR const & rectLayerKHR ) const VULKAN_HPP_NOEXCEPT 12654 { 12655 std::size_t seed = 0; 12656 VULKAN_HPP_HASH_COMBINE( seed, rectLayerKHR.offset ); 12657 VULKAN_HPP_HASH_COMBINE( seed, rectLayerKHR.extent ); 12658 VULKAN_HPP_HASH_COMBINE( seed, rectLayerKHR.layer ); 12659 return seed; 12660 } 12661 }; 12662 12663 template <> 12664 struct hash<VULKAN_HPP_NAMESPACE::PresentRegionKHR> 12665 { operator ()std::hash12666 std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentRegionKHR const & presentRegionKHR ) const VULKAN_HPP_NOEXCEPT 12667 { 12668 std::size_t seed = 0; 12669 VULKAN_HPP_HASH_COMBINE( seed, presentRegionKHR.rectangleCount ); 12670 VULKAN_HPP_HASH_COMBINE( seed, presentRegionKHR.pRectangles ); 12671 return seed; 12672 } 12673 }; 12674 12675 template <> 12676 struct hash<VULKAN_HPP_NAMESPACE::PresentRegionsKHR> 12677 { operator ()std::hash12678 std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentRegionsKHR const & presentRegionsKHR ) const VULKAN_HPP_NOEXCEPT 12679 { 12680 std::size_t seed = 0; 12681 VULKAN_HPP_HASH_COMBINE( seed, presentRegionsKHR.sType ); 12682 VULKAN_HPP_HASH_COMBINE( seed, presentRegionsKHR.pNext ); 12683 VULKAN_HPP_HASH_COMBINE( seed, presentRegionsKHR.swapchainCount ); 12684 VULKAN_HPP_HASH_COMBINE( seed, presentRegionsKHR.pRegions ); 12685 return seed; 12686 } 12687 }; 12688 12689 template <> 12690 struct hash<VULKAN_HPP_NAMESPACE::PresentTimeGOOGLE> 12691 { operator ()std::hash12692 std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentTimeGOOGLE const & presentTimeGOOGLE ) const VULKAN_HPP_NOEXCEPT 12693 { 12694 std::size_t seed = 0; 12695 VULKAN_HPP_HASH_COMBINE( seed, presentTimeGOOGLE.presentID ); 12696 VULKAN_HPP_HASH_COMBINE( seed, presentTimeGOOGLE.desiredPresentTime ); 12697 return seed; 12698 } 12699 }; 12700 12701 template <> 12702 struct hash<VULKAN_HPP_NAMESPACE::PresentTimesInfoGOOGLE> 12703 { operator ()std::hash12704 std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentTimesInfoGOOGLE const & presentTimesInfoGOOGLE ) const VULKAN_HPP_NOEXCEPT 12705 { 12706 std::size_t seed = 0; 12707 VULKAN_HPP_HASH_COMBINE( seed, presentTimesInfoGOOGLE.sType ); 12708 VULKAN_HPP_HASH_COMBINE( seed, presentTimesInfoGOOGLE.pNext ); 12709 VULKAN_HPP_HASH_COMBINE( seed, presentTimesInfoGOOGLE.swapchainCount ); 12710 VULKAN_HPP_HASH_COMBINE( seed, presentTimesInfoGOOGLE.pTimes ); 12711 return seed; 12712 } 12713 }; 12714 12715 template <> 12716 struct hash<VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo> 12717 { operator ()std::hash12718 std::size_t operator()( VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo const & privateDataSlotCreateInfo ) const VULKAN_HPP_NOEXCEPT 12719 { 12720 std::size_t seed = 0; 12721 VULKAN_HPP_HASH_COMBINE( seed, privateDataSlotCreateInfo.sType ); 12722 VULKAN_HPP_HASH_COMBINE( seed, privateDataSlotCreateInfo.pNext ); 12723 VULKAN_HPP_HASH_COMBINE( seed, privateDataSlotCreateInfo.flags ); 12724 return seed; 12725 } 12726 }; 12727 12728 template <> 12729 struct hash<VULKAN_HPP_NAMESPACE::ProtectedSubmitInfo> 12730 { operator ()std::hash12731 std::size_t operator()( VULKAN_HPP_NAMESPACE::ProtectedSubmitInfo const & protectedSubmitInfo ) const VULKAN_HPP_NOEXCEPT 12732 { 12733 std::size_t seed = 0; 12734 VULKAN_HPP_HASH_COMBINE( seed, protectedSubmitInfo.sType ); 12735 VULKAN_HPP_HASH_COMBINE( seed, protectedSubmitInfo.pNext ); 12736 VULKAN_HPP_HASH_COMBINE( seed, protectedSubmitInfo.protectedSubmit ); 12737 return seed; 12738 } 12739 }; 12740 12741 template <> 12742 struct hash<VULKAN_HPP_NAMESPACE::QueryLowLatencySupportNV> 12743 { operator ()std::hash12744 std::size_t operator()( VULKAN_HPP_NAMESPACE::QueryLowLatencySupportNV const & queryLowLatencySupportNV ) const VULKAN_HPP_NOEXCEPT 12745 { 12746 std::size_t seed = 0; 12747 VULKAN_HPP_HASH_COMBINE( seed, queryLowLatencySupportNV.sType ); 12748 VULKAN_HPP_HASH_COMBINE( seed, queryLowLatencySupportNV.pNext ); 12749 VULKAN_HPP_HASH_COMBINE( seed, queryLowLatencySupportNV.pQueriedLowLatencyData ); 12750 return seed; 12751 } 12752 }; 12753 12754 template <> 12755 struct hash<VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo> 12756 { operator ()std::hash12757 std::size_t operator()( VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo const & queryPoolCreateInfo ) const VULKAN_HPP_NOEXCEPT 12758 { 12759 std::size_t seed = 0; 12760 VULKAN_HPP_HASH_COMBINE( seed, queryPoolCreateInfo.sType ); 12761 VULKAN_HPP_HASH_COMBINE( seed, queryPoolCreateInfo.pNext ); 12762 VULKAN_HPP_HASH_COMBINE( seed, queryPoolCreateInfo.flags ); 12763 VULKAN_HPP_HASH_COMBINE( seed, queryPoolCreateInfo.queryType ); 12764 VULKAN_HPP_HASH_COMBINE( seed, queryPoolCreateInfo.queryCount ); 12765 VULKAN_HPP_HASH_COMBINE( seed, queryPoolCreateInfo.pipelineStatistics ); 12766 return seed; 12767 } 12768 }; 12769 12770 template <> 12771 struct hash<VULKAN_HPP_NAMESPACE::QueryPoolPerformanceCreateInfoKHR> 12772 { operator ()std::hash12773 std::size_t operator()( VULKAN_HPP_NAMESPACE::QueryPoolPerformanceCreateInfoKHR const & queryPoolPerformanceCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 12774 { 12775 std::size_t seed = 0; 12776 VULKAN_HPP_HASH_COMBINE( seed, queryPoolPerformanceCreateInfoKHR.sType ); 12777 VULKAN_HPP_HASH_COMBINE( seed, queryPoolPerformanceCreateInfoKHR.pNext ); 12778 VULKAN_HPP_HASH_COMBINE( seed, queryPoolPerformanceCreateInfoKHR.queueFamilyIndex ); 12779 VULKAN_HPP_HASH_COMBINE( seed, queryPoolPerformanceCreateInfoKHR.counterIndexCount ); 12780 VULKAN_HPP_HASH_COMBINE( seed, queryPoolPerformanceCreateInfoKHR.pCounterIndices ); 12781 return seed; 12782 } 12783 }; 12784 12785 template <> 12786 struct hash<VULKAN_HPP_NAMESPACE::QueryPoolPerformanceQueryCreateInfoINTEL> 12787 { 12788 std::size_t operator ()std::hash12789 operator()( VULKAN_HPP_NAMESPACE::QueryPoolPerformanceQueryCreateInfoINTEL const & queryPoolPerformanceQueryCreateInfoINTEL ) const VULKAN_HPP_NOEXCEPT 12790 { 12791 std::size_t seed = 0; 12792 VULKAN_HPP_HASH_COMBINE( seed, queryPoolPerformanceQueryCreateInfoINTEL.sType ); 12793 VULKAN_HPP_HASH_COMBINE( seed, queryPoolPerformanceQueryCreateInfoINTEL.pNext ); 12794 VULKAN_HPP_HASH_COMBINE( seed, queryPoolPerformanceQueryCreateInfoINTEL.performanceCountersSampling ); 12795 return seed; 12796 } 12797 }; 12798 12799 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 12800 template <> 12801 struct hash<VULKAN_HPP_NAMESPACE::QueryPoolVideoEncodeFeedbackCreateInfoKHR> 12802 { 12803 std::size_t operator ()std::hash12804 operator()( VULKAN_HPP_NAMESPACE::QueryPoolVideoEncodeFeedbackCreateInfoKHR const & queryPoolVideoEncodeFeedbackCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 12805 { 12806 std::size_t seed = 0; 12807 VULKAN_HPP_HASH_COMBINE( seed, queryPoolVideoEncodeFeedbackCreateInfoKHR.sType ); 12808 VULKAN_HPP_HASH_COMBINE( seed, queryPoolVideoEncodeFeedbackCreateInfoKHR.pNext ); 12809 VULKAN_HPP_HASH_COMBINE( seed, queryPoolVideoEncodeFeedbackCreateInfoKHR.encodeFeedbackFlags ); 12810 return seed; 12811 } 12812 }; 12813 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 12814 12815 template <> 12816 struct hash<VULKAN_HPP_NAMESPACE::QueueFamilyCheckpointProperties2NV> 12817 { operator ()std::hash12818 std::size_t operator()( VULKAN_HPP_NAMESPACE::QueueFamilyCheckpointProperties2NV const & queueFamilyCheckpointProperties2NV ) const VULKAN_HPP_NOEXCEPT 12819 { 12820 std::size_t seed = 0; 12821 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyCheckpointProperties2NV.sType ); 12822 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyCheckpointProperties2NV.pNext ); 12823 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyCheckpointProperties2NV.checkpointExecutionStageMask ); 12824 return seed; 12825 } 12826 }; 12827 12828 template <> 12829 struct hash<VULKAN_HPP_NAMESPACE::QueueFamilyCheckpointPropertiesNV> 12830 { operator ()std::hash12831 std::size_t operator()( VULKAN_HPP_NAMESPACE::QueueFamilyCheckpointPropertiesNV const & queueFamilyCheckpointPropertiesNV ) const VULKAN_HPP_NOEXCEPT 12832 { 12833 std::size_t seed = 0; 12834 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyCheckpointPropertiesNV.sType ); 12835 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyCheckpointPropertiesNV.pNext ); 12836 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyCheckpointPropertiesNV.checkpointExecutionStageMask ); 12837 return seed; 12838 } 12839 }; 12840 12841 template <> 12842 struct hash<VULKAN_HPP_NAMESPACE::QueueFamilyGlobalPriorityPropertiesKHR> 12843 { 12844 std::size_t operator ()std::hash12845 operator()( VULKAN_HPP_NAMESPACE::QueueFamilyGlobalPriorityPropertiesKHR const & queueFamilyGlobalPriorityPropertiesKHR ) const VULKAN_HPP_NOEXCEPT 12846 { 12847 std::size_t seed = 0; 12848 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyGlobalPriorityPropertiesKHR.sType ); 12849 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyGlobalPriorityPropertiesKHR.pNext ); 12850 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyGlobalPriorityPropertiesKHR.priorityCount ); 12851 for ( size_t i = 0; i < VK_MAX_GLOBAL_PRIORITY_SIZE_KHR; ++i ) 12852 { 12853 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyGlobalPriorityPropertiesKHR.priorities[i] ); 12854 } 12855 return seed; 12856 } 12857 }; 12858 12859 template <> 12860 struct hash<VULKAN_HPP_NAMESPACE::QueueFamilyProperties> 12861 { operator ()std::hash12862 std::size_t operator()( VULKAN_HPP_NAMESPACE::QueueFamilyProperties const & queueFamilyProperties ) const VULKAN_HPP_NOEXCEPT 12863 { 12864 std::size_t seed = 0; 12865 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyProperties.queueFlags ); 12866 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyProperties.queueCount ); 12867 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyProperties.timestampValidBits ); 12868 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyProperties.minImageTransferGranularity ); 12869 return seed; 12870 } 12871 }; 12872 12873 template <> 12874 struct hash<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2> 12875 { operator ()std::hash12876 std::size_t operator()( VULKAN_HPP_NAMESPACE::QueueFamilyProperties2 const & queueFamilyProperties2 ) const VULKAN_HPP_NOEXCEPT 12877 { 12878 std::size_t seed = 0; 12879 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyProperties2.sType ); 12880 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyProperties2.pNext ); 12881 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyProperties2.queueFamilyProperties ); 12882 return seed; 12883 } 12884 }; 12885 12886 template <> 12887 struct hash<VULKAN_HPP_NAMESPACE::QueueFamilyQueryResultStatusPropertiesKHR> 12888 { 12889 std::size_t operator ()std::hash12890 operator()( VULKAN_HPP_NAMESPACE::QueueFamilyQueryResultStatusPropertiesKHR const & queueFamilyQueryResultStatusPropertiesKHR ) const VULKAN_HPP_NOEXCEPT 12891 { 12892 std::size_t seed = 0; 12893 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyQueryResultStatusPropertiesKHR.sType ); 12894 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyQueryResultStatusPropertiesKHR.pNext ); 12895 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyQueryResultStatusPropertiesKHR.queryResultStatusSupport ); 12896 return seed; 12897 } 12898 }; 12899 12900 template <> 12901 struct hash<VULKAN_HPP_NAMESPACE::QueueFamilyVideoPropertiesKHR> 12902 { operator ()std::hash12903 std::size_t operator()( VULKAN_HPP_NAMESPACE::QueueFamilyVideoPropertiesKHR const & queueFamilyVideoPropertiesKHR ) const VULKAN_HPP_NOEXCEPT 12904 { 12905 std::size_t seed = 0; 12906 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyVideoPropertiesKHR.sType ); 12907 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyVideoPropertiesKHR.pNext ); 12908 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyVideoPropertiesKHR.videoCodecOperations ); 12909 return seed; 12910 } 12911 }; 12912 12913 template <> 12914 struct hash<VULKAN_HPP_NAMESPACE::RayTracingShaderGroupCreateInfoKHR> 12915 { operator ()std::hash12916 std::size_t operator()( VULKAN_HPP_NAMESPACE::RayTracingShaderGroupCreateInfoKHR const & rayTracingShaderGroupCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 12917 { 12918 std::size_t seed = 0; 12919 VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoKHR.sType ); 12920 VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoKHR.pNext ); 12921 VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoKHR.type ); 12922 VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoKHR.generalShader ); 12923 VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoKHR.closestHitShader ); 12924 VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoKHR.anyHitShader ); 12925 VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoKHR.intersectionShader ); 12926 VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoKHR.pShaderGroupCaptureReplayHandle ); 12927 return seed; 12928 } 12929 }; 12930 12931 template <> 12932 struct hash<VULKAN_HPP_NAMESPACE::RayTracingPipelineInterfaceCreateInfoKHR> 12933 { 12934 std::size_t operator ()std::hash12935 operator()( VULKAN_HPP_NAMESPACE::RayTracingPipelineInterfaceCreateInfoKHR const & rayTracingPipelineInterfaceCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 12936 { 12937 std::size_t seed = 0; 12938 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineInterfaceCreateInfoKHR.sType ); 12939 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineInterfaceCreateInfoKHR.pNext ); 12940 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineInterfaceCreateInfoKHR.maxPipelineRayPayloadSize ); 12941 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineInterfaceCreateInfoKHR.maxPipelineRayHitAttributeSize ); 12942 return seed; 12943 } 12944 }; 12945 12946 template <> 12947 struct hash<VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> 12948 { operator ()std::hash12949 std::size_t operator()( VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR const & rayTracingPipelineCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 12950 { 12951 std::size_t seed = 0; 12952 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.sType ); 12953 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.pNext ); 12954 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.flags ); 12955 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.stageCount ); 12956 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.pStages ); 12957 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.groupCount ); 12958 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.pGroups ); 12959 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.maxPipelineRayRecursionDepth ); 12960 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.pLibraryInfo ); 12961 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.pLibraryInterface ); 12962 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.pDynamicState ); 12963 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.layout ); 12964 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.basePipelineHandle ); 12965 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.basePipelineIndex ); 12966 return seed; 12967 } 12968 }; 12969 12970 template <> 12971 struct hash<VULKAN_HPP_NAMESPACE::RayTracingShaderGroupCreateInfoNV> 12972 { operator ()std::hash12973 std::size_t operator()( VULKAN_HPP_NAMESPACE::RayTracingShaderGroupCreateInfoNV const & rayTracingShaderGroupCreateInfoNV ) const VULKAN_HPP_NOEXCEPT 12974 { 12975 std::size_t seed = 0; 12976 VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoNV.sType ); 12977 VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoNV.pNext ); 12978 VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoNV.type ); 12979 VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoNV.generalShader ); 12980 VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoNV.closestHitShader ); 12981 VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoNV.anyHitShader ); 12982 VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoNV.intersectionShader ); 12983 return seed; 12984 } 12985 }; 12986 12987 template <> 12988 struct hash<VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> 12989 { operator ()std::hash12990 std::size_t operator()( VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV const & rayTracingPipelineCreateInfoNV ) const VULKAN_HPP_NOEXCEPT 12991 { 12992 std::size_t seed = 0; 12993 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.sType ); 12994 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.pNext ); 12995 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.flags ); 12996 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.stageCount ); 12997 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.pStages ); 12998 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.groupCount ); 12999 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.pGroups ); 13000 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.maxRecursionDepth ); 13001 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.layout ); 13002 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.basePipelineHandle ); 13003 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.basePipelineIndex ); 13004 return seed; 13005 } 13006 }; 13007 13008 template <> 13009 struct hash<VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE> 13010 { operator ()std::hash13011 std::size_t operator()( VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE const & refreshCycleDurationGOOGLE ) const VULKAN_HPP_NOEXCEPT 13012 { 13013 std::size_t seed = 0; 13014 VULKAN_HPP_HASH_COMBINE( seed, refreshCycleDurationGOOGLE.refreshDuration ); 13015 return seed; 13016 } 13017 }; 13018 13019 template <> 13020 struct hash<VULKAN_HPP_NAMESPACE::ReleaseSwapchainImagesInfoEXT> 13021 { operator ()std::hash13022 std::size_t operator()( VULKAN_HPP_NAMESPACE::ReleaseSwapchainImagesInfoEXT const & releaseSwapchainImagesInfoEXT ) const VULKAN_HPP_NOEXCEPT 13023 { 13024 std::size_t seed = 0; 13025 VULKAN_HPP_HASH_COMBINE( seed, releaseSwapchainImagesInfoEXT.sType ); 13026 VULKAN_HPP_HASH_COMBINE( seed, releaseSwapchainImagesInfoEXT.pNext ); 13027 VULKAN_HPP_HASH_COMBINE( seed, releaseSwapchainImagesInfoEXT.swapchain ); 13028 VULKAN_HPP_HASH_COMBINE( seed, releaseSwapchainImagesInfoEXT.imageIndexCount ); 13029 VULKAN_HPP_HASH_COMBINE( seed, releaseSwapchainImagesInfoEXT.pImageIndices ); 13030 return seed; 13031 } 13032 }; 13033 13034 template <> 13035 struct hash<VULKAN_HPP_NAMESPACE::RenderPassAttachmentBeginInfo> 13036 { operator ()std::hash13037 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassAttachmentBeginInfo const & renderPassAttachmentBeginInfo ) const VULKAN_HPP_NOEXCEPT 13038 { 13039 std::size_t seed = 0; 13040 VULKAN_HPP_HASH_COMBINE( seed, renderPassAttachmentBeginInfo.sType ); 13041 VULKAN_HPP_HASH_COMBINE( seed, renderPassAttachmentBeginInfo.pNext ); 13042 VULKAN_HPP_HASH_COMBINE( seed, renderPassAttachmentBeginInfo.attachmentCount ); 13043 VULKAN_HPP_HASH_COMBINE( seed, renderPassAttachmentBeginInfo.pAttachments ); 13044 return seed; 13045 } 13046 }; 13047 13048 template <> 13049 struct hash<VULKAN_HPP_NAMESPACE::RenderPassBeginInfo> 13050 { operator ()std::hash13051 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassBeginInfo const & renderPassBeginInfo ) const VULKAN_HPP_NOEXCEPT 13052 { 13053 std::size_t seed = 0; 13054 VULKAN_HPP_HASH_COMBINE( seed, renderPassBeginInfo.sType ); 13055 VULKAN_HPP_HASH_COMBINE( seed, renderPassBeginInfo.pNext ); 13056 VULKAN_HPP_HASH_COMBINE( seed, renderPassBeginInfo.renderPass ); 13057 VULKAN_HPP_HASH_COMBINE( seed, renderPassBeginInfo.framebuffer ); 13058 VULKAN_HPP_HASH_COMBINE( seed, renderPassBeginInfo.renderArea ); 13059 VULKAN_HPP_HASH_COMBINE( seed, renderPassBeginInfo.clearValueCount ); 13060 VULKAN_HPP_HASH_COMBINE( seed, renderPassBeginInfo.pClearValues ); 13061 return seed; 13062 } 13063 }; 13064 13065 template <> 13066 struct hash<VULKAN_HPP_NAMESPACE::SubpassDescription> 13067 { operator ()std::hash13068 std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassDescription const & subpassDescription ) const VULKAN_HPP_NOEXCEPT 13069 { 13070 std::size_t seed = 0; 13071 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.flags ); 13072 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.pipelineBindPoint ); 13073 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.inputAttachmentCount ); 13074 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.pInputAttachments ); 13075 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.colorAttachmentCount ); 13076 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.pColorAttachments ); 13077 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.pResolveAttachments ); 13078 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.pDepthStencilAttachment ); 13079 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.preserveAttachmentCount ); 13080 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.pPreserveAttachments ); 13081 return seed; 13082 } 13083 }; 13084 13085 template <> 13086 struct hash<VULKAN_HPP_NAMESPACE::SubpassDependency> 13087 { operator ()std::hash13088 std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassDependency const & subpassDependency ) const VULKAN_HPP_NOEXCEPT 13089 { 13090 std::size_t seed = 0; 13091 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency.srcSubpass ); 13092 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency.dstSubpass ); 13093 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency.srcStageMask ); 13094 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency.dstStageMask ); 13095 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency.srcAccessMask ); 13096 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency.dstAccessMask ); 13097 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency.dependencyFlags ); 13098 return seed; 13099 } 13100 }; 13101 13102 template <> 13103 struct hash<VULKAN_HPP_NAMESPACE::RenderPassCreateInfo> 13104 { operator ()std::hash13105 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassCreateInfo const & renderPassCreateInfo ) const VULKAN_HPP_NOEXCEPT 13106 { 13107 std::size_t seed = 0; 13108 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo.sType ); 13109 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo.pNext ); 13110 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo.flags ); 13111 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo.attachmentCount ); 13112 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo.pAttachments ); 13113 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo.subpassCount ); 13114 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo.pSubpasses ); 13115 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo.dependencyCount ); 13116 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo.pDependencies ); 13117 return seed; 13118 } 13119 }; 13120 13121 template <> 13122 struct hash<VULKAN_HPP_NAMESPACE::SubpassDescription2> 13123 { operator ()std::hash13124 std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassDescription2 const & subpassDescription2 ) const VULKAN_HPP_NOEXCEPT 13125 { 13126 std::size_t seed = 0; 13127 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.sType ); 13128 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.pNext ); 13129 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.flags ); 13130 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.pipelineBindPoint ); 13131 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.viewMask ); 13132 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.inputAttachmentCount ); 13133 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.pInputAttachments ); 13134 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.colorAttachmentCount ); 13135 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.pColorAttachments ); 13136 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.pResolveAttachments ); 13137 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.pDepthStencilAttachment ); 13138 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.preserveAttachmentCount ); 13139 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.pPreserveAttachments ); 13140 return seed; 13141 } 13142 }; 13143 13144 template <> 13145 struct hash<VULKAN_HPP_NAMESPACE::SubpassDependency2> 13146 { operator ()std::hash13147 std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassDependency2 const & subpassDependency2 ) const VULKAN_HPP_NOEXCEPT 13148 { 13149 std::size_t seed = 0; 13150 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.sType ); 13151 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.pNext ); 13152 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.srcSubpass ); 13153 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.dstSubpass ); 13154 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.srcStageMask ); 13155 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.dstStageMask ); 13156 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.srcAccessMask ); 13157 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.dstAccessMask ); 13158 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.dependencyFlags ); 13159 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.viewOffset ); 13160 return seed; 13161 } 13162 }; 13163 13164 template <> 13165 struct hash<VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2> 13166 { operator ()std::hash13167 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 const & renderPassCreateInfo2 ) const VULKAN_HPP_NOEXCEPT 13168 { 13169 std::size_t seed = 0; 13170 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.sType ); 13171 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.pNext ); 13172 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.flags ); 13173 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.attachmentCount ); 13174 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.pAttachments ); 13175 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.subpassCount ); 13176 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.pSubpasses ); 13177 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.dependencyCount ); 13178 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.pDependencies ); 13179 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.correlatedViewMaskCount ); 13180 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.pCorrelatedViewMasks ); 13181 return seed; 13182 } 13183 }; 13184 13185 template <> 13186 struct hash<VULKAN_HPP_NAMESPACE::RenderPassCreationControlEXT> 13187 { operator ()std::hash13188 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassCreationControlEXT const & renderPassCreationControlEXT ) const VULKAN_HPP_NOEXCEPT 13189 { 13190 std::size_t seed = 0; 13191 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreationControlEXT.sType ); 13192 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreationControlEXT.pNext ); 13193 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreationControlEXT.disallowMerging ); 13194 return seed; 13195 } 13196 }; 13197 13198 template <> 13199 struct hash<VULKAN_HPP_NAMESPACE::RenderPassCreationFeedbackInfoEXT> 13200 { operator ()std::hash13201 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassCreationFeedbackInfoEXT const & renderPassCreationFeedbackInfoEXT ) const VULKAN_HPP_NOEXCEPT 13202 { 13203 std::size_t seed = 0; 13204 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreationFeedbackInfoEXT.postMergeSubpassCount ); 13205 return seed; 13206 } 13207 }; 13208 13209 template <> 13210 struct hash<VULKAN_HPP_NAMESPACE::RenderPassCreationFeedbackCreateInfoEXT> 13211 { 13212 std::size_t operator ()std::hash13213 operator()( VULKAN_HPP_NAMESPACE::RenderPassCreationFeedbackCreateInfoEXT const & renderPassCreationFeedbackCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 13214 { 13215 std::size_t seed = 0; 13216 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreationFeedbackCreateInfoEXT.sType ); 13217 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreationFeedbackCreateInfoEXT.pNext ); 13218 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreationFeedbackCreateInfoEXT.pRenderPassFeedback ); 13219 return seed; 13220 } 13221 }; 13222 13223 template <> 13224 struct hash<VULKAN_HPP_NAMESPACE::RenderPassFragmentDensityMapCreateInfoEXT> 13225 { 13226 std::size_t operator ()std::hash13227 operator()( VULKAN_HPP_NAMESPACE::RenderPassFragmentDensityMapCreateInfoEXT const & renderPassFragmentDensityMapCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 13228 { 13229 std::size_t seed = 0; 13230 VULKAN_HPP_HASH_COMBINE( seed, renderPassFragmentDensityMapCreateInfoEXT.sType ); 13231 VULKAN_HPP_HASH_COMBINE( seed, renderPassFragmentDensityMapCreateInfoEXT.pNext ); 13232 VULKAN_HPP_HASH_COMBINE( seed, renderPassFragmentDensityMapCreateInfoEXT.fragmentDensityMapAttachment ); 13233 return seed; 13234 } 13235 }; 13236 13237 template <> 13238 struct hash<VULKAN_HPP_NAMESPACE::RenderPassInputAttachmentAspectCreateInfo> 13239 { 13240 std::size_t operator ()std::hash13241 operator()( VULKAN_HPP_NAMESPACE::RenderPassInputAttachmentAspectCreateInfo const & renderPassInputAttachmentAspectCreateInfo ) const VULKAN_HPP_NOEXCEPT 13242 { 13243 std::size_t seed = 0; 13244 VULKAN_HPP_HASH_COMBINE( seed, renderPassInputAttachmentAspectCreateInfo.sType ); 13245 VULKAN_HPP_HASH_COMBINE( seed, renderPassInputAttachmentAspectCreateInfo.pNext ); 13246 VULKAN_HPP_HASH_COMBINE( seed, renderPassInputAttachmentAspectCreateInfo.aspectReferenceCount ); 13247 VULKAN_HPP_HASH_COMBINE( seed, renderPassInputAttachmentAspectCreateInfo.pAspectReferences ); 13248 return seed; 13249 } 13250 }; 13251 13252 template <> 13253 struct hash<VULKAN_HPP_NAMESPACE::RenderPassMultiviewCreateInfo> 13254 { operator ()std::hash13255 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassMultiviewCreateInfo const & renderPassMultiviewCreateInfo ) const VULKAN_HPP_NOEXCEPT 13256 { 13257 std::size_t seed = 0; 13258 VULKAN_HPP_HASH_COMBINE( seed, renderPassMultiviewCreateInfo.sType ); 13259 VULKAN_HPP_HASH_COMBINE( seed, renderPassMultiviewCreateInfo.pNext ); 13260 VULKAN_HPP_HASH_COMBINE( seed, renderPassMultiviewCreateInfo.subpassCount ); 13261 VULKAN_HPP_HASH_COMBINE( seed, renderPassMultiviewCreateInfo.pViewMasks ); 13262 VULKAN_HPP_HASH_COMBINE( seed, renderPassMultiviewCreateInfo.dependencyCount ); 13263 VULKAN_HPP_HASH_COMBINE( seed, renderPassMultiviewCreateInfo.pViewOffsets ); 13264 VULKAN_HPP_HASH_COMBINE( seed, renderPassMultiviewCreateInfo.correlationMaskCount ); 13265 VULKAN_HPP_HASH_COMBINE( seed, renderPassMultiviewCreateInfo.pCorrelationMasks ); 13266 return seed; 13267 } 13268 }; 13269 13270 template <> 13271 struct hash<VULKAN_HPP_NAMESPACE::SubpassSampleLocationsEXT> 13272 { operator ()std::hash13273 std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassSampleLocationsEXT const & subpassSampleLocationsEXT ) const VULKAN_HPP_NOEXCEPT 13274 { 13275 std::size_t seed = 0; 13276 VULKAN_HPP_HASH_COMBINE( seed, subpassSampleLocationsEXT.subpassIndex ); 13277 VULKAN_HPP_HASH_COMBINE( seed, subpassSampleLocationsEXT.sampleLocationsInfo ); 13278 return seed; 13279 } 13280 }; 13281 13282 template <> 13283 struct hash<VULKAN_HPP_NAMESPACE::RenderPassSampleLocationsBeginInfoEXT> 13284 { 13285 std::size_t operator ()std::hash13286 operator()( VULKAN_HPP_NAMESPACE::RenderPassSampleLocationsBeginInfoEXT const & renderPassSampleLocationsBeginInfoEXT ) const VULKAN_HPP_NOEXCEPT 13287 { 13288 std::size_t seed = 0; 13289 VULKAN_HPP_HASH_COMBINE( seed, renderPassSampleLocationsBeginInfoEXT.sType ); 13290 VULKAN_HPP_HASH_COMBINE( seed, renderPassSampleLocationsBeginInfoEXT.pNext ); 13291 VULKAN_HPP_HASH_COMBINE( seed, renderPassSampleLocationsBeginInfoEXT.attachmentInitialSampleLocationsCount ); 13292 VULKAN_HPP_HASH_COMBINE( seed, renderPassSampleLocationsBeginInfoEXT.pAttachmentInitialSampleLocations ); 13293 VULKAN_HPP_HASH_COMBINE( seed, renderPassSampleLocationsBeginInfoEXT.postSubpassSampleLocationsCount ); 13294 VULKAN_HPP_HASH_COMBINE( seed, renderPassSampleLocationsBeginInfoEXT.pPostSubpassSampleLocations ); 13295 return seed; 13296 } 13297 }; 13298 13299 template <> 13300 struct hash<VULKAN_HPP_NAMESPACE::RenderPassSubpassFeedbackInfoEXT> 13301 { operator ()std::hash13302 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassSubpassFeedbackInfoEXT const & renderPassSubpassFeedbackInfoEXT ) const VULKAN_HPP_NOEXCEPT 13303 { 13304 std::size_t seed = 0; 13305 VULKAN_HPP_HASH_COMBINE( seed, renderPassSubpassFeedbackInfoEXT.subpassMergeStatus ); 13306 for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) 13307 { 13308 VULKAN_HPP_HASH_COMBINE( seed, renderPassSubpassFeedbackInfoEXT.description[i] ); 13309 } 13310 VULKAN_HPP_HASH_COMBINE( seed, renderPassSubpassFeedbackInfoEXT.postMergeIndex ); 13311 return seed; 13312 } 13313 }; 13314 13315 template <> 13316 struct hash<VULKAN_HPP_NAMESPACE::RenderPassSubpassFeedbackCreateInfoEXT> 13317 { 13318 std::size_t operator ()std::hash13319 operator()( VULKAN_HPP_NAMESPACE::RenderPassSubpassFeedbackCreateInfoEXT const & renderPassSubpassFeedbackCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 13320 { 13321 std::size_t seed = 0; 13322 VULKAN_HPP_HASH_COMBINE( seed, renderPassSubpassFeedbackCreateInfoEXT.sType ); 13323 VULKAN_HPP_HASH_COMBINE( seed, renderPassSubpassFeedbackCreateInfoEXT.pNext ); 13324 VULKAN_HPP_HASH_COMBINE( seed, renderPassSubpassFeedbackCreateInfoEXT.pSubpassFeedback ); 13325 return seed; 13326 } 13327 }; 13328 13329 template <> 13330 struct hash<VULKAN_HPP_NAMESPACE::RenderPassTransformBeginInfoQCOM> 13331 { operator ()std::hash13332 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassTransformBeginInfoQCOM const & renderPassTransformBeginInfoQCOM ) const VULKAN_HPP_NOEXCEPT 13333 { 13334 std::size_t seed = 0; 13335 VULKAN_HPP_HASH_COMBINE( seed, renderPassTransformBeginInfoQCOM.sType ); 13336 VULKAN_HPP_HASH_COMBINE( seed, renderPassTransformBeginInfoQCOM.pNext ); 13337 VULKAN_HPP_HASH_COMBINE( seed, renderPassTransformBeginInfoQCOM.transform ); 13338 return seed; 13339 } 13340 }; 13341 13342 template <> 13343 struct hash<VULKAN_HPP_NAMESPACE::RenderingAreaInfoKHR> 13344 { operator ()std::hash13345 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderingAreaInfoKHR const & renderingAreaInfoKHR ) const VULKAN_HPP_NOEXCEPT 13346 { 13347 std::size_t seed = 0; 13348 VULKAN_HPP_HASH_COMBINE( seed, renderingAreaInfoKHR.sType ); 13349 VULKAN_HPP_HASH_COMBINE( seed, renderingAreaInfoKHR.pNext ); 13350 VULKAN_HPP_HASH_COMBINE( seed, renderingAreaInfoKHR.viewMask ); 13351 VULKAN_HPP_HASH_COMBINE( seed, renderingAreaInfoKHR.colorAttachmentCount ); 13352 VULKAN_HPP_HASH_COMBINE( seed, renderingAreaInfoKHR.pColorAttachmentFormats ); 13353 VULKAN_HPP_HASH_COMBINE( seed, renderingAreaInfoKHR.depthAttachmentFormat ); 13354 VULKAN_HPP_HASH_COMBINE( seed, renderingAreaInfoKHR.stencilAttachmentFormat ); 13355 return seed; 13356 } 13357 }; 13358 13359 template <> 13360 struct hash<VULKAN_HPP_NAMESPACE::RenderingFragmentDensityMapAttachmentInfoEXT> 13361 { operator ()std::hash13362 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderingFragmentDensityMapAttachmentInfoEXT const & renderingFragmentDensityMapAttachmentInfoEXT ) const 13363 VULKAN_HPP_NOEXCEPT 13364 { 13365 std::size_t seed = 0; 13366 VULKAN_HPP_HASH_COMBINE( seed, renderingFragmentDensityMapAttachmentInfoEXT.sType ); 13367 VULKAN_HPP_HASH_COMBINE( seed, renderingFragmentDensityMapAttachmentInfoEXT.pNext ); 13368 VULKAN_HPP_HASH_COMBINE( seed, renderingFragmentDensityMapAttachmentInfoEXT.imageView ); 13369 VULKAN_HPP_HASH_COMBINE( seed, renderingFragmentDensityMapAttachmentInfoEXT.imageLayout ); 13370 return seed; 13371 } 13372 }; 13373 13374 template <> 13375 struct hash<VULKAN_HPP_NAMESPACE::RenderingFragmentShadingRateAttachmentInfoKHR> 13376 { operator ()std::hash13377 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderingFragmentShadingRateAttachmentInfoKHR const & renderingFragmentShadingRateAttachmentInfoKHR ) const 13378 VULKAN_HPP_NOEXCEPT 13379 { 13380 std::size_t seed = 0; 13381 VULKAN_HPP_HASH_COMBINE( seed, renderingFragmentShadingRateAttachmentInfoKHR.sType ); 13382 VULKAN_HPP_HASH_COMBINE( seed, renderingFragmentShadingRateAttachmentInfoKHR.pNext ); 13383 VULKAN_HPP_HASH_COMBINE( seed, renderingFragmentShadingRateAttachmentInfoKHR.imageView ); 13384 VULKAN_HPP_HASH_COMBINE( seed, renderingFragmentShadingRateAttachmentInfoKHR.imageLayout ); 13385 VULKAN_HPP_HASH_COMBINE( seed, renderingFragmentShadingRateAttachmentInfoKHR.shadingRateAttachmentTexelSize ); 13386 return seed; 13387 } 13388 }; 13389 13390 template <> 13391 struct hash<VULKAN_HPP_NAMESPACE::RenderingInfo> 13392 { operator ()std::hash13393 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderingInfo const & renderingInfo ) const VULKAN_HPP_NOEXCEPT 13394 { 13395 std::size_t seed = 0; 13396 VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.sType ); 13397 VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.pNext ); 13398 VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.flags ); 13399 VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.renderArea ); 13400 VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.layerCount ); 13401 VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.viewMask ); 13402 VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.colorAttachmentCount ); 13403 VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.pColorAttachments ); 13404 VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.pDepthAttachment ); 13405 VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.pStencilAttachment ); 13406 return seed; 13407 } 13408 }; 13409 13410 template <> 13411 struct hash<VULKAN_HPP_NAMESPACE::ResolveImageInfo2> 13412 { operator ()std::hash13413 std::size_t operator()( VULKAN_HPP_NAMESPACE::ResolveImageInfo2 const & resolveImageInfo2 ) const VULKAN_HPP_NOEXCEPT 13414 { 13415 std::size_t seed = 0; 13416 VULKAN_HPP_HASH_COMBINE( seed, resolveImageInfo2.sType ); 13417 VULKAN_HPP_HASH_COMBINE( seed, resolveImageInfo2.pNext ); 13418 VULKAN_HPP_HASH_COMBINE( seed, resolveImageInfo2.srcImage ); 13419 VULKAN_HPP_HASH_COMBINE( seed, resolveImageInfo2.srcImageLayout ); 13420 VULKAN_HPP_HASH_COMBINE( seed, resolveImageInfo2.dstImage ); 13421 VULKAN_HPP_HASH_COMBINE( seed, resolveImageInfo2.dstImageLayout ); 13422 VULKAN_HPP_HASH_COMBINE( seed, resolveImageInfo2.regionCount ); 13423 VULKAN_HPP_HASH_COMBINE( seed, resolveImageInfo2.pRegions ); 13424 return seed; 13425 } 13426 }; 13427 13428 template <> 13429 struct hash<VULKAN_HPP_NAMESPACE::SamplerBlockMatchWindowCreateInfoQCOM> 13430 { 13431 std::size_t operator ()std::hash13432 operator()( VULKAN_HPP_NAMESPACE::SamplerBlockMatchWindowCreateInfoQCOM const & samplerBlockMatchWindowCreateInfoQCOM ) const VULKAN_HPP_NOEXCEPT 13433 { 13434 std::size_t seed = 0; 13435 VULKAN_HPP_HASH_COMBINE( seed, samplerBlockMatchWindowCreateInfoQCOM.sType ); 13436 VULKAN_HPP_HASH_COMBINE( seed, samplerBlockMatchWindowCreateInfoQCOM.pNext ); 13437 VULKAN_HPP_HASH_COMBINE( seed, samplerBlockMatchWindowCreateInfoQCOM.windowExtent ); 13438 VULKAN_HPP_HASH_COMBINE( seed, samplerBlockMatchWindowCreateInfoQCOM.windowCompareMode ); 13439 return seed; 13440 } 13441 }; 13442 13443 template <> 13444 struct hash<VULKAN_HPP_NAMESPACE::SamplerBorderColorComponentMappingCreateInfoEXT> 13445 { operator ()std::hash13446 std::size_t operator()( 13447 VULKAN_HPP_NAMESPACE::SamplerBorderColorComponentMappingCreateInfoEXT const & samplerBorderColorComponentMappingCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 13448 { 13449 std::size_t seed = 0; 13450 VULKAN_HPP_HASH_COMBINE( seed, samplerBorderColorComponentMappingCreateInfoEXT.sType ); 13451 VULKAN_HPP_HASH_COMBINE( seed, samplerBorderColorComponentMappingCreateInfoEXT.pNext ); 13452 VULKAN_HPP_HASH_COMBINE( seed, samplerBorderColorComponentMappingCreateInfoEXT.components ); 13453 VULKAN_HPP_HASH_COMBINE( seed, samplerBorderColorComponentMappingCreateInfoEXT.srgb ); 13454 return seed; 13455 } 13456 }; 13457 13458 template <> 13459 struct hash<VULKAN_HPP_NAMESPACE::SamplerCaptureDescriptorDataInfoEXT> 13460 { operator ()std::hash13461 std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerCaptureDescriptorDataInfoEXT const & samplerCaptureDescriptorDataInfoEXT ) const VULKAN_HPP_NOEXCEPT 13462 { 13463 std::size_t seed = 0; 13464 VULKAN_HPP_HASH_COMBINE( seed, samplerCaptureDescriptorDataInfoEXT.sType ); 13465 VULKAN_HPP_HASH_COMBINE( seed, samplerCaptureDescriptorDataInfoEXT.pNext ); 13466 VULKAN_HPP_HASH_COMBINE( seed, samplerCaptureDescriptorDataInfoEXT.sampler ); 13467 return seed; 13468 } 13469 }; 13470 13471 template <> 13472 struct hash<VULKAN_HPP_NAMESPACE::SamplerCreateInfo> 13473 { operator ()std::hash13474 std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerCreateInfo const & samplerCreateInfo ) const VULKAN_HPP_NOEXCEPT 13475 { 13476 std::size_t seed = 0; 13477 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.sType ); 13478 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.pNext ); 13479 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.flags ); 13480 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.magFilter ); 13481 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.minFilter ); 13482 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.mipmapMode ); 13483 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.addressModeU ); 13484 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.addressModeV ); 13485 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.addressModeW ); 13486 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.mipLodBias ); 13487 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.anisotropyEnable ); 13488 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.maxAnisotropy ); 13489 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.compareEnable ); 13490 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.compareOp ); 13491 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.minLod ); 13492 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.maxLod ); 13493 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.borderColor ); 13494 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.unnormalizedCoordinates ); 13495 return seed; 13496 } 13497 }; 13498 13499 template <> 13500 struct hash<VULKAN_HPP_NAMESPACE::SamplerCubicWeightsCreateInfoQCOM> 13501 { operator ()std::hash13502 std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerCubicWeightsCreateInfoQCOM const & samplerCubicWeightsCreateInfoQCOM ) const VULKAN_HPP_NOEXCEPT 13503 { 13504 std::size_t seed = 0; 13505 VULKAN_HPP_HASH_COMBINE( seed, samplerCubicWeightsCreateInfoQCOM.sType ); 13506 VULKAN_HPP_HASH_COMBINE( seed, samplerCubicWeightsCreateInfoQCOM.pNext ); 13507 VULKAN_HPP_HASH_COMBINE( seed, samplerCubicWeightsCreateInfoQCOM.cubicWeights ); 13508 return seed; 13509 } 13510 }; 13511 13512 template <> 13513 struct hash<VULKAN_HPP_NAMESPACE::SamplerReductionModeCreateInfo> 13514 { operator ()std::hash13515 std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerReductionModeCreateInfo const & samplerReductionModeCreateInfo ) const VULKAN_HPP_NOEXCEPT 13516 { 13517 std::size_t seed = 0; 13518 VULKAN_HPP_HASH_COMBINE( seed, samplerReductionModeCreateInfo.sType ); 13519 VULKAN_HPP_HASH_COMBINE( seed, samplerReductionModeCreateInfo.pNext ); 13520 VULKAN_HPP_HASH_COMBINE( seed, samplerReductionModeCreateInfo.reductionMode ); 13521 return seed; 13522 } 13523 }; 13524 13525 template <> 13526 struct hash<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo> 13527 { operator ()std::hash13528 std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo const & samplerYcbcrConversionCreateInfo ) const VULKAN_HPP_NOEXCEPT 13529 { 13530 std::size_t seed = 0; 13531 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.sType ); 13532 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.pNext ); 13533 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.format ); 13534 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.ycbcrModel ); 13535 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.ycbcrRange ); 13536 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.components ); 13537 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.xChromaOffset ); 13538 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.yChromaOffset ); 13539 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.chromaFilter ); 13540 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.forceExplicitReconstruction ); 13541 return seed; 13542 } 13543 }; 13544 13545 template <> 13546 struct hash<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionImageFormatProperties> 13547 { operator ()std::hash13548 std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionImageFormatProperties const & samplerYcbcrConversionImageFormatProperties ) const 13549 VULKAN_HPP_NOEXCEPT 13550 { 13551 std::size_t seed = 0; 13552 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionImageFormatProperties.sType ); 13553 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionImageFormatProperties.pNext ); 13554 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionImageFormatProperties.combinedImageSamplerDescriptorCount ); 13555 return seed; 13556 } 13557 }; 13558 13559 template <> 13560 struct hash<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionInfo> 13561 { operator ()std::hash13562 std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionInfo const & samplerYcbcrConversionInfo ) const VULKAN_HPP_NOEXCEPT 13563 { 13564 std::size_t seed = 0; 13565 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionInfo.sType ); 13566 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionInfo.pNext ); 13567 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionInfo.conversion ); 13568 return seed; 13569 } 13570 }; 13571 13572 template <> 13573 struct hash<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM> 13574 { operator ()std::hash13575 std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM const & samplerYcbcrConversionYcbcrDegammaCreateInfoQCOM ) 13576 const VULKAN_HPP_NOEXCEPT 13577 { 13578 std::size_t seed = 0; 13579 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionYcbcrDegammaCreateInfoQCOM.sType ); 13580 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionYcbcrDegammaCreateInfoQCOM.pNext ); 13581 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionYcbcrDegammaCreateInfoQCOM.enableYDegamma ); 13582 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionYcbcrDegammaCreateInfoQCOM.enableCbCrDegamma ); 13583 return seed; 13584 } 13585 }; 13586 13587 # if defined( VK_USE_PLATFORM_SCREEN_QNX ) 13588 template <> 13589 struct hash<VULKAN_HPP_NAMESPACE::ScreenBufferFormatPropertiesQNX> 13590 { operator ()std::hash13591 std::size_t operator()( VULKAN_HPP_NAMESPACE::ScreenBufferFormatPropertiesQNX const & screenBufferFormatPropertiesQNX ) const VULKAN_HPP_NOEXCEPT 13592 { 13593 std::size_t seed = 0; 13594 VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.sType ); 13595 VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.pNext ); 13596 VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.format ); 13597 VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.externalFormat ); 13598 VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.screenUsage ); 13599 VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.formatFeatures ); 13600 VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.samplerYcbcrConversionComponents ); 13601 VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.suggestedYcbcrModel ); 13602 VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.suggestedYcbcrRange ); 13603 VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.suggestedXChromaOffset ); 13604 VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.suggestedYChromaOffset ); 13605 return seed; 13606 } 13607 }; 13608 # endif /*VK_USE_PLATFORM_SCREEN_QNX*/ 13609 13610 # if defined( VK_USE_PLATFORM_SCREEN_QNX ) 13611 template <> 13612 struct hash<VULKAN_HPP_NAMESPACE::ScreenBufferPropertiesQNX> 13613 { operator ()std::hash13614 std::size_t operator()( VULKAN_HPP_NAMESPACE::ScreenBufferPropertiesQNX const & screenBufferPropertiesQNX ) const VULKAN_HPP_NOEXCEPT 13615 { 13616 std::size_t seed = 0; 13617 VULKAN_HPP_HASH_COMBINE( seed, screenBufferPropertiesQNX.sType ); 13618 VULKAN_HPP_HASH_COMBINE( seed, screenBufferPropertiesQNX.pNext ); 13619 VULKAN_HPP_HASH_COMBINE( seed, screenBufferPropertiesQNX.allocationSize ); 13620 VULKAN_HPP_HASH_COMBINE( seed, screenBufferPropertiesQNX.memoryTypeBits ); 13621 return seed; 13622 } 13623 }; 13624 # endif /*VK_USE_PLATFORM_SCREEN_QNX*/ 13625 13626 # if defined( VK_USE_PLATFORM_SCREEN_QNX ) 13627 template <> 13628 struct hash<VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX> 13629 { operator ()std::hash13630 std::size_t operator()( VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX const & screenSurfaceCreateInfoQNX ) const VULKAN_HPP_NOEXCEPT 13631 { 13632 std::size_t seed = 0; 13633 VULKAN_HPP_HASH_COMBINE( seed, screenSurfaceCreateInfoQNX.sType ); 13634 VULKAN_HPP_HASH_COMBINE( seed, screenSurfaceCreateInfoQNX.pNext ); 13635 VULKAN_HPP_HASH_COMBINE( seed, screenSurfaceCreateInfoQNX.flags ); 13636 VULKAN_HPP_HASH_COMBINE( seed, screenSurfaceCreateInfoQNX.context ); 13637 VULKAN_HPP_HASH_COMBINE( seed, screenSurfaceCreateInfoQNX.window ); 13638 return seed; 13639 } 13640 }; 13641 # endif /*VK_USE_PLATFORM_SCREEN_QNX*/ 13642 13643 template <> 13644 struct hash<VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo> 13645 { operator ()std::hash13646 std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo const & semaphoreCreateInfo ) const VULKAN_HPP_NOEXCEPT 13647 { 13648 std::size_t seed = 0; 13649 VULKAN_HPP_HASH_COMBINE( seed, semaphoreCreateInfo.sType ); 13650 VULKAN_HPP_HASH_COMBINE( seed, semaphoreCreateInfo.pNext ); 13651 VULKAN_HPP_HASH_COMBINE( seed, semaphoreCreateInfo.flags ); 13652 return seed; 13653 } 13654 }; 13655 13656 template <> 13657 struct hash<VULKAN_HPP_NAMESPACE::SemaphoreGetFdInfoKHR> 13658 { operator ()std::hash13659 std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreGetFdInfoKHR const & semaphoreGetFdInfoKHR ) const VULKAN_HPP_NOEXCEPT 13660 { 13661 std::size_t seed = 0; 13662 VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetFdInfoKHR.sType ); 13663 VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetFdInfoKHR.pNext ); 13664 VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetFdInfoKHR.semaphore ); 13665 VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetFdInfoKHR.handleType ); 13666 return seed; 13667 } 13668 }; 13669 13670 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 13671 template <> 13672 struct hash<VULKAN_HPP_NAMESPACE::SemaphoreGetWin32HandleInfoKHR> 13673 { operator ()std::hash13674 std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreGetWin32HandleInfoKHR const & semaphoreGetWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT 13675 { 13676 std::size_t seed = 0; 13677 VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetWin32HandleInfoKHR.sType ); 13678 VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetWin32HandleInfoKHR.pNext ); 13679 VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetWin32HandleInfoKHR.semaphore ); 13680 VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetWin32HandleInfoKHR.handleType ); 13681 return seed; 13682 } 13683 }; 13684 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 13685 13686 # if defined( VK_USE_PLATFORM_FUCHSIA ) 13687 template <> 13688 struct hash<VULKAN_HPP_NAMESPACE::SemaphoreGetZirconHandleInfoFUCHSIA> 13689 { operator ()std::hash13690 std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreGetZirconHandleInfoFUCHSIA const & semaphoreGetZirconHandleInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT 13691 { 13692 std::size_t seed = 0; 13693 VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetZirconHandleInfoFUCHSIA.sType ); 13694 VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetZirconHandleInfoFUCHSIA.pNext ); 13695 VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetZirconHandleInfoFUCHSIA.semaphore ); 13696 VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetZirconHandleInfoFUCHSIA.handleType ); 13697 return seed; 13698 } 13699 }; 13700 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 13701 13702 template <> 13703 struct hash<VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo> 13704 { operator ()std::hash13705 std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo const & semaphoreSignalInfo ) const VULKAN_HPP_NOEXCEPT 13706 { 13707 std::size_t seed = 0; 13708 VULKAN_HPP_HASH_COMBINE( seed, semaphoreSignalInfo.sType ); 13709 VULKAN_HPP_HASH_COMBINE( seed, semaphoreSignalInfo.pNext ); 13710 VULKAN_HPP_HASH_COMBINE( seed, semaphoreSignalInfo.semaphore ); 13711 VULKAN_HPP_HASH_COMBINE( seed, semaphoreSignalInfo.value ); 13712 return seed; 13713 } 13714 }; 13715 13716 template <> 13717 struct hash<VULKAN_HPP_NAMESPACE::SemaphoreSubmitInfo> 13718 { operator ()std::hash13719 std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreSubmitInfo const & semaphoreSubmitInfo ) const VULKAN_HPP_NOEXCEPT 13720 { 13721 std::size_t seed = 0; 13722 VULKAN_HPP_HASH_COMBINE( seed, semaphoreSubmitInfo.sType ); 13723 VULKAN_HPP_HASH_COMBINE( seed, semaphoreSubmitInfo.pNext ); 13724 VULKAN_HPP_HASH_COMBINE( seed, semaphoreSubmitInfo.semaphore ); 13725 VULKAN_HPP_HASH_COMBINE( seed, semaphoreSubmitInfo.value ); 13726 VULKAN_HPP_HASH_COMBINE( seed, semaphoreSubmitInfo.stageMask ); 13727 VULKAN_HPP_HASH_COMBINE( seed, semaphoreSubmitInfo.deviceIndex ); 13728 return seed; 13729 } 13730 }; 13731 13732 template <> 13733 struct hash<VULKAN_HPP_NAMESPACE::SemaphoreTypeCreateInfo> 13734 { operator ()std::hash13735 std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreTypeCreateInfo const & semaphoreTypeCreateInfo ) const VULKAN_HPP_NOEXCEPT 13736 { 13737 std::size_t seed = 0; 13738 VULKAN_HPP_HASH_COMBINE( seed, semaphoreTypeCreateInfo.sType ); 13739 VULKAN_HPP_HASH_COMBINE( seed, semaphoreTypeCreateInfo.pNext ); 13740 VULKAN_HPP_HASH_COMBINE( seed, semaphoreTypeCreateInfo.semaphoreType ); 13741 VULKAN_HPP_HASH_COMBINE( seed, semaphoreTypeCreateInfo.initialValue ); 13742 return seed; 13743 } 13744 }; 13745 13746 template <> 13747 struct hash<VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo> 13748 { operator ()std::hash13749 std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo const & semaphoreWaitInfo ) const VULKAN_HPP_NOEXCEPT 13750 { 13751 std::size_t seed = 0; 13752 VULKAN_HPP_HASH_COMBINE( seed, semaphoreWaitInfo.sType ); 13753 VULKAN_HPP_HASH_COMBINE( seed, semaphoreWaitInfo.pNext ); 13754 VULKAN_HPP_HASH_COMBINE( seed, semaphoreWaitInfo.flags ); 13755 VULKAN_HPP_HASH_COMBINE( seed, semaphoreWaitInfo.semaphoreCount ); 13756 VULKAN_HPP_HASH_COMBINE( seed, semaphoreWaitInfo.pSemaphores ); 13757 VULKAN_HPP_HASH_COMBINE( seed, semaphoreWaitInfo.pValues ); 13758 return seed; 13759 } 13760 }; 13761 13762 template <> 13763 struct hash<VULKAN_HPP_NAMESPACE::SetLatencyMarkerInfoNV> 13764 { operator ()std::hash13765 std::size_t operator()( VULKAN_HPP_NAMESPACE::SetLatencyMarkerInfoNV const & setLatencyMarkerInfoNV ) const VULKAN_HPP_NOEXCEPT 13766 { 13767 std::size_t seed = 0; 13768 VULKAN_HPP_HASH_COMBINE( seed, setLatencyMarkerInfoNV.sType ); 13769 VULKAN_HPP_HASH_COMBINE( seed, setLatencyMarkerInfoNV.pNext ); 13770 VULKAN_HPP_HASH_COMBINE( seed, setLatencyMarkerInfoNV.presentID ); 13771 VULKAN_HPP_HASH_COMBINE( seed, setLatencyMarkerInfoNV.marker ); 13772 return seed; 13773 } 13774 }; 13775 13776 template <> 13777 struct hash<VULKAN_HPP_NAMESPACE::SetStateFlagsIndirectCommandNV> 13778 { operator ()std::hash13779 std::size_t operator()( VULKAN_HPP_NAMESPACE::SetStateFlagsIndirectCommandNV const & setStateFlagsIndirectCommandNV ) const VULKAN_HPP_NOEXCEPT 13780 { 13781 std::size_t seed = 0; 13782 VULKAN_HPP_HASH_COMBINE( seed, setStateFlagsIndirectCommandNV.data ); 13783 return seed; 13784 } 13785 }; 13786 13787 template <> 13788 struct hash<VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT> 13789 { operator ()std::hash13790 std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT const & shaderCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 13791 { 13792 std::size_t seed = 0; 13793 VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.sType ); 13794 VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.pNext ); 13795 VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.flags ); 13796 VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.stage ); 13797 VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.nextStage ); 13798 VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.codeType ); 13799 VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.codeSize ); 13800 VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.pCode ); 13801 for ( const char * p = shaderCreateInfoEXT.pName; *p != '\0'; ++p ) 13802 { 13803 VULKAN_HPP_HASH_COMBINE( seed, *p ); 13804 } 13805 VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.setLayoutCount ); 13806 VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.pSetLayouts ); 13807 VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.pushConstantRangeCount ); 13808 VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.pPushConstantRanges ); 13809 VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.pSpecializationInfo ); 13810 return seed; 13811 } 13812 }; 13813 13814 template <> 13815 struct hash<VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo> 13816 { operator ()std::hash13817 std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo const & shaderModuleCreateInfo ) const VULKAN_HPP_NOEXCEPT 13818 { 13819 std::size_t seed = 0; 13820 VULKAN_HPP_HASH_COMBINE( seed, shaderModuleCreateInfo.sType ); 13821 VULKAN_HPP_HASH_COMBINE( seed, shaderModuleCreateInfo.pNext ); 13822 VULKAN_HPP_HASH_COMBINE( seed, shaderModuleCreateInfo.flags ); 13823 VULKAN_HPP_HASH_COMBINE( seed, shaderModuleCreateInfo.codeSize ); 13824 VULKAN_HPP_HASH_COMBINE( seed, shaderModuleCreateInfo.pCode ); 13825 return seed; 13826 } 13827 }; 13828 13829 template <> 13830 struct hash<VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT> 13831 { operator ()std::hash13832 std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT const & shaderModuleIdentifierEXT ) const VULKAN_HPP_NOEXCEPT 13833 { 13834 std::size_t seed = 0; 13835 VULKAN_HPP_HASH_COMBINE( seed, shaderModuleIdentifierEXT.sType ); 13836 VULKAN_HPP_HASH_COMBINE( seed, shaderModuleIdentifierEXT.pNext ); 13837 VULKAN_HPP_HASH_COMBINE( seed, shaderModuleIdentifierEXT.identifierSize ); 13838 for ( size_t i = 0; i < VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT; ++i ) 13839 { 13840 VULKAN_HPP_HASH_COMBINE( seed, shaderModuleIdentifierEXT.identifier[i] ); 13841 } 13842 return seed; 13843 } 13844 }; 13845 13846 template <> 13847 struct hash<VULKAN_HPP_NAMESPACE::ShaderModuleValidationCacheCreateInfoEXT> 13848 { 13849 std::size_t operator ()std::hash13850 operator()( VULKAN_HPP_NAMESPACE::ShaderModuleValidationCacheCreateInfoEXT const & shaderModuleValidationCacheCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 13851 { 13852 std::size_t seed = 0; 13853 VULKAN_HPP_HASH_COMBINE( seed, shaderModuleValidationCacheCreateInfoEXT.sType ); 13854 VULKAN_HPP_HASH_COMBINE( seed, shaderModuleValidationCacheCreateInfoEXT.pNext ); 13855 VULKAN_HPP_HASH_COMBINE( seed, shaderModuleValidationCacheCreateInfoEXT.validationCache ); 13856 return seed; 13857 } 13858 }; 13859 13860 template <> 13861 struct hash<VULKAN_HPP_NAMESPACE::ShaderResourceUsageAMD> 13862 { operator ()std::hash13863 std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderResourceUsageAMD const & shaderResourceUsageAMD ) const VULKAN_HPP_NOEXCEPT 13864 { 13865 std::size_t seed = 0; 13866 VULKAN_HPP_HASH_COMBINE( seed, shaderResourceUsageAMD.numUsedVgprs ); 13867 VULKAN_HPP_HASH_COMBINE( seed, shaderResourceUsageAMD.numUsedSgprs ); 13868 VULKAN_HPP_HASH_COMBINE( seed, shaderResourceUsageAMD.ldsSizePerLocalWorkGroup ); 13869 VULKAN_HPP_HASH_COMBINE( seed, shaderResourceUsageAMD.ldsUsageSizeInBytes ); 13870 VULKAN_HPP_HASH_COMBINE( seed, shaderResourceUsageAMD.scratchMemUsageInBytes ); 13871 return seed; 13872 } 13873 }; 13874 13875 template <> 13876 struct hash<VULKAN_HPP_NAMESPACE::ShaderStatisticsInfoAMD> 13877 { operator ()std::hash13878 std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderStatisticsInfoAMD const & shaderStatisticsInfoAMD ) const VULKAN_HPP_NOEXCEPT 13879 { 13880 std::size_t seed = 0; 13881 VULKAN_HPP_HASH_COMBINE( seed, shaderStatisticsInfoAMD.shaderStageMask ); 13882 VULKAN_HPP_HASH_COMBINE( seed, shaderStatisticsInfoAMD.resourceUsage ); 13883 VULKAN_HPP_HASH_COMBINE( seed, shaderStatisticsInfoAMD.numPhysicalVgprs ); 13884 VULKAN_HPP_HASH_COMBINE( seed, shaderStatisticsInfoAMD.numPhysicalSgprs ); 13885 VULKAN_HPP_HASH_COMBINE( seed, shaderStatisticsInfoAMD.numAvailableVgprs ); 13886 VULKAN_HPP_HASH_COMBINE( seed, shaderStatisticsInfoAMD.numAvailableSgprs ); 13887 for ( size_t i = 0; i < 3; ++i ) 13888 { 13889 VULKAN_HPP_HASH_COMBINE( seed, shaderStatisticsInfoAMD.computeWorkGroupSize[i] ); 13890 } 13891 return seed; 13892 } 13893 }; 13894 13895 template <> 13896 struct hash<VULKAN_HPP_NAMESPACE::SharedPresentSurfaceCapabilitiesKHR> 13897 { operator ()std::hash13898 std::size_t operator()( VULKAN_HPP_NAMESPACE::SharedPresentSurfaceCapabilitiesKHR const & sharedPresentSurfaceCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT 13899 { 13900 std::size_t seed = 0; 13901 VULKAN_HPP_HASH_COMBINE( seed, sharedPresentSurfaceCapabilitiesKHR.sType ); 13902 VULKAN_HPP_HASH_COMBINE( seed, sharedPresentSurfaceCapabilitiesKHR.pNext ); 13903 VULKAN_HPP_HASH_COMBINE( seed, sharedPresentSurfaceCapabilitiesKHR.sharedPresentSupportedUsageFlags ); 13904 return seed; 13905 } 13906 }; 13907 13908 template <> 13909 struct hash<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties> 13910 { operator ()std::hash13911 std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageFormatProperties const & sparseImageFormatProperties ) const VULKAN_HPP_NOEXCEPT 13912 { 13913 std::size_t seed = 0; 13914 VULKAN_HPP_HASH_COMBINE( seed, sparseImageFormatProperties.aspectMask ); 13915 VULKAN_HPP_HASH_COMBINE( seed, sparseImageFormatProperties.imageGranularity ); 13916 VULKAN_HPP_HASH_COMBINE( seed, sparseImageFormatProperties.flags ); 13917 return seed; 13918 } 13919 }; 13920 13921 template <> 13922 struct hash<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2> 13923 { operator ()std::hash13924 std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2 const & sparseImageFormatProperties2 ) const VULKAN_HPP_NOEXCEPT 13925 { 13926 std::size_t seed = 0; 13927 VULKAN_HPP_HASH_COMBINE( seed, sparseImageFormatProperties2.sType ); 13928 VULKAN_HPP_HASH_COMBINE( seed, sparseImageFormatProperties2.pNext ); 13929 VULKAN_HPP_HASH_COMBINE( seed, sparseImageFormatProperties2.properties ); 13930 return seed; 13931 } 13932 }; 13933 13934 template <> 13935 struct hash<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements> 13936 { operator ()std::hash13937 std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements const & sparseImageMemoryRequirements ) const VULKAN_HPP_NOEXCEPT 13938 { 13939 std::size_t seed = 0; 13940 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryRequirements.formatProperties ); 13941 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryRequirements.imageMipTailFirstLod ); 13942 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryRequirements.imageMipTailSize ); 13943 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryRequirements.imageMipTailOffset ); 13944 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryRequirements.imageMipTailStride ); 13945 return seed; 13946 } 13947 }; 13948 13949 template <> 13950 struct hash<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2> 13951 { operator ()std::hash13952 std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 const & sparseImageMemoryRequirements2 ) const VULKAN_HPP_NOEXCEPT 13953 { 13954 std::size_t seed = 0; 13955 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryRequirements2.sType ); 13956 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryRequirements2.pNext ); 13957 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryRequirements2.memoryRequirements ); 13958 return seed; 13959 } 13960 }; 13961 13962 # if defined( VK_USE_PLATFORM_GGP ) 13963 template <> 13964 struct hash<VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP> 13965 { operator ()std::hash13966 std::size_t operator()( VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP const & streamDescriptorSurfaceCreateInfoGGP ) const VULKAN_HPP_NOEXCEPT 13967 { 13968 std::size_t seed = 0; 13969 VULKAN_HPP_HASH_COMBINE( seed, streamDescriptorSurfaceCreateInfoGGP.sType ); 13970 VULKAN_HPP_HASH_COMBINE( seed, streamDescriptorSurfaceCreateInfoGGP.pNext ); 13971 VULKAN_HPP_HASH_COMBINE( seed, streamDescriptorSurfaceCreateInfoGGP.flags ); 13972 VULKAN_HPP_HASH_COMBINE( seed, streamDescriptorSurfaceCreateInfoGGP.streamDescriptor ); 13973 return seed; 13974 } 13975 }; 13976 # endif /*VK_USE_PLATFORM_GGP*/ 13977 13978 template <> 13979 struct hash<VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR> 13980 { operator ()std::hash13981 std::size_t operator()( VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR const & stridedDeviceAddressRegionKHR ) const VULKAN_HPP_NOEXCEPT 13982 { 13983 std::size_t seed = 0; 13984 VULKAN_HPP_HASH_COMBINE( seed, stridedDeviceAddressRegionKHR.deviceAddress ); 13985 VULKAN_HPP_HASH_COMBINE( seed, stridedDeviceAddressRegionKHR.stride ); 13986 VULKAN_HPP_HASH_COMBINE( seed, stridedDeviceAddressRegionKHR.size ); 13987 return seed; 13988 } 13989 }; 13990 13991 template <> 13992 struct hash<VULKAN_HPP_NAMESPACE::SubmitInfo> 13993 { operator ()std::hash13994 std::size_t operator()( VULKAN_HPP_NAMESPACE::SubmitInfo const & submitInfo ) const VULKAN_HPP_NOEXCEPT 13995 { 13996 std::size_t seed = 0; 13997 VULKAN_HPP_HASH_COMBINE( seed, submitInfo.sType ); 13998 VULKAN_HPP_HASH_COMBINE( seed, submitInfo.pNext ); 13999 VULKAN_HPP_HASH_COMBINE( seed, submitInfo.waitSemaphoreCount ); 14000 VULKAN_HPP_HASH_COMBINE( seed, submitInfo.pWaitSemaphores ); 14001 VULKAN_HPP_HASH_COMBINE( seed, submitInfo.pWaitDstStageMask ); 14002 VULKAN_HPP_HASH_COMBINE( seed, submitInfo.commandBufferCount ); 14003 VULKAN_HPP_HASH_COMBINE( seed, submitInfo.pCommandBuffers ); 14004 VULKAN_HPP_HASH_COMBINE( seed, submitInfo.signalSemaphoreCount ); 14005 VULKAN_HPP_HASH_COMBINE( seed, submitInfo.pSignalSemaphores ); 14006 return seed; 14007 } 14008 }; 14009 14010 template <> 14011 struct hash<VULKAN_HPP_NAMESPACE::SubmitInfo2> 14012 { operator ()std::hash14013 std::size_t operator()( VULKAN_HPP_NAMESPACE::SubmitInfo2 const & submitInfo2 ) const VULKAN_HPP_NOEXCEPT 14014 { 14015 std::size_t seed = 0; 14016 VULKAN_HPP_HASH_COMBINE( seed, submitInfo2.sType ); 14017 VULKAN_HPP_HASH_COMBINE( seed, submitInfo2.pNext ); 14018 VULKAN_HPP_HASH_COMBINE( seed, submitInfo2.flags ); 14019 VULKAN_HPP_HASH_COMBINE( seed, submitInfo2.waitSemaphoreInfoCount ); 14020 VULKAN_HPP_HASH_COMBINE( seed, submitInfo2.pWaitSemaphoreInfos ); 14021 VULKAN_HPP_HASH_COMBINE( seed, submitInfo2.commandBufferInfoCount ); 14022 VULKAN_HPP_HASH_COMBINE( seed, submitInfo2.pCommandBufferInfos ); 14023 VULKAN_HPP_HASH_COMBINE( seed, submitInfo2.signalSemaphoreInfoCount ); 14024 VULKAN_HPP_HASH_COMBINE( seed, submitInfo2.pSignalSemaphoreInfos ); 14025 return seed; 14026 } 14027 }; 14028 14029 template <> 14030 struct hash<VULKAN_HPP_NAMESPACE::SubpassBeginInfo> 14031 { operator ()std::hash14032 std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassBeginInfo const & subpassBeginInfo ) const VULKAN_HPP_NOEXCEPT 14033 { 14034 std::size_t seed = 0; 14035 VULKAN_HPP_HASH_COMBINE( seed, subpassBeginInfo.sType ); 14036 VULKAN_HPP_HASH_COMBINE( seed, subpassBeginInfo.pNext ); 14037 VULKAN_HPP_HASH_COMBINE( seed, subpassBeginInfo.contents ); 14038 return seed; 14039 } 14040 }; 14041 14042 template <> 14043 struct hash<VULKAN_HPP_NAMESPACE::SubpassDescriptionDepthStencilResolve> 14044 { 14045 std::size_t operator ()std::hash14046 operator()( VULKAN_HPP_NAMESPACE::SubpassDescriptionDepthStencilResolve const & subpassDescriptionDepthStencilResolve ) const VULKAN_HPP_NOEXCEPT 14047 { 14048 std::size_t seed = 0; 14049 VULKAN_HPP_HASH_COMBINE( seed, subpassDescriptionDepthStencilResolve.sType ); 14050 VULKAN_HPP_HASH_COMBINE( seed, subpassDescriptionDepthStencilResolve.pNext ); 14051 VULKAN_HPP_HASH_COMBINE( seed, subpassDescriptionDepthStencilResolve.depthResolveMode ); 14052 VULKAN_HPP_HASH_COMBINE( seed, subpassDescriptionDepthStencilResolve.stencilResolveMode ); 14053 VULKAN_HPP_HASH_COMBINE( seed, subpassDescriptionDepthStencilResolve.pDepthStencilResolveAttachment ); 14054 return seed; 14055 } 14056 }; 14057 14058 template <> 14059 struct hash<VULKAN_HPP_NAMESPACE::SubpassEndInfo> 14060 { operator ()std::hash14061 std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassEndInfo const & subpassEndInfo ) const VULKAN_HPP_NOEXCEPT 14062 { 14063 std::size_t seed = 0; 14064 VULKAN_HPP_HASH_COMBINE( seed, subpassEndInfo.sType ); 14065 VULKAN_HPP_HASH_COMBINE( seed, subpassEndInfo.pNext ); 14066 return seed; 14067 } 14068 }; 14069 14070 template <> 14071 struct hash<VULKAN_HPP_NAMESPACE::SubpassFragmentDensityMapOffsetEndInfoQCOM> 14072 { operator ()std::hash14073 std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassFragmentDensityMapOffsetEndInfoQCOM const & subpassFragmentDensityMapOffsetEndInfoQCOM ) const 14074 VULKAN_HPP_NOEXCEPT 14075 { 14076 std::size_t seed = 0; 14077 VULKAN_HPP_HASH_COMBINE( seed, subpassFragmentDensityMapOffsetEndInfoQCOM.sType ); 14078 VULKAN_HPP_HASH_COMBINE( seed, subpassFragmentDensityMapOffsetEndInfoQCOM.pNext ); 14079 VULKAN_HPP_HASH_COMBINE( seed, subpassFragmentDensityMapOffsetEndInfoQCOM.fragmentDensityOffsetCount ); 14080 VULKAN_HPP_HASH_COMBINE( seed, subpassFragmentDensityMapOffsetEndInfoQCOM.pFragmentDensityOffsets ); 14081 return seed; 14082 } 14083 }; 14084 14085 template <> 14086 struct hash<VULKAN_HPP_NAMESPACE::SubpassResolvePerformanceQueryEXT> 14087 { operator ()std::hash14088 std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassResolvePerformanceQueryEXT const & subpassResolvePerformanceQueryEXT ) const VULKAN_HPP_NOEXCEPT 14089 { 14090 std::size_t seed = 0; 14091 VULKAN_HPP_HASH_COMBINE( seed, subpassResolvePerformanceQueryEXT.sType ); 14092 VULKAN_HPP_HASH_COMBINE( seed, subpassResolvePerformanceQueryEXT.pNext ); 14093 VULKAN_HPP_HASH_COMBINE( seed, subpassResolvePerformanceQueryEXT.optimal ); 14094 return seed; 14095 } 14096 }; 14097 14098 template <> 14099 struct hash<VULKAN_HPP_NAMESPACE::SubpassShadingPipelineCreateInfoHUAWEI> 14100 { 14101 std::size_t operator ()std::hash14102 operator()( VULKAN_HPP_NAMESPACE::SubpassShadingPipelineCreateInfoHUAWEI const & subpassShadingPipelineCreateInfoHUAWEI ) const VULKAN_HPP_NOEXCEPT 14103 { 14104 std::size_t seed = 0; 14105 VULKAN_HPP_HASH_COMBINE( seed, subpassShadingPipelineCreateInfoHUAWEI.sType ); 14106 VULKAN_HPP_HASH_COMBINE( seed, subpassShadingPipelineCreateInfoHUAWEI.pNext ); 14107 VULKAN_HPP_HASH_COMBINE( seed, subpassShadingPipelineCreateInfoHUAWEI.renderPass ); 14108 VULKAN_HPP_HASH_COMBINE( seed, subpassShadingPipelineCreateInfoHUAWEI.subpass ); 14109 return seed; 14110 } 14111 }; 14112 14113 template <> 14114 struct hash<VULKAN_HPP_NAMESPACE::SubresourceHostMemcpySizeEXT> 14115 { operator ()std::hash14116 std::size_t operator()( VULKAN_HPP_NAMESPACE::SubresourceHostMemcpySizeEXT const & subresourceHostMemcpySizeEXT ) const VULKAN_HPP_NOEXCEPT 14117 { 14118 std::size_t seed = 0; 14119 VULKAN_HPP_HASH_COMBINE( seed, subresourceHostMemcpySizeEXT.sType ); 14120 VULKAN_HPP_HASH_COMBINE( seed, subresourceHostMemcpySizeEXT.pNext ); 14121 VULKAN_HPP_HASH_COMBINE( seed, subresourceHostMemcpySizeEXT.size ); 14122 return seed; 14123 } 14124 }; 14125 14126 template <> 14127 struct hash<VULKAN_HPP_NAMESPACE::SubresourceLayout2KHR> 14128 { operator ()std::hash14129 std::size_t operator()( VULKAN_HPP_NAMESPACE::SubresourceLayout2KHR const & subresourceLayout2KHR ) const VULKAN_HPP_NOEXCEPT 14130 { 14131 std::size_t seed = 0; 14132 VULKAN_HPP_HASH_COMBINE( seed, subresourceLayout2KHR.sType ); 14133 VULKAN_HPP_HASH_COMBINE( seed, subresourceLayout2KHR.pNext ); 14134 VULKAN_HPP_HASH_COMBINE( seed, subresourceLayout2KHR.subresourceLayout ); 14135 return seed; 14136 } 14137 }; 14138 14139 template <> 14140 struct hash<VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT> 14141 { operator ()std::hash14142 std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT const & surfaceCapabilities2EXT ) const VULKAN_HPP_NOEXCEPT 14143 { 14144 std::size_t seed = 0; 14145 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.sType ); 14146 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.pNext ); 14147 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.minImageCount ); 14148 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.maxImageCount ); 14149 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.currentExtent ); 14150 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.minImageExtent ); 14151 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.maxImageExtent ); 14152 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.maxImageArrayLayers ); 14153 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.supportedTransforms ); 14154 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.currentTransform ); 14155 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.supportedCompositeAlpha ); 14156 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.supportedUsageFlags ); 14157 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.supportedSurfaceCounters ); 14158 return seed; 14159 } 14160 }; 14161 14162 template <> 14163 struct hash<VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR> 14164 { operator ()std::hash14165 std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR const & surfaceCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT 14166 { 14167 std::size_t seed = 0; 14168 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.minImageCount ); 14169 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.maxImageCount ); 14170 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.currentExtent ); 14171 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.minImageExtent ); 14172 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.maxImageExtent ); 14173 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.maxImageArrayLayers ); 14174 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.supportedTransforms ); 14175 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.currentTransform ); 14176 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.supportedCompositeAlpha ); 14177 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.supportedUsageFlags ); 14178 return seed; 14179 } 14180 }; 14181 14182 template <> 14183 struct hash<VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR> 14184 { operator ()std::hash14185 std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR const & surfaceCapabilities2KHR ) const VULKAN_HPP_NOEXCEPT 14186 { 14187 std::size_t seed = 0; 14188 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2KHR.sType ); 14189 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2KHR.pNext ); 14190 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2KHR.surfaceCapabilities ); 14191 return seed; 14192 } 14193 }; 14194 14195 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 14196 template <> 14197 struct hash<VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesFullScreenExclusiveEXT> 14198 { 14199 std::size_t operator ()std::hash14200 operator()( VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesFullScreenExclusiveEXT const & surfaceCapabilitiesFullScreenExclusiveEXT ) const VULKAN_HPP_NOEXCEPT 14201 { 14202 std::size_t seed = 0; 14203 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesFullScreenExclusiveEXT.sType ); 14204 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesFullScreenExclusiveEXT.pNext ); 14205 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesFullScreenExclusiveEXT.fullScreenExclusiveSupported ); 14206 return seed; 14207 } 14208 }; 14209 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 14210 14211 template <> 14212 struct hash<VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesPresentBarrierNV> 14213 { operator ()std::hash14214 std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesPresentBarrierNV const & surfaceCapabilitiesPresentBarrierNV ) const VULKAN_HPP_NOEXCEPT 14215 { 14216 std::size_t seed = 0; 14217 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesPresentBarrierNV.sType ); 14218 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesPresentBarrierNV.pNext ); 14219 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesPresentBarrierNV.presentBarrierSupported ); 14220 return seed; 14221 } 14222 }; 14223 14224 template <> 14225 struct hash<VULKAN_HPP_NAMESPACE::SurfaceFormatKHR> 14226 { operator ()std::hash14227 std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceFormatKHR const & surfaceFormatKHR ) const VULKAN_HPP_NOEXCEPT 14228 { 14229 std::size_t seed = 0; 14230 VULKAN_HPP_HASH_COMBINE( seed, surfaceFormatKHR.format ); 14231 VULKAN_HPP_HASH_COMBINE( seed, surfaceFormatKHR.colorSpace ); 14232 return seed; 14233 } 14234 }; 14235 14236 template <> 14237 struct hash<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR> 14238 { operator ()std::hash14239 std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR const & surfaceFormat2KHR ) const VULKAN_HPP_NOEXCEPT 14240 { 14241 std::size_t seed = 0; 14242 VULKAN_HPP_HASH_COMBINE( seed, surfaceFormat2KHR.sType ); 14243 VULKAN_HPP_HASH_COMBINE( seed, surfaceFormat2KHR.pNext ); 14244 VULKAN_HPP_HASH_COMBINE( seed, surfaceFormat2KHR.surfaceFormat ); 14245 return seed; 14246 } 14247 }; 14248 14249 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 14250 template <> 14251 struct hash<VULKAN_HPP_NAMESPACE::SurfaceFullScreenExclusiveInfoEXT> 14252 { operator ()std::hash14253 std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceFullScreenExclusiveInfoEXT const & surfaceFullScreenExclusiveInfoEXT ) const VULKAN_HPP_NOEXCEPT 14254 { 14255 std::size_t seed = 0; 14256 VULKAN_HPP_HASH_COMBINE( seed, surfaceFullScreenExclusiveInfoEXT.sType ); 14257 VULKAN_HPP_HASH_COMBINE( seed, surfaceFullScreenExclusiveInfoEXT.pNext ); 14258 VULKAN_HPP_HASH_COMBINE( seed, surfaceFullScreenExclusiveInfoEXT.fullScreenExclusive ); 14259 return seed; 14260 } 14261 }; 14262 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 14263 14264 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 14265 template <> 14266 struct hash<VULKAN_HPP_NAMESPACE::SurfaceFullScreenExclusiveWin32InfoEXT> 14267 { 14268 std::size_t operator ()std::hash14269 operator()( VULKAN_HPP_NAMESPACE::SurfaceFullScreenExclusiveWin32InfoEXT const & surfaceFullScreenExclusiveWin32InfoEXT ) const VULKAN_HPP_NOEXCEPT 14270 { 14271 std::size_t seed = 0; 14272 VULKAN_HPP_HASH_COMBINE( seed, surfaceFullScreenExclusiveWin32InfoEXT.sType ); 14273 VULKAN_HPP_HASH_COMBINE( seed, surfaceFullScreenExclusiveWin32InfoEXT.pNext ); 14274 VULKAN_HPP_HASH_COMBINE( seed, surfaceFullScreenExclusiveWin32InfoEXT.hmonitor ); 14275 return seed; 14276 } 14277 }; 14278 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 14279 14280 template <> 14281 struct hash<VULKAN_HPP_NAMESPACE::SurfacePresentModeCompatibilityEXT> 14282 { operator ()std::hash14283 std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfacePresentModeCompatibilityEXT const & surfacePresentModeCompatibilityEXT ) const VULKAN_HPP_NOEXCEPT 14284 { 14285 std::size_t seed = 0; 14286 VULKAN_HPP_HASH_COMBINE( seed, surfacePresentModeCompatibilityEXT.sType ); 14287 VULKAN_HPP_HASH_COMBINE( seed, surfacePresentModeCompatibilityEXT.pNext ); 14288 VULKAN_HPP_HASH_COMBINE( seed, surfacePresentModeCompatibilityEXT.presentModeCount ); 14289 VULKAN_HPP_HASH_COMBINE( seed, surfacePresentModeCompatibilityEXT.pPresentModes ); 14290 return seed; 14291 } 14292 }; 14293 14294 template <> 14295 struct hash<VULKAN_HPP_NAMESPACE::SurfacePresentModeEXT> 14296 { operator ()std::hash14297 std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfacePresentModeEXT const & surfacePresentModeEXT ) const VULKAN_HPP_NOEXCEPT 14298 { 14299 std::size_t seed = 0; 14300 VULKAN_HPP_HASH_COMBINE( seed, surfacePresentModeEXT.sType ); 14301 VULKAN_HPP_HASH_COMBINE( seed, surfacePresentModeEXT.pNext ); 14302 VULKAN_HPP_HASH_COMBINE( seed, surfacePresentModeEXT.presentMode ); 14303 return seed; 14304 } 14305 }; 14306 14307 template <> 14308 struct hash<VULKAN_HPP_NAMESPACE::SurfacePresentScalingCapabilitiesEXT> 14309 { operator ()std::hash14310 std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfacePresentScalingCapabilitiesEXT const & surfacePresentScalingCapabilitiesEXT ) const VULKAN_HPP_NOEXCEPT 14311 { 14312 std::size_t seed = 0; 14313 VULKAN_HPP_HASH_COMBINE( seed, surfacePresentScalingCapabilitiesEXT.sType ); 14314 VULKAN_HPP_HASH_COMBINE( seed, surfacePresentScalingCapabilitiesEXT.pNext ); 14315 VULKAN_HPP_HASH_COMBINE( seed, surfacePresentScalingCapabilitiesEXT.supportedPresentScaling ); 14316 VULKAN_HPP_HASH_COMBINE( seed, surfacePresentScalingCapabilitiesEXT.supportedPresentGravityX ); 14317 VULKAN_HPP_HASH_COMBINE( seed, surfacePresentScalingCapabilitiesEXT.supportedPresentGravityY ); 14318 VULKAN_HPP_HASH_COMBINE( seed, surfacePresentScalingCapabilitiesEXT.minScaledImageExtent ); 14319 VULKAN_HPP_HASH_COMBINE( seed, surfacePresentScalingCapabilitiesEXT.maxScaledImageExtent ); 14320 return seed; 14321 } 14322 }; 14323 14324 template <> 14325 struct hash<VULKAN_HPP_NAMESPACE::SurfaceProtectedCapabilitiesKHR> 14326 { operator ()std::hash14327 std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceProtectedCapabilitiesKHR const & surfaceProtectedCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT 14328 { 14329 std::size_t seed = 0; 14330 VULKAN_HPP_HASH_COMBINE( seed, surfaceProtectedCapabilitiesKHR.sType ); 14331 VULKAN_HPP_HASH_COMBINE( seed, surfaceProtectedCapabilitiesKHR.pNext ); 14332 VULKAN_HPP_HASH_COMBINE( seed, surfaceProtectedCapabilitiesKHR.supportsProtected ); 14333 return seed; 14334 } 14335 }; 14336 14337 template <> 14338 struct hash<VULKAN_HPP_NAMESPACE::SwapchainCounterCreateInfoEXT> 14339 { operator ()std::hash14340 std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainCounterCreateInfoEXT const & swapchainCounterCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 14341 { 14342 std::size_t seed = 0; 14343 VULKAN_HPP_HASH_COMBINE( seed, swapchainCounterCreateInfoEXT.sType ); 14344 VULKAN_HPP_HASH_COMBINE( seed, swapchainCounterCreateInfoEXT.pNext ); 14345 VULKAN_HPP_HASH_COMBINE( seed, swapchainCounterCreateInfoEXT.surfaceCounters ); 14346 return seed; 14347 } 14348 }; 14349 14350 template <> 14351 struct hash<VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> 14352 { operator ()std::hash14353 std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR const & swapchainCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 14354 { 14355 std::size_t seed = 0; 14356 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.sType ); 14357 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.pNext ); 14358 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.flags ); 14359 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.surface ); 14360 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.minImageCount ); 14361 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.imageFormat ); 14362 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.imageColorSpace ); 14363 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.imageExtent ); 14364 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.imageArrayLayers ); 14365 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.imageUsage ); 14366 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.imageSharingMode ); 14367 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.queueFamilyIndexCount ); 14368 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.pQueueFamilyIndices ); 14369 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.preTransform ); 14370 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.compositeAlpha ); 14371 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.presentMode ); 14372 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.clipped ); 14373 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.oldSwapchain ); 14374 return seed; 14375 } 14376 }; 14377 14378 template <> 14379 struct hash<VULKAN_HPP_NAMESPACE::SwapchainDisplayNativeHdrCreateInfoAMD> 14380 { 14381 std::size_t operator ()std::hash14382 operator()( VULKAN_HPP_NAMESPACE::SwapchainDisplayNativeHdrCreateInfoAMD const & swapchainDisplayNativeHdrCreateInfoAMD ) const VULKAN_HPP_NOEXCEPT 14383 { 14384 std::size_t seed = 0; 14385 VULKAN_HPP_HASH_COMBINE( seed, swapchainDisplayNativeHdrCreateInfoAMD.sType ); 14386 VULKAN_HPP_HASH_COMBINE( seed, swapchainDisplayNativeHdrCreateInfoAMD.pNext ); 14387 VULKAN_HPP_HASH_COMBINE( seed, swapchainDisplayNativeHdrCreateInfoAMD.localDimmingEnable ); 14388 return seed; 14389 } 14390 }; 14391 14392 template <> 14393 struct hash<VULKAN_HPP_NAMESPACE::SwapchainLatencyCreateInfoNV> 14394 { operator ()std::hash14395 std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainLatencyCreateInfoNV const & swapchainLatencyCreateInfoNV ) const VULKAN_HPP_NOEXCEPT 14396 { 14397 std::size_t seed = 0; 14398 VULKAN_HPP_HASH_COMBINE( seed, swapchainLatencyCreateInfoNV.sType ); 14399 VULKAN_HPP_HASH_COMBINE( seed, swapchainLatencyCreateInfoNV.pNext ); 14400 VULKAN_HPP_HASH_COMBINE( seed, swapchainLatencyCreateInfoNV.latencyModeEnable ); 14401 return seed; 14402 } 14403 }; 14404 14405 template <> 14406 struct hash<VULKAN_HPP_NAMESPACE::SwapchainPresentBarrierCreateInfoNV> 14407 { operator ()std::hash14408 std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainPresentBarrierCreateInfoNV const & swapchainPresentBarrierCreateInfoNV ) const VULKAN_HPP_NOEXCEPT 14409 { 14410 std::size_t seed = 0; 14411 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentBarrierCreateInfoNV.sType ); 14412 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentBarrierCreateInfoNV.pNext ); 14413 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentBarrierCreateInfoNV.presentBarrierEnable ); 14414 return seed; 14415 } 14416 }; 14417 14418 template <> 14419 struct hash<VULKAN_HPP_NAMESPACE::SwapchainPresentFenceInfoEXT> 14420 { operator ()std::hash14421 std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainPresentFenceInfoEXT const & swapchainPresentFenceInfoEXT ) const VULKAN_HPP_NOEXCEPT 14422 { 14423 std::size_t seed = 0; 14424 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentFenceInfoEXT.sType ); 14425 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentFenceInfoEXT.pNext ); 14426 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentFenceInfoEXT.swapchainCount ); 14427 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentFenceInfoEXT.pFences ); 14428 return seed; 14429 } 14430 }; 14431 14432 template <> 14433 struct hash<VULKAN_HPP_NAMESPACE::SwapchainPresentModeInfoEXT> 14434 { operator ()std::hash14435 std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainPresentModeInfoEXT const & swapchainPresentModeInfoEXT ) const VULKAN_HPP_NOEXCEPT 14436 { 14437 std::size_t seed = 0; 14438 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentModeInfoEXT.sType ); 14439 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentModeInfoEXT.pNext ); 14440 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentModeInfoEXT.swapchainCount ); 14441 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentModeInfoEXT.pPresentModes ); 14442 return seed; 14443 } 14444 }; 14445 14446 template <> 14447 struct hash<VULKAN_HPP_NAMESPACE::SwapchainPresentModesCreateInfoEXT> 14448 { operator ()std::hash14449 std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainPresentModesCreateInfoEXT const & swapchainPresentModesCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 14450 { 14451 std::size_t seed = 0; 14452 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentModesCreateInfoEXT.sType ); 14453 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentModesCreateInfoEXT.pNext ); 14454 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentModesCreateInfoEXT.presentModeCount ); 14455 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentModesCreateInfoEXT.pPresentModes ); 14456 return seed; 14457 } 14458 }; 14459 14460 template <> 14461 struct hash<VULKAN_HPP_NAMESPACE::SwapchainPresentScalingCreateInfoEXT> 14462 { operator ()std::hash14463 std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainPresentScalingCreateInfoEXT const & swapchainPresentScalingCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 14464 { 14465 std::size_t seed = 0; 14466 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentScalingCreateInfoEXT.sType ); 14467 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentScalingCreateInfoEXT.pNext ); 14468 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentScalingCreateInfoEXT.scalingBehavior ); 14469 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentScalingCreateInfoEXT.presentGravityX ); 14470 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentScalingCreateInfoEXT.presentGravityY ); 14471 return seed; 14472 } 14473 }; 14474 14475 template <> 14476 struct hash<VULKAN_HPP_NAMESPACE::TextureLODGatherFormatPropertiesAMD> 14477 { operator ()std::hash14478 std::size_t operator()( VULKAN_HPP_NAMESPACE::TextureLODGatherFormatPropertiesAMD const & textureLODGatherFormatPropertiesAMD ) const VULKAN_HPP_NOEXCEPT 14479 { 14480 std::size_t seed = 0; 14481 VULKAN_HPP_HASH_COMBINE( seed, textureLODGatherFormatPropertiesAMD.sType ); 14482 VULKAN_HPP_HASH_COMBINE( seed, textureLODGatherFormatPropertiesAMD.pNext ); 14483 VULKAN_HPP_HASH_COMBINE( seed, textureLODGatherFormatPropertiesAMD.supportsTextureGatherLODBiasAMD ); 14484 return seed; 14485 } 14486 }; 14487 14488 template <> 14489 struct hash<VULKAN_HPP_NAMESPACE::TilePropertiesQCOM> 14490 { operator ()std::hash14491 std::size_t operator()( VULKAN_HPP_NAMESPACE::TilePropertiesQCOM const & tilePropertiesQCOM ) const VULKAN_HPP_NOEXCEPT 14492 { 14493 std::size_t seed = 0; 14494 VULKAN_HPP_HASH_COMBINE( seed, tilePropertiesQCOM.sType ); 14495 VULKAN_HPP_HASH_COMBINE( seed, tilePropertiesQCOM.pNext ); 14496 VULKAN_HPP_HASH_COMBINE( seed, tilePropertiesQCOM.tileSize ); 14497 VULKAN_HPP_HASH_COMBINE( seed, tilePropertiesQCOM.apronSize ); 14498 VULKAN_HPP_HASH_COMBINE( seed, tilePropertiesQCOM.origin ); 14499 return seed; 14500 } 14501 }; 14502 14503 template <> 14504 struct hash<VULKAN_HPP_NAMESPACE::TimelineSemaphoreSubmitInfo> 14505 { operator ()std::hash14506 std::size_t operator()( VULKAN_HPP_NAMESPACE::TimelineSemaphoreSubmitInfo const & timelineSemaphoreSubmitInfo ) const VULKAN_HPP_NOEXCEPT 14507 { 14508 std::size_t seed = 0; 14509 VULKAN_HPP_HASH_COMBINE( seed, timelineSemaphoreSubmitInfo.sType ); 14510 VULKAN_HPP_HASH_COMBINE( seed, timelineSemaphoreSubmitInfo.pNext ); 14511 VULKAN_HPP_HASH_COMBINE( seed, timelineSemaphoreSubmitInfo.waitSemaphoreValueCount ); 14512 VULKAN_HPP_HASH_COMBINE( seed, timelineSemaphoreSubmitInfo.pWaitSemaphoreValues ); 14513 VULKAN_HPP_HASH_COMBINE( seed, timelineSemaphoreSubmitInfo.signalSemaphoreValueCount ); 14514 VULKAN_HPP_HASH_COMBINE( seed, timelineSemaphoreSubmitInfo.pSignalSemaphoreValues ); 14515 return seed; 14516 } 14517 }; 14518 14519 template <> 14520 struct hash<VULKAN_HPP_NAMESPACE::TraceRaysIndirectCommand2KHR> 14521 { operator ()std::hash14522 std::size_t operator()( VULKAN_HPP_NAMESPACE::TraceRaysIndirectCommand2KHR const & traceRaysIndirectCommand2KHR ) const VULKAN_HPP_NOEXCEPT 14523 { 14524 std::size_t seed = 0; 14525 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.raygenShaderRecordAddress ); 14526 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.raygenShaderRecordSize ); 14527 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.missShaderBindingTableAddress ); 14528 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.missShaderBindingTableSize ); 14529 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.missShaderBindingTableStride ); 14530 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.hitShaderBindingTableAddress ); 14531 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.hitShaderBindingTableSize ); 14532 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.hitShaderBindingTableStride ); 14533 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.callableShaderBindingTableAddress ); 14534 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.callableShaderBindingTableSize ); 14535 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.callableShaderBindingTableStride ); 14536 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.width ); 14537 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.height ); 14538 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.depth ); 14539 return seed; 14540 } 14541 }; 14542 14543 template <> 14544 struct hash<VULKAN_HPP_NAMESPACE::TraceRaysIndirectCommandKHR> 14545 { operator ()std::hash14546 std::size_t operator()( VULKAN_HPP_NAMESPACE::TraceRaysIndirectCommandKHR const & traceRaysIndirectCommandKHR ) const VULKAN_HPP_NOEXCEPT 14547 { 14548 std::size_t seed = 0; 14549 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommandKHR.width ); 14550 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommandKHR.height ); 14551 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommandKHR.depth ); 14552 return seed; 14553 } 14554 }; 14555 14556 template <> 14557 struct hash<VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT> 14558 { operator ()std::hash14559 std::size_t operator()( VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT const & validationCacheCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 14560 { 14561 std::size_t seed = 0; 14562 VULKAN_HPP_HASH_COMBINE( seed, validationCacheCreateInfoEXT.sType ); 14563 VULKAN_HPP_HASH_COMBINE( seed, validationCacheCreateInfoEXT.pNext ); 14564 VULKAN_HPP_HASH_COMBINE( seed, validationCacheCreateInfoEXT.flags ); 14565 VULKAN_HPP_HASH_COMBINE( seed, validationCacheCreateInfoEXT.initialDataSize ); 14566 VULKAN_HPP_HASH_COMBINE( seed, validationCacheCreateInfoEXT.pInitialData ); 14567 return seed; 14568 } 14569 }; 14570 14571 template <> 14572 struct hash<VULKAN_HPP_NAMESPACE::ValidationFeaturesEXT> 14573 { operator ()std::hash14574 std::size_t operator()( VULKAN_HPP_NAMESPACE::ValidationFeaturesEXT const & validationFeaturesEXT ) const VULKAN_HPP_NOEXCEPT 14575 { 14576 std::size_t seed = 0; 14577 VULKAN_HPP_HASH_COMBINE( seed, validationFeaturesEXT.sType ); 14578 VULKAN_HPP_HASH_COMBINE( seed, validationFeaturesEXT.pNext ); 14579 VULKAN_HPP_HASH_COMBINE( seed, validationFeaturesEXT.enabledValidationFeatureCount ); 14580 VULKAN_HPP_HASH_COMBINE( seed, validationFeaturesEXT.pEnabledValidationFeatures ); 14581 VULKAN_HPP_HASH_COMBINE( seed, validationFeaturesEXT.disabledValidationFeatureCount ); 14582 VULKAN_HPP_HASH_COMBINE( seed, validationFeaturesEXT.pDisabledValidationFeatures ); 14583 return seed; 14584 } 14585 }; 14586 14587 template <> 14588 struct hash<VULKAN_HPP_NAMESPACE::ValidationFlagsEXT> 14589 { operator ()std::hash14590 std::size_t operator()( VULKAN_HPP_NAMESPACE::ValidationFlagsEXT const & validationFlagsEXT ) const VULKAN_HPP_NOEXCEPT 14591 { 14592 std::size_t seed = 0; 14593 VULKAN_HPP_HASH_COMBINE( seed, validationFlagsEXT.sType ); 14594 VULKAN_HPP_HASH_COMBINE( seed, validationFlagsEXT.pNext ); 14595 VULKAN_HPP_HASH_COMBINE( seed, validationFlagsEXT.disabledValidationCheckCount ); 14596 VULKAN_HPP_HASH_COMBINE( seed, validationFlagsEXT.pDisabledValidationChecks ); 14597 return seed; 14598 } 14599 }; 14600 14601 template <> 14602 struct hash<VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT> 14603 { operator ()std::hash14604 std::size_t operator()( VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT const & vertexInputAttributeDescription2EXT ) const VULKAN_HPP_NOEXCEPT 14605 { 14606 std::size_t seed = 0; 14607 VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription2EXT.sType ); 14608 VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription2EXT.pNext ); 14609 VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription2EXT.location ); 14610 VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription2EXT.binding ); 14611 VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription2EXT.format ); 14612 VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription2EXT.offset ); 14613 return seed; 14614 } 14615 }; 14616 14617 template <> 14618 struct hash<VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT> 14619 { operator ()std::hash14620 std::size_t operator()( VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT const & vertexInputBindingDescription2EXT ) const VULKAN_HPP_NOEXCEPT 14621 { 14622 std::size_t seed = 0; 14623 VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDescription2EXT.sType ); 14624 VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDescription2EXT.pNext ); 14625 VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDescription2EXT.binding ); 14626 VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDescription2EXT.stride ); 14627 VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDescription2EXT.inputRate ); 14628 VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDescription2EXT.divisor ); 14629 return seed; 14630 } 14631 }; 14632 14633 # if defined( VK_USE_PLATFORM_VI_NN ) 14634 template <> 14635 struct hash<VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN> 14636 { operator ()std::hash14637 std::size_t operator()( VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN const & viSurfaceCreateInfoNN ) const VULKAN_HPP_NOEXCEPT 14638 { 14639 std::size_t seed = 0; 14640 VULKAN_HPP_HASH_COMBINE( seed, viSurfaceCreateInfoNN.sType ); 14641 VULKAN_HPP_HASH_COMBINE( seed, viSurfaceCreateInfoNN.pNext ); 14642 VULKAN_HPP_HASH_COMBINE( seed, viSurfaceCreateInfoNN.flags ); 14643 VULKAN_HPP_HASH_COMBINE( seed, viSurfaceCreateInfoNN.window ); 14644 return seed; 14645 } 14646 }; 14647 # endif /*VK_USE_PLATFORM_VI_NN*/ 14648 14649 template <> 14650 struct hash<VULKAN_HPP_NAMESPACE::VideoPictureResourceInfoKHR> 14651 { operator ()std::hash14652 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoPictureResourceInfoKHR const & videoPictureResourceInfoKHR ) const VULKAN_HPP_NOEXCEPT 14653 { 14654 std::size_t seed = 0; 14655 VULKAN_HPP_HASH_COMBINE( seed, videoPictureResourceInfoKHR.sType ); 14656 VULKAN_HPP_HASH_COMBINE( seed, videoPictureResourceInfoKHR.pNext ); 14657 VULKAN_HPP_HASH_COMBINE( seed, videoPictureResourceInfoKHR.codedOffset ); 14658 VULKAN_HPP_HASH_COMBINE( seed, videoPictureResourceInfoKHR.codedExtent ); 14659 VULKAN_HPP_HASH_COMBINE( seed, videoPictureResourceInfoKHR.baseArrayLayer ); 14660 VULKAN_HPP_HASH_COMBINE( seed, videoPictureResourceInfoKHR.imageViewBinding ); 14661 return seed; 14662 } 14663 }; 14664 14665 template <> 14666 struct hash<VULKAN_HPP_NAMESPACE::VideoReferenceSlotInfoKHR> 14667 { operator ()std::hash14668 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoReferenceSlotInfoKHR const & videoReferenceSlotInfoKHR ) const VULKAN_HPP_NOEXCEPT 14669 { 14670 std::size_t seed = 0; 14671 VULKAN_HPP_HASH_COMBINE( seed, videoReferenceSlotInfoKHR.sType ); 14672 VULKAN_HPP_HASH_COMBINE( seed, videoReferenceSlotInfoKHR.pNext ); 14673 VULKAN_HPP_HASH_COMBINE( seed, videoReferenceSlotInfoKHR.slotIndex ); 14674 VULKAN_HPP_HASH_COMBINE( seed, videoReferenceSlotInfoKHR.pPictureResource ); 14675 return seed; 14676 } 14677 }; 14678 14679 template <> 14680 struct hash<VULKAN_HPP_NAMESPACE::VideoBeginCodingInfoKHR> 14681 { operator ()std::hash14682 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoBeginCodingInfoKHR const & videoBeginCodingInfoKHR ) const VULKAN_HPP_NOEXCEPT 14683 { 14684 std::size_t seed = 0; 14685 VULKAN_HPP_HASH_COMBINE( seed, videoBeginCodingInfoKHR.sType ); 14686 VULKAN_HPP_HASH_COMBINE( seed, videoBeginCodingInfoKHR.pNext ); 14687 VULKAN_HPP_HASH_COMBINE( seed, videoBeginCodingInfoKHR.flags ); 14688 VULKAN_HPP_HASH_COMBINE( seed, videoBeginCodingInfoKHR.videoSession ); 14689 VULKAN_HPP_HASH_COMBINE( seed, videoBeginCodingInfoKHR.videoSessionParameters ); 14690 VULKAN_HPP_HASH_COMBINE( seed, videoBeginCodingInfoKHR.referenceSlotCount ); 14691 VULKAN_HPP_HASH_COMBINE( seed, videoBeginCodingInfoKHR.pReferenceSlots ); 14692 return seed; 14693 } 14694 }; 14695 14696 template <> 14697 struct hash<VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR> 14698 { operator ()std::hash14699 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR const & videoCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT 14700 { 14701 std::size_t seed = 0; 14702 VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.sType ); 14703 VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.pNext ); 14704 VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.flags ); 14705 VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.minBitstreamBufferOffsetAlignment ); 14706 VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.minBitstreamBufferSizeAlignment ); 14707 VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.pictureAccessGranularity ); 14708 VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.minCodedExtent ); 14709 VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.maxCodedExtent ); 14710 VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.maxDpbSlots ); 14711 VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.maxActiveReferencePictures ); 14712 VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.stdHeaderVersion ); 14713 return seed; 14714 } 14715 }; 14716 14717 template <> 14718 struct hash<VULKAN_HPP_NAMESPACE::VideoCodingControlInfoKHR> 14719 { operator ()std::hash14720 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoCodingControlInfoKHR const & videoCodingControlInfoKHR ) const VULKAN_HPP_NOEXCEPT 14721 { 14722 std::size_t seed = 0; 14723 VULKAN_HPP_HASH_COMBINE( seed, videoCodingControlInfoKHR.sType ); 14724 VULKAN_HPP_HASH_COMBINE( seed, videoCodingControlInfoKHR.pNext ); 14725 VULKAN_HPP_HASH_COMBINE( seed, videoCodingControlInfoKHR.flags ); 14726 return seed; 14727 } 14728 }; 14729 14730 template <> 14731 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeCapabilitiesKHR> 14732 { operator ()std::hash14733 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeCapabilitiesKHR const & videoDecodeCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT 14734 { 14735 std::size_t seed = 0; 14736 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeCapabilitiesKHR.sType ); 14737 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeCapabilitiesKHR.pNext ); 14738 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeCapabilitiesKHR.flags ); 14739 return seed; 14740 } 14741 }; 14742 14743 template <> 14744 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH264CapabilitiesKHR> 14745 { operator ()std::hash14746 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264CapabilitiesKHR const & videoDecodeH264CapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT 14747 { 14748 std::size_t seed = 0; 14749 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264CapabilitiesKHR.sType ); 14750 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264CapabilitiesKHR.pNext ); 14751 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264CapabilitiesKHR.maxLevelIdc ); 14752 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264CapabilitiesKHR.fieldOffsetGranularity ); 14753 return seed; 14754 } 14755 }; 14756 14757 template <> 14758 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH264DpbSlotInfoKHR> 14759 { operator ()std::hash14760 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264DpbSlotInfoKHR const & videoDecodeH264DpbSlotInfoKHR ) const VULKAN_HPP_NOEXCEPT 14761 { 14762 std::size_t seed = 0; 14763 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264DpbSlotInfoKHR.sType ); 14764 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264DpbSlotInfoKHR.pNext ); 14765 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264DpbSlotInfoKHR.pStdReferenceInfo ); 14766 return seed; 14767 } 14768 }; 14769 14770 template <> 14771 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH264PictureInfoKHR> 14772 { operator ()std::hash14773 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264PictureInfoKHR const & videoDecodeH264PictureInfoKHR ) const VULKAN_HPP_NOEXCEPT 14774 { 14775 std::size_t seed = 0; 14776 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264PictureInfoKHR.sType ); 14777 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264PictureInfoKHR.pNext ); 14778 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264PictureInfoKHR.pStdPictureInfo ); 14779 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264PictureInfoKHR.sliceCount ); 14780 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264PictureInfoKHR.pSliceOffsets ); 14781 return seed; 14782 } 14783 }; 14784 14785 template <> 14786 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH264ProfileInfoKHR> 14787 { operator ()std::hash14788 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264ProfileInfoKHR const & videoDecodeH264ProfileInfoKHR ) const VULKAN_HPP_NOEXCEPT 14789 { 14790 std::size_t seed = 0; 14791 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264ProfileInfoKHR.sType ); 14792 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264ProfileInfoKHR.pNext ); 14793 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264ProfileInfoKHR.stdProfileIdc ); 14794 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264ProfileInfoKHR.pictureLayout ); 14795 return seed; 14796 } 14797 }; 14798 14799 template <> 14800 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH264SessionParametersAddInfoKHR> 14801 { operator ()std::hash14802 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264SessionParametersAddInfoKHR const & videoDecodeH264SessionParametersAddInfoKHR ) const 14803 VULKAN_HPP_NOEXCEPT 14804 { 14805 std::size_t seed = 0; 14806 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersAddInfoKHR.sType ); 14807 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersAddInfoKHR.pNext ); 14808 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersAddInfoKHR.stdSPSCount ); 14809 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersAddInfoKHR.pStdSPSs ); 14810 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersAddInfoKHR.stdPPSCount ); 14811 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersAddInfoKHR.pStdPPSs ); 14812 return seed; 14813 } 14814 }; 14815 14816 template <> 14817 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH264SessionParametersCreateInfoKHR> 14818 { operator ()std::hash14819 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264SessionParametersCreateInfoKHR const & videoDecodeH264SessionParametersCreateInfoKHR ) const 14820 VULKAN_HPP_NOEXCEPT 14821 { 14822 std::size_t seed = 0; 14823 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersCreateInfoKHR.sType ); 14824 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersCreateInfoKHR.pNext ); 14825 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersCreateInfoKHR.maxStdSPSCount ); 14826 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersCreateInfoKHR.maxStdPPSCount ); 14827 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersCreateInfoKHR.pParametersAddInfo ); 14828 return seed; 14829 } 14830 }; 14831 14832 template <> 14833 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH265CapabilitiesKHR> 14834 { operator ()std::hash14835 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265CapabilitiesKHR const & videoDecodeH265CapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT 14836 { 14837 std::size_t seed = 0; 14838 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265CapabilitiesKHR.sType ); 14839 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265CapabilitiesKHR.pNext ); 14840 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265CapabilitiesKHR.maxLevelIdc ); 14841 return seed; 14842 } 14843 }; 14844 14845 template <> 14846 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH265DpbSlotInfoKHR> 14847 { operator ()std::hash14848 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265DpbSlotInfoKHR const & videoDecodeH265DpbSlotInfoKHR ) const VULKAN_HPP_NOEXCEPT 14849 { 14850 std::size_t seed = 0; 14851 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265DpbSlotInfoKHR.sType ); 14852 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265DpbSlotInfoKHR.pNext ); 14853 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265DpbSlotInfoKHR.pStdReferenceInfo ); 14854 return seed; 14855 } 14856 }; 14857 14858 template <> 14859 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH265PictureInfoKHR> 14860 { operator ()std::hash14861 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265PictureInfoKHR const & videoDecodeH265PictureInfoKHR ) const VULKAN_HPP_NOEXCEPT 14862 { 14863 std::size_t seed = 0; 14864 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265PictureInfoKHR.sType ); 14865 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265PictureInfoKHR.pNext ); 14866 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265PictureInfoKHR.pStdPictureInfo ); 14867 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265PictureInfoKHR.sliceSegmentCount ); 14868 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265PictureInfoKHR.pSliceSegmentOffsets ); 14869 return seed; 14870 } 14871 }; 14872 14873 template <> 14874 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH265ProfileInfoKHR> 14875 { operator ()std::hash14876 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265ProfileInfoKHR const & videoDecodeH265ProfileInfoKHR ) const VULKAN_HPP_NOEXCEPT 14877 { 14878 std::size_t seed = 0; 14879 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265ProfileInfoKHR.sType ); 14880 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265ProfileInfoKHR.pNext ); 14881 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265ProfileInfoKHR.stdProfileIdc ); 14882 return seed; 14883 } 14884 }; 14885 14886 template <> 14887 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH265SessionParametersAddInfoKHR> 14888 { operator ()std::hash14889 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265SessionParametersAddInfoKHR const & videoDecodeH265SessionParametersAddInfoKHR ) const 14890 VULKAN_HPP_NOEXCEPT 14891 { 14892 std::size_t seed = 0; 14893 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersAddInfoKHR.sType ); 14894 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersAddInfoKHR.pNext ); 14895 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersAddInfoKHR.stdVPSCount ); 14896 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersAddInfoKHR.pStdVPSs ); 14897 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersAddInfoKHR.stdSPSCount ); 14898 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersAddInfoKHR.pStdSPSs ); 14899 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersAddInfoKHR.stdPPSCount ); 14900 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersAddInfoKHR.pStdPPSs ); 14901 return seed; 14902 } 14903 }; 14904 14905 template <> 14906 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH265SessionParametersCreateInfoKHR> 14907 { operator ()std::hash14908 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265SessionParametersCreateInfoKHR const & videoDecodeH265SessionParametersCreateInfoKHR ) const 14909 VULKAN_HPP_NOEXCEPT 14910 { 14911 std::size_t seed = 0; 14912 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersCreateInfoKHR.sType ); 14913 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersCreateInfoKHR.pNext ); 14914 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersCreateInfoKHR.maxStdVPSCount ); 14915 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersCreateInfoKHR.maxStdSPSCount ); 14916 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersCreateInfoKHR.maxStdPPSCount ); 14917 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersCreateInfoKHR.pParametersAddInfo ); 14918 return seed; 14919 } 14920 }; 14921 14922 template <> 14923 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR> 14924 { operator ()std::hash14925 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR const & videoDecodeInfoKHR ) const VULKAN_HPP_NOEXCEPT 14926 { 14927 std::size_t seed = 0; 14928 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.sType ); 14929 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.pNext ); 14930 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.flags ); 14931 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.srcBuffer ); 14932 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.srcBufferOffset ); 14933 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.srcBufferRange ); 14934 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.dstPictureResource ); 14935 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.pSetupReferenceSlot ); 14936 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.referenceSlotCount ); 14937 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.pReferenceSlots ); 14938 return seed; 14939 } 14940 }; 14941 14942 template <> 14943 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeUsageInfoKHR> 14944 { operator ()std::hash14945 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeUsageInfoKHR const & videoDecodeUsageInfoKHR ) const VULKAN_HPP_NOEXCEPT 14946 { 14947 std::size_t seed = 0; 14948 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeUsageInfoKHR.sType ); 14949 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeUsageInfoKHR.pNext ); 14950 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeUsageInfoKHR.videoUsageHints ); 14951 return seed; 14952 } 14953 }; 14954 14955 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 14956 template <> 14957 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeCapabilitiesKHR> 14958 { operator ()std::hash14959 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeCapabilitiesKHR const & videoEncodeCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT 14960 { 14961 std::size_t seed = 0; 14962 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.sType ); 14963 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.pNext ); 14964 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.flags ); 14965 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.rateControlModes ); 14966 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.maxRateControlLayers ); 14967 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.maxBitrate ); 14968 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.maxQualityLevels ); 14969 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.encodeInputPictureGranularity ); 14970 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.supportedEncodeFeedbackFlags ); 14971 return seed; 14972 } 14973 }; 14974 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 14975 14976 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 14977 template <> 14978 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilitiesEXT> 14979 { operator ()std::hash14980 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilitiesEXT const & videoEncodeH264CapabilitiesEXT ) const VULKAN_HPP_NOEXCEPT 14981 { 14982 std::size_t seed = 0; 14983 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesEXT.sType ); 14984 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesEXT.pNext ); 14985 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesEXT.flags ); 14986 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesEXT.maxLevelIdc ); 14987 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesEXT.maxSliceCount ); 14988 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesEXT.maxPPictureL0ReferenceCount ); 14989 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesEXT.maxBPictureL0ReferenceCount ); 14990 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesEXT.maxL1ReferenceCount ); 14991 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesEXT.maxTemporalLayerCount ); 14992 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesEXT.expectDyadicTemporalLayerPattern ); 14993 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesEXT.minQp ); 14994 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesEXT.maxQp ); 14995 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesEXT.prefersGopRemainingFrames ); 14996 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesEXT.requiresGopRemainingFrames ); 14997 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesEXT.stdSyntaxFlags ); 14998 return seed; 14999 } 15000 }; 15001 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 15002 15003 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 15004 template <> 15005 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoEXT> 15006 { operator ()std::hash15007 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoEXT const & videoEncodeH264DpbSlotInfoEXT ) const VULKAN_HPP_NOEXCEPT 15008 { 15009 std::size_t seed = 0; 15010 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264DpbSlotInfoEXT.sType ); 15011 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264DpbSlotInfoEXT.pNext ); 15012 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264DpbSlotInfoEXT.pStdReferenceInfo ); 15013 return seed; 15014 } 15015 }; 15016 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 15017 15018 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 15019 template <> 15020 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264FrameSizeEXT> 15021 { operator ()std::hash15022 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264FrameSizeEXT const & videoEncodeH264FrameSizeEXT ) const VULKAN_HPP_NOEXCEPT 15023 { 15024 std::size_t seed = 0; 15025 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264FrameSizeEXT.frameISize ); 15026 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264FrameSizeEXT.framePSize ); 15027 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264FrameSizeEXT.frameBSize ); 15028 return seed; 15029 } 15030 }; 15031 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 15032 15033 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 15034 template <> 15035 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264GopRemainingFrameInfoEXT> 15036 { 15037 std::size_t operator ()std::hash15038 operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264GopRemainingFrameInfoEXT const & videoEncodeH264GopRemainingFrameInfoEXT ) const VULKAN_HPP_NOEXCEPT 15039 { 15040 std::size_t seed = 0; 15041 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264GopRemainingFrameInfoEXT.sType ); 15042 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264GopRemainingFrameInfoEXT.pNext ); 15043 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264GopRemainingFrameInfoEXT.useGopRemainingFrames ); 15044 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264GopRemainingFrameInfoEXT.gopRemainingI ); 15045 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264GopRemainingFrameInfoEXT.gopRemainingP ); 15046 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264GopRemainingFrameInfoEXT.gopRemainingB ); 15047 return seed; 15048 } 15049 }; 15050 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 15051 15052 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 15053 template <> 15054 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264NaluSliceInfoEXT> 15055 { operator ()std::hash15056 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264NaluSliceInfoEXT const & videoEncodeH264NaluSliceInfoEXT ) const VULKAN_HPP_NOEXCEPT 15057 { 15058 std::size_t seed = 0; 15059 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264NaluSliceInfoEXT.sType ); 15060 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264NaluSliceInfoEXT.pNext ); 15061 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264NaluSliceInfoEXT.constantQp ); 15062 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264NaluSliceInfoEXT.pStdSliceHeader ); 15063 return seed; 15064 } 15065 }; 15066 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 15067 15068 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 15069 template <> 15070 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264PictureInfoEXT> 15071 { operator ()std::hash15072 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264PictureInfoEXT const & videoEncodeH264PictureInfoEXT ) const VULKAN_HPP_NOEXCEPT 15073 { 15074 std::size_t seed = 0; 15075 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264PictureInfoEXT.sType ); 15076 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264PictureInfoEXT.pNext ); 15077 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264PictureInfoEXT.naluSliceEntryCount ); 15078 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264PictureInfoEXT.pNaluSliceEntries ); 15079 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264PictureInfoEXT.pStdPictureInfo ); 15080 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264PictureInfoEXT.generatePrefixNalu ); 15081 return seed; 15082 } 15083 }; 15084 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 15085 15086 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 15087 template <> 15088 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264ProfileInfoEXT> 15089 { operator ()std::hash15090 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264ProfileInfoEXT const & videoEncodeH264ProfileInfoEXT ) const VULKAN_HPP_NOEXCEPT 15091 { 15092 std::size_t seed = 0; 15093 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264ProfileInfoEXT.sType ); 15094 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264ProfileInfoEXT.pNext ); 15095 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264ProfileInfoEXT.stdProfileIdc ); 15096 return seed; 15097 } 15098 }; 15099 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 15100 15101 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 15102 template <> 15103 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264QpEXT> 15104 { operator ()std::hash15105 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264QpEXT const & videoEncodeH264QpEXT ) const VULKAN_HPP_NOEXCEPT 15106 { 15107 std::size_t seed = 0; 15108 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QpEXT.qpI ); 15109 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QpEXT.qpP ); 15110 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QpEXT.qpB ); 15111 return seed; 15112 } 15113 }; 15114 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 15115 15116 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 15117 template <> 15118 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264QualityLevelPropertiesEXT> 15119 { 15120 std::size_t operator ()std::hash15121 operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264QualityLevelPropertiesEXT const & videoEncodeH264QualityLevelPropertiesEXT ) const VULKAN_HPP_NOEXCEPT 15122 { 15123 std::size_t seed = 0; 15124 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesEXT.sType ); 15125 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesEXT.pNext ); 15126 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesEXT.preferredRateControlFlags ); 15127 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesEXT.preferredGopFrameCount ); 15128 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesEXT.preferredIdrPeriod ); 15129 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesEXT.preferredConsecutiveBFrameCount ); 15130 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesEXT.preferredTemporalLayerCount ); 15131 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesEXT.preferredConstantQp ); 15132 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesEXT.preferredMaxL0ReferenceCount ); 15133 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesEXT.preferredMaxL1ReferenceCount ); 15134 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesEXT.preferredStdEntropyCodingModeFlag ); 15135 return seed; 15136 } 15137 }; 15138 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 15139 15140 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 15141 template <> 15142 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlInfoEXT> 15143 { operator ()std::hash15144 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlInfoEXT const & videoEncodeH264RateControlInfoEXT ) const VULKAN_HPP_NOEXCEPT 15145 { 15146 std::size_t seed = 0; 15147 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlInfoEXT.sType ); 15148 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlInfoEXT.pNext ); 15149 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlInfoEXT.flags ); 15150 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlInfoEXT.gopFrameCount ); 15151 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlInfoEXT.idrPeriod ); 15152 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlInfoEXT.consecutiveBFrameCount ); 15153 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlInfoEXT.temporalLayerCount ); 15154 return seed; 15155 } 15156 }; 15157 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 15158 15159 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 15160 template <> 15161 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlLayerInfoEXT> 15162 { 15163 std::size_t operator ()std::hash15164 operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlLayerInfoEXT const & videoEncodeH264RateControlLayerInfoEXT ) const VULKAN_HPP_NOEXCEPT 15165 { 15166 std::size_t seed = 0; 15167 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoEXT.sType ); 15168 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoEXT.pNext ); 15169 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoEXT.useMinQp ); 15170 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoEXT.minQp ); 15171 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoEXT.useMaxQp ); 15172 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoEXT.maxQp ); 15173 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoEXT.useMaxFrameSize ); 15174 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoEXT.maxFrameSize ); 15175 return seed; 15176 } 15177 }; 15178 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 15179 15180 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 15181 template <> 15182 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionCreateInfoEXT> 15183 { operator ()std::hash15184 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionCreateInfoEXT const & videoEncodeH264SessionCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 15185 { 15186 std::size_t seed = 0; 15187 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionCreateInfoEXT.sType ); 15188 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionCreateInfoEXT.pNext ); 15189 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionCreateInfoEXT.useMaxLevelIdc ); 15190 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionCreateInfoEXT.maxLevelIdc ); 15191 return seed; 15192 } 15193 }; 15194 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 15195 15196 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 15197 template <> 15198 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersAddInfoEXT> 15199 { operator ()std::hash15200 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersAddInfoEXT const & videoEncodeH264SessionParametersAddInfoEXT ) const 15201 VULKAN_HPP_NOEXCEPT 15202 { 15203 std::size_t seed = 0; 15204 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersAddInfoEXT.sType ); 15205 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersAddInfoEXT.pNext ); 15206 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersAddInfoEXT.stdSPSCount ); 15207 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersAddInfoEXT.pStdSPSs ); 15208 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersAddInfoEXT.stdPPSCount ); 15209 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersAddInfoEXT.pStdPPSs ); 15210 return seed; 15211 } 15212 }; 15213 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 15214 15215 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 15216 template <> 15217 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersCreateInfoEXT> 15218 { operator ()std::hash15219 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersCreateInfoEXT const & videoEncodeH264SessionParametersCreateInfoEXT ) const 15220 VULKAN_HPP_NOEXCEPT 15221 { 15222 std::size_t seed = 0; 15223 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersCreateInfoEXT.sType ); 15224 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersCreateInfoEXT.pNext ); 15225 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersCreateInfoEXT.maxStdSPSCount ); 15226 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersCreateInfoEXT.maxStdPPSCount ); 15227 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersCreateInfoEXT.pParametersAddInfo ); 15228 return seed; 15229 } 15230 }; 15231 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 15232 15233 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 15234 template <> 15235 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersFeedbackInfoEXT> 15236 { operator ()std::hash15237 std::size_t operator()( 15238 VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersFeedbackInfoEXT const & videoEncodeH264SessionParametersFeedbackInfoEXT ) const VULKAN_HPP_NOEXCEPT 15239 { 15240 std::size_t seed = 0; 15241 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersFeedbackInfoEXT.sType ); 15242 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersFeedbackInfoEXT.pNext ); 15243 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersFeedbackInfoEXT.hasStdSPSOverrides ); 15244 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersFeedbackInfoEXT.hasStdPPSOverrides ); 15245 return seed; 15246 } 15247 }; 15248 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 15249 15250 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 15251 template <> 15252 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersGetInfoEXT> 15253 { operator ()std::hash15254 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersGetInfoEXT const & videoEncodeH264SessionParametersGetInfoEXT ) const 15255 VULKAN_HPP_NOEXCEPT 15256 { 15257 std::size_t seed = 0; 15258 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersGetInfoEXT.sType ); 15259 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersGetInfoEXT.pNext ); 15260 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersGetInfoEXT.writeStdSPS ); 15261 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersGetInfoEXT.writeStdPPS ); 15262 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersGetInfoEXT.stdSPSId ); 15263 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersGetInfoEXT.stdPPSId ); 15264 return seed; 15265 } 15266 }; 15267 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 15268 15269 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 15270 template <> 15271 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265CapabilitiesEXT> 15272 { operator ()std::hash15273 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265CapabilitiesEXT const & videoEncodeH265CapabilitiesEXT ) const VULKAN_HPP_NOEXCEPT 15274 { 15275 std::size_t seed = 0; 15276 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.sType ); 15277 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.pNext ); 15278 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.flags ); 15279 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.maxLevelIdc ); 15280 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.maxSliceSegmentCount ); 15281 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.maxTiles ); 15282 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.ctbSizes ); 15283 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.transformBlockSizes ); 15284 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.maxPPictureL0ReferenceCount ); 15285 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.maxBPictureL0ReferenceCount ); 15286 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.maxL1ReferenceCount ); 15287 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.maxSubLayerCount ); 15288 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.expectDyadicTemporalSubLayerPattern ); 15289 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.minQp ); 15290 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.maxQp ); 15291 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.prefersGopRemainingFrames ); 15292 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.requiresGopRemainingFrames ); 15293 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.stdSyntaxFlags ); 15294 return seed; 15295 } 15296 }; 15297 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 15298 15299 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 15300 template <> 15301 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265DpbSlotInfoEXT> 15302 { operator ()std::hash15303 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265DpbSlotInfoEXT const & videoEncodeH265DpbSlotInfoEXT ) const VULKAN_HPP_NOEXCEPT 15304 { 15305 std::size_t seed = 0; 15306 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265DpbSlotInfoEXT.sType ); 15307 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265DpbSlotInfoEXT.pNext ); 15308 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265DpbSlotInfoEXT.pStdReferenceInfo ); 15309 return seed; 15310 } 15311 }; 15312 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 15313 15314 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 15315 template <> 15316 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265FrameSizeEXT> 15317 { operator ()std::hash15318 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265FrameSizeEXT const & videoEncodeH265FrameSizeEXT ) const VULKAN_HPP_NOEXCEPT 15319 { 15320 std::size_t seed = 0; 15321 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265FrameSizeEXT.frameISize ); 15322 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265FrameSizeEXT.framePSize ); 15323 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265FrameSizeEXT.frameBSize ); 15324 return seed; 15325 } 15326 }; 15327 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 15328 15329 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 15330 template <> 15331 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265GopRemainingFrameInfoEXT> 15332 { 15333 std::size_t operator ()std::hash15334 operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265GopRemainingFrameInfoEXT const & videoEncodeH265GopRemainingFrameInfoEXT ) const VULKAN_HPP_NOEXCEPT 15335 { 15336 std::size_t seed = 0; 15337 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265GopRemainingFrameInfoEXT.sType ); 15338 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265GopRemainingFrameInfoEXT.pNext ); 15339 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265GopRemainingFrameInfoEXT.useGopRemainingFrames ); 15340 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265GopRemainingFrameInfoEXT.gopRemainingI ); 15341 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265GopRemainingFrameInfoEXT.gopRemainingP ); 15342 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265GopRemainingFrameInfoEXT.gopRemainingB ); 15343 return seed; 15344 } 15345 }; 15346 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 15347 15348 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 15349 template <> 15350 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceSegmentInfoEXT> 15351 { 15352 std::size_t operator ()std::hash15353 operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceSegmentInfoEXT const & videoEncodeH265NaluSliceSegmentInfoEXT ) const VULKAN_HPP_NOEXCEPT 15354 { 15355 std::size_t seed = 0; 15356 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265NaluSliceSegmentInfoEXT.sType ); 15357 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265NaluSliceSegmentInfoEXT.pNext ); 15358 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265NaluSliceSegmentInfoEXT.constantQp ); 15359 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265NaluSliceSegmentInfoEXT.pStdSliceSegmentHeader ); 15360 return seed; 15361 } 15362 }; 15363 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 15364 15365 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 15366 template <> 15367 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265PictureInfoEXT> 15368 { operator ()std::hash15369 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265PictureInfoEXT const & videoEncodeH265PictureInfoEXT ) const VULKAN_HPP_NOEXCEPT 15370 { 15371 std::size_t seed = 0; 15372 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265PictureInfoEXT.sType ); 15373 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265PictureInfoEXT.pNext ); 15374 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265PictureInfoEXT.naluSliceSegmentEntryCount ); 15375 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265PictureInfoEXT.pNaluSliceSegmentEntries ); 15376 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265PictureInfoEXT.pStdPictureInfo ); 15377 return seed; 15378 } 15379 }; 15380 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 15381 15382 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 15383 template <> 15384 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265ProfileInfoEXT> 15385 { operator ()std::hash15386 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265ProfileInfoEXT const & videoEncodeH265ProfileInfoEXT ) const VULKAN_HPP_NOEXCEPT 15387 { 15388 std::size_t seed = 0; 15389 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265ProfileInfoEXT.sType ); 15390 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265ProfileInfoEXT.pNext ); 15391 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265ProfileInfoEXT.stdProfileIdc ); 15392 return seed; 15393 } 15394 }; 15395 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 15396 15397 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 15398 template <> 15399 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265QpEXT> 15400 { operator ()std::hash15401 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265QpEXT const & videoEncodeH265QpEXT ) const VULKAN_HPP_NOEXCEPT 15402 { 15403 std::size_t seed = 0; 15404 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QpEXT.qpI ); 15405 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QpEXT.qpP ); 15406 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QpEXT.qpB ); 15407 return seed; 15408 } 15409 }; 15410 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 15411 15412 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 15413 template <> 15414 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265QualityLevelPropertiesEXT> 15415 { 15416 std::size_t operator ()std::hash15417 operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265QualityLevelPropertiesEXT const & videoEncodeH265QualityLevelPropertiesEXT ) const VULKAN_HPP_NOEXCEPT 15418 { 15419 std::size_t seed = 0; 15420 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesEXT.sType ); 15421 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesEXT.pNext ); 15422 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesEXT.preferredRateControlFlags ); 15423 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesEXT.preferredGopFrameCount ); 15424 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesEXT.preferredIdrPeriod ); 15425 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesEXT.preferredConsecutiveBFrameCount ); 15426 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesEXT.preferredSubLayerCount ); 15427 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesEXT.preferredConstantQp ); 15428 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesEXT.preferredMaxL0ReferenceCount ); 15429 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesEXT.preferredMaxL1ReferenceCount ); 15430 return seed; 15431 } 15432 }; 15433 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 15434 15435 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 15436 template <> 15437 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlInfoEXT> 15438 { operator ()std::hash15439 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlInfoEXT const & videoEncodeH265RateControlInfoEXT ) const VULKAN_HPP_NOEXCEPT 15440 { 15441 std::size_t seed = 0; 15442 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlInfoEXT.sType ); 15443 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlInfoEXT.pNext ); 15444 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlInfoEXT.flags ); 15445 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlInfoEXT.gopFrameCount ); 15446 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlInfoEXT.idrPeriod ); 15447 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlInfoEXT.consecutiveBFrameCount ); 15448 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlInfoEXT.subLayerCount ); 15449 return seed; 15450 } 15451 }; 15452 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 15453 15454 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 15455 template <> 15456 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlLayerInfoEXT> 15457 { 15458 std::size_t operator ()std::hash15459 operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlLayerInfoEXT const & videoEncodeH265RateControlLayerInfoEXT ) const VULKAN_HPP_NOEXCEPT 15460 { 15461 std::size_t seed = 0; 15462 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoEXT.sType ); 15463 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoEXT.pNext ); 15464 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoEXT.useMinQp ); 15465 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoEXT.minQp ); 15466 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoEXT.useMaxQp ); 15467 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoEXT.maxQp ); 15468 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoEXT.useMaxFrameSize ); 15469 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoEXT.maxFrameSize ); 15470 return seed; 15471 } 15472 }; 15473 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 15474 15475 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 15476 template <> 15477 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionCreateInfoEXT> 15478 { operator ()std::hash15479 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionCreateInfoEXT const & videoEncodeH265SessionCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT 15480 { 15481 std::size_t seed = 0; 15482 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionCreateInfoEXT.sType ); 15483 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionCreateInfoEXT.pNext ); 15484 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionCreateInfoEXT.useMaxLevelIdc ); 15485 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionCreateInfoEXT.maxLevelIdc ); 15486 return seed; 15487 } 15488 }; 15489 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 15490 15491 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 15492 template <> 15493 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersAddInfoEXT> 15494 { operator ()std::hash15495 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersAddInfoEXT const & videoEncodeH265SessionParametersAddInfoEXT ) const 15496 VULKAN_HPP_NOEXCEPT 15497 { 15498 std::size_t seed = 0; 15499 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersAddInfoEXT.sType ); 15500 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersAddInfoEXT.pNext ); 15501 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersAddInfoEXT.stdVPSCount ); 15502 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersAddInfoEXT.pStdVPSs ); 15503 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersAddInfoEXT.stdSPSCount ); 15504 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersAddInfoEXT.pStdSPSs ); 15505 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersAddInfoEXT.stdPPSCount ); 15506 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersAddInfoEXT.pStdPPSs ); 15507 return seed; 15508 } 15509 }; 15510 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 15511 15512 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 15513 template <> 15514 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersCreateInfoEXT> 15515 { operator ()std::hash15516 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersCreateInfoEXT const & videoEncodeH265SessionParametersCreateInfoEXT ) const 15517 VULKAN_HPP_NOEXCEPT 15518 { 15519 std::size_t seed = 0; 15520 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersCreateInfoEXT.sType ); 15521 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersCreateInfoEXT.pNext ); 15522 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersCreateInfoEXT.maxStdVPSCount ); 15523 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersCreateInfoEXT.maxStdSPSCount ); 15524 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersCreateInfoEXT.maxStdPPSCount ); 15525 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersCreateInfoEXT.pParametersAddInfo ); 15526 return seed; 15527 } 15528 }; 15529 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 15530 15531 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 15532 template <> 15533 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersFeedbackInfoEXT> 15534 { operator ()std::hash15535 std::size_t operator()( 15536 VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersFeedbackInfoEXT const & videoEncodeH265SessionParametersFeedbackInfoEXT ) const VULKAN_HPP_NOEXCEPT 15537 { 15538 std::size_t seed = 0; 15539 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersFeedbackInfoEXT.sType ); 15540 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersFeedbackInfoEXT.pNext ); 15541 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersFeedbackInfoEXT.hasStdVPSOverrides ); 15542 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersFeedbackInfoEXT.hasStdSPSOverrides ); 15543 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersFeedbackInfoEXT.hasStdPPSOverrides ); 15544 return seed; 15545 } 15546 }; 15547 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 15548 15549 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 15550 template <> 15551 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersGetInfoEXT> 15552 { operator ()std::hash15553 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersGetInfoEXT const & videoEncodeH265SessionParametersGetInfoEXT ) const 15554 VULKAN_HPP_NOEXCEPT 15555 { 15556 std::size_t seed = 0; 15557 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersGetInfoEXT.sType ); 15558 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersGetInfoEXT.pNext ); 15559 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersGetInfoEXT.writeStdVPS ); 15560 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersGetInfoEXT.writeStdSPS ); 15561 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersGetInfoEXT.writeStdPPS ); 15562 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersGetInfoEXT.stdVPSId ); 15563 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersGetInfoEXT.stdSPSId ); 15564 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersGetInfoEXT.stdPPSId ); 15565 return seed; 15566 } 15567 }; 15568 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 15569 15570 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 15571 template <> 15572 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeInfoKHR> 15573 { operator ()std::hash15574 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeInfoKHR const & videoEncodeInfoKHR ) const VULKAN_HPP_NOEXCEPT 15575 { 15576 std::size_t seed = 0; 15577 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.sType ); 15578 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.pNext ); 15579 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.flags ); 15580 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.dstBuffer ); 15581 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.dstBufferOffset ); 15582 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.dstBufferRange ); 15583 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.srcPictureResource ); 15584 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.pSetupReferenceSlot ); 15585 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.referenceSlotCount ); 15586 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.pReferenceSlots ); 15587 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.precedingExternallyEncodedBytes ); 15588 return seed; 15589 } 15590 }; 15591 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 15592 15593 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 15594 template <> 15595 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelInfoKHR> 15596 { operator ()std::hash15597 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelInfoKHR const & videoEncodeQualityLevelInfoKHR ) const VULKAN_HPP_NOEXCEPT 15598 { 15599 std::size_t seed = 0; 15600 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQualityLevelInfoKHR.sType ); 15601 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQualityLevelInfoKHR.pNext ); 15602 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQualityLevelInfoKHR.qualityLevel ); 15603 return seed; 15604 } 15605 }; 15606 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 15607 15608 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 15609 template <> 15610 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelPropertiesKHR> 15611 { operator ()std::hash15612 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelPropertiesKHR const & videoEncodeQualityLevelPropertiesKHR ) const VULKAN_HPP_NOEXCEPT 15613 { 15614 std::size_t seed = 0; 15615 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQualityLevelPropertiesKHR.sType ); 15616 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQualityLevelPropertiesKHR.pNext ); 15617 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQualityLevelPropertiesKHR.preferredRateControlMode ); 15618 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQualityLevelPropertiesKHR.preferredRateControlLayerCount ); 15619 return seed; 15620 } 15621 }; 15622 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 15623 15624 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 15625 template <> 15626 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeRateControlLayerInfoKHR> 15627 { operator ()std::hash15628 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeRateControlLayerInfoKHR const & videoEncodeRateControlLayerInfoKHR ) const VULKAN_HPP_NOEXCEPT 15629 { 15630 std::size_t seed = 0; 15631 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlLayerInfoKHR.sType ); 15632 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlLayerInfoKHR.pNext ); 15633 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlLayerInfoKHR.averageBitrate ); 15634 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlLayerInfoKHR.maxBitrate ); 15635 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlLayerInfoKHR.frameRateNumerator ); 15636 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlLayerInfoKHR.frameRateDenominator ); 15637 return seed; 15638 } 15639 }; 15640 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 15641 15642 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 15643 template <> 15644 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeRateControlInfoKHR> 15645 { operator ()std::hash15646 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeRateControlInfoKHR const & videoEncodeRateControlInfoKHR ) const VULKAN_HPP_NOEXCEPT 15647 { 15648 std::size_t seed = 0; 15649 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlInfoKHR.sType ); 15650 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlInfoKHR.pNext ); 15651 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlInfoKHR.flags ); 15652 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlInfoKHR.rateControlMode ); 15653 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlInfoKHR.layerCount ); 15654 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlInfoKHR.pLayers ); 15655 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlInfoKHR.virtualBufferSizeInMs ); 15656 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlInfoKHR.initialVirtualBufferSizeInMs ); 15657 return seed; 15658 } 15659 }; 15660 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 15661 15662 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 15663 template <> 15664 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersFeedbackInfoKHR> 15665 { operator ()std::hash15666 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersFeedbackInfoKHR const & videoEncodeSessionParametersFeedbackInfoKHR ) const 15667 VULKAN_HPP_NOEXCEPT 15668 { 15669 std::size_t seed = 0; 15670 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionParametersFeedbackInfoKHR.sType ); 15671 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionParametersFeedbackInfoKHR.pNext ); 15672 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionParametersFeedbackInfoKHR.hasOverrides ); 15673 return seed; 15674 } 15675 }; 15676 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 15677 15678 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 15679 template <> 15680 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR> 15681 { 15682 std::size_t operator ()std::hash15683 operator()( VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR const & videoEncodeSessionParametersGetInfoKHR ) const VULKAN_HPP_NOEXCEPT 15684 { 15685 std::size_t seed = 0; 15686 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionParametersGetInfoKHR.sType ); 15687 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionParametersGetInfoKHR.pNext ); 15688 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionParametersGetInfoKHR.videoSessionParameters ); 15689 return seed; 15690 } 15691 }; 15692 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 15693 15694 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 15695 template <> 15696 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeUsageInfoKHR> 15697 { operator ()std::hash15698 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeUsageInfoKHR const & videoEncodeUsageInfoKHR ) const VULKAN_HPP_NOEXCEPT 15699 { 15700 std::size_t seed = 0; 15701 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeUsageInfoKHR.sType ); 15702 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeUsageInfoKHR.pNext ); 15703 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeUsageInfoKHR.videoUsageHints ); 15704 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeUsageInfoKHR.videoContentHints ); 15705 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeUsageInfoKHR.tuningMode ); 15706 return seed; 15707 } 15708 }; 15709 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 15710 15711 template <> 15712 struct hash<VULKAN_HPP_NAMESPACE::VideoEndCodingInfoKHR> 15713 { operator ()std::hash15714 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEndCodingInfoKHR const & videoEndCodingInfoKHR ) const VULKAN_HPP_NOEXCEPT 15715 { 15716 std::size_t seed = 0; 15717 VULKAN_HPP_HASH_COMBINE( seed, videoEndCodingInfoKHR.sType ); 15718 VULKAN_HPP_HASH_COMBINE( seed, videoEndCodingInfoKHR.pNext ); 15719 VULKAN_HPP_HASH_COMBINE( seed, videoEndCodingInfoKHR.flags ); 15720 return seed; 15721 } 15722 }; 15723 15724 template <> 15725 struct hash<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR> 15726 { operator ()std::hash15727 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR const & videoFormatPropertiesKHR ) const VULKAN_HPP_NOEXCEPT 15728 { 15729 std::size_t seed = 0; 15730 VULKAN_HPP_HASH_COMBINE( seed, videoFormatPropertiesKHR.sType ); 15731 VULKAN_HPP_HASH_COMBINE( seed, videoFormatPropertiesKHR.pNext ); 15732 VULKAN_HPP_HASH_COMBINE( seed, videoFormatPropertiesKHR.format ); 15733 VULKAN_HPP_HASH_COMBINE( seed, videoFormatPropertiesKHR.componentMapping ); 15734 VULKAN_HPP_HASH_COMBINE( seed, videoFormatPropertiesKHR.imageCreateFlags ); 15735 VULKAN_HPP_HASH_COMBINE( seed, videoFormatPropertiesKHR.imageType ); 15736 VULKAN_HPP_HASH_COMBINE( seed, videoFormatPropertiesKHR.imageTiling ); 15737 VULKAN_HPP_HASH_COMBINE( seed, videoFormatPropertiesKHR.imageUsageFlags ); 15738 return seed; 15739 } 15740 }; 15741 15742 template <> 15743 struct hash<VULKAN_HPP_NAMESPACE::VideoProfileListInfoKHR> 15744 { operator ()std::hash15745 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoProfileListInfoKHR const & videoProfileListInfoKHR ) const VULKAN_HPP_NOEXCEPT 15746 { 15747 std::size_t seed = 0; 15748 VULKAN_HPP_HASH_COMBINE( seed, videoProfileListInfoKHR.sType ); 15749 VULKAN_HPP_HASH_COMBINE( seed, videoProfileListInfoKHR.pNext ); 15750 VULKAN_HPP_HASH_COMBINE( seed, videoProfileListInfoKHR.profileCount ); 15751 VULKAN_HPP_HASH_COMBINE( seed, videoProfileListInfoKHR.pProfiles ); 15752 return seed; 15753 } 15754 }; 15755 15756 template <> 15757 struct hash<VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR> 15758 { operator ()std::hash15759 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR const & videoSessionCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 15760 { 15761 std::size_t seed = 0; 15762 VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.sType ); 15763 VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.pNext ); 15764 VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.queueFamilyIndex ); 15765 VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.flags ); 15766 VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.pVideoProfile ); 15767 VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.pictureFormat ); 15768 VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.maxCodedExtent ); 15769 VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.referencePictureFormat ); 15770 VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.maxDpbSlots ); 15771 VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.maxActiveReferencePictures ); 15772 VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.pStdHeaderVersion ); 15773 return seed; 15774 } 15775 }; 15776 15777 template <> 15778 struct hash<VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR> 15779 { operator ()std::hash15780 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR const & videoSessionMemoryRequirementsKHR ) const VULKAN_HPP_NOEXCEPT 15781 { 15782 std::size_t seed = 0; 15783 VULKAN_HPP_HASH_COMBINE( seed, videoSessionMemoryRequirementsKHR.sType ); 15784 VULKAN_HPP_HASH_COMBINE( seed, videoSessionMemoryRequirementsKHR.pNext ); 15785 VULKAN_HPP_HASH_COMBINE( seed, videoSessionMemoryRequirementsKHR.memoryBindIndex ); 15786 VULKAN_HPP_HASH_COMBINE( seed, videoSessionMemoryRequirementsKHR.memoryRequirements ); 15787 return seed; 15788 } 15789 }; 15790 15791 template <> 15792 struct hash<VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR> 15793 { operator ()std::hash15794 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR const & videoSessionParametersCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 15795 { 15796 std::size_t seed = 0; 15797 VULKAN_HPP_HASH_COMBINE( seed, videoSessionParametersCreateInfoKHR.sType ); 15798 VULKAN_HPP_HASH_COMBINE( seed, videoSessionParametersCreateInfoKHR.pNext ); 15799 VULKAN_HPP_HASH_COMBINE( seed, videoSessionParametersCreateInfoKHR.flags ); 15800 VULKAN_HPP_HASH_COMBINE( seed, videoSessionParametersCreateInfoKHR.videoSessionParametersTemplate ); 15801 VULKAN_HPP_HASH_COMBINE( seed, videoSessionParametersCreateInfoKHR.videoSession ); 15802 return seed; 15803 } 15804 }; 15805 15806 template <> 15807 struct hash<VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR> 15808 { operator ()std::hash15809 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR const & videoSessionParametersUpdateInfoKHR ) const VULKAN_HPP_NOEXCEPT 15810 { 15811 std::size_t seed = 0; 15812 VULKAN_HPP_HASH_COMBINE( seed, videoSessionParametersUpdateInfoKHR.sType ); 15813 VULKAN_HPP_HASH_COMBINE( seed, videoSessionParametersUpdateInfoKHR.pNext ); 15814 VULKAN_HPP_HASH_COMBINE( seed, videoSessionParametersUpdateInfoKHR.updateSequenceCount ); 15815 return seed; 15816 } 15817 }; 15818 15819 # if defined( VK_USE_PLATFORM_WAYLAND_KHR ) 15820 template <> 15821 struct hash<VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR> 15822 { operator ()std::hash15823 std::size_t operator()( VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR const & waylandSurfaceCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 15824 { 15825 std::size_t seed = 0; 15826 VULKAN_HPP_HASH_COMBINE( seed, waylandSurfaceCreateInfoKHR.sType ); 15827 VULKAN_HPP_HASH_COMBINE( seed, waylandSurfaceCreateInfoKHR.pNext ); 15828 VULKAN_HPP_HASH_COMBINE( seed, waylandSurfaceCreateInfoKHR.flags ); 15829 VULKAN_HPP_HASH_COMBINE( seed, waylandSurfaceCreateInfoKHR.display ); 15830 VULKAN_HPP_HASH_COMBINE( seed, waylandSurfaceCreateInfoKHR.surface ); 15831 return seed; 15832 } 15833 }; 15834 # endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ 15835 15836 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 15837 template <> 15838 struct hash<VULKAN_HPP_NAMESPACE::Win32KeyedMutexAcquireReleaseInfoKHR> 15839 { operator ()std::hash15840 std::size_t operator()( VULKAN_HPP_NAMESPACE::Win32KeyedMutexAcquireReleaseInfoKHR const & win32KeyedMutexAcquireReleaseInfoKHR ) const VULKAN_HPP_NOEXCEPT 15841 { 15842 std::size_t seed = 0; 15843 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoKHR.sType ); 15844 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoKHR.pNext ); 15845 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoKHR.acquireCount ); 15846 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoKHR.pAcquireSyncs ); 15847 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoKHR.pAcquireKeys ); 15848 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoKHR.pAcquireTimeouts ); 15849 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoKHR.releaseCount ); 15850 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoKHR.pReleaseSyncs ); 15851 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoKHR.pReleaseKeys ); 15852 return seed; 15853 } 15854 }; 15855 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 15856 15857 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 15858 template <> 15859 struct hash<VULKAN_HPP_NAMESPACE::Win32KeyedMutexAcquireReleaseInfoNV> 15860 { operator ()std::hash15861 std::size_t operator()( VULKAN_HPP_NAMESPACE::Win32KeyedMutexAcquireReleaseInfoNV const & win32KeyedMutexAcquireReleaseInfoNV ) const VULKAN_HPP_NOEXCEPT 15862 { 15863 std::size_t seed = 0; 15864 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoNV.sType ); 15865 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoNV.pNext ); 15866 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoNV.acquireCount ); 15867 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoNV.pAcquireSyncs ); 15868 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoNV.pAcquireKeys ); 15869 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoNV.pAcquireTimeoutMilliseconds ); 15870 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoNV.releaseCount ); 15871 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoNV.pReleaseSyncs ); 15872 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoNV.pReleaseKeys ); 15873 return seed; 15874 } 15875 }; 15876 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 15877 15878 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 15879 template <> 15880 struct hash<VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR> 15881 { operator ()std::hash15882 std::size_t operator()( VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR const & win32SurfaceCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 15883 { 15884 std::size_t seed = 0; 15885 VULKAN_HPP_HASH_COMBINE( seed, win32SurfaceCreateInfoKHR.sType ); 15886 VULKAN_HPP_HASH_COMBINE( seed, win32SurfaceCreateInfoKHR.pNext ); 15887 VULKAN_HPP_HASH_COMBINE( seed, win32SurfaceCreateInfoKHR.flags ); 15888 VULKAN_HPP_HASH_COMBINE( seed, win32SurfaceCreateInfoKHR.hinstance ); 15889 VULKAN_HPP_HASH_COMBINE( seed, win32SurfaceCreateInfoKHR.hwnd ); 15890 return seed; 15891 } 15892 }; 15893 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 15894 15895 template <> 15896 struct hash<VULKAN_HPP_NAMESPACE::WriteDescriptorSet> 15897 { operator ()std::hash15898 std::size_t operator()( VULKAN_HPP_NAMESPACE::WriteDescriptorSet const & writeDescriptorSet ) const VULKAN_HPP_NOEXCEPT 15899 { 15900 std::size_t seed = 0; 15901 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.sType ); 15902 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.pNext ); 15903 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.dstSet ); 15904 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.dstBinding ); 15905 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.dstArrayElement ); 15906 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.descriptorCount ); 15907 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.descriptorType ); 15908 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.pImageInfo ); 15909 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.pBufferInfo ); 15910 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.pTexelBufferView ); 15911 return seed; 15912 } 15913 }; 15914 15915 template <> 15916 struct hash<VULKAN_HPP_NAMESPACE::WriteDescriptorSetAccelerationStructureKHR> 15917 { operator ()std::hash15918 std::size_t operator()( VULKAN_HPP_NAMESPACE::WriteDescriptorSetAccelerationStructureKHR const & writeDescriptorSetAccelerationStructureKHR ) const 15919 VULKAN_HPP_NOEXCEPT 15920 { 15921 std::size_t seed = 0; 15922 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetAccelerationStructureKHR.sType ); 15923 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetAccelerationStructureKHR.pNext ); 15924 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetAccelerationStructureKHR.accelerationStructureCount ); 15925 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetAccelerationStructureKHR.pAccelerationStructures ); 15926 return seed; 15927 } 15928 }; 15929 15930 template <> 15931 struct hash<VULKAN_HPP_NAMESPACE::WriteDescriptorSetAccelerationStructureNV> 15932 { 15933 std::size_t operator ()std::hash15934 operator()( VULKAN_HPP_NAMESPACE::WriteDescriptorSetAccelerationStructureNV const & writeDescriptorSetAccelerationStructureNV ) const VULKAN_HPP_NOEXCEPT 15935 { 15936 std::size_t seed = 0; 15937 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetAccelerationStructureNV.sType ); 15938 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetAccelerationStructureNV.pNext ); 15939 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetAccelerationStructureNV.accelerationStructureCount ); 15940 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetAccelerationStructureNV.pAccelerationStructures ); 15941 return seed; 15942 } 15943 }; 15944 15945 template <> 15946 struct hash<VULKAN_HPP_NAMESPACE::WriteDescriptorSetInlineUniformBlock> 15947 { operator ()std::hash15948 std::size_t operator()( VULKAN_HPP_NAMESPACE::WriteDescriptorSetInlineUniformBlock const & writeDescriptorSetInlineUniformBlock ) const VULKAN_HPP_NOEXCEPT 15949 { 15950 std::size_t seed = 0; 15951 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetInlineUniformBlock.sType ); 15952 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetInlineUniformBlock.pNext ); 15953 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetInlineUniformBlock.dataSize ); 15954 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetInlineUniformBlock.pData ); 15955 return seed; 15956 } 15957 }; 15958 15959 # if defined( VK_USE_PLATFORM_XCB_KHR ) 15960 template <> 15961 struct hash<VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR> 15962 { operator ()std::hash15963 std::size_t operator()( VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR const & xcbSurfaceCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 15964 { 15965 std::size_t seed = 0; 15966 VULKAN_HPP_HASH_COMBINE( seed, xcbSurfaceCreateInfoKHR.sType ); 15967 VULKAN_HPP_HASH_COMBINE( seed, xcbSurfaceCreateInfoKHR.pNext ); 15968 VULKAN_HPP_HASH_COMBINE( seed, xcbSurfaceCreateInfoKHR.flags ); 15969 VULKAN_HPP_HASH_COMBINE( seed, xcbSurfaceCreateInfoKHR.connection ); 15970 VULKAN_HPP_HASH_COMBINE( seed, xcbSurfaceCreateInfoKHR.window ); 15971 return seed; 15972 } 15973 }; 15974 # endif /*VK_USE_PLATFORM_XCB_KHR*/ 15975 15976 # if defined( VK_USE_PLATFORM_XLIB_KHR ) 15977 template <> 15978 struct hash<VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR> 15979 { operator ()std::hash15980 std::size_t operator()( VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR const & xlibSurfaceCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT 15981 { 15982 std::size_t seed = 0; 15983 VULKAN_HPP_HASH_COMBINE( seed, xlibSurfaceCreateInfoKHR.sType ); 15984 VULKAN_HPP_HASH_COMBINE( seed, xlibSurfaceCreateInfoKHR.pNext ); 15985 VULKAN_HPP_HASH_COMBINE( seed, xlibSurfaceCreateInfoKHR.flags ); 15986 VULKAN_HPP_HASH_COMBINE( seed, xlibSurfaceCreateInfoKHR.dpy ); 15987 VULKAN_HPP_HASH_COMBINE( seed, xlibSurfaceCreateInfoKHR.window ); 15988 return seed; 15989 } 15990 }; 15991 # endif /*VK_USE_PLATFORM_XLIB_KHR*/ 15992 15993 #endif // 14 <= VULKAN_HPP_CPP_VERSION 15994 15995 } // namespace std 15996 #endif 15997