Vulkan-Hpp
vulkan_hash.hpp
Go to the documentation of this file.
1 // Copyright 2015-2024 The Khronos Group Inc.
2 //
3 // SPDX-License-Identifier: Apache-2.0 OR MIT
4 //
5 
6 // This header is generated from the Khronos Vulkan XML API Registry.
7 
8 #ifndef VULKAN_HASH_HPP
9 #define VULKAN_HASH_HPP
10 
11 #include <vulkan/vulkan.hpp>
12 
13 namespace std
14 {
15  //=======================================
16  //=== HASH structures for Flags types ===
17  //=======================================
18 
19  template <typename BitType>
20  struct hash<VULKAN_HPP_NAMESPACE::Flags<BitType>>
21  {
22  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  {
37  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  {
46  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  {
55  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  {
64  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  {
73  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  {
82  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  {
91  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  {
100  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  {
109  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  {
118  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  {
127  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  {
136  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  {
145  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  {
154  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  {
163  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  {
172  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  {
181  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  {
190  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  {
199  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  {
208  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  {
217  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  {
226  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  {
235  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  {
244  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  {
253  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  {
264  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  {
273  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  {
284  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  {
295  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  {
306  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  {
317  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  {
326  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  {
337  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  {
348  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  {
357  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  {
368  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  {
377  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  {
388  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  {
399  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  {
410  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  {
421  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  {
432  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  {
443  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  {
454  std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV const & indirectCommandsLayoutNV ) const VULKAN_HPP_NOEXCEPT
455  {
456  return std::hash<VkIndirectCommandsLayoutNV>{}( static_cast<VkIndirectCommandsLayoutNV>( indirectCommandsLayoutNV ) );
457  }
458  };
459 
460 #if defined( VK_ENABLE_BETA_EXTENSIONS )
461  //=== VK_NV_cuda_kernel_launch ===
462 
463  template <>
464  struct hash<VULKAN_HPP_NAMESPACE::CudaModuleNV>
465  {
466  std::size_t operator()( VULKAN_HPP_NAMESPACE::CudaModuleNV const & cudaModuleNV ) const VULKAN_HPP_NOEXCEPT
467  {
468  return std::hash<VkCudaModuleNV>{}( static_cast<VkCudaModuleNV>( cudaModuleNV ) );
469  }
470  };
471 
472  template <>
473  struct hash<VULKAN_HPP_NAMESPACE::CudaFunctionNV>
474  {
475  std::size_t operator()( VULKAN_HPP_NAMESPACE::CudaFunctionNV const & cudaFunctionNV ) const VULKAN_HPP_NOEXCEPT
476  {
477  return std::hash<VkCudaFunctionNV>{}( static_cast<VkCudaFunctionNV>( cudaFunctionNV ) );
478  }
479  };
480 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
481 
482 #if defined( VK_USE_PLATFORM_FUCHSIA )
483  //=== VK_FUCHSIA_buffer_collection ===
484 
485  template <>
486  struct hash<VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA>
487  {
488  std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA const & bufferCollectionFUCHSIA ) const VULKAN_HPP_NOEXCEPT
489  {
490  return std::hash<VkBufferCollectionFUCHSIA>{}( static_cast<VkBufferCollectionFUCHSIA>( bufferCollectionFUCHSIA ) );
491  }
492  };
493 #endif /*VK_USE_PLATFORM_FUCHSIA*/
494 
495  //=== VK_EXT_opacity_micromap ===
496 
497  template <>
498  struct hash<VULKAN_HPP_NAMESPACE::MicromapEXT>
499  {
500  std::size_t operator()( VULKAN_HPP_NAMESPACE::MicromapEXT const & micromapEXT ) const VULKAN_HPP_NOEXCEPT
501  {
502  return std::hash<VkMicromapEXT>{}( static_cast<VkMicromapEXT>( micromapEXT ) );
503  }
504  };
505 
506  //=== VK_NV_optical_flow ===
507 
508  template <>
509  struct hash<VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV>
510  {
511  std::size_t operator()( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV const & opticalFlowSessionNV ) const VULKAN_HPP_NOEXCEPT
512  {
513  return std::hash<VkOpticalFlowSessionNV>{}( static_cast<VkOpticalFlowSessionNV>( opticalFlowSessionNV ) );
514  }
515  };
516 
517  //=== VK_EXT_shader_object ===
518 
519  template <>
520  struct hash<VULKAN_HPP_NAMESPACE::ShaderEXT>
521  {
522  std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderEXT const & shaderEXT ) const VULKAN_HPP_NOEXCEPT
523  {
524  return std::hash<VkShaderEXT>{}( static_cast<VkShaderEXT>( shaderEXT ) );
525  }
526  };
527 
528 #if 14 <= VULKAN_HPP_CPP_VERSION
529  //======================================
530  //=== HASH structures for structures ===
531  //======================================
532 
533 # if !defined( VULKAN_HPP_HASH_COMBINE )
534 # define VULKAN_HPP_HASH_COMBINE( seed, value ) \
535  seed ^= std::hash<std::decay<decltype( value )>::type>{}( value ) + 0x9e3779b9 + ( seed << 6 ) + ( seed >> 2 )
536 # endif
537 
538  template <>
539  struct hash<VULKAN_HPP_NAMESPACE::AabbPositionsKHR>
540  {
541  std::size_t operator()( VULKAN_HPP_NAMESPACE::AabbPositionsKHR const & aabbPositionsKHR ) const VULKAN_HPP_NOEXCEPT
542  {
543  std::size_t seed = 0;
544  VULKAN_HPP_HASH_COMBINE( seed, aabbPositionsKHR.minX );
545  VULKAN_HPP_HASH_COMBINE( seed, aabbPositionsKHR.minY );
546  VULKAN_HPP_HASH_COMBINE( seed, aabbPositionsKHR.minZ );
547  VULKAN_HPP_HASH_COMBINE( seed, aabbPositionsKHR.maxX );
548  VULKAN_HPP_HASH_COMBINE( seed, aabbPositionsKHR.maxY );
549  VULKAN_HPP_HASH_COMBINE( seed, aabbPositionsKHR.maxZ );
550  return seed;
551  }
552  };
553 
554  template <>
555  struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR>
556  {
557  std::size_t
558  operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR const & accelerationStructureBuildRangeInfoKHR ) const VULKAN_HPP_NOEXCEPT
559  {
560  std::size_t seed = 0;
561  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildRangeInfoKHR.primitiveCount );
562  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildRangeInfoKHR.primitiveOffset );
563  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildRangeInfoKHR.firstVertex );
564  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildRangeInfoKHR.transformOffset );
565  return seed;
566  }
567  };
568 
569  template <>
570  struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR>
571  {
572  std::size_t
573  operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR const & accelerationStructureBuildSizesInfoKHR ) const VULKAN_HPP_NOEXCEPT
574  {
575  std::size_t seed = 0;
576  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildSizesInfoKHR.sType );
577  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildSizesInfoKHR.pNext );
578  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildSizesInfoKHR.accelerationStructureSize );
579  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildSizesInfoKHR.updateScratchSize );
580  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildSizesInfoKHR.buildScratchSize );
581  return seed;
582  }
583  };
584 
585  template <>
586  struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureCaptureDescriptorDataInfoEXT>
587  {
588  std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureCaptureDescriptorDataInfoEXT const & accelerationStructureCaptureDescriptorDataInfoEXT )
589  const VULKAN_HPP_NOEXCEPT
590  {
591  std::size_t seed = 0;
592  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCaptureDescriptorDataInfoEXT.sType );
593  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCaptureDescriptorDataInfoEXT.pNext );
594  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCaptureDescriptorDataInfoEXT.accelerationStructure );
595  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCaptureDescriptorDataInfoEXT.accelerationStructureNV );
596  return seed;
597  }
598  };
599 
600  template <>
601  struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR>
602  {
603  std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR const & accelerationStructureCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
604  {
605  std::size_t seed = 0;
606  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoKHR.sType );
607  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoKHR.pNext );
608  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoKHR.createFlags );
609  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoKHR.buffer );
610  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoKHR.offset );
611  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoKHR.size );
612  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoKHR.type );
613  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoKHR.deviceAddress );
614  return seed;
615  }
616  };
617 
618  template <>
619  struct hash<VULKAN_HPP_NAMESPACE::GeometryTrianglesNV>
620  {
621  std::size_t operator()( VULKAN_HPP_NAMESPACE::GeometryTrianglesNV const & geometryTrianglesNV ) const VULKAN_HPP_NOEXCEPT
622  {
623  std::size_t seed = 0;
624  VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.sType );
625  VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.pNext );
626  VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.vertexData );
627  VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.vertexOffset );
628  VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.vertexCount );
629  VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.vertexStride );
630  VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.vertexFormat );
631  VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.indexData );
632  VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.indexOffset );
633  VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.indexCount );
634  VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.indexType );
635  VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.transformData );
636  VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.transformOffset );
637  return seed;
638  }
639  };
640 
641  template <>
642  struct hash<VULKAN_HPP_NAMESPACE::GeometryAABBNV>
643  {
644  std::size_t operator()( VULKAN_HPP_NAMESPACE::GeometryAABBNV const & geometryAABBNV ) const VULKAN_HPP_NOEXCEPT
645  {
646  std::size_t seed = 0;
647  VULKAN_HPP_HASH_COMBINE( seed, geometryAABBNV.sType );
648  VULKAN_HPP_HASH_COMBINE( seed, geometryAABBNV.pNext );
649  VULKAN_HPP_HASH_COMBINE( seed, geometryAABBNV.aabbData );
650  VULKAN_HPP_HASH_COMBINE( seed, geometryAABBNV.numAABBs );
651  VULKAN_HPP_HASH_COMBINE( seed, geometryAABBNV.stride );
652  VULKAN_HPP_HASH_COMBINE( seed, geometryAABBNV.offset );
653  return seed;
654  }
655  };
656 
657  template <>
658  struct hash<VULKAN_HPP_NAMESPACE::GeometryDataNV>
659  {
660  std::size_t operator()( VULKAN_HPP_NAMESPACE::GeometryDataNV const & geometryDataNV ) const VULKAN_HPP_NOEXCEPT
661  {
662  std::size_t seed = 0;
663  VULKAN_HPP_HASH_COMBINE( seed, geometryDataNV.triangles );
664  VULKAN_HPP_HASH_COMBINE( seed, geometryDataNV.aabbs );
665  return seed;
666  }
667  };
668 
669  template <>
670  struct hash<VULKAN_HPP_NAMESPACE::GeometryNV>
671  {
672  std::size_t operator()( VULKAN_HPP_NAMESPACE::GeometryNV const & geometryNV ) const VULKAN_HPP_NOEXCEPT
673  {
674  std::size_t seed = 0;
675  VULKAN_HPP_HASH_COMBINE( seed, geometryNV.sType );
676  VULKAN_HPP_HASH_COMBINE( seed, geometryNV.pNext );
677  VULKAN_HPP_HASH_COMBINE( seed, geometryNV.geometryType );
678  VULKAN_HPP_HASH_COMBINE( seed, geometryNV.geometry );
679  VULKAN_HPP_HASH_COMBINE( seed, geometryNV.flags );
680  return seed;
681  }
682  };
683 
684  template <>
685  struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV>
686  {
687  std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV const & accelerationStructureInfoNV ) const VULKAN_HPP_NOEXCEPT
688  {
689  std::size_t seed = 0;
690  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInfoNV.sType );
691  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInfoNV.pNext );
692  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInfoNV.type );
693  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInfoNV.flags );
694  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInfoNV.instanceCount );
695  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInfoNV.geometryCount );
696  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInfoNV.pGeometries );
697  return seed;
698  }
699  };
700 
701  template <>
702  struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV>
703  {
704  std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV const & accelerationStructureCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
705  {
706  std::size_t seed = 0;
707  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoNV.sType );
708  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoNV.pNext );
709  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoNV.compactedSize );
710  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoNV.info );
711  return seed;
712  }
713  };
714 
715  template <>
716  struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR>
717  {
718  std::size_t
719  operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR const & accelerationStructureDeviceAddressInfoKHR ) const VULKAN_HPP_NOEXCEPT
720  {
721  std::size_t seed = 0;
722  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureDeviceAddressInfoKHR.sType );
723  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureDeviceAddressInfoKHR.pNext );
724  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureDeviceAddressInfoKHR.accelerationStructure );
725  return seed;
726  }
727  };
728 
729  template <>
730  struct hash<VULKAN_HPP_NAMESPACE::TransformMatrixKHR>
731  {
732  std::size_t operator()( VULKAN_HPP_NAMESPACE::TransformMatrixKHR const & transformMatrixKHR ) const VULKAN_HPP_NOEXCEPT
733  {
734  std::size_t seed = 0;
735  for ( size_t i = 0; i < 3; ++i )
736  {
737  for ( size_t j = 0; j < 4; ++j )
738  {
739  VULKAN_HPP_HASH_COMBINE( seed, transformMatrixKHR.matrix[i][j] );
740  }
741  }
742  return seed;
743  }
744  };
745 
746  template <>
747  struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureInstanceKHR>
748  {
749  std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureInstanceKHR const & accelerationStructureInstanceKHR ) const VULKAN_HPP_NOEXCEPT
750  {
751  std::size_t seed = 0;
752  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInstanceKHR.transform );
753  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInstanceKHR.instanceCustomIndex );
754  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInstanceKHR.mask );
755  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInstanceKHR.instanceShaderBindingTableRecordOffset );
756  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInstanceKHR.flags );
757  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInstanceKHR.accelerationStructureReference );
758  return seed;
759  }
760  };
761 
762  template <>
763  struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureMatrixMotionInstanceNV>
764  {
765  std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureMatrixMotionInstanceNV const & accelerationStructureMatrixMotionInstanceNV ) const
766  VULKAN_HPP_NOEXCEPT
767  {
768  std::size_t seed = 0;
769  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMatrixMotionInstanceNV.transformT0 );
770  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMatrixMotionInstanceNV.transformT1 );
771  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMatrixMotionInstanceNV.instanceCustomIndex );
772  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMatrixMotionInstanceNV.mask );
773  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMatrixMotionInstanceNV.instanceShaderBindingTableRecordOffset );
774  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMatrixMotionInstanceNV.flags );
775  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMatrixMotionInstanceNV.accelerationStructureReference );
776  return seed;
777  }
778  };
779 
780  template <>
781  struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV>
782  {
783  std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV const & accelerationStructureMemoryRequirementsInfoNV ) const
784  VULKAN_HPP_NOEXCEPT
785  {
786  std::size_t seed = 0;
787  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMemoryRequirementsInfoNV.sType );
788  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMemoryRequirementsInfoNV.pNext );
789  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMemoryRequirementsInfoNV.type );
790  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMemoryRequirementsInfoNV.accelerationStructure );
791  return seed;
792  }
793  };
794 
795  template <>
796  struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInfoNV>
797  {
798  std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInfoNV const & accelerationStructureMotionInfoNV ) const VULKAN_HPP_NOEXCEPT
799  {
800  std::size_t seed = 0;
801  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMotionInfoNV.sType );
802  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMotionInfoNV.pNext );
803  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMotionInfoNV.maxInstances );
804  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMotionInfoNV.flags );
805  return seed;
806  }
807  };
808 
809  template <>
810  struct hash<VULKAN_HPP_NAMESPACE::SRTDataNV>
811  {
812  std::size_t operator()( VULKAN_HPP_NAMESPACE::SRTDataNV const & sRTDataNV ) const VULKAN_HPP_NOEXCEPT
813  {
814  std::size_t seed = 0;
815  VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.sx );
816  VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.a );
817  VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.b );
818  VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.pvx );
819  VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.sy );
820  VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.c );
821  VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.pvy );
822  VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.sz );
823  VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.pvz );
824  VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.qx );
825  VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.qy );
826  VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.qz );
827  VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.qw );
828  VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.tx );
829  VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.ty );
830  VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.tz );
831  return seed;
832  }
833  };
834 
835  template <>
836  struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureSRTMotionInstanceNV>
837  {
838  std::size_t
839  operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureSRTMotionInstanceNV const & accelerationStructureSRTMotionInstanceNV ) const VULKAN_HPP_NOEXCEPT
840  {
841  std::size_t seed = 0;
842  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureSRTMotionInstanceNV.transformT0 );
843  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureSRTMotionInstanceNV.transformT1 );
844  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureSRTMotionInstanceNV.instanceCustomIndex );
845  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureSRTMotionInstanceNV.mask );
846  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureSRTMotionInstanceNV.instanceShaderBindingTableRecordOffset );
847  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureSRTMotionInstanceNV.flags );
848  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureSRTMotionInstanceNV.accelerationStructureReference );
849  return seed;
850  }
851  };
852 
853  template <>
854  struct hash<VULKAN_HPP_NAMESPACE::MicromapUsageEXT>
855  {
856  std::size_t operator()( VULKAN_HPP_NAMESPACE::MicromapUsageEXT const & micromapUsageEXT ) const VULKAN_HPP_NOEXCEPT
857  {
858  std::size_t seed = 0;
859  VULKAN_HPP_HASH_COMBINE( seed, micromapUsageEXT.count );
860  VULKAN_HPP_HASH_COMBINE( seed, micromapUsageEXT.subdivisionLevel );
861  VULKAN_HPP_HASH_COMBINE( seed, micromapUsageEXT.format );
862  return seed;
863  }
864  };
865 
866  template <>
867  struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureVersionInfoKHR>
868  {
869  std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureVersionInfoKHR const & accelerationStructureVersionInfoKHR ) const VULKAN_HPP_NOEXCEPT
870  {
871  std::size_t seed = 0;
872  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureVersionInfoKHR.sType );
873  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureVersionInfoKHR.pNext );
874  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureVersionInfoKHR.pVersionData );
875  return seed;
876  }
877  };
878 
879  template <>
880  struct hash<VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR>
881  {
882  std::size_t operator()( VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR const & acquireNextImageInfoKHR ) const VULKAN_HPP_NOEXCEPT
883  {
884  std::size_t seed = 0;
885  VULKAN_HPP_HASH_COMBINE( seed, acquireNextImageInfoKHR.sType );
886  VULKAN_HPP_HASH_COMBINE( seed, acquireNextImageInfoKHR.pNext );
887  VULKAN_HPP_HASH_COMBINE( seed, acquireNextImageInfoKHR.swapchain );
888  VULKAN_HPP_HASH_COMBINE( seed, acquireNextImageInfoKHR.timeout );
889  VULKAN_HPP_HASH_COMBINE( seed, acquireNextImageInfoKHR.semaphore );
890  VULKAN_HPP_HASH_COMBINE( seed, acquireNextImageInfoKHR.fence );
891  VULKAN_HPP_HASH_COMBINE( seed, acquireNextImageInfoKHR.deviceMask );
892  return seed;
893  }
894  };
895 
896  template <>
897  struct hash<VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR>
898  {
899  std::size_t operator()( VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR const & acquireProfilingLockInfoKHR ) const VULKAN_HPP_NOEXCEPT
900  {
901  std::size_t seed = 0;
902  VULKAN_HPP_HASH_COMBINE( seed, acquireProfilingLockInfoKHR.sType );
903  VULKAN_HPP_HASH_COMBINE( seed, acquireProfilingLockInfoKHR.pNext );
904  VULKAN_HPP_HASH_COMBINE( seed, acquireProfilingLockInfoKHR.flags );
905  VULKAN_HPP_HASH_COMBINE( seed, acquireProfilingLockInfoKHR.timeout );
906  return seed;
907  }
908  };
909 
910  template <>
911  struct hash<VULKAN_HPP_NAMESPACE::AllocationCallbacks>
912  {
913  std::size_t operator()( VULKAN_HPP_NAMESPACE::AllocationCallbacks const & allocationCallbacks ) const VULKAN_HPP_NOEXCEPT
914  {
915  std::size_t seed = 0;
916  VULKAN_HPP_HASH_COMBINE( seed, allocationCallbacks.pUserData );
917  VULKAN_HPP_HASH_COMBINE( seed, allocationCallbacks.pfnAllocation );
918  VULKAN_HPP_HASH_COMBINE( seed, allocationCallbacks.pfnReallocation );
919  VULKAN_HPP_HASH_COMBINE( seed, allocationCallbacks.pfnFree );
920  VULKAN_HPP_HASH_COMBINE( seed, allocationCallbacks.pfnInternalAllocation );
921  VULKAN_HPP_HASH_COMBINE( seed, allocationCallbacks.pfnInternalFree );
922  return seed;
923  }
924  };
925 
926  template <>
927  struct hash<VULKAN_HPP_NAMESPACE::AmigoProfilingSubmitInfoSEC>
928  {
929  std::size_t operator()( VULKAN_HPP_NAMESPACE::AmigoProfilingSubmitInfoSEC const & amigoProfilingSubmitInfoSEC ) const VULKAN_HPP_NOEXCEPT
930  {
931  std::size_t seed = 0;
932  VULKAN_HPP_HASH_COMBINE( seed, amigoProfilingSubmitInfoSEC.sType );
933  VULKAN_HPP_HASH_COMBINE( seed, amigoProfilingSubmitInfoSEC.pNext );
934  VULKAN_HPP_HASH_COMBINE( seed, amigoProfilingSubmitInfoSEC.firstDrawTimestamp );
935  VULKAN_HPP_HASH_COMBINE( seed, amigoProfilingSubmitInfoSEC.swapBufferTimestamp );
936  return seed;
937  }
938  };
939 
940  template <>
941  struct hash<VULKAN_HPP_NAMESPACE::ComponentMapping>
942  {
943  std::size_t operator()( VULKAN_HPP_NAMESPACE::ComponentMapping const & componentMapping ) const VULKAN_HPP_NOEXCEPT
944  {
945  std::size_t seed = 0;
946  VULKAN_HPP_HASH_COMBINE( seed, componentMapping.r );
947  VULKAN_HPP_HASH_COMBINE( seed, componentMapping.g );
948  VULKAN_HPP_HASH_COMBINE( seed, componentMapping.b );
949  VULKAN_HPP_HASH_COMBINE( seed, componentMapping.a );
950  return seed;
951  }
952  };
953 
954 # if defined( VK_USE_PLATFORM_ANDROID_KHR )
955  template <>
956  struct hash<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatProperties2ANDROID>
957  {
958  std::size_t operator()( VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatProperties2ANDROID const & androidHardwareBufferFormatProperties2ANDROID ) const
959  VULKAN_HPP_NOEXCEPT
960  {
961  std::size_t seed = 0;
962  VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.sType );
963  VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.pNext );
964  VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.format );
965  VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.externalFormat );
966  VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.formatFeatures );
967  VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.samplerYcbcrConversionComponents );
968  VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.suggestedYcbcrModel );
969  VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.suggestedYcbcrRange );
970  VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.suggestedXChromaOffset );
971  VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.suggestedYChromaOffset );
972  return seed;
973  }
974  };
975 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/
976 
977 # if defined( VK_USE_PLATFORM_ANDROID_KHR )
978  template <>
979  struct hash<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatPropertiesANDROID>
980  {
981  std::size_t operator()( VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatPropertiesANDROID const & androidHardwareBufferFormatPropertiesANDROID ) const
982  VULKAN_HPP_NOEXCEPT
983  {
984  std::size_t seed = 0;
985  VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.sType );
986  VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.pNext );
987  VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.format );
988  VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.externalFormat );
989  VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.formatFeatures );
990  VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.samplerYcbcrConversionComponents );
991  VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.suggestedYcbcrModel );
992  VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.suggestedYcbcrRange );
993  VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.suggestedXChromaOffset );
994  VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.suggestedYChromaOffset );
995  return seed;
996  }
997  };
998 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/
999 
1000 # if defined( VK_USE_PLATFORM_ANDROID_KHR )
1001  template <>
1002  struct hash<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatResolvePropertiesANDROID>
1003  {
1004  std::size_t
1005  operator()( VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatResolvePropertiesANDROID const & androidHardwareBufferFormatResolvePropertiesANDROID ) const
1006  VULKAN_HPP_NOEXCEPT
1007  {
1008  std::size_t seed = 0;
1009  VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatResolvePropertiesANDROID.sType );
1010  VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatResolvePropertiesANDROID.pNext );
1011  VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatResolvePropertiesANDROID.colorAttachmentFormat );
1012  return seed;
1013  }
1014  };
1015 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/
1016 
1017 # if defined( VK_USE_PLATFORM_ANDROID_KHR )
1018  template <>
1019  struct hash<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID>
1020  {
1021  std::size_t
1022  operator()( VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID const & androidHardwareBufferPropertiesANDROID ) const VULKAN_HPP_NOEXCEPT
1023  {
1024  std::size_t seed = 0;
1025  VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferPropertiesANDROID.sType );
1026  VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferPropertiesANDROID.pNext );
1027  VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferPropertiesANDROID.allocationSize );
1028  VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferPropertiesANDROID.memoryTypeBits );
1029  return seed;
1030  }
1031  };
1032 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/
1033 
1034 # if defined( VK_USE_PLATFORM_ANDROID_KHR )
1035  template <>
1036  struct hash<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferUsageANDROID>
1037  {
1038  std::size_t operator()( VULKAN_HPP_NAMESPACE::AndroidHardwareBufferUsageANDROID const & androidHardwareBufferUsageANDROID ) const VULKAN_HPP_NOEXCEPT
1039  {
1040  std::size_t seed = 0;
1041  VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferUsageANDROID.sType );
1042  VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferUsageANDROID.pNext );
1043  VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferUsageANDROID.androidHardwareBufferUsage );
1044  return seed;
1045  }
1046  };
1047 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/
1048 
1049 # if defined( VK_USE_PLATFORM_ANDROID_KHR )
1050  template <>
1051  struct hash<VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR>
1052  {
1053  std::size_t operator()( VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR const & androidSurfaceCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
1054  {
1055  std::size_t seed = 0;
1056  VULKAN_HPP_HASH_COMBINE( seed, androidSurfaceCreateInfoKHR.sType );
1057  VULKAN_HPP_HASH_COMBINE( seed, androidSurfaceCreateInfoKHR.pNext );
1058  VULKAN_HPP_HASH_COMBINE( seed, androidSurfaceCreateInfoKHR.flags );
1059  VULKAN_HPP_HASH_COMBINE( seed, androidSurfaceCreateInfoKHR.window );
1060  return seed;
1061  }
1062  };
1063 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/
1064 
1065  template <>
1066  struct hash<VULKAN_HPP_NAMESPACE::ApplicationInfo>
1067  {
1068  std::size_t operator()( VULKAN_HPP_NAMESPACE::ApplicationInfo const & applicationInfo ) const VULKAN_HPP_NOEXCEPT
1069  {
1070  std::size_t seed = 0;
1071  VULKAN_HPP_HASH_COMBINE( seed, applicationInfo.sType );
1072  VULKAN_HPP_HASH_COMBINE( seed, applicationInfo.pNext );
1073  for ( const char * p = applicationInfo.pApplicationName; *p != '\0'; ++p )
1074  {
1075  VULKAN_HPP_HASH_COMBINE( seed, *p );
1076  }
1077  VULKAN_HPP_HASH_COMBINE( seed, applicationInfo.applicationVersion );
1078  for ( const char * p = applicationInfo.pEngineName; *p != '\0'; ++p )
1079  {
1080  VULKAN_HPP_HASH_COMBINE( seed, *p );
1081  }
1082  VULKAN_HPP_HASH_COMBINE( seed, applicationInfo.engineVersion );
1083  VULKAN_HPP_HASH_COMBINE( seed, applicationInfo.apiVersion );
1084  return seed;
1085  }
1086  };
1087 
1088  template <>
1089  struct hash<VULKAN_HPP_NAMESPACE::AttachmentDescription>
1090  {
1091  std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentDescription const & attachmentDescription ) const VULKAN_HPP_NOEXCEPT
1092  {
1093  std::size_t seed = 0;
1094  VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.flags );
1095  VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.format );
1096  VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.samples );
1097  VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.loadOp );
1098  VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.storeOp );
1099  VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.stencilLoadOp );
1100  VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.stencilStoreOp );
1101  VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.initialLayout );
1102  VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.finalLayout );
1103  return seed;
1104  }
1105  };
1106 
1107  template <>
1108  struct hash<VULKAN_HPP_NAMESPACE::AttachmentDescription2>
1109  {
1110  std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentDescription2 const & attachmentDescription2 ) const VULKAN_HPP_NOEXCEPT
1111  {
1112  std::size_t seed = 0;
1113  VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.sType );
1114  VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.pNext );
1115  VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.flags );
1116  VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.format );
1117  VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.samples );
1118  VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.loadOp );
1119  VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.storeOp );
1120  VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.stencilLoadOp );
1121  VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.stencilStoreOp );
1122  VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.initialLayout );
1123  VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.finalLayout );
1124  return seed;
1125  }
1126  };
1127 
1128  template <>
1129  struct hash<VULKAN_HPP_NAMESPACE::AttachmentDescriptionStencilLayout>
1130  {
1131  std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentDescriptionStencilLayout const & attachmentDescriptionStencilLayout ) const VULKAN_HPP_NOEXCEPT
1132  {
1133  std::size_t seed = 0;
1134  VULKAN_HPP_HASH_COMBINE( seed, attachmentDescriptionStencilLayout.sType );
1135  VULKAN_HPP_HASH_COMBINE( seed, attachmentDescriptionStencilLayout.pNext );
1136  VULKAN_HPP_HASH_COMBINE( seed, attachmentDescriptionStencilLayout.stencilInitialLayout );
1137  VULKAN_HPP_HASH_COMBINE( seed, attachmentDescriptionStencilLayout.stencilFinalLayout );
1138  return seed;
1139  }
1140  };
1141 
1142  template <>
1143  struct hash<VULKAN_HPP_NAMESPACE::AttachmentReference>
1144  {
1145  std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentReference const & attachmentReference ) const VULKAN_HPP_NOEXCEPT
1146  {
1147  std::size_t seed = 0;
1148  VULKAN_HPP_HASH_COMBINE( seed, attachmentReference.attachment );
1149  VULKAN_HPP_HASH_COMBINE( seed, attachmentReference.layout );
1150  return seed;
1151  }
1152  };
1153 
1154  template <>
1155  struct hash<VULKAN_HPP_NAMESPACE::AttachmentReference2>
1156  {
1157  std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentReference2 const & attachmentReference2 ) const VULKAN_HPP_NOEXCEPT
1158  {
1159  std::size_t seed = 0;
1160  VULKAN_HPP_HASH_COMBINE( seed, attachmentReference2.sType );
1161  VULKAN_HPP_HASH_COMBINE( seed, attachmentReference2.pNext );
1162  VULKAN_HPP_HASH_COMBINE( seed, attachmentReference2.attachment );
1163  VULKAN_HPP_HASH_COMBINE( seed, attachmentReference2.layout );
1164  VULKAN_HPP_HASH_COMBINE( seed, attachmentReference2.aspectMask );
1165  return seed;
1166  }
1167  };
1168 
1169  template <>
1170  struct hash<VULKAN_HPP_NAMESPACE::AttachmentReferenceStencilLayout>
1171  {
1172  std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentReferenceStencilLayout const & attachmentReferenceStencilLayout ) const VULKAN_HPP_NOEXCEPT
1173  {
1174  std::size_t seed = 0;
1175  VULKAN_HPP_HASH_COMBINE( seed, attachmentReferenceStencilLayout.sType );
1176  VULKAN_HPP_HASH_COMBINE( seed, attachmentReferenceStencilLayout.pNext );
1177  VULKAN_HPP_HASH_COMBINE( seed, attachmentReferenceStencilLayout.stencilLayout );
1178  return seed;
1179  }
1180  };
1181 
1182  template <>
1183  struct hash<VULKAN_HPP_NAMESPACE::AttachmentSampleCountInfoAMD>
1184  {
1185  std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentSampleCountInfoAMD const & attachmentSampleCountInfoAMD ) const VULKAN_HPP_NOEXCEPT
1186  {
1187  std::size_t seed = 0;
1188  VULKAN_HPP_HASH_COMBINE( seed, attachmentSampleCountInfoAMD.sType );
1189  VULKAN_HPP_HASH_COMBINE( seed, attachmentSampleCountInfoAMD.pNext );
1190  VULKAN_HPP_HASH_COMBINE( seed, attachmentSampleCountInfoAMD.colorAttachmentCount );
1191  VULKAN_HPP_HASH_COMBINE( seed, attachmentSampleCountInfoAMD.pColorAttachmentSamples );
1192  VULKAN_HPP_HASH_COMBINE( seed, attachmentSampleCountInfoAMD.depthStencilAttachmentSamples );
1193  return seed;
1194  }
1195  };
1196 
1197  template <>
1198  struct hash<VULKAN_HPP_NAMESPACE::Extent2D>
1199  {
1200  std::size_t operator()( VULKAN_HPP_NAMESPACE::Extent2D const & extent2D ) const VULKAN_HPP_NOEXCEPT
1201  {
1202  std::size_t seed = 0;
1203  VULKAN_HPP_HASH_COMBINE( seed, extent2D.width );
1204  VULKAN_HPP_HASH_COMBINE( seed, extent2D.height );
1205  return seed;
1206  }
1207  };
1208 
1209  template <>
1210  struct hash<VULKAN_HPP_NAMESPACE::SampleLocationEXT>
1211  {
1212  std::size_t operator()( VULKAN_HPP_NAMESPACE::SampleLocationEXT const & sampleLocationEXT ) const VULKAN_HPP_NOEXCEPT
1213  {
1214  std::size_t seed = 0;
1215  VULKAN_HPP_HASH_COMBINE( seed, sampleLocationEXT.x );
1216  VULKAN_HPP_HASH_COMBINE( seed, sampleLocationEXT.y );
1217  return seed;
1218  }
1219  };
1220 
1221  template <>
1222  struct hash<VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT>
1223  {
1224  std::size_t operator()( VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT const & sampleLocationsInfoEXT ) const VULKAN_HPP_NOEXCEPT
1225  {
1226  std::size_t seed = 0;
1227  VULKAN_HPP_HASH_COMBINE( seed, sampleLocationsInfoEXT.sType );
1228  VULKAN_HPP_HASH_COMBINE( seed, sampleLocationsInfoEXT.pNext );
1229  VULKAN_HPP_HASH_COMBINE( seed, sampleLocationsInfoEXT.sampleLocationsPerPixel );
1230  VULKAN_HPP_HASH_COMBINE( seed, sampleLocationsInfoEXT.sampleLocationGridSize );
1231  VULKAN_HPP_HASH_COMBINE( seed, sampleLocationsInfoEXT.sampleLocationsCount );
1232  VULKAN_HPP_HASH_COMBINE( seed, sampleLocationsInfoEXT.pSampleLocations );
1233  return seed;
1234  }
1235  };
1236 
1237  template <>
1238  struct hash<VULKAN_HPP_NAMESPACE::AttachmentSampleLocationsEXT>
1239  {
1240  std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentSampleLocationsEXT const & attachmentSampleLocationsEXT ) const VULKAN_HPP_NOEXCEPT
1241  {
1242  std::size_t seed = 0;
1243  VULKAN_HPP_HASH_COMBINE( seed, attachmentSampleLocationsEXT.attachmentIndex );
1244  VULKAN_HPP_HASH_COMBINE( seed, attachmentSampleLocationsEXT.sampleLocationsInfo );
1245  return seed;
1246  }
1247  };
1248 
1249  template <>
1250  struct hash<VULKAN_HPP_NAMESPACE::BaseInStructure>
1251  {
1252  std::size_t operator()( VULKAN_HPP_NAMESPACE::BaseInStructure const & baseInStructure ) const VULKAN_HPP_NOEXCEPT
1253  {
1254  std::size_t seed = 0;
1255  VULKAN_HPP_HASH_COMBINE( seed, baseInStructure.sType );
1256  VULKAN_HPP_HASH_COMBINE( seed, baseInStructure.pNext );
1257  return seed;
1258  }
1259  };
1260 
1261  template <>
1262  struct hash<VULKAN_HPP_NAMESPACE::BaseOutStructure>
1263  {
1264  std::size_t operator()( VULKAN_HPP_NAMESPACE::BaseOutStructure const & baseOutStructure ) const VULKAN_HPP_NOEXCEPT
1265  {
1266  std::size_t seed = 0;
1267  VULKAN_HPP_HASH_COMBINE( seed, baseOutStructure.sType );
1268  VULKAN_HPP_HASH_COMBINE( seed, baseOutStructure.pNext );
1269  return seed;
1270  }
1271  };
1272 
1273  template <>
1274  struct hash<VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV>
1275  {
1276  std::size_t
1277  operator()( VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV const & bindAccelerationStructureMemoryInfoNV ) const VULKAN_HPP_NOEXCEPT
1278  {
1279  std::size_t seed = 0;
1280  VULKAN_HPP_HASH_COMBINE( seed, bindAccelerationStructureMemoryInfoNV.sType );
1281  VULKAN_HPP_HASH_COMBINE( seed, bindAccelerationStructureMemoryInfoNV.pNext );
1282  VULKAN_HPP_HASH_COMBINE( seed, bindAccelerationStructureMemoryInfoNV.accelerationStructure );
1283  VULKAN_HPP_HASH_COMBINE( seed, bindAccelerationStructureMemoryInfoNV.memory );
1284  VULKAN_HPP_HASH_COMBINE( seed, bindAccelerationStructureMemoryInfoNV.memoryOffset );
1285  VULKAN_HPP_HASH_COMBINE( seed, bindAccelerationStructureMemoryInfoNV.deviceIndexCount );
1286  VULKAN_HPP_HASH_COMBINE( seed, bindAccelerationStructureMemoryInfoNV.pDeviceIndices );
1287  return seed;
1288  }
1289  };
1290 
1291  template <>
1292  struct hash<VULKAN_HPP_NAMESPACE::BindBufferMemoryDeviceGroupInfo>
1293  {
1294  std::size_t operator()( VULKAN_HPP_NAMESPACE::BindBufferMemoryDeviceGroupInfo const & bindBufferMemoryDeviceGroupInfo ) const VULKAN_HPP_NOEXCEPT
1295  {
1296  std::size_t seed = 0;
1297  VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryDeviceGroupInfo.sType );
1298  VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryDeviceGroupInfo.pNext );
1299  VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryDeviceGroupInfo.deviceIndexCount );
1300  VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryDeviceGroupInfo.pDeviceIndices );
1301  return seed;
1302  }
1303  };
1304 
1305  template <>
1306  struct hash<VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo>
1307  {
1308  std::size_t operator()( VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo const & bindBufferMemoryInfo ) const VULKAN_HPP_NOEXCEPT
1309  {
1310  std::size_t seed = 0;
1311  VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryInfo.sType );
1312  VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryInfo.pNext );
1313  VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryInfo.buffer );
1314  VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryInfo.memory );
1315  VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryInfo.memoryOffset );
1316  return seed;
1317  }
1318  };
1319 
1320  template <>
1321  struct hash<VULKAN_HPP_NAMESPACE::BindDescriptorBufferEmbeddedSamplersInfoEXT>
1322  {
1323  std::size_t operator()( VULKAN_HPP_NAMESPACE::BindDescriptorBufferEmbeddedSamplersInfoEXT const & bindDescriptorBufferEmbeddedSamplersInfoEXT ) const
1324  VULKAN_HPP_NOEXCEPT
1325  {
1326  std::size_t seed = 0;
1327  VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorBufferEmbeddedSamplersInfoEXT.sType );
1328  VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorBufferEmbeddedSamplersInfoEXT.pNext );
1329  VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorBufferEmbeddedSamplersInfoEXT.stageFlags );
1330  VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorBufferEmbeddedSamplersInfoEXT.layout );
1331  VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorBufferEmbeddedSamplersInfoEXT.set );
1332  return seed;
1333  }
1334  };
1335 
1336  template <>
1337  struct hash<VULKAN_HPP_NAMESPACE::BindDescriptorSetsInfoKHR>
1338  {
1339  std::size_t operator()( VULKAN_HPP_NAMESPACE::BindDescriptorSetsInfoKHR const & bindDescriptorSetsInfoKHR ) const VULKAN_HPP_NOEXCEPT
1340  {
1341  std::size_t seed = 0;
1342  VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorSetsInfoKHR.sType );
1343  VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorSetsInfoKHR.pNext );
1344  VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorSetsInfoKHR.stageFlags );
1345  VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorSetsInfoKHR.layout );
1346  VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorSetsInfoKHR.firstSet );
1347  VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorSetsInfoKHR.descriptorSetCount );
1348  VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorSetsInfoKHR.pDescriptorSets );
1349  VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorSetsInfoKHR.dynamicOffsetCount );
1350  VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorSetsInfoKHR.pDynamicOffsets );
1351  return seed;
1352  }
1353  };
1354 
1355  template <>
1356  struct hash<VULKAN_HPP_NAMESPACE::Offset2D>
1357  {
1358  std::size_t operator()( VULKAN_HPP_NAMESPACE::Offset2D const & offset2D ) const VULKAN_HPP_NOEXCEPT
1359  {
1360  std::size_t seed = 0;
1361  VULKAN_HPP_HASH_COMBINE( seed, offset2D.x );
1362  VULKAN_HPP_HASH_COMBINE( seed, offset2D.y );
1363  return seed;
1364  }
1365  };
1366 
1367  template <>
1368  struct hash<VULKAN_HPP_NAMESPACE::Rect2D>
1369  {
1370  std::size_t operator()( VULKAN_HPP_NAMESPACE::Rect2D const & rect2D ) const VULKAN_HPP_NOEXCEPT
1371  {
1372  std::size_t seed = 0;
1373  VULKAN_HPP_HASH_COMBINE( seed, rect2D.offset );
1374  VULKAN_HPP_HASH_COMBINE( seed, rect2D.extent );
1375  return seed;
1376  }
1377  };
1378 
1379  template <>
1380  struct hash<VULKAN_HPP_NAMESPACE::BindImageMemoryDeviceGroupInfo>
1381  {
1382  std::size_t operator()( VULKAN_HPP_NAMESPACE::BindImageMemoryDeviceGroupInfo const & bindImageMemoryDeviceGroupInfo ) const VULKAN_HPP_NOEXCEPT
1383  {
1384  std::size_t seed = 0;
1385  VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryDeviceGroupInfo.sType );
1386  VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryDeviceGroupInfo.pNext );
1387  VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryDeviceGroupInfo.deviceIndexCount );
1388  VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryDeviceGroupInfo.pDeviceIndices );
1389  VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryDeviceGroupInfo.splitInstanceBindRegionCount );
1390  VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryDeviceGroupInfo.pSplitInstanceBindRegions );
1391  return seed;
1392  }
1393  };
1394 
1395  template <>
1396  struct hash<VULKAN_HPP_NAMESPACE::BindImageMemoryInfo>
1397  {
1398  std::size_t operator()( VULKAN_HPP_NAMESPACE::BindImageMemoryInfo const & bindImageMemoryInfo ) const VULKAN_HPP_NOEXCEPT
1399  {
1400  std::size_t seed = 0;
1401  VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryInfo.sType );
1402  VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryInfo.pNext );
1403  VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryInfo.image );
1404  VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryInfo.memory );
1405  VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryInfo.memoryOffset );
1406  return seed;
1407  }
1408  };
1409 
1410  template <>
1411  struct hash<VULKAN_HPP_NAMESPACE::BindImageMemorySwapchainInfoKHR>
1412  {
1413  std::size_t operator()( VULKAN_HPP_NAMESPACE::BindImageMemorySwapchainInfoKHR const & bindImageMemorySwapchainInfoKHR ) const VULKAN_HPP_NOEXCEPT
1414  {
1415  std::size_t seed = 0;
1416  VULKAN_HPP_HASH_COMBINE( seed, bindImageMemorySwapchainInfoKHR.sType );
1417  VULKAN_HPP_HASH_COMBINE( seed, bindImageMemorySwapchainInfoKHR.pNext );
1418  VULKAN_HPP_HASH_COMBINE( seed, bindImageMemorySwapchainInfoKHR.swapchain );
1419  VULKAN_HPP_HASH_COMBINE( seed, bindImageMemorySwapchainInfoKHR.imageIndex );
1420  return seed;
1421  }
1422  };
1423 
1424  template <>
1425  struct hash<VULKAN_HPP_NAMESPACE::BindImagePlaneMemoryInfo>
1426  {
1427  std::size_t operator()( VULKAN_HPP_NAMESPACE::BindImagePlaneMemoryInfo const & bindImagePlaneMemoryInfo ) const VULKAN_HPP_NOEXCEPT
1428  {
1429  std::size_t seed = 0;
1430  VULKAN_HPP_HASH_COMBINE( seed, bindImagePlaneMemoryInfo.sType );
1431  VULKAN_HPP_HASH_COMBINE( seed, bindImagePlaneMemoryInfo.pNext );
1432  VULKAN_HPP_HASH_COMBINE( seed, bindImagePlaneMemoryInfo.planeAspect );
1433  return seed;
1434  }
1435  };
1436 
1437  template <>
1438  struct hash<VULKAN_HPP_NAMESPACE::BindIndexBufferIndirectCommandNV>
1439  {
1440  std::size_t operator()( VULKAN_HPP_NAMESPACE::BindIndexBufferIndirectCommandNV const & bindIndexBufferIndirectCommandNV ) const VULKAN_HPP_NOEXCEPT
1441  {
1442  std::size_t seed = 0;
1443  VULKAN_HPP_HASH_COMBINE( seed, bindIndexBufferIndirectCommandNV.bufferAddress );
1444  VULKAN_HPP_HASH_COMBINE( seed, bindIndexBufferIndirectCommandNV.size );
1445  VULKAN_HPP_HASH_COMBINE( seed, bindIndexBufferIndirectCommandNV.indexType );
1446  return seed;
1447  }
1448  };
1449 
1450  template <>
1451  struct hash<VULKAN_HPP_NAMESPACE::BindMemoryStatusKHR>
1452  {
1453  std::size_t operator()( VULKAN_HPP_NAMESPACE::BindMemoryStatusKHR const & bindMemoryStatusKHR ) const VULKAN_HPP_NOEXCEPT
1454  {
1455  std::size_t seed = 0;
1456  VULKAN_HPP_HASH_COMBINE( seed, bindMemoryStatusKHR.sType );
1457  VULKAN_HPP_HASH_COMBINE( seed, bindMemoryStatusKHR.pNext );
1458  VULKAN_HPP_HASH_COMBINE( seed, bindMemoryStatusKHR.pResult );
1459  return seed;
1460  }
1461  };
1462 
1463  template <>
1464  struct hash<VULKAN_HPP_NAMESPACE::BindPipelineIndirectCommandNV>
1465  {
1466  std::size_t operator()( VULKAN_HPP_NAMESPACE::BindPipelineIndirectCommandNV const & bindPipelineIndirectCommandNV ) const VULKAN_HPP_NOEXCEPT
1467  {
1468  std::size_t seed = 0;
1469  VULKAN_HPP_HASH_COMBINE( seed, bindPipelineIndirectCommandNV.pipelineAddress );
1470  return seed;
1471  }
1472  };
1473 
1474  template <>
1475  struct hash<VULKAN_HPP_NAMESPACE::BindShaderGroupIndirectCommandNV>
1476  {
1477  std::size_t operator()( VULKAN_HPP_NAMESPACE::BindShaderGroupIndirectCommandNV const & bindShaderGroupIndirectCommandNV ) const VULKAN_HPP_NOEXCEPT
1478  {
1479  std::size_t seed = 0;
1480  VULKAN_HPP_HASH_COMBINE( seed, bindShaderGroupIndirectCommandNV.groupIndex );
1481  return seed;
1482  }
1483  };
1484 
1485  template <>
1486  struct hash<VULKAN_HPP_NAMESPACE::SparseMemoryBind>
1487  {
1488  std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseMemoryBind const & sparseMemoryBind ) const VULKAN_HPP_NOEXCEPT
1489  {
1490  std::size_t seed = 0;
1491  VULKAN_HPP_HASH_COMBINE( seed, sparseMemoryBind.resourceOffset );
1492  VULKAN_HPP_HASH_COMBINE( seed, sparseMemoryBind.size );
1493  VULKAN_HPP_HASH_COMBINE( seed, sparseMemoryBind.memory );
1494  VULKAN_HPP_HASH_COMBINE( seed, sparseMemoryBind.memoryOffset );
1495  VULKAN_HPP_HASH_COMBINE( seed, sparseMemoryBind.flags );
1496  return seed;
1497  }
1498  };
1499 
1500  template <>
1501  struct hash<VULKAN_HPP_NAMESPACE::SparseBufferMemoryBindInfo>
1502  {
1503  std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseBufferMemoryBindInfo const & sparseBufferMemoryBindInfo ) const VULKAN_HPP_NOEXCEPT
1504  {
1505  std::size_t seed = 0;
1506  VULKAN_HPP_HASH_COMBINE( seed, sparseBufferMemoryBindInfo.buffer );
1507  VULKAN_HPP_HASH_COMBINE( seed, sparseBufferMemoryBindInfo.bindCount );
1508  VULKAN_HPP_HASH_COMBINE( seed, sparseBufferMemoryBindInfo.pBinds );
1509  return seed;
1510  }
1511  };
1512 
1513  template <>
1514  struct hash<VULKAN_HPP_NAMESPACE::SparseImageOpaqueMemoryBindInfo>
1515  {
1516  std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageOpaqueMemoryBindInfo const & sparseImageOpaqueMemoryBindInfo ) const VULKAN_HPP_NOEXCEPT
1517  {
1518  std::size_t seed = 0;
1519  VULKAN_HPP_HASH_COMBINE( seed, sparseImageOpaqueMemoryBindInfo.image );
1520  VULKAN_HPP_HASH_COMBINE( seed, sparseImageOpaqueMemoryBindInfo.bindCount );
1521  VULKAN_HPP_HASH_COMBINE( seed, sparseImageOpaqueMemoryBindInfo.pBinds );
1522  return seed;
1523  }
1524  };
1525 
1526  template <>
1527  struct hash<VULKAN_HPP_NAMESPACE::ImageSubresource>
1528  {
1529  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageSubresource const & imageSubresource ) const VULKAN_HPP_NOEXCEPT
1530  {
1531  std::size_t seed = 0;
1532  VULKAN_HPP_HASH_COMBINE( seed, imageSubresource.aspectMask );
1533  VULKAN_HPP_HASH_COMBINE( seed, imageSubresource.mipLevel );
1534  VULKAN_HPP_HASH_COMBINE( seed, imageSubresource.arrayLayer );
1535  return seed;
1536  }
1537  };
1538 
1539  template <>
1540  struct hash<VULKAN_HPP_NAMESPACE::Offset3D>
1541  {
1542  std::size_t operator()( VULKAN_HPP_NAMESPACE::Offset3D const & offset3D ) const VULKAN_HPP_NOEXCEPT
1543  {
1544  std::size_t seed = 0;
1545  VULKAN_HPP_HASH_COMBINE( seed, offset3D.x );
1546  VULKAN_HPP_HASH_COMBINE( seed, offset3D.y );
1547  VULKAN_HPP_HASH_COMBINE( seed, offset3D.z );
1548  return seed;
1549  }
1550  };
1551 
1552  template <>
1553  struct hash<VULKAN_HPP_NAMESPACE::Extent3D>
1554  {
1555  std::size_t operator()( VULKAN_HPP_NAMESPACE::Extent3D const & extent3D ) const VULKAN_HPP_NOEXCEPT
1556  {
1557  std::size_t seed = 0;
1558  VULKAN_HPP_HASH_COMBINE( seed, extent3D.width );
1559  VULKAN_HPP_HASH_COMBINE( seed, extent3D.height );
1560  VULKAN_HPP_HASH_COMBINE( seed, extent3D.depth );
1561  return seed;
1562  }
1563  };
1564 
1565  template <>
1566  struct hash<VULKAN_HPP_NAMESPACE::SparseImageMemoryBind>
1567  {
1568  std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageMemoryBind const & sparseImageMemoryBind ) const VULKAN_HPP_NOEXCEPT
1569  {
1570  std::size_t seed = 0;
1571  VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBind.subresource );
1572  VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBind.offset );
1573  VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBind.extent );
1574  VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBind.memory );
1575  VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBind.memoryOffset );
1576  VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBind.flags );
1577  return seed;
1578  }
1579  };
1580 
1581  template <>
1582  struct hash<VULKAN_HPP_NAMESPACE::SparseImageMemoryBindInfo>
1583  {
1584  std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageMemoryBindInfo const & sparseImageMemoryBindInfo ) const VULKAN_HPP_NOEXCEPT
1585  {
1586  std::size_t seed = 0;
1587  VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBindInfo.image );
1588  VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBindInfo.bindCount );
1589  VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBindInfo.pBinds );
1590  return seed;
1591  }
1592  };
1593 
1594  template <>
1595  struct hash<VULKAN_HPP_NAMESPACE::BindSparseInfo>
1596  {
1597  std::size_t operator()( VULKAN_HPP_NAMESPACE::BindSparseInfo const & bindSparseInfo ) const VULKAN_HPP_NOEXCEPT
1598  {
1599  std::size_t seed = 0;
1600  VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.sType );
1601  VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.pNext );
1602  VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.waitSemaphoreCount );
1603  VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.pWaitSemaphores );
1604  VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.bufferBindCount );
1605  VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.pBufferBinds );
1606  VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.imageOpaqueBindCount );
1607  VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.pImageOpaqueBinds );
1608  VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.imageBindCount );
1609  VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.pImageBinds );
1610  VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.signalSemaphoreCount );
1611  VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.pSignalSemaphores );
1612  return seed;
1613  }
1614  };
1615 
1616  template <>
1617  struct hash<VULKAN_HPP_NAMESPACE::BindVertexBufferIndirectCommandNV>
1618  {
1619  std::size_t operator()( VULKAN_HPP_NAMESPACE::BindVertexBufferIndirectCommandNV const & bindVertexBufferIndirectCommandNV ) const VULKAN_HPP_NOEXCEPT
1620  {
1621  std::size_t seed = 0;
1622  VULKAN_HPP_HASH_COMBINE( seed, bindVertexBufferIndirectCommandNV.bufferAddress );
1623  VULKAN_HPP_HASH_COMBINE( seed, bindVertexBufferIndirectCommandNV.size );
1624  VULKAN_HPP_HASH_COMBINE( seed, bindVertexBufferIndirectCommandNV.stride );
1625  return seed;
1626  }
1627  };
1628 
1629  template <>
1630  struct hash<VULKAN_HPP_NAMESPACE::BindVideoSessionMemoryInfoKHR>
1631  {
1632  std::size_t operator()( VULKAN_HPP_NAMESPACE::BindVideoSessionMemoryInfoKHR const & bindVideoSessionMemoryInfoKHR ) const VULKAN_HPP_NOEXCEPT
1633  {
1634  std::size_t seed = 0;
1635  VULKAN_HPP_HASH_COMBINE( seed, bindVideoSessionMemoryInfoKHR.sType );
1636  VULKAN_HPP_HASH_COMBINE( seed, bindVideoSessionMemoryInfoKHR.pNext );
1637  VULKAN_HPP_HASH_COMBINE( seed, bindVideoSessionMemoryInfoKHR.memoryBindIndex );
1638  VULKAN_HPP_HASH_COMBINE( seed, bindVideoSessionMemoryInfoKHR.memory );
1639  VULKAN_HPP_HASH_COMBINE( seed, bindVideoSessionMemoryInfoKHR.memoryOffset );
1640  VULKAN_HPP_HASH_COMBINE( seed, bindVideoSessionMemoryInfoKHR.memorySize );
1641  return seed;
1642  }
1643  };
1644 
1645  template <>
1646  struct hash<VULKAN_HPP_NAMESPACE::BlitImageCubicWeightsInfoQCOM>
1647  {
1648  std::size_t operator()( VULKAN_HPP_NAMESPACE::BlitImageCubicWeightsInfoQCOM const & blitImageCubicWeightsInfoQCOM ) const VULKAN_HPP_NOEXCEPT
1649  {
1650  std::size_t seed = 0;
1651  VULKAN_HPP_HASH_COMBINE( seed, blitImageCubicWeightsInfoQCOM.sType );
1652  VULKAN_HPP_HASH_COMBINE( seed, blitImageCubicWeightsInfoQCOM.pNext );
1653  VULKAN_HPP_HASH_COMBINE( seed, blitImageCubicWeightsInfoQCOM.cubicWeights );
1654  return seed;
1655  }
1656  };
1657 
1658  template <>
1659  struct hash<VULKAN_HPP_NAMESPACE::ImageSubresourceLayers>
1660  {
1661  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const & imageSubresourceLayers ) const VULKAN_HPP_NOEXCEPT
1662  {
1663  std::size_t seed = 0;
1664  VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceLayers.aspectMask );
1665  VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceLayers.mipLevel );
1666  VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceLayers.baseArrayLayer );
1667  VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceLayers.layerCount );
1668  return seed;
1669  }
1670  };
1671 
1672  template <>
1673  struct hash<VULKAN_HPP_NAMESPACE::ImageBlit2>
1674  {
1675  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageBlit2 const & imageBlit2 ) const VULKAN_HPP_NOEXCEPT
1676  {
1677  std::size_t seed = 0;
1678  VULKAN_HPP_HASH_COMBINE( seed, imageBlit2.sType );
1679  VULKAN_HPP_HASH_COMBINE( seed, imageBlit2.pNext );
1680  VULKAN_HPP_HASH_COMBINE( seed, imageBlit2.srcSubresource );
1681  for ( size_t i = 0; i < 2; ++i )
1682  {
1683  VULKAN_HPP_HASH_COMBINE( seed, imageBlit2.srcOffsets[i] );
1684  }
1685  VULKAN_HPP_HASH_COMBINE( seed, imageBlit2.dstSubresource );
1686  for ( size_t i = 0; i < 2; ++i )
1687  {
1688  VULKAN_HPP_HASH_COMBINE( seed, imageBlit2.dstOffsets[i] );
1689  }
1690  return seed;
1691  }
1692  };
1693 
1694  template <>
1695  struct hash<VULKAN_HPP_NAMESPACE::BlitImageInfo2>
1696  {
1697  std::size_t operator()( VULKAN_HPP_NAMESPACE::BlitImageInfo2 const & blitImageInfo2 ) const VULKAN_HPP_NOEXCEPT
1698  {
1699  std::size_t seed = 0;
1700  VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.sType );
1701  VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.pNext );
1702  VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.srcImage );
1703  VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.srcImageLayout );
1704  VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.dstImage );
1705  VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.dstImageLayout );
1706  VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.regionCount );
1707  VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.pRegions );
1708  VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.filter );
1709  return seed;
1710  }
1711  };
1712 
1713  template <>
1714  struct hash<VULKAN_HPP_NAMESPACE::BufferCaptureDescriptorDataInfoEXT>
1715  {
1716  std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCaptureDescriptorDataInfoEXT const & bufferCaptureDescriptorDataInfoEXT ) const VULKAN_HPP_NOEXCEPT
1717  {
1718  std::size_t seed = 0;
1719  VULKAN_HPP_HASH_COMBINE( seed, bufferCaptureDescriptorDataInfoEXT.sType );
1720  VULKAN_HPP_HASH_COMBINE( seed, bufferCaptureDescriptorDataInfoEXT.pNext );
1721  VULKAN_HPP_HASH_COMBINE( seed, bufferCaptureDescriptorDataInfoEXT.buffer );
1722  return seed;
1723  }
1724  };
1725 
1726 # if defined( VK_USE_PLATFORM_FUCHSIA )
1727  template <>
1728  struct hash<VULKAN_HPP_NAMESPACE::BufferCollectionBufferCreateInfoFUCHSIA>
1729  {
1730  std::size_t
1731  operator()( VULKAN_HPP_NAMESPACE::BufferCollectionBufferCreateInfoFUCHSIA const & bufferCollectionBufferCreateInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT
1732  {
1733  std::size_t seed = 0;
1734  VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionBufferCreateInfoFUCHSIA.sType );
1735  VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionBufferCreateInfoFUCHSIA.pNext );
1736  VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionBufferCreateInfoFUCHSIA.collection );
1737  VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionBufferCreateInfoFUCHSIA.index );
1738  return seed;
1739  }
1740  };
1741 # endif /*VK_USE_PLATFORM_FUCHSIA*/
1742 
1743 # if defined( VK_USE_PLATFORM_FUCHSIA )
1744  template <>
1745  struct hash<VULKAN_HPP_NAMESPACE::BufferCollectionConstraintsInfoFUCHSIA>
1746  {
1747  std::size_t
1748  operator()( VULKAN_HPP_NAMESPACE::BufferCollectionConstraintsInfoFUCHSIA const & bufferCollectionConstraintsInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT
1749  {
1750  std::size_t seed = 0;
1751  VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionConstraintsInfoFUCHSIA.sType );
1752  VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionConstraintsInfoFUCHSIA.pNext );
1753  VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionConstraintsInfoFUCHSIA.minBufferCount );
1754  VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionConstraintsInfoFUCHSIA.maxBufferCount );
1755  VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionConstraintsInfoFUCHSIA.minBufferCountForCamping );
1756  VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionConstraintsInfoFUCHSIA.minBufferCountForDedicatedSlack );
1757  VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionConstraintsInfoFUCHSIA.minBufferCountForSharedSlack );
1758  return seed;
1759  }
1760  };
1761 # endif /*VK_USE_PLATFORM_FUCHSIA*/
1762 
1763 # if defined( VK_USE_PLATFORM_FUCHSIA )
1764  template <>
1765  struct hash<VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA>
1766  {
1767  std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA const & bufferCollectionCreateInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT
1768  {
1769  std::size_t seed = 0;
1770  VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionCreateInfoFUCHSIA.sType );
1771  VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionCreateInfoFUCHSIA.pNext );
1772  VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionCreateInfoFUCHSIA.collectionToken );
1773  return seed;
1774  }
1775  };
1776 # endif /*VK_USE_PLATFORM_FUCHSIA*/
1777 
1778 # if defined( VK_USE_PLATFORM_FUCHSIA )
1779  template <>
1780  struct hash<VULKAN_HPP_NAMESPACE::BufferCollectionImageCreateInfoFUCHSIA>
1781  {
1782  std::size_t
1783  operator()( VULKAN_HPP_NAMESPACE::BufferCollectionImageCreateInfoFUCHSIA const & bufferCollectionImageCreateInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT
1784  {
1785  std::size_t seed = 0;
1786  VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionImageCreateInfoFUCHSIA.sType );
1787  VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionImageCreateInfoFUCHSIA.pNext );
1788  VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionImageCreateInfoFUCHSIA.collection );
1789  VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionImageCreateInfoFUCHSIA.index );
1790  return seed;
1791  }
1792  };
1793 # endif /*VK_USE_PLATFORM_FUCHSIA*/
1794 
1795 # if defined( VK_USE_PLATFORM_FUCHSIA )
1796  template <>
1797  struct hash<VULKAN_HPP_NAMESPACE::SysmemColorSpaceFUCHSIA>
1798  {
1799  std::size_t operator()( VULKAN_HPP_NAMESPACE::SysmemColorSpaceFUCHSIA const & sysmemColorSpaceFUCHSIA ) const VULKAN_HPP_NOEXCEPT
1800  {
1801  std::size_t seed = 0;
1802  VULKAN_HPP_HASH_COMBINE( seed, sysmemColorSpaceFUCHSIA.sType );
1803  VULKAN_HPP_HASH_COMBINE( seed, sysmemColorSpaceFUCHSIA.pNext );
1804  VULKAN_HPP_HASH_COMBINE( seed, sysmemColorSpaceFUCHSIA.colorSpace );
1805  return seed;
1806  }
1807  };
1808 # endif /*VK_USE_PLATFORM_FUCHSIA*/
1809 
1810 # if defined( VK_USE_PLATFORM_FUCHSIA )
1811  template <>
1812  struct hash<VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA>
1813  {
1814  std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA const & bufferCollectionPropertiesFUCHSIA ) const VULKAN_HPP_NOEXCEPT
1815  {
1816  std::size_t seed = 0;
1817  VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.sType );
1818  VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.pNext );
1819  VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.memoryTypeBits );
1820  VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.bufferCount );
1821  VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.createInfoIndex );
1822  VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.sysmemPixelFormat );
1823  VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.formatFeatures );
1824  VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.sysmemColorSpaceIndex );
1825  VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.samplerYcbcrConversionComponents );
1826  VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.suggestedYcbcrModel );
1827  VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.suggestedYcbcrRange );
1828  VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.suggestedXChromaOffset );
1829  VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.suggestedYChromaOffset );
1830  return seed;
1831  }
1832  };
1833 # endif /*VK_USE_PLATFORM_FUCHSIA*/
1834 
1835  template <>
1836  struct hash<VULKAN_HPP_NAMESPACE::BufferCreateInfo>
1837  {
1838  std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCreateInfo const & bufferCreateInfo ) const VULKAN_HPP_NOEXCEPT
1839  {
1840  std::size_t seed = 0;
1841  VULKAN_HPP_HASH_COMBINE( seed, bufferCreateInfo.sType );
1842  VULKAN_HPP_HASH_COMBINE( seed, bufferCreateInfo.pNext );
1843  VULKAN_HPP_HASH_COMBINE( seed, bufferCreateInfo.flags );
1844  VULKAN_HPP_HASH_COMBINE( seed, bufferCreateInfo.size );
1845  VULKAN_HPP_HASH_COMBINE( seed, bufferCreateInfo.usage );
1846  VULKAN_HPP_HASH_COMBINE( seed, bufferCreateInfo.sharingMode );
1847  VULKAN_HPP_HASH_COMBINE( seed, bufferCreateInfo.queueFamilyIndexCount );
1848  VULKAN_HPP_HASH_COMBINE( seed, bufferCreateInfo.pQueueFamilyIndices );
1849  return seed;
1850  }
1851  };
1852 
1853 # if defined( VK_USE_PLATFORM_FUCHSIA )
1854  template <>
1855  struct hash<VULKAN_HPP_NAMESPACE::BufferConstraintsInfoFUCHSIA>
1856  {
1857  std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferConstraintsInfoFUCHSIA const & bufferConstraintsInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT
1858  {
1859  std::size_t seed = 0;
1860  VULKAN_HPP_HASH_COMBINE( seed, bufferConstraintsInfoFUCHSIA.sType );
1861  VULKAN_HPP_HASH_COMBINE( seed, bufferConstraintsInfoFUCHSIA.pNext );
1862  VULKAN_HPP_HASH_COMBINE( seed, bufferConstraintsInfoFUCHSIA.createInfo );
1863  VULKAN_HPP_HASH_COMBINE( seed, bufferConstraintsInfoFUCHSIA.requiredFormatFeatures );
1864  VULKAN_HPP_HASH_COMBINE( seed, bufferConstraintsInfoFUCHSIA.bufferCollectionConstraints );
1865  return seed;
1866  }
1867  };
1868 # endif /*VK_USE_PLATFORM_FUCHSIA*/
1869 
1870  template <>
1871  struct hash<VULKAN_HPP_NAMESPACE::BufferCopy>
1872  {
1873  std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCopy const & bufferCopy ) const VULKAN_HPP_NOEXCEPT
1874  {
1875  std::size_t seed = 0;
1876  VULKAN_HPP_HASH_COMBINE( seed, bufferCopy.srcOffset );
1877  VULKAN_HPP_HASH_COMBINE( seed, bufferCopy.dstOffset );
1878  VULKAN_HPP_HASH_COMBINE( seed, bufferCopy.size );
1879  return seed;
1880  }
1881  };
1882 
1883  template <>
1884  struct hash<VULKAN_HPP_NAMESPACE::BufferCopy2>
1885  {
1886  std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCopy2 const & bufferCopy2 ) const VULKAN_HPP_NOEXCEPT
1887  {
1888  std::size_t seed = 0;
1889  VULKAN_HPP_HASH_COMBINE( seed, bufferCopy2.sType );
1890  VULKAN_HPP_HASH_COMBINE( seed, bufferCopy2.pNext );
1891  VULKAN_HPP_HASH_COMBINE( seed, bufferCopy2.srcOffset );
1892  VULKAN_HPP_HASH_COMBINE( seed, bufferCopy2.dstOffset );
1893  VULKAN_HPP_HASH_COMBINE( seed, bufferCopy2.size );
1894  return seed;
1895  }
1896  };
1897 
1898  template <>
1899  struct hash<VULKAN_HPP_NAMESPACE::BufferDeviceAddressCreateInfoEXT>
1900  {
1901  std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferDeviceAddressCreateInfoEXT const & bufferDeviceAddressCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
1902  {
1903  std::size_t seed = 0;
1904  VULKAN_HPP_HASH_COMBINE( seed, bufferDeviceAddressCreateInfoEXT.sType );
1905  VULKAN_HPP_HASH_COMBINE( seed, bufferDeviceAddressCreateInfoEXT.pNext );
1906  VULKAN_HPP_HASH_COMBINE( seed, bufferDeviceAddressCreateInfoEXT.deviceAddress );
1907  return seed;
1908  }
1909  };
1910 
1911  template <>
1912  struct hash<VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo>
1913  {
1914  std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo const & bufferDeviceAddressInfo ) const VULKAN_HPP_NOEXCEPT
1915  {
1916  std::size_t seed = 0;
1917  VULKAN_HPP_HASH_COMBINE( seed, bufferDeviceAddressInfo.sType );
1918  VULKAN_HPP_HASH_COMBINE( seed, bufferDeviceAddressInfo.pNext );
1919  VULKAN_HPP_HASH_COMBINE( seed, bufferDeviceAddressInfo.buffer );
1920  return seed;
1921  }
1922  };
1923 
1924  template <>
1925  struct hash<VULKAN_HPP_NAMESPACE::BufferImageCopy>
1926  {
1927  std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferImageCopy const & bufferImageCopy ) const VULKAN_HPP_NOEXCEPT
1928  {
1929  std::size_t seed = 0;
1930  VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy.bufferOffset );
1931  VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy.bufferRowLength );
1932  VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy.bufferImageHeight );
1933  VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy.imageSubresource );
1934  VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy.imageOffset );
1935  VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy.imageExtent );
1936  return seed;
1937  }
1938  };
1939 
1940  template <>
1941  struct hash<VULKAN_HPP_NAMESPACE::BufferImageCopy2>
1942  {
1943  std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferImageCopy2 const & bufferImageCopy2 ) const VULKAN_HPP_NOEXCEPT
1944  {
1945  std::size_t seed = 0;
1946  VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy2.sType );
1947  VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy2.pNext );
1948  VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy2.bufferOffset );
1949  VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy2.bufferRowLength );
1950  VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy2.bufferImageHeight );
1951  VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy2.imageSubresource );
1952  VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy2.imageOffset );
1953  VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy2.imageExtent );
1954  return seed;
1955  }
1956  };
1957 
1958  template <>
1959  struct hash<VULKAN_HPP_NAMESPACE::BufferMemoryBarrier>
1960  {
1961  std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferMemoryBarrier const & bufferMemoryBarrier ) const VULKAN_HPP_NOEXCEPT
1962  {
1963  std::size_t seed = 0;
1964  VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.sType );
1965  VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.pNext );
1966  VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.srcAccessMask );
1967  VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.dstAccessMask );
1968  VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.srcQueueFamilyIndex );
1969  VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.dstQueueFamilyIndex );
1970  VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.buffer );
1971  VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.offset );
1972  VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.size );
1973  return seed;
1974  }
1975  };
1976 
1977  template <>
1978  struct hash<VULKAN_HPP_NAMESPACE::BufferMemoryBarrier2>
1979  {
1980  std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferMemoryBarrier2 const & bufferMemoryBarrier2 ) const VULKAN_HPP_NOEXCEPT
1981  {
1982  std::size_t seed = 0;
1983  VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.sType );
1984  VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.pNext );
1985  VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.srcStageMask );
1986  VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.srcAccessMask );
1987  VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.dstStageMask );
1988  VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.dstAccessMask );
1989  VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.srcQueueFamilyIndex );
1990  VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.dstQueueFamilyIndex );
1991  VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.buffer );
1992  VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.offset );
1993  VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.size );
1994  return seed;
1995  }
1996  };
1997 
1998  template <>
1999  struct hash<VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2>
2000  {
2001  std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 const & bufferMemoryRequirementsInfo2 ) const VULKAN_HPP_NOEXCEPT
2002  {
2003  std::size_t seed = 0;
2004  VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryRequirementsInfo2.sType );
2005  VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryRequirementsInfo2.pNext );
2006  VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryRequirementsInfo2.buffer );
2007  return seed;
2008  }
2009  };
2010 
2011  template <>
2012  struct hash<VULKAN_HPP_NAMESPACE::BufferOpaqueCaptureAddressCreateInfo>
2013  {
2014  std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferOpaqueCaptureAddressCreateInfo const & bufferOpaqueCaptureAddressCreateInfo ) const VULKAN_HPP_NOEXCEPT
2015  {
2016  std::size_t seed = 0;
2017  VULKAN_HPP_HASH_COMBINE( seed, bufferOpaqueCaptureAddressCreateInfo.sType );
2018  VULKAN_HPP_HASH_COMBINE( seed, bufferOpaqueCaptureAddressCreateInfo.pNext );
2019  VULKAN_HPP_HASH_COMBINE( seed, bufferOpaqueCaptureAddressCreateInfo.opaqueCaptureAddress );
2020  return seed;
2021  }
2022  };
2023 
2024  template <>
2025  struct hash<VULKAN_HPP_NAMESPACE::BufferUsageFlags2CreateInfoKHR>
2026  {
2027  std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferUsageFlags2CreateInfoKHR const & bufferUsageFlags2CreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
2028  {
2029  std::size_t seed = 0;
2030  VULKAN_HPP_HASH_COMBINE( seed, bufferUsageFlags2CreateInfoKHR.sType );
2031  VULKAN_HPP_HASH_COMBINE( seed, bufferUsageFlags2CreateInfoKHR.pNext );
2032  VULKAN_HPP_HASH_COMBINE( seed, bufferUsageFlags2CreateInfoKHR.usage );
2033  return seed;
2034  }
2035  };
2036 
2037  template <>
2038  struct hash<VULKAN_HPP_NAMESPACE::BufferViewCreateInfo>
2039  {
2040  std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferViewCreateInfo const & bufferViewCreateInfo ) const VULKAN_HPP_NOEXCEPT
2041  {
2042  std::size_t seed = 0;
2043  VULKAN_HPP_HASH_COMBINE( seed, bufferViewCreateInfo.sType );
2044  VULKAN_HPP_HASH_COMBINE( seed, bufferViewCreateInfo.pNext );
2045  VULKAN_HPP_HASH_COMBINE( seed, bufferViewCreateInfo.flags );
2046  VULKAN_HPP_HASH_COMBINE( seed, bufferViewCreateInfo.buffer );
2047  VULKAN_HPP_HASH_COMBINE( seed, bufferViewCreateInfo.format );
2048  VULKAN_HPP_HASH_COMBINE( seed, bufferViewCreateInfo.offset );
2049  VULKAN_HPP_HASH_COMBINE( seed, bufferViewCreateInfo.range );
2050  return seed;
2051  }
2052  };
2053 
2054  template <>
2055  struct hash<VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR>
2056  {
2057  std::size_t operator()( VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR const & calibratedTimestampInfoKHR ) const VULKAN_HPP_NOEXCEPT
2058  {
2059  std::size_t seed = 0;
2060  VULKAN_HPP_HASH_COMBINE( seed, calibratedTimestampInfoKHR.sType );
2061  VULKAN_HPP_HASH_COMBINE( seed, calibratedTimestampInfoKHR.pNext );
2062  VULKAN_HPP_HASH_COMBINE( seed, calibratedTimestampInfoKHR.timeDomain );
2063  return seed;
2064  }
2065  };
2066 
2067  template <>
2068  struct hash<VULKAN_HPP_NAMESPACE::CheckpointData2NV>
2069  {
2070  std::size_t operator()( VULKAN_HPP_NAMESPACE::CheckpointData2NV const & checkpointData2NV ) const VULKAN_HPP_NOEXCEPT
2071  {
2072  std::size_t seed = 0;
2073  VULKAN_HPP_HASH_COMBINE( seed, checkpointData2NV.sType );
2074  VULKAN_HPP_HASH_COMBINE( seed, checkpointData2NV.pNext );
2075  VULKAN_HPP_HASH_COMBINE( seed, checkpointData2NV.stage );
2076  VULKAN_HPP_HASH_COMBINE( seed, checkpointData2NV.pCheckpointMarker );
2077  return seed;
2078  }
2079  };
2080 
2081  template <>
2082  struct hash<VULKAN_HPP_NAMESPACE::CheckpointDataNV>
2083  {
2084  std::size_t operator()( VULKAN_HPP_NAMESPACE::CheckpointDataNV const & checkpointDataNV ) const VULKAN_HPP_NOEXCEPT
2085  {
2086  std::size_t seed = 0;
2087  VULKAN_HPP_HASH_COMBINE( seed, checkpointDataNV.sType );
2088  VULKAN_HPP_HASH_COMBINE( seed, checkpointDataNV.pNext );
2089  VULKAN_HPP_HASH_COMBINE( seed, checkpointDataNV.stage );
2090  VULKAN_HPP_HASH_COMBINE( seed, checkpointDataNV.pCheckpointMarker );
2091  return seed;
2092  }
2093  };
2094 
2095  template <>
2096  struct hash<VULKAN_HPP_NAMESPACE::ClearDepthStencilValue>
2097  {
2098  std::size_t operator()( VULKAN_HPP_NAMESPACE::ClearDepthStencilValue const & clearDepthStencilValue ) const VULKAN_HPP_NOEXCEPT
2099  {
2100  std::size_t seed = 0;
2101  VULKAN_HPP_HASH_COMBINE( seed, clearDepthStencilValue.depth );
2102  VULKAN_HPP_HASH_COMBINE( seed, clearDepthStencilValue.stencil );
2103  return seed;
2104  }
2105  };
2106 
2107  template <>
2108  struct hash<VULKAN_HPP_NAMESPACE::ClearRect>
2109  {
2110  std::size_t operator()( VULKAN_HPP_NAMESPACE::ClearRect const & clearRect ) const VULKAN_HPP_NOEXCEPT
2111  {
2112  std::size_t seed = 0;
2113  VULKAN_HPP_HASH_COMBINE( seed, clearRect.rect );
2114  VULKAN_HPP_HASH_COMBINE( seed, clearRect.baseArrayLayer );
2115  VULKAN_HPP_HASH_COMBINE( seed, clearRect.layerCount );
2116  return seed;
2117  }
2118  };
2119 
2120  template <>
2121  struct hash<VULKAN_HPP_NAMESPACE::CoarseSampleLocationNV>
2122  {
2123  std::size_t operator()( VULKAN_HPP_NAMESPACE::CoarseSampleLocationNV const & coarseSampleLocationNV ) const VULKAN_HPP_NOEXCEPT
2124  {
2125  std::size_t seed = 0;
2126  VULKAN_HPP_HASH_COMBINE( seed, coarseSampleLocationNV.pixelX );
2127  VULKAN_HPP_HASH_COMBINE( seed, coarseSampleLocationNV.pixelY );
2128  VULKAN_HPP_HASH_COMBINE( seed, coarseSampleLocationNV.sample );
2129  return seed;
2130  }
2131  };
2132 
2133  template <>
2134  struct hash<VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV>
2135  {
2136  std::size_t operator()( VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV const & coarseSampleOrderCustomNV ) const VULKAN_HPP_NOEXCEPT
2137  {
2138  std::size_t seed = 0;
2139  VULKAN_HPP_HASH_COMBINE( seed, coarseSampleOrderCustomNV.shadingRate );
2140  VULKAN_HPP_HASH_COMBINE( seed, coarseSampleOrderCustomNV.sampleCount );
2141  VULKAN_HPP_HASH_COMBINE( seed, coarseSampleOrderCustomNV.sampleLocationCount );
2142  VULKAN_HPP_HASH_COMBINE( seed, coarseSampleOrderCustomNV.pSampleLocations );
2143  return seed;
2144  }
2145  };
2146 
2147  template <>
2148  struct hash<VULKAN_HPP_NAMESPACE::ColorBlendAdvancedEXT>
2149  {
2150  std::size_t operator()( VULKAN_HPP_NAMESPACE::ColorBlendAdvancedEXT const & colorBlendAdvancedEXT ) const VULKAN_HPP_NOEXCEPT
2151  {
2152  std::size_t seed = 0;
2153  VULKAN_HPP_HASH_COMBINE( seed, colorBlendAdvancedEXT.advancedBlendOp );
2154  VULKAN_HPP_HASH_COMBINE( seed, colorBlendAdvancedEXT.srcPremultiplied );
2155  VULKAN_HPP_HASH_COMBINE( seed, colorBlendAdvancedEXT.dstPremultiplied );
2156  VULKAN_HPP_HASH_COMBINE( seed, colorBlendAdvancedEXT.blendOverlap );
2157  VULKAN_HPP_HASH_COMBINE( seed, colorBlendAdvancedEXT.clampResults );
2158  return seed;
2159  }
2160  };
2161 
2162  template <>
2163  struct hash<VULKAN_HPP_NAMESPACE::ColorBlendEquationEXT>
2164  {
2165  std::size_t operator()( VULKAN_HPP_NAMESPACE::ColorBlendEquationEXT const & colorBlendEquationEXT ) const VULKAN_HPP_NOEXCEPT
2166  {
2167  std::size_t seed = 0;
2168  VULKAN_HPP_HASH_COMBINE( seed, colorBlendEquationEXT.srcColorBlendFactor );
2169  VULKAN_HPP_HASH_COMBINE( seed, colorBlendEquationEXT.dstColorBlendFactor );
2170  VULKAN_HPP_HASH_COMBINE( seed, colorBlendEquationEXT.colorBlendOp );
2171  VULKAN_HPP_HASH_COMBINE( seed, colorBlendEquationEXT.srcAlphaBlendFactor );
2172  VULKAN_HPP_HASH_COMBINE( seed, colorBlendEquationEXT.dstAlphaBlendFactor );
2173  VULKAN_HPP_HASH_COMBINE( seed, colorBlendEquationEXT.alphaBlendOp );
2174  return seed;
2175  }
2176  };
2177 
2178  template <>
2179  struct hash<VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo>
2180  {
2181  std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo const & commandBufferAllocateInfo ) const VULKAN_HPP_NOEXCEPT
2182  {
2183  std::size_t seed = 0;
2184  VULKAN_HPP_HASH_COMBINE( seed, commandBufferAllocateInfo.sType );
2185  VULKAN_HPP_HASH_COMBINE( seed, commandBufferAllocateInfo.pNext );
2186  VULKAN_HPP_HASH_COMBINE( seed, commandBufferAllocateInfo.commandPool );
2187  VULKAN_HPP_HASH_COMBINE( seed, commandBufferAllocateInfo.level );
2188  VULKAN_HPP_HASH_COMBINE( seed, commandBufferAllocateInfo.commandBufferCount );
2189  return seed;
2190  }
2191  };
2192 
2193  template <>
2194  struct hash<VULKAN_HPP_NAMESPACE::CommandBufferInheritanceInfo>
2195  {
2196  std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceInfo const & commandBufferInheritanceInfo ) const VULKAN_HPP_NOEXCEPT
2197  {
2198  std::size_t seed = 0;
2199  VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceInfo.sType );
2200  VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceInfo.pNext );
2201  VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceInfo.renderPass );
2202  VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceInfo.subpass );
2203  VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceInfo.framebuffer );
2204  VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceInfo.occlusionQueryEnable );
2205  VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceInfo.queryFlags );
2206  VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceInfo.pipelineStatistics );
2207  return seed;
2208  }
2209  };
2210 
2211  template <>
2212  struct hash<VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo>
2213  {
2214  std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo const & commandBufferBeginInfo ) const VULKAN_HPP_NOEXCEPT
2215  {
2216  std::size_t seed = 0;
2217  VULKAN_HPP_HASH_COMBINE( seed, commandBufferBeginInfo.sType );
2218  VULKAN_HPP_HASH_COMBINE( seed, commandBufferBeginInfo.pNext );
2219  VULKAN_HPP_HASH_COMBINE( seed, commandBufferBeginInfo.flags );
2220  VULKAN_HPP_HASH_COMBINE( seed, commandBufferBeginInfo.pInheritanceInfo );
2221  return seed;
2222  }
2223  };
2224 
2225  template <>
2226  struct hash<VULKAN_HPP_NAMESPACE::CommandBufferInheritanceConditionalRenderingInfoEXT>
2227  {
2228  std::size_t
2229  operator()( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceConditionalRenderingInfoEXT const & commandBufferInheritanceConditionalRenderingInfoEXT ) const
2230  VULKAN_HPP_NOEXCEPT
2231  {
2232  std::size_t seed = 0;
2233  VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceConditionalRenderingInfoEXT.sType );
2234  VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceConditionalRenderingInfoEXT.pNext );
2235  VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceConditionalRenderingInfoEXT.conditionalRenderingEnable );
2236  return seed;
2237  }
2238  };
2239 
2240  template <>
2241  struct hash<VULKAN_HPP_NAMESPACE::CommandBufferInheritanceRenderPassTransformInfoQCOM>
2242  {
2243  std::size_t
2244  operator()( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceRenderPassTransformInfoQCOM const & commandBufferInheritanceRenderPassTransformInfoQCOM ) const
2245  VULKAN_HPP_NOEXCEPT
2246  {
2247  std::size_t seed = 0;
2248  VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderPassTransformInfoQCOM.sType );
2249  VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderPassTransformInfoQCOM.pNext );
2250  VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderPassTransformInfoQCOM.transform );
2251  VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderPassTransformInfoQCOM.renderArea );
2252  return seed;
2253  }
2254  };
2255 
2256  template <>
2257  struct hash<VULKAN_HPP_NAMESPACE::CommandBufferInheritanceRenderingInfo>
2258  {
2259  std::size_t
2260  operator()( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceRenderingInfo const & commandBufferInheritanceRenderingInfo ) const VULKAN_HPP_NOEXCEPT
2261  {
2262  std::size_t seed = 0;
2263  VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.sType );
2264  VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.pNext );
2265  VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.flags );
2266  VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.viewMask );
2267  VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.colorAttachmentCount );
2268  VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.pColorAttachmentFormats );
2269  VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.depthAttachmentFormat );
2270  VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.stencilAttachmentFormat );
2271  VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.rasterizationSamples );
2272  return seed;
2273  }
2274  };
2275 
2276  template <>
2277  struct hash<VULKAN_HPP_NAMESPACE::Viewport>
2278  {
2279  std::size_t operator()( VULKAN_HPP_NAMESPACE::Viewport const & viewport ) const VULKAN_HPP_NOEXCEPT
2280  {
2281  std::size_t seed = 0;
2282  VULKAN_HPP_HASH_COMBINE( seed, viewport.x );
2283  VULKAN_HPP_HASH_COMBINE( seed, viewport.y );
2284  VULKAN_HPP_HASH_COMBINE( seed, viewport.width );
2285  VULKAN_HPP_HASH_COMBINE( seed, viewport.height );
2286  VULKAN_HPP_HASH_COMBINE( seed, viewport.minDepth );
2287  VULKAN_HPP_HASH_COMBINE( seed, viewport.maxDepth );
2288  return seed;
2289  }
2290  };
2291 
2292  template <>
2293  struct hash<VULKAN_HPP_NAMESPACE::CommandBufferInheritanceViewportScissorInfoNV>
2294  {
2295  std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceViewportScissorInfoNV const & commandBufferInheritanceViewportScissorInfoNV ) const
2296  VULKAN_HPP_NOEXCEPT
2297  {
2298  std::size_t seed = 0;
2299  VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceViewportScissorInfoNV.sType );
2300  VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceViewportScissorInfoNV.pNext );
2301  VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceViewportScissorInfoNV.viewportScissor2D );
2302  VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceViewportScissorInfoNV.viewportDepthCount );
2303  VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceViewportScissorInfoNV.pViewportDepths );
2304  return seed;
2305  }
2306  };
2307 
2308  template <>
2309  struct hash<VULKAN_HPP_NAMESPACE::CommandBufferSubmitInfo>
2310  {
2311  std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBufferSubmitInfo const & commandBufferSubmitInfo ) const VULKAN_HPP_NOEXCEPT
2312  {
2313  std::size_t seed = 0;
2314  VULKAN_HPP_HASH_COMBINE( seed, commandBufferSubmitInfo.sType );
2315  VULKAN_HPP_HASH_COMBINE( seed, commandBufferSubmitInfo.pNext );
2316  VULKAN_HPP_HASH_COMBINE( seed, commandBufferSubmitInfo.commandBuffer );
2317  VULKAN_HPP_HASH_COMBINE( seed, commandBufferSubmitInfo.deviceMask );
2318  return seed;
2319  }
2320  };
2321 
2322  template <>
2323  struct hash<VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo>
2324  {
2325  std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo const & commandPoolCreateInfo ) const VULKAN_HPP_NOEXCEPT
2326  {
2327  std::size_t seed = 0;
2328  VULKAN_HPP_HASH_COMBINE( seed, commandPoolCreateInfo.sType );
2329  VULKAN_HPP_HASH_COMBINE( seed, commandPoolCreateInfo.pNext );
2330  VULKAN_HPP_HASH_COMBINE( seed, commandPoolCreateInfo.flags );
2331  VULKAN_HPP_HASH_COMBINE( seed, commandPoolCreateInfo.queueFamilyIndex );
2332  return seed;
2333  }
2334  };
2335 
2336  template <>
2337  struct hash<VULKAN_HPP_NAMESPACE::SpecializationMapEntry>
2338  {
2339  std::size_t operator()( VULKAN_HPP_NAMESPACE::SpecializationMapEntry const & specializationMapEntry ) const VULKAN_HPP_NOEXCEPT
2340  {
2341  std::size_t seed = 0;
2342  VULKAN_HPP_HASH_COMBINE( seed, specializationMapEntry.constantID );
2343  VULKAN_HPP_HASH_COMBINE( seed, specializationMapEntry.offset );
2344  VULKAN_HPP_HASH_COMBINE( seed, specializationMapEntry.size );
2345  return seed;
2346  }
2347  };
2348 
2349  template <>
2350  struct hash<VULKAN_HPP_NAMESPACE::SpecializationInfo>
2351  {
2352  std::size_t operator()( VULKAN_HPP_NAMESPACE::SpecializationInfo const & specializationInfo ) const VULKAN_HPP_NOEXCEPT
2353  {
2354  std::size_t seed = 0;
2355  VULKAN_HPP_HASH_COMBINE( seed, specializationInfo.mapEntryCount );
2356  VULKAN_HPP_HASH_COMBINE( seed, specializationInfo.pMapEntries );
2357  VULKAN_HPP_HASH_COMBINE( seed, specializationInfo.dataSize );
2358  VULKAN_HPP_HASH_COMBINE( seed, specializationInfo.pData );
2359  return seed;
2360  }
2361  };
2362 
2363  template <>
2364  struct hash<VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo>
2365  {
2366  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo const & pipelineShaderStageCreateInfo ) const VULKAN_HPP_NOEXCEPT
2367  {
2368  std::size_t seed = 0;
2369  VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageCreateInfo.sType );
2370  VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageCreateInfo.pNext );
2371  VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageCreateInfo.flags );
2372  VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageCreateInfo.stage );
2373  VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageCreateInfo.module );
2374  for ( const char * p = pipelineShaderStageCreateInfo.pName; *p != '\0'; ++p )
2375  {
2376  VULKAN_HPP_HASH_COMBINE( seed, *p );
2377  }
2378  VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageCreateInfo.pSpecializationInfo );
2379  return seed;
2380  }
2381  };
2382 
2383  template <>
2384  struct hash<VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo>
2385  {
2386  std::size_t operator()( VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo const & computePipelineCreateInfo ) const VULKAN_HPP_NOEXCEPT
2387  {
2388  std::size_t seed = 0;
2389  VULKAN_HPP_HASH_COMBINE( seed, computePipelineCreateInfo.sType );
2390  VULKAN_HPP_HASH_COMBINE( seed, computePipelineCreateInfo.pNext );
2391  VULKAN_HPP_HASH_COMBINE( seed, computePipelineCreateInfo.flags );
2392  VULKAN_HPP_HASH_COMBINE( seed, computePipelineCreateInfo.stage );
2393  VULKAN_HPP_HASH_COMBINE( seed, computePipelineCreateInfo.layout );
2394  VULKAN_HPP_HASH_COMBINE( seed, computePipelineCreateInfo.basePipelineHandle );
2395  VULKAN_HPP_HASH_COMBINE( seed, computePipelineCreateInfo.basePipelineIndex );
2396  return seed;
2397  }
2398  };
2399 
2400  template <>
2401  struct hash<VULKAN_HPP_NAMESPACE::ComputePipelineIndirectBufferInfoNV>
2402  {
2403  std::size_t operator()( VULKAN_HPP_NAMESPACE::ComputePipelineIndirectBufferInfoNV const & computePipelineIndirectBufferInfoNV ) const VULKAN_HPP_NOEXCEPT
2404  {
2405  std::size_t seed = 0;
2406  VULKAN_HPP_HASH_COMBINE( seed, computePipelineIndirectBufferInfoNV.sType );
2407  VULKAN_HPP_HASH_COMBINE( seed, computePipelineIndirectBufferInfoNV.pNext );
2408  VULKAN_HPP_HASH_COMBINE( seed, computePipelineIndirectBufferInfoNV.deviceAddress );
2409  VULKAN_HPP_HASH_COMBINE( seed, computePipelineIndirectBufferInfoNV.size );
2410  VULKAN_HPP_HASH_COMBINE( seed, computePipelineIndirectBufferInfoNV.pipelineDeviceAddressCaptureReplay );
2411  return seed;
2412  }
2413  };
2414 
2415  template <>
2416  struct hash<VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfoEXT>
2417  {
2418  std::size_t operator()( VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfoEXT const & conditionalRenderingBeginInfoEXT ) const VULKAN_HPP_NOEXCEPT
2419  {
2420  std::size_t seed = 0;
2421  VULKAN_HPP_HASH_COMBINE( seed, conditionalRenderingBeginInfoEXT.sType );
2422  VULKAN_HPP_HASH_COMBINE( seed, conditionalRenderingBeginInfoEXT.pNext );
2423  VULKAN_HPP_HASH_COMBINE( seed, conditionalRenderingBeginInfoEXT.buffer );
2424  VULKAN_HPP_HASH_COMBINE( seed, conditionalRenderingBeginInfoEXT.offset );
2425  VULKAN_HPP_HASH_COMBINE( seed, conditionalRenderingBeginInfoEXT.flags );
2426  return seed;
2427  }
2428  };
2429 
2430  template <>
2431  struct hash<VULKAN_HPP_NAMESPACE::ConformanceVersion>
2432  {
2433  std::size_t operator()( VULKAN_HPP_NAMESPACE::ConformanceVersion const & conformanceVersion ) const VULKAN_HPP_NOEXCEPT
2434  {
2435  std::size_t seed = 0;
2436  VULKAN_HPP_HASH_COMBINE( seed, conformanceVersion.major );
2437  VULKAN_HPP_HASH_COMBINE( seed, conformanceVersion.minor );
2438  VULKAN_HPP_HASH_COMBINE( seed, conformanceVersion.subminor );
2439  VULKAN_HPP_HASH_COMBINE( seed, conformanceVersion.patch );
2440  return seed;
2441  }
2442  };
2443 
2444  template <>
2445  struct hash<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR>
2446  {
2447  std::size_t operator()( VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR const & cooperativeMatrixPropertiesKHR ) const VULKAN_HPP_NOEXCEPT
2448  {
2449  std::size_t seed = 0;
2450  VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.sType );
2451  VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.pNext );
2452  VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.MSize );
2453  VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.NSize );
2454  VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.KSize );
2455  VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.AType );
2456  VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.BType );
2457  VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.CType );
2458  VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.ResultType );
2459  VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.saturatingAccumulation );
2460  VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.scope );
2461  return seed;
2462  }
2463  };
2464 
2465  template <>
2466  struct hash<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV>
2467  {
2468  std::size_t operator()( VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV const & cooperativeMatrixPropertiesNV ) const VULKAN_HPP_NOEXCEPT
2469  {
2470  std::size_t seed = 0;
2471  VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.sType );
2472  VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.pNext );
2473  VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.MSize );
2474  VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.NSize );
2475  VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.KSize );
2476  VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.AType );
2477  VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.BType );
2478  VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.CType );
2479  VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.DType );
2480  VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.scope );
2481  return seed;
2482  }
2483  };
2484 
2485  template <>
2486  struct hash<VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR>
2487  {
2488  std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR const & copyAccelerationStructureInfoKHR ) const VULKAN_HPP_NOEXCEPT
2489  {
2490  std::size_t seed = 0;
2491  VULKAN_HPP_HASH_COMBINE( seed, copyAccelerationStructureInfoKHR.sType );
2492  VULKAN_HPP_HASH_COMBINE( seed, copyAccelerationStructureInfoKHR.pNext );
2493  VULKAN_HPP_HASH_COMBINE( seed, copyAccelerationStructureInfoKHR.src );
2494  VULKAN_HPP_HASH_COMBINE( seed, copyAccelerationStructureInfoKHR.dst );
2495  VULKAN_HPP_HASH_COMBINE( seed, copyAccelerationStructureInfoKHR.mode );
2496  return seed;
2497  }
2498  };
2499 
2500  template <>
2501  struct hash<VULKAN_HPP_NAMESPACE::CopyBufferInfo2>
2502  {
2503  std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyBufferInfo2 const & copyBufferInfo2 ) const VULKAN_HPP_NOEXCEPT
2504  {
2505  std::size_t seed = 0;
2506  VULKAN_HPP_HASH_COMBINE( seed, copyBufferInfo2.sType );
2507  VULKAN_HPP_HASH_COMBINE( seed, copyBufferInfo2.pNext );
2508  VULKAN_HPP_HASH_COMBINE( seed, copyBufferInfo2.srcBuffer );
2509  VULKAN_HPP_HASH_COMBINE( seed, copyBufferInfo2.dstBuffer );
2510  VULKAN_HPP_HASH_COMBINE( seed, copyBufferInfo2.regionCount );
2511  VULKAN_HPP_HASH_COMBINE( seed, copyBufferInfo2.pRegions );
2512  return seed;
2513  }
2514  };
2515 
2516  template <>
2517  struct hash<VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2>
2518  {
2519  std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 const & copyBufferToImageInfo2 ) const VULKAN_HPP_NOEXCEPT
2520  {
2521  std::size_t seed = 0;
2522  VULKAN_HPP_HASH_COMBINE( seed, copyBufferToImageInfo2.sType );
2523  VULKAN_HPP_HASH_COMBINE( seed, copyBufferToImageInfo2.pNext );
2524  VULKAN_HPP_HASH_COMBINE( seed, copyBufferToImageInfo2.srcBuffer );
2525  VULKAN_HPP_HASH_COMBINE( seed, copyBufferToImageInfo2.dstImage );
2526  VULKAN_HPP_HASH_COMBINE( seed, copyBufferToImageInfo2.dstImageLayout );
2527  VULKAN_HPP_HASH_COMBINE( seed, copyBufferToImageInfo2.regionCount );
2528  VULKAN_HPP_HASH_COMBINE( seed, copyBufferToImageInfo2.pRegions );
2529  return seed;
2530  }
2531  };
2532 
2533  template <>
2534  struct hash<VULKAN_HPP_NAMESPACE::CopyCommandTransformInfoQCOM>
2535  {
2536  std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyCommandTransformInfoQCOM const & copyCommandTransformInfoQCOM ) const VULKAN_HPP_NOEXCEPT
2537  {
2538  std::size_t seed = 0;
2539  VULKAN_HPP_HASH_COMBINE( seed, copyCommandTransformInfoQCOM.sType );
2540  VULKAN_HPP_HASH_COMBINE( seed, copyCommandTransformInfoQCOM.pNext );
2541  VULKAN_HPP_HASH_COMBINE( seed, copyCommandTransformInfoQCOM.transform );
2542  return seed;
2543  }
2544  };
2545 
2546  template <>
2547  struct hash<VULKAN_HPP_NAMESPACE::CopyDescriptorSet>
2548  {
2549  std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyDescriptorSet const & copyDescriptorSet ) const VULKAN_HPP_NOEXCEPT
2550  {
2551  std::size_t seed = 0;
2552  VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.sType );
2553  VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.pNext );
2554  VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.srcSet );
2555  VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.srcBinding );
2556  VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.srcArrayElement );
2557  VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.dstSet );
2558  VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.dstBinding );
2559  VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.dstArrayElement );
2560  VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.descriptorCount );
2561  return seed;
2562  }
2563  };
2564 
2565  template <>
2566  struct hash<VULKAN_HPP_NAMESPACE::ImageCopy2>
2567  {
2568  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageCopy2 const & imageCopy2 ) const VULKAN_HPP_NOEXCEPT
2569  {
2570  std::size_t seed = 0;
2571  VULKAN_HPP_HASH_COMBINE( seed, imageCopy2.sType );
2572  VULKAN_HPP_HASH_COMBINE( seed, imageCopy2.pNext );
2573  VULKAN_HPP_HASH_COMBINE( seed, imageCopy2.srcSubresource );
2574  VULKAN_HPP_HASH_COMBINE( seed, imageCopy2.srcOffset );
2575  VULKAN_HPP_HASH_COMBINE( seed, imageCopy2.dstSubresource );
2576  VULKAN_HPP_HASH_COMBINE( seed, imageCopy2.dstOffset );
2577  VULKAN_HPP_HASH_COMBINE( seed, imageCopy2.extent );
2578  return seed;
2579  }
2580  };
2581 
2582  template <>
2583  struct hash<VULKAN_HPP_NAMESPACE::CopyImageInfo2>
2584  {
2585  std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyImageInfo2 const & copyImageInfo2 ) const VULKAN_HPP_NOEXCEPT
2586  {
2587  std::size_t seed = 0;
2588  VULKAN_HPP_HASH_COMBINE( seed, copyImageInfo2.sType );
2589  VULKAN_HPP_HASH_COMBINE( seed, copyImageInfo2.pNext );
2590  VULKAN_HPP_HASH_COMBINE( seed, copyImageInfo2.srcImage );
2591  VULKAN_HPP_HASH_COMBINE( seed, copyImageInfo2.srcImageLayout );
2592  VULKAN_HPP_HASH_COMBINE( seed, copyImageInfo2.dstImage );
2593  VULKAN_HPP_HASH_COMBINE( seed, copyImageInfo2.dstImageLayout );
2594  VULKAN_HPP_HASH_COMBINE( seed, copyImageInfo2.regionCount );
2595  VULKAN_HPP_HASH_COMBINE( seed, copyImageInfo2.pRegions );
2596  return seed;
2597  }
2598  };
2599 
2600  template <>
2601  struct hash<VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2>
2602  {
2603  std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 const & copyImageToBufferInfo2 ) const VULKAN_HPP_NOEXCEPT
2604  {
2605  std::size_t seed = 0;
2606  VULKAN_HPP_HASH_COMBINE( seed, copyImageToBufferInfo2.sType );
2607  VULKAN_HPP_HASH_COMBINE( seed, copyImageToBufferInfo2.pNext );
2608  VULKAN_HPP_HASH_COMBINE( seed, copyImageToBufferInfo2.srcImage );
2609  VULKAN_HPP_HASH_COMBINE( seed, copyImageToBufferInfo2.srcImageLayout );
2610  VULKAN_HPP_HASH_COMBINE( seed, copyImageToBufferInfo2.dstBuffer );
2611  VULKAN_HPP_HASH_COMBINE( seed, copyImageToBufferInfo2.regionCount );
2612  VULKAN_HPP_HASH_COMBINE( seed, copyImageToBufferInfo2.pRegions );
2613  return seed;
2614  }
2615  };
2616 
2617  template <>
2618  struct hash<VULKAN_HPP_NAMESPACE::CopyImageToImageInfoEXT>
2619  {
2620  std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyImageToImageInfoEXT const & copyImageToImageInfoEXT ) const VULKAN_HPP_NOEXCEPT
2621  {
2622  std::size_t seed = 0;
2623  VULKAN_HPP_HASH_COMBINE( seed, copyImageToImageInfoEXT.sType );
2624  VULKAN_HPP_HASH_COMBINE( seed, copyImageToImageInfoEXT.pNext );
2625  VULKAN_HPP_HASH_COMBINE( seed, copyImageToImageInfoEXT.flags );
2626  VULKAN_HPP_HASH_COMBINE( seed, copyImageToImageInfoEXT.srcImage );
2627  VULKAN_HPP_HASH_COMBINE( seed, copyImageToImageInfoEXT.srcImageLayout );
2628  VULKAN_HPP_HASH_COMBINE( seed, copyImageToImageInfoEXT.dstImage );
2629  VULKAN_HPP_HASH_COMBINE( seed, copyImageToImageInfoEXT.dstImageLayout );
2630  VULKAN_HPP_HASH_COMBINE( seed, copyImageToImageInfoEXT.regionCount );
2631  VULKAN_HPP_HASH_COMBINE( seed, copyImageToImageInfoEXT.pRegions );
2632  return seed;
2633  }
2634  };
2635 
2636  template <>
2637  struct hash<VULKAN_HPP_NAMESPACE::ImageToMemoryCopyEXT>
2638  {
2639  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageToMemoryCopyEXT const & imageToMemoryCopyEXT ) const VULKAN_HPP_NOEXCEPT
2640  {
2641  std::size_t seed = 0;
2642  VULKAN_HPP_HASH_COMBINE( seed, imageToMemoryCopyEXT.sType );
2643  VULKAN_HPP_HASH_COMBINE( seed, imageToMemoryCopyEXT.pNext );
2644  VULKAN_HPP_HASH_COMBINE( seed, imageToMemoryCopyEXT.pHostPointer );
2645  VULKAN_HPP_HASH_COMBINE( seed, imageToMemoryCopyEXT.memoryRowLength );
2646  VULKAN_HPP_HASH_COMBINE( seed, imageToMemoryCopyEXT.memoryImageHeight );
2647  VULKAN_HPP_HASH_COMBINE( seed, imageToMemoryCopyEXT.imageSubresource );
2648  VULKAN_HPP_HASH_COMBINE( seed, imageToMemoryCopyEXT.imageOffset );
2649  VULKAN_HPP_HASH_COMBINE( seed, imageToMemoryCopyEXT.imageExtent );
2650  return seed;
2651  }
2652  };
2653 
2654  template <>
2655  struct hash<VULKAN_HPP_NAMESPACE::CopyImageToMemoryInfoEXT>
2656  {
2657  std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyImageToMemoryInfoEXT const & copyImageToMemoryInfoEXT ) const VULKAN_HPP_NOEXCEPT
2658  {
2659  std::size_t seed = 0;
2660  VULKAN_HPP_HASH_COMBINE( seed, copyImageToMemoryInfoEXT.sType );
2661  VULKAN_HPP_HASH_COMBINE( seed, copyImageToMemoryInfoEXT.pNext );
2662  VULKAN_HPP_HASH_COMBINE( seed, copyImageToMemoryInfoEXT.flags );
2663  VULKAN_HPP_HASH_COMBINE( seed, copyImageToMemoryInfoEXT.srcImage );
2664  VULKAN_HPP_HASH_COMBINE( seed, copyImageToMemoryInfoEXT.srcImageLayout );
2665  VULKAN_HPP_HASH_COMBINE( seed, copyImageToMemoryInfoEXT.regionCount );
2666  VULKAN_HPP_HASH_COMBINE( seed, copyImageToMemoryInfoEXT.pRegions );
2667  return seed;
2668  }
2669  };
2670 
2671  template <>
2672  struct hash<VULKAN_HPP_NAMESPACE::CopyMemoryIndirectCommandNV>
2673  {
2674  std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyMemoryIndirectCommandNV const & copyMemoryIndirectCommandNV ) const VULKAN_HPP_NOEXCEPT
2675  {
2676  std::size_t seed = 0;
2677  VULKAN_HPP_HASH_COMBINE( seed, copyMemoryIndirectCommandNV.srcAddress );
2678  VULKAN_HPP_HASH_COMBINE( seed, copyMemoryIndirectCommandNV.dstAddress );
2679  VULKAN_HPP_HASH_COMBINE( seed, copyMemoryIndirectCommandNV.size );
2680  return seed;
2681  }
2682  };
2683 
2684  template <>
2685  struct hash<VULKAN_HPP_NAMESPACE::CopyMemoryToImageIndirectCommandNV>
2686  {
2687  std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyMemoryToImageIndirectCommandNV const & copyMemoryToImageIndirectCommandNV ) const VULKAN_HPP_NOEXCEPT
2688  {
2689  std::size_t seed = 0;
2690  VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectCommandNV.srcAddress );
2691  VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectCommandNV.bufferRowLength );
2692  VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectCommandNV.bufferImageHeight );
2693  VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectCommandNV.imageSubresource );
2694  VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectCommandNV.imageOffset );
2695  VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectCommandNV.imageExtent );
2696  return seed;
2697  }
2698  };
2699 
2700  template <>
2701  struct hash<VULKAN_HPP_NAMESPACE::MemoryToImageCopyEXT>
2702  {
2703  std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryToImageCopyEXT const & memoryToImageCopyEXT ) const VULKAN_HPP_NOEXCEPT
2704  {
2705  std::size_t seed = 0;
2706  VULKAN_HPP_HASH_COMBINE( seed, memoryToImageCopyEXT.sType );
2707  VULKAN_HPP_HASH_COMBINE( seed, memoryToImageCopyEXT.pNext );
2708  VULKAN_HPP_HASH_COMBINE( seed, memoryToImageCopyEXT.pHostPointer );
2709  VULKAN_HPP_HASH_COMBINE( seed, memoryToImageCopyEXT.memoryRowLength );
2710  VULKAN_HPP_HASH_COMBINE( seed, memoryToImageCopyEXT.memoryImageHeight );
2711  VULKAN_HPP_HASH_COMBINE( seed, memoryToImageCopyEXT.imageSubresource );
2712  VULKAN_HPP_HASH_COMBINE( seed, memoryToImageCopyEXT.imageOffset );
2713  VULKAN_HPP_HASH_COMBINE( seed, memoryToImageCopyEXT.imageExtent );
2714  return seed;
2715  }
2716  };
2717 
2718  template <>
2719  struct hash<VULKAN_HPP_NAMESPACE::CopyMemoryToImageInfoEXT>
2720  {
2721  std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyMemoryToImageInfoEXT const & copyMemoryToImageInfoEXT ) const VULKAN_HPP_NOEXCEPT
2722  {
2723  std::size_t seed = 0;
2724  VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageInfoEXT.sType );
2725  VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageInfoEXT.pNext );
2726  VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageInfoEXT.flags );
2727  VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageInfoEXT.dstImage );
2728  VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageInfoEXT.dstImageLayout );
2729  VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageInfoEXT.regionCount );
2730  VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageInfoEXT.pRegions );
2731  return seed;
2732  }
2733  };
2734 
2735  template <>
2736  struct hash<VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT>
2737  {
2738  std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT const & copyMicromapInfoEXT ) const VULKAN_HPP_NOEXCEPT
2739  {
2740  std::size_t seed = 0;
2741  VULKAN_HPP_HASH_COMBINE( seed, copyMicromapInfoEXT.sType );
2742  VULKAN_HPP_HASH_COMBINE( seed, copyMicromapInfoEXT.pNext );
2743  VULKAN_HPP_HASH_COMBINE( seed, copyMicromapInfoEXT.src );
2744  VULKAN_HPP_HASH_COMBINE( seed, copyMicromapInfoEXT.dst );
2745  VULKAN_HPP_HASH_COMBINE( seed, copyMicromapInfoEXT.mode );
2746  return seed;
2747  }
2748  };
2749 
2750  template <>
2751  struct hash<VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX>
2752  {
2753  std::size_t operator()( VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX const & cuFunctionCreateInfoNVX ) const VULKAN_HPP_NOEXCEPT
2754  {
2755  std::size_t seed = 0;
2756  VULKAN_HPP_HASH_COMBINE( seed, cuFunctionCreateInfoNVX.sType );
2757  VULKAN_HPP_HASH_COMBINE( seed, cuFunctionCreateInfoNVX.pNext );
2758  VULKAN_HPP_HASH_COMBINE( seed, cuFunctionCreateInfoNVX.module );
2759  for ( const char * p = cuFunctionCreateInfoNVX.pName; *p != '\0'; ++p )
2760  {
2761  VULKAN_HPP_HASH_COMBINE( seed, *p );
2762  }
2763  return seed;
2764  }
2765  };
2766 
2767  template <>
2768  struct hash<VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX>
2769  {
2770  std::size_t operator()( VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX const & cuLaunchInfoNVX ) const VULKAN_HPP_NOEXCEPT
2771  {
2772  std::size_t seed = 0;
2773  VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.sType );
2774  VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.pNext );
2775  VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.function );
2776  VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.gridDimX );
2777  VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.gridDimY );
2778  VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.gridDimZ );
2779  VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.blockDimX );
2780  VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.blockDimY );
2781  VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.blockDimZ );
2782  VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.sharedMemBytes );
2783  VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.paramCount );
2784  VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.pParams );
2785  VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.extraCount );
2786  VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.pExtras );
2787  return seed;
2788  }
2789  };
2790 
2791  template <>
2792  struct hash<VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX>
2793  {
2794  std::size_t operator()( VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX const & cuModuleCreateInfoNVX ) const VULKAN_HPP_NOEXCEPT
2795  {
2796  std::size_t seed = 0;
2797  VULKAN_HPP_HASH_COMBINE( seed, cuModuleCreateInfoNVX.sType );
2798  VULKAN_HPP_HASH_COMBINE( seed, cuModuleCreateInfoNVX.pNext );
2799  VULKAN_HPP_HASH_COMBINE( seed, cuModuleCreateInfoNVX.dataSize );
2800  VULKAN_HPP_HASH_COMBINE( seed, cuModuleCreateInfoNVX.pData );
2801  return seed;
2802  }
2803  };
2804 
2805 # if defined( VK_ENABLE_BETA_EXTENSIONS )
2806  template <>
2807  struct hash<VULKAN_HPP_NAMESPACE::CudaFunctionCreateInfoNV>
2808  {
2809  std::size_t operator()( VULKAN_HPP_NAMESPACE::CudaFunctionCreateInfoNV const & cudaFunctionCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
2810  {
2811  std::size_t seed = 0;
2812  VULKAN_HPP_HASH_COMBINE( seed, cudaFunctionCreateInfoNV.sType );
2813  VULKAN_HPP_HASH_COMBINE( seed, cudaFunctionCreateInfoNV.pNext );
2814  VULKAN_HPP_HASH_COMBINE( seed, cudaFunctionCreateInfoNV.module );
2815  for ( const char * p = cudaFunctionCreateInfoNV.pName; *p != '\0'; ++p )
2816  {
2817  VULKAN_HPP_HASH_COMBINE( seed, *p );
2818  }
2819  return seed;
2820  }
2821  };
2822 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
2823 
2824 # if defined( VK_ENABLE_BETA_EXTENSIONS )
2825  template <>
2826  struct hash<VULKAN_HPP_NAMESPACE::CudaLaunchInfoNV>
2827  {
2828  std::size_t operator()( VULKAN_HPP_NAMESPACE::CudaLaunchInfoNV const & cudaLaunchInfoNV ) const VULKAN_HPP_NOEXCEPT
2829  {
2830  std::size_t seed = 0;
2831  VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.sType );
2832  VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.pNext );
2833  VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.function );
2834  VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.gridDimX );
2835  VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.gridDimY );
2836  VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.gridDimZ );
2837  VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.blockDimX );
2838  VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.blockDimY );
2839  VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.blockDimZ );
2840  VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.sharedMemBytes );
2841  VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.paramCount );
2842  VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.pParams );
2843  VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.extraCount );
2844  VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.pExtras );
2845  return seed;
2846  }
2847  };
2848 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
2849 
2850 # if defined( VK_ENABLE_BETA_EXTENSIONS )
2851  template <>
2852  struct hash<VULKAN_HPP_NAMESPACE::CudaModuleCreateInfoNV>
2853  {
2854  std::size_t operator()( VULKAN_HPP_NAMESPACE::CudaModuleCreateInfoNV const & cudaModuleCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
2855  {
2856  std::size_t seed = 0;
2857  VULKAN_HPP_HASH_COMBINE( seed, cudaModuleCreateInfoNV.sType );
2858  VULKAN_HPP_HASH_COMBINE( seed, cudaModuleCreateInfoNV.pNext );
2859  VULKAN_HPP_HASH_COMBINE( seed, cudaModuleCreateInfoNV.dataSize );
2860  VULKAN_HPP_HASH_COMBINE( seed, cudaModuleCreateInfoNV.pData );
2861  return seed;
2862  }
2863  };
2864 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
2865 
2866 # if defined( VK_USE_PLATFORM_WIN32_KHR )
2867  template <>
2868  struct hash<VULKAN_HPP_NAMESPACE::D3D12FenceSubmitInfoKHR>
2869  {
2870  std::size_t operator()( VULKAN_HPP_NAMESPACE::D3D12FenceSubmitInfoKHR const & d3D12FenceSubmitInfoKHR ) const VULKAN_HPP_NOEXCEPT
2871  {
2872  std::size_t seed = 0;
2873  VULKAN_HPP_HASH_COMBINE( seed, d3D12FenceSubmitInfoKHR.sType );
2874  VULKAN_HPP_HASH_COMBINE( seed, d3D12FenceSubmitInfoKHR.pNext );
2875  VULKAN_HPP_HASH_COMBINE( seed, d3D12FenceSubmitInfoKHR.waitSemaphoreValuesCount );
2876  VULKAN_HPP_HASH_COMBINE( seed, d3D12FenceSubmitInfoKHR.pWaitSemaphoreValues );
2877  VULKAN_HPP_HASH_COMBINE( seed, d3D12FenceSubmitInfoKHR.signalSemaphoreValuesCount );
2878  VULKAN_HPP_HASH_COMBINE( seed, d3D12FenceSubmitInfoKHR.pSignalSemaphoreValues );
2879  return seed;
2880  }
2881  };
2882 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
2883 
2884  template <>
2885  struct hash<VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT>
2886  {
2887  std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT const & debugMarkerMarkerInfoEXT ) const VULKAN_HPP_NOEXCEPT
2888  {
2889  std::size_t seed = 0;
2890  VULKAN_HPP_HASH_COMBINE( seed, debugMarkerMarkerInfoEXT.sType );
2891  VULKAN_HPP_HASH_COMBINE( seed, debugMarkerMarkerInfoEXT.pNext );
2892  for ( const char * p = debugMarkerMarkerInfoEXT.pMarkerName; *p != '\0'; ++p )
2893  {
2894  VULKAN_HPP_HASH_COMBINE( seed, *p );
2895  }
2896  for ( size_t i = 0; i < 4; ++i )
2897  {
2898  VULKAN_HPP_HASH_COMBINE( seed, debugMarkerMarkerInfoEXT.color[i] );
2899  }
2900  return seed;
2901  }
2902  };
2903 
2904  template <>
2905  struct hash<VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT>
2906  {
2907  std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT const & debugMarkerObjectNameInfoEXT ) const VULKAN_HPP_NOEXCEPT
2908  {
2909  std::size_t seed = 0;
2910  VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectNameInfoEXT.sType );
2911  VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectNameInfoEXT.pNext );
2912  VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectNameInfoEXT.objectType );
2913  VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectNameInfoEXT.object );
2914  for ( const char * p = debugMarkerObjectNameInfoEXT.pObjectName; *p != '\0'; ++p )
2915  {
2916  VULKAN_HPP_HASH_COMBINE( seed, *p );
2917  }
2918  return seed;
2919  }
2920  };
2921 
2922  template <>
2923  struct hash<VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT>
2924  {
2925  std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT const & debugMarkerObjectTagInfoEXT ) const VULKAN_HPP_NOEXCEPT
2926  {
2927  std::size_t seed = 0;
2928  VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectTagInfoEXT.sType );
2929  VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectTagInfoEXT.pNext );
2930  VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectTagInfoEXT.objectType );
2931  VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectTagInfoEXT.object );
2932  VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectTagInfoEXT.tagName );
2933  VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectTagInfoEXT.tagSize );
2934  VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectTagInfoEXT.pTag );
2935  return seed;
2936  }
2937  };
2938 
2939  template <>
2940  struct hash<VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT>
2941  {
2942  std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT const & debugReportCallbackCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
2943  {
2944  std::size_t seed = 0;
2945  VULKAN_HPP_HASH_COMBINE( seed, debugReportCallbackCreateInfoEXT.sType );
2946  VULKAN_HPP_HASH_COMBINE( seed, debugReportCallbackCreateInfoEXT.pNext );
2947  VULKAN_HPP_HASH_COMBINE( seed, debugReportCallbackCreateInfoEXT.flags );
2948  VULKAN_HPP_HASH_COMBINE( seed, debugReportCallbackCreateInfoEXT.pfnCallback );
2949  VULKAN_HPP_HASH_COMBINE( seed, debugReportCallbackCreateInfoEXT.pUserData );
2950  return seed;
2951  }
2952  };
2953 
2954  template <>
2955  struct hash<VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT>
2956  {
2957  std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT const & debugUtilsLabelEXT ) const VULKAN_HPP_NOEXCEPT
2958  {
2959  std::size_t seed = 0;
2960  VULKAN_HPP_HASH_COMBINE( seed, debugUtilsLabelEXT.sType );
2961  VULKAN_HPP_HASH_COMBINE( seed, debugUtilsLabelEXT.pNext );
2962  for ( const char * p = debugUtilsLabelEXT.pLabelName; *p != '\0'; ++p )
2963  {
2964  VULKAN_HPP_HASH_COMBINE( seed, *p );
2965  }
2966  for ( size_t i = 0; i < 4; ++i )
2967  {
2968  VULKAN_HPP_HASH_COMBINE( seed, debugUtilsLabelEXT.color[i] );
2969  }
2970  return seed;
2971  }
2972  };
2973 
2974  template <>
2975  struct hash<VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT>
2976  {
2977  std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT const & debugUtilsObjectNameInfoEXT ) const VULKAN_HPP_NOEXCEPT
2978  {
2979  std::size_t seed = 0;
2980  VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectNameInfoEXT.sType );
2981  VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectNameInfoEXT.pNext );
2982  VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectNameInfoEXT.objectType );
2983  VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectNameInfoEXT.objectHandle );
2984  for ( const char * p = debugUtilsObjectNameInfoEXT.pObjectName; *p != '\0'; ++p )
2985  {
2986  VULKAN_HPP_HASH_COMBINE( seed, *p );
2987  }
2988  return seed;
2989  }
2990  };
2991 
2992  template <>
2993  struct hash<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataEXT>
2994  {
2995  std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataEXT const & debugUtilsMessengerCallbackDataEXT ) const VULKAN_HPP_NOEXCEPT
2996  {
2997  std::size_t seed = 0;
2998  VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.sType );
2999  VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.pNext );
3000  VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.flags );
3001  for ( const char * p = debugUtilsMessengerCallbackDataEXT.pMessageIdName; *p != '\0'; ++p )
3002  {
3003  VULKAN_HPP_HASH_COMBINE( seed, *p );
3004  }
3005  VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.messageIdNumber );
3006  for ( const char * p = debugUtilsMessengerCallbackDataEXT.pMessage; *p != '\0'; ++p )
3007  {
3008  VULKAN_HPP_HASH_COMBINE( seed, *p );
3009  }
3010  VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.queueLabelCount );
3011  VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.pQueueLabels );
3012  VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.cmdBufLabelCount );
3013  VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.pCmdBufLabels );
3014  VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.objectCount );
3015  VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.pObjects );
3016  return seed;
3017  }
3018  };
3019 
3020  template <>
3021  struct hash<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT>
3022  {
3023  std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT const & debugUtilsMessengerCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
3024  {
3025  std::size_t seed = 0;
3026  VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCreateInfoEXT.sType );
3027  VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCreateInfoEXT.pNext );
3028  VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCreateInfoEXT.flags );
3029  VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCreateInfoEXT.messageSeverity );
3030  VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCreateInfoEXT.messageType );
3031  VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCreateInfoEXT.pfnUserCallback );
3032  VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCreateInfoEXT.pUserData );
3033  return seed;
3034  }
3035  };
3036 
3037  template <>
3038  struct hash<VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT>
3039  {
3040  std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT const & debugUtilsObjectTagInfoEXT ) const VULKAN_HPP_NOEXCEPT
3041  {
3042  std::size_t seed = 0;
3043  VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectTagInfoEXT.sType );
3044  VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectTagInfoEXT.pNext );
3045  VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectTagInfoEXT.objectType );
3046  VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectTagInfoEXT.objectHandle );
3047  VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectTagInfoEXT.tagName );
3048  VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectTagInfoEXT.tagSize );
3049  VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectTagInfoEXT.pTag );
3050  return seed;
3051  }
3052  };
3053 
3054  template <>
3055  struct hash<VULKAN_HPP_NAMESPACE::DecompressMemoryRegionNV>
3056  {
3057  std::size_t operator()( VULKAN_HPP_NAMESPACE::DecompressMemoryRegionNV const & decompressMemoryRegionNV ) const VULKAN_HPP_NOEXCEPT
3058  {
3059  std::size_t seed = 0;
3060  VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryRegionNV.srcAddress );
3061  VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryRegionNV.dstAddress );
3062  VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryRegionNV.compressedSize );
3063  VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryRegionNV.decompressedSize );
3064  VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryRegionNV.decompressionMethod );
3065  return seed;
3066  }
3067  };
3068 
3069  template <>
3070  struct hash<VULKAN_HPP_NAMESPACE::DedicatedAllocationBufferCreateInfoNV>
3071  {
3072  std::size_t
3073  operator()( VULKAN_HPP_NAMESPACE::DedicatedAllocationBufferCreateInfoNV const & dedicatedAllocationBufferCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
3074  {
3075  std::size_t seed = 0;
3076  VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationBufferCreateInfoNV.sType );
3077  VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationBufferCreateInfoNV.pNext );
3078  VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationBufferCreateInfoNV.dedicatedAllocation );
3079  return seed;
3080  }
3081  };
3082 
3083  template <>
3084  struct hash<VULKAN_HPP_NAMESPACE::DedicatedAllocationImageCreateInfoNV>
3085  {
3086  std::size_t operator()( VULKAN_HPP_NAMESPACE::DedicatedAllocationImageCreateInfoNV const & dedicatedAllocationImageCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
3087  {
3088  std::size_t seed = 0;
3089  VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationImageCreateInfoNV.sType );
3090  VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationImageCreateInfoNV.pNext );
3091  VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationImageCreateInfoNV.dedicatedAllocation );
3092  return seed;
3093  }
3094  };
3095 
3096  template <>
3097  struct hash<VULKAN_HPP_NAMESPACE::DedicatedAllocationMemoryAllocateInfoNV>
3098  {
3099  std::size_t
3100  operator()( VULKAN_HPP_NAMESPACE::DedicatedAllocationMemoryAllocateInfoNV const & dedicatedAllocationMemoryAllocateInfoNV ) const VULKAN_HPP_NOEXCEPT
3101  {
3102  std::size_t seed = 0;
3103  VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationMemoryAllocateInfoNV.sType );
3104  VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationMemoryAllocateInfoNV.pNext );
3105  VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationMemoryAllocateInfoNV.image );
3106  VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationMemoryAllocateInfoNV.buffer );
3107  return seed;
3108  }
3109  };
3110 
3111  template <>
3112  struct hash<VULKAN_HPP_NAMESPACE::MemoryBarrier2>
3113  {
3114  std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryBarrier2 const & memoryBarrier2 ) const VULKAN_HPP_NOEXCEPT
3115  {
3116  std::size_t seed = 0;
3117  VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier2.sType );
3118  VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier2.pNext );
3119  VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier2.srcStageMask );
3120  VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier2.srcAccessMask );
3121  VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier2.dstStageMask );
3122  VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier2.dstAccessMask );
3123  return seed;
3124  }
3125  };
3126 
3127  template <>
3128  struct hash<VULKAN_HPP_NAMESPACE::ImageSubresourceRange>
3129  {
3130  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageSubresourceRange const & imageSubresourceRange ) const VULKAN_HPP_NOEXCEPT
3131  {
3132  std::size_t seed = 0;
3133  VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceRange.aspectMask );
3134  VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceRange.baseMipLevel );
3135  VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceRange.levelCount );
3136  VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceRange.baseArrayLayer );
3137  VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceRange.layerCount );
3138  return seed;
3139  }
3140  };
3141 
3142  template <>
3143  struct hash<VULKAN_HPP_NAMESPACE::ImageMemoryBarrier2>
3144  {
3145  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageMemoryBarrier2 const & imageMemoryBarrier2 ) const VULKAN_HPP_NOEXCEPT
3146  {
3147  std::size_t seed = 0;
3148  VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.sType );
3149  VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.pNext );
3150  VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.srcStageMask );
3151  VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.srcAccessMask );
3152  VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.dstStageMask );
3153  VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.dstAccessMask );
3154  VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.oldLayout );
3155  VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.newLayout );
3156  VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.srcQueueFamilyIndex );
3157  VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.dstQueueFamilyIndex );
3158  VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.image );
3159  VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.subresourceRange );
3160  return seed;
3161  }
3162  };
3163 
3164  template <>
3165  struct hash<VULKAN_HPP_NAMESPACE::DependencyInfo>
3166  {
3167  std::size_t operator()( VULKAN_HPP_NAMESPACE::DependencyInfo const & dependencyInfo ) const VULKAN_HPP_NOEXCEPT
3168  {
3169  std::size_t seed = 0;
3170  VULKAN_HPP_HASH_COMBINE( seed, dependencyInfo.sType );
3171  VULKAN_HPP_HASH_COMBINE( seed, dependencyInfo.pNext );
3172  VULKAN_HPP_HASH_COMBINE( seed, dependencyInfo.dependencyFlags );
3173  VULKAN_HPP_HASH_COMBINE( seed, dependencyInfo.memoryBarrierCount );
3174  VULKAN_HPP_HASH_COMBINE( seed, dependencyInfo.pMemoryBarriers );
3175  VULKAN_HPP_HASH_COMBINE( seed, dependencyInfo.bufferMemoryBarrierCount );
3176  VULKAN_HPP_HASH_COMBINE( seed, dependencyInfo.pBufferMemoryBarriers );
3177  VULKAN_HPP_HASH_COMBINE( seed, dependencyInfo.imageMemoryBarrierCount );
3178  VULKAN_HPP_HASH_COMBINE( seed, dependencyInfo.pImageMemoryBarriers );
3179  return seed;
3180  }
3181  };
3182 
3183  template <>
3184  struct hash<VULKAN_HPP_NAMESPACE::DepthBiasInfoEXT>
3185  {
3186  std::size_t operator()( VULKAN_HPP_NAMESPACE::DepthBiasInfoEXT const & depthBiasInfoEXT ) const VULKAN_HPP_NOEXCEPT
3187  {
3188  std::size_t seed = 0;
3189  VULKAN_HPP_HASH_COMBINE( seed, depthBiasInfoEXT.sType );
3190  VULKAN_HPP_HASH_COMBINE( seed, depthBiasInfoEXT.pNext );
3191  VULKAN_HPP_HASH_COMBINE( seed, depthBiasInfoEXT.depthBiasConstantFactor );
3192  VULKAN_HPP_HASH_COMBINE( seed, depthBiasInfoEXT.depthBiasClamp );
3193  VULKAN_HPP_HASH_COMBINE( seed, depthBiasInfoEXT.depthBiasSlopeFactor );
3194  return seed;
3195  }
3196  };
3197 
3198  template <>
3199  struct hash<VULKAN_HPP_NAMESPACE::DepthBiasRepresentationInfoEXT>
3200  {
3201  std::size_t operator()( VULKAN_HPP_NAMESPACE::DepthBiasRepresentationInfoEXT const & depthBiasRepresentationInfoEXT ) const VULKAN_HPP_NOEXCEPT
3202  {
3203  std::size_t seed = 0;
3204  VULKAN_HPP_HASH_COMBINE( seed, depthBiasRepresentationInfoEXT.sType );
3205  VULKAN_HPP_HASH_COMBINE( seed, depthBiasRepresentationInfoEXT.pNext );
3206  VULKAN_HPP_HASH_COMBINE( seed, depthBiasRepresentationInfoEXT.depthBiasRepresentation );
3207  VULKAN_HPP_HASH_COMBINE( seed, depthBiasRepresentationInfoEXT.depthBiasExact );
3208  return seed;
3209  }
3210  };
3211 
3212  template <>
3213  struct hash<VULKAN_HPP_NAMESPACE::DescriptorAddressInfoEXT>
3214  {
3215  std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorAddressInfoEXT const & descriptorAddressInfoEXT ) const VULKAN_HPP_NOEXCEPT
3216  {
3217  std::size_t seed = 0;
3218  VULKAN_HPP_HASH_COMBINE( seed, descriptorAddressInfoEXT.sType );
3219  VULKAN_HPP_HASH_COMBINE( seed, descriptorAddressInfoEXT.pNext );
3220  VULKAN_HPP_HASH_COMBINE( seed, descriptorAddressInfoEXT.address );
3221  VULKAN_HPP_HASH_COMBINE( seed, descriptorAddressInfoEXT.range );
3222  VULKAN_HPP_HASH_COMBINE( seed, descriptorAddressInfoEXT.format );
3223  return seed;
3224  }
3225  };
3226 
3227  template <>
3228  struct hash<VULKAN_HPP_NAMESPACE::DescriptorBufferBindingInfoEXT>
3229  {
3230  std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorBufferBindingInfoEXT const & descriptorBufferBindingInfoEXT ) const VULKAN_HPP_NOEXCEPT
3231  {
3232  std::size_t seed = 0;
3233  VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferBindingInfoEXT.sType );
3234  VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferBindingInfoEXT.pNext );
3235  VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferBindingInfoEXT.address );
3236  VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferBindingInfoEXT.usage );
3237  return seed;
3238  }
3239  };
3240 
3241  template <>
3242  struct hash<VULKAN_HPP_NAMESPACE::DescriptorBufferBindingPushDescriptorBufferHandleEXT>
3243  {
3244  std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorBufferBindingPushDescriptorBufferHandleEXT const &
3245  descriptorBufferBindingPushDescriptorBufferHandleEXT ) const VULKAN_HPP_NOEXCEPT
3246  {
3247  std::size_t seed = 0;
3248  VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferBindingPushDescriptorBufferHandleEXT.sType );
3249  VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferBindingPushDescriptorBufferHandleEXT.pNext );
3250  VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferBindingPushDescriptorBufferHandleEXT.buffer );
3251  return seed;
3252  }
3253  };
3254 
3255  template <>
3256  struct hash<VULKAN_HPP_NAMESPACE::DescriptorBufferInfo>
3257  {
3258  std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorBufferInfo const & descriptorBufferInfo ) const VULKAN_HPP_NOEXCEPT
3259  {
3260  std::size_t seed = 0;
3261  VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferInfo.buffer );
3262  VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferInfo.offset );
3263  VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferInfo.range );
3264  return seed;
3265  }
3266  };
3267 
3268  template <>
3269  struct hash<VULKAN_HPP_NAMESPACE::DescriptorImageInfo>
3270  {
3271  std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorImageInfo const & descriptorImageInfo ) const VULKAN_HPP_NOEXCEPT
3272  {
3273  std::size_t seed = 0;
3274  VULKAN_HPP_HASH_COMBINE( seed, descriptorImageInfo.sampler );
3275  VULKAN_HPP_HASH_COMBINE( seed, descriptorImageInfo.imageView );
3276  VULKAN_HPP_HASH_COMBINE( seed, descriptorImageInfo.imageLayout );
3277  return seed;
3278  }
3279  };
3280 
3281  template <>
3282  struct hash<VULKAN_HPP_NAMESPACE::DescriptorPoolSize>
3283  {
3284  std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorPoolSize const & descriptorPoolSize ) const VULKAN_HPP_NOEXCEPT
3285  {
3286  std::size_t seed = 0;
3287  VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolSize.type );
3288  VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolSize.descriptorCount );
3289  return seed;
3290  }
3291  };
3292 
3293  template <>
3294  struct hash<VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo>
3295  {
3296  std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo const & descriptorPoolCreateInfo ) const VULKAN_HPP_NOEXCEPT
3297  {
3298  std::size_t seed = 0;
3299  VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolCreateInfo.sType );
3300  VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolCreateInfo.pNext );
3301  VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolCreateInfo.flags );
3302  VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolCreateInfo.maxSets );
3303  VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolCreateInfo.poolSizeCount );
3304  VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolCreateInfo.pPoolSizes );
3305  return seed;
3306  }
3307  };
3308 
3309  template <>
3310  struct hash<VULKAN_HPP_NAMESPACE::DescriptorPoolInlineUniformBlockCreateInfo>
3311  {
3312  std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorPoolInlineUniformBlockCreateInfo const & descriptorPoolInlineUniformBlockCreateInfo ) const
3313  VULKAN_HPP_NOEXCEPT
3314  {
3315  std::size_t seed = 0;
3316  VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolInlineUniformBlockCreateInfo.sType );
3317  VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolInlineUniformBlockCreateInfo.pNext );
3318  VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolInlineUniformBlockCreateInfo.maxInlineUniformBlockBindings );
3319  return seed;
3320  }
3321  };
3322 
3323  template <>
3324  struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo>
3325  {
3326  std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo const & descriptorSetAllocateInfo ) const VULKAN_HPP_NOEXCEPT
3327  {
3328  std::size_t seed = 0;
3329  VULKAN_HPP_HASH_COMBINE( seed, descriptorSetAllocateInfo.sType );
3330  VULKAN_HPP_HASH_COMBINE( seed, descriptorSetAllocateInfo.pNext );
3331  VULKAN_HPP_HASH_COMBINE( seed, descriptorSetAllocateInfo.descriptorPool );
3332  VULKAN_HPP_HASH_COMBINE( seed, descriptorSetAllocateInfo.descriptorSetCount );
3333  VULKAN_HPP_HASH_COMBINE( seed, descriptorSetAllocateInfo.pSetLayouts );
3334  return seed;
3335  }
3336  };
3337 
3338  template <>
3339  struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetBindingReferenceVALVE>
3340  {
3341  std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetBindingReferenceVALVE const & descriptorSetBindingReferenceVALVE ) const VULKAN_HPP_NOEXCEPT
3342  {
3343  std::size_t seed = 0;
3344  VULKAN_HPP_HASH_COMBINE( seed, descriptorSetBindingReferenceVALVE.sType );
3345  VULKAN_HPP_HASH_COMBINE( seed, descriptorSetBindingReferenceVALVE.pNext );
3346  VULKAN_HPP_HASH_COMBINE( seed, descriptorSetBindingReferenceVALVE.descriptorSetLayout );
3347  VULKAN_HPP_HASH_COMBINE( seed, descriptorSetBindingReferenceVALVE.binding );
3348  return seed;
3349  }
3350  };
3351 
3352  template <>
3353  struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBinding>
3354  {
3355  std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBinding const & descriptorSetLayoutBinding ) const VULKAN_HPP_NOEXCEPT
3356  {
3357  std::size_t seed = 0;
3358  VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutBinding.binding );
3359  VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutBinding.descriptorType );
3360  VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutBinding.descriptorCount );
3361  VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutBinding.stageFlags );
3362  VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutBinding.pImmutableSamplers );
3363  return seed;
3364  }
3365  };
3366 
3367  template <>
3368  struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBindingFlagsCreateInfo>
3369  {
3370  std::size_t
3371  operator()( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBindingFlagsCreateInfo const & descriptorSetLayoutBindingFlagsCreateInfo ) const VULKAN_HPP_NOEXCEPT
3372  {
3373  std::size_t seed = 0;
3374  VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutBindingFlagsCreateInfo.sType );
3375  VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutBindingFlagsCreateInfo.pNext );
3376  VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutBindingFlagsCreateInfo.bindingCount );
3377  VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutBindingFlagsCreateInfo.pBindingFlags );
3378  return seed;
3379  }
3380  };
3381 
3382  template <>
3383  struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo>
3384  {
3385  std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo const & descriptorSetLayoutCreateInfo ) const VULKAN_HPP_NOEXCEPT
3386  {
3387  std::size_t seed = 0;
3388  VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutCreateInfo.sType );
3389  VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutCreateInfo.pNext );
3390  VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutCreateInfo.flags );
3391  VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutCreateInfo.bindingCount );
3392  VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutCreateInfo.pBindings );
3393  return seed;
3394  }
3395  };
3396 
3397  template <>
3398  struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutHostMappingInfoVALVE>
3399  {
3400  std::size_t
3401  operator()( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutHostMappingInfoVALVE const & descriptorSetLayoutHostMappingInfoVALVE ) const VULKAN_HPP_NOEXCEPT
3402  {
3403  std::size_t seed = 0;
3404  VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutHostMappingInfoVALVE.sType );
3405  VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutHostMappingInfoVALVE.pNext );
3406  VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutHostMappingInfoVALVE.descriptorOffset );
3407  VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutHostMappingInfoVALVE.descriptorSize );
3408  return seed;
3409  }
3410  };
3411 
3412  template <>
3413  struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport>
3414  {
3415  std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport const & descriptorSetLayoutSupport ) const VULKAN_HPP_NOEXCEPT
3416  {
3417  std::size_t seed = 0;
3418  VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutSupport.sType );
3419  VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutSupport.pNext );
3420  VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutSupport.supported );
3421  return seed;
3422  }
3423  };
3424 
3425  template <>
3426  struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetVariableDescriptorCountAllocateInfo>
3427  {
3428  std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetVariableDescriptorCountAllocateInfo const & descriptorSetVariableDescriptorCountAllocateInfo )
3429  const VULKAN_HPP_NOEXCEPT
3430  {
3431  std::size_t seed = 0;
3432  VULKAN_HPP_HASH_COMBINE( seed, descriptorSetVariableDescriptorCountAllocateInfo.sType );
3433  VULKAN_HPP_HASH_COMBINE( seed, descriptorSetVariableDescriptorCountAllocateInfo.pNext );
3434  VULKAN_HPP_HASH_COMBINE( seed, descriptorSetVariableDescriptorCountAllocateInfo.descriptorSetCount );
3435  VULKAN_HPP_HASH_COMBINE( seed, descriptorSetVariableDescriptorCountAllocateInfo.pDescriptorCounts );
3436  return seed;
3437  }
3438  };
3439 
3440  template <>
3441  struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetVariableDescriptorCountLayoutSupport>
3442  {
3443  std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetVariableDescriptorCountLayoutSupport const & descriptorSetVariableDescriptorCountLayoutSupport )
3444  const VULKAN_HPP_NOEXCEPT
3445  {
3446  std::size_t seed = 0;
3447  VULKAN_HPP_HASH_COMBINE( seed, descriptorSetVariableDescriptorCountLayoutSupport.sType );
3448  VULKAN_HPP_HASH_COMBINE( seed, descriptorSetVariableDescriptorCountLayoutSupport.pNext );
3449  VULKAN_HPP_HASH_COMBINE( seed, descriptorSetVariableDescriptorCountLayoutSupport.maxVariableDescriptorCount );
3450  return seed;
3451  }
3452  };
3453 
3454  template <>
3455  struct hash<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateEntry>
3456  {
3457  std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateEntry const & descriptorUpdateTemplateEntry ) const VULKAN_HPP_NOEXCEPT
3458  {
3459  std::size_t seed = 0;
3460  VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateEntry.dstBinding );
3461  VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateEntry.dstArrayElement );
3462  VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateEntry.descriptorCount );
3463  VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateEntry.descriptorType );
3464  VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateEntry.offset );
3465  VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateEntry.stride );
3466  return seed;
3467  }
3468  };
3469 
3470  template <>
3471  struct hash<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo>
3472  {
3473  std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo const & descriptorUpdateTemplateCreateInfo ) const VULKAN_HPP_NOEXCEPT
3474  {
3475  std::size_t seed = 0;
3476  VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.sType );
3477  VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.pNext );
3478  VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.flags );
3479  VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.descriptorUpdateEntryCount );
3480  VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.pDescriptorUpdateEntries );
3481  VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.templateType );
3482  VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.descriptorSetLayout );
3483  VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.pipelineBindPoint );
3484  VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.pipelineLayout );
3485  VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.set );
3486  return seed;
3487  }
3488  };
3489 
3490  template <>
3491  struct hash<VULKAN_HPP_NAMESPACE::DeviceAddressBindingCallbackDataEXT>
3492  {
3493  std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceAddressBindingCallbackDataEXT const & deviceAddressBindingCallbackDataEXT ) const VULKAN_HPP_NOEXCEPT
3494  {
3495  std::size_t seed = 0;
3496  VULKAN_HPP_HASH_COMBINE( seed, deviceAddressBindingCallbackDataEXT.sType );
3497  VULKAN_HPP_HASH_COMBINE( seed, deviceAddressBindingCallbackDataEXT.pNext );
3498  VULKAN_HPP_HASH_COMBINE( seed, deviceAddressBindingCallbackDataEXT.flags );
3499  VULKAN_HPP_HASH_COMBINE( seed, deviceAddressBindingCallbackDataEXT.baseAddress );
3500  VULKAN_HPP_HASH_COMBINE( seed, deviceAddressBindingCallbackDataEXT.size );
3501  VULKAN_HPP_HASH_COMBINE( seed, deviceAddressBindingCallbackDataEXT.bindingType );
3502  return seed;
3503  }
3504  };
3505 
3506  template <>
3507  struct hash<VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements>
3508  {
3509  std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements const & deviceBufferMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
3510  {
3511  std::size_t seed = 0;
3512  VULKAN_HPP_HASH_COMBINE( seed, deviceBufferMemoryRequirements.sType );
3513  VULKAN_HPP_HASH_COMBINE( seed, deviceBufferMemoryRequirements.pNext );
3514  VULKAN_HPP_HASH_COMBINE( seed, deviceBufferMemoryRequirements.pCreateInfo );
3515  return seed;
3516  }
3517  };
3518 
3519  template <>
3520  struct hash<VULKAN_HPP_NAMESPACE::DeviceQueueCreateInfo>
3521  {
3522  std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceQueueCreateInfo const & deviceQueueCreateInfo ) const VULKAN_HPP_NOEXCEPT
3523  {
3524  std::size_t seed = 0;
3525  VULKAN_HPP_HASH_COMBINE( seed, deviceQueueCreateInfo.sType );
3526  VULKAN_HPP_HASH_COMBINE( seed, deviceQueueCreateInfo.pNext );
3527  VULKAN_HPP_HASH_COMBINE( seed, deviceQueueCreateInfo.flags );
3528  VULKAN_HPP_HASH_COMBINE( seed, deviceQueueCreateInfo.queueFamilyIndex );
3529  VULKAN_HPP_HASH_COMBINE( seed, deviceQueueCreateInfo.queueCount );
3530  VULKAN_HPP_HASH_COMBINE( seed, deviceQueueCreateInfo.pQueuePriorities );
3531  return seed;
3532  }
3533  };
3534 
3535  template <>
3536  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures>
3537  {
3538  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures const & physicalDeviceFeatures ) const VULKAN_HPP_NOEXCEPT
3539  {
3540  std::size_t seed = 0;
3541  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.robustBufferAccess );
3542  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.fullDrawIndexUint32 );
3543  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.imageCubeArray );
3544  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.independentBlend );
3545  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.geometryShader );
3546  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.tessellationShader );
3547  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sampleRateShading );
3548  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.dualSrcBlend );
3549  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.logicOp );
3550  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.multiDrawIndirect );
3551  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.drawIndirectFirstInstance );
3552  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.depthClamp );
3553  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.depthBiasClamp );
3554  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.fillModeNonSolid );
3555  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.depthBounds );
3556  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.wideLines );
3557  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.largePoints );
3558  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.alphaToOne );
3559  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.multiViewport );
3560  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.samplerAnisotropy );
3561  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.textureCompressionETC2 );
3562  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.textureCompressionASTC_LDR );
3563  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.textureCompressionBC );
3564  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.occlusionQueryPrecise );
3565  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.pipelineStatisticsQuery );
3566  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.vertexPipelineStoresAndAtomics );
3567  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.fragmentStoresAndAtomics );
3568  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderTessellationAndGeometryPointSize );
3569  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderImageGatherExtended );
3570  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderStorageImageExtendedFormats );
3571  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderStorageImageMultisample );
3572  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderStorageImageReadWithoutFormat );
3573  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderStorageImageWriteWithoutFormat );
3574  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderUniformBufferArrayDynamicIndexing );
3575  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderSampledImageArrayDynamicIndexing );
3576  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderStorageBufferArrayDynamicIndexing );
3577  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderStorageImageArrayDynamicIndexing );
3578  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderClipDistance );
3579  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderCullDistance );
3580  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderFloat64 );
3581  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderInt64 );
3582  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderInt16 );
3583  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderResourceResidency );
3584  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderResourceMinLod );
3585  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sparseBinding );
3586  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sparseResidencyBuffer );
3587  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sparseResidencyImage2D );
3588  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sparseResidencyImage3D );
3589  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sparseResidency2Samples );
3590  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sparseResidency4Samples );
3591  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sparseResidency8Samples );
3592  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sparseResidency16Samples );
3593  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sparseResidencyAliased );
3594  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.variableMultisampleRate );
3595  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.inheritedQueries );
3596  return seed;
3597  }
3598  };
3599 
3600  template <>
3601  struct hash<VULKAN_HPP_NAMESPACE::DeviceCreateInfo>
3602  {
3603  std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceCreateInfo const & deviceCreateInfo ) const VULKAN_HPP_NOEXCEPT
3604  {
3605  std::size_t seed = 0;
3606  VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.sType );
3607  VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.pNext );
3608  VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.flags );
3609  VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.queueCreateInfoCount );
3610  VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.pQueueCreateInfos );
3611  VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.enabledLayerCount );
3612  for ( size_t i = 0; i < deviceCreateInfo.enabledLayerCount; ++i )
3613  {
3614  for ( const char * p = deviceCreateInfo.ppEnabledLayerNames[i]; *p != '\0'; ++p )
3615  {
3616  VULKAN_HPP_HASH_COMBINE( seed, *p );
3617  }
3618  }
3619  VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.enabledExtensionCount );
3620  for ( size_t i = 0; i < deviceCreateInfo.enabledExtensionCount; ++i )
3621  {
3622  for ( const char * p = deviceCreateInfo.ppEnabledExtensionNames[i]; *p != '\0'; ++p )
3623  {
3624  VULKAN_HPP_HASH_COMBINE( seed, *p );
3625  }
3626  }
3627  VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.pEnabledFeatures );
3628  return seed;
3629  }
3630  };
3631 
3632  template <>
3633  struct hash<VULKAN_HPP_NAMESPACE::DeviceDeviceMemoryReportCreateInfoEXT>
3634  {
3635  std::size_t
3636  operator()( VULKAN_HPP_NAMESPACE::DeviceDeviceMemoryReportCreateInfoEXT const & deviceDeviceMemoryReportCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
3637  {
3638  std::size_t seed = 0;
3639  VULKAN_HPP_HASH_COMBINE( seed, deviceDeviceMemoryReportCreateInfoEXT.sType );
3640  VULKAN_HPP_HASH_COMBINE( seed, deviceDeviceMemoryReportCreateInfoEXT.pNext );
3641  VULKAN_HPP_HASH_COMBINE( seed, deviceDeviceMemoryReportCreateInfoEXT.flags );
3642  VULKAN_HPP_HASH_COMBINE( seed, deviceDeviceMemoryReportCreateInfoEXT.pfnUserCallback );
3643  VULKAN_HPP_HASH_COMBINE( seed, deviceDeviceMemoryReportCreateInfoEXT.pUserData );
3644  return seed;
3645  }
3646  };
3647 
3648  template <>
3649  struct hash<VULKAN_HPP_NAMESPACE::DeviceDiagnosticsConfigCreateInfoNV>
3650  {
3651  std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceDiagnosticsConfigCreateInfoNV const & deviceDiagnosticsConfigCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
3652  {
3653  std::size_t seed = 0;
3654  VULKAN_HPP_HASH_COMBINE( seed, deviceDiagnosticsConfigCreateInfoNV.sType );
3655  VULKAN_HPP_HASH_COMBINE( seed, deviceDiagnosticsConfigCreateInfoNV.pNext );
3656  VULKAN_HPP_HASH_COMBINE( seed, deviceDiagnosticsConfigCreateInfoNV.flags );
3657  return seed;
3658  }
3659  };
3660 
3661  template <>
3662  struct hash<VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT>
3663  {
3664  std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT const & deviceEventInfoEXT ) const VULKAN_HPP_NOEXCEPT
3665  {
3666  std::size_t seed = 0;
3667  VULKAN_HPP_HASH_COMBINE( seed, deviceEventInfoEXT.sType );
3668  VULKAN_HPP_HASH_COMBINE( seed, deviceEventInfoEXT.pNext );
3669  VULKAN_HPP_HASH_COMBINE( seed, deviceEventInfoEXT.deviceEvent );
3670  return seed;
3671  }
3672  };
3673 
3674  template <>
3675  struct hash<VULKAN_HPP_NAMESPACE::DeviceFaultAddressInfoEXT>
3676  {
3677  std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceFaultAddressInfoEXT const & deviceFaultAddressInfoEXT ) const VULKAN_HPP_NOEXCEPT
3678  {
3679  std::size_t seed = 0;
3680  VULKAN_HPP_HASH_COMBINE( seed, deviceFaultAddressInfoEXT.addressType );
3681  VULKAN_HPP_HASH_COMBINE( seed, deviceFaultAddressInfoEXT.reportedAddress );
3682  VULKAN_HPP_HASH_COMBINE( seed, deviceFaultAddressInfoEXT.addressPrecision );
3683  return seed;
3684  }
3685  };
3686 
3687  template <>
3688  struct hash<VULKAN_HPP_NAMESPACE::DeviceFaultCountsEXT>
3689  {
3690  std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceFaultCountsEXT const & deviceFaultCountsEXT ) const VULKAN_HPP_NOEXCEPT
3691  {
3692  std::size_t seed = 0;
3693  VULKAN_HPP_HASH_COMBINE( seed, deviceFaultCountsEXT.sType );
3694  VULKAN_HPP_HASH_COMBINE( seed, deviceFaultCountsEXT.pNext );
3695  VULKAN_HPP_HASH_COMBINE( seed, deviceFaultCountsEXT.addressInfoCount );
3696  VULKAN_HPP_HASH_COMBINE( seed, deviceFaultCountsEXT.vendorInfoCount );
3697  VULKAN_HPP_HASH_COMBINE( seed, deviceFaultCountsEXT.vendorBinarySize );
3698  return seed;
3699  }
3700  };
3701 
3702  template <>
3703  struct hash<VULKAN_HPP_NAMESPACE::DeviceFaultVendorInfoEXT>
3704  {
3705  std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceFaultVendorInfoEXT const & deviceFaultVendorInfoEXT ) const VULKAN_HPP_NOEXCEPT
3706  {
3707  std::size_t seed = 0;
3708  for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i )
3709  {
3710  VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorInfoEXT.description[i] );
3711  }
3712  VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorInfoEXT.vendorFaultCode );
3713  VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorInfoEXT.vendorFaultData );
3714  return seed;
3715  }
3716  };
3717 
3718  template <>
3719  struct hash<VULKAN_HPP_NAMESPACE::DeviceFaultInfoEXT>
3720  {
3721  std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceFaultInfoEXT const & deviceFaultInfoEXT ) const VULKAN_HPP_NOEXCEPT
3722  {
3723  std::size_t seed = 0;
3724  VULKAN_HPP_HASH_COMBINE( seed, deviceFaultInfoEXT.sType );
3725  VULKAN_HPP_HASH_COMBINE( seed, deviceFaultInfoEXT.pNext );
3726  for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i )
3727  {
3728  VULKAN_HPP_HASH_COMBINE( seed, deviceFaultInfoEXT.description[i] );
3729  }
3730  VULKAN_HPP_HASH_COMBINE( seed, deviceFaultInfoEXT.pAddressInfos );
3731  VULKAN_HPP_HASH_COMBINE( seed, deviceFaultInfoEXT.pVendorInfos );
3732  VULKAN_HPP_HASH_COMBINE( seed, deviceFaultInfoEXT.pVendorBinaryData );
3733  return seed;
3734  }
3735  };
3736 
3737  template <>
3738  struct hash<VULKAN_HPP_NAMESPACE::DeviceFaultVendorBinaryHeaderVersionOneEXT>
3739  {
3740  std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceFaultVendorBinaryHeaderVersionOneEXT const & deviceFaultVendorBinaryHeaderVersionOneEXT ) const
3741  VULKAN_HPP_NOEXCEPT
3742  {
3743  std::size_t seed = 0;
3744  VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.headerSize );
3745  VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.headerVersion );
3746  VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.vendorID );
3747  VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.deviceID );
3748  VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.driverVersion );
3749  for ( size_t i = 0; i < VK_UUID_SIZE; ++i )
3750  {
3751  VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.pipelineCacheUUID[i] );
3752  }
3753  VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.applicationNameOffset );
3754  VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.applicationVersion );
3755  VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.engineNameOffset );
3756  VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.engineVersion );
3757  VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.apiVersion );
3758  return seed;
3759  }
3760  };
3761 
3762  template <>
3763  struct hash<VULKAN_HPP_NAMESPACE::DeviceGroupBindSparseInfo>
3764  {
3765  std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupBindSparseInfo const & deviceGroupBindSparseInfo ) const VULKAN_HPP_NOEXCEPT
3766  {
3767  std::size_t seed = 0;
3768  VULKAN_HPP_HASH_COMBINE( seed, deviceGroupBindSparseInfo.sType );
3769  VULKAN_HPP_HASH_COMBINE( seed, deviceGroupBindSparseInfo.pNext );
3770  VULKAN_HPP_HASH_COMBINE( seed, deviceGroupBindSparseInfo.resourceDeviceIndex );
3771  VULKAN_HPP_HASH_COMBINE( seed, deviceGroupBindSparseInfo.memoryDeviceIndex );
3772  return seed;
3773  }
3774  };
3775 
3776  template <>
3777  struct hash<VULKAN_HPP_NAMESPACE::DeviceGroupCommandBufferBeginInfo>
3778  {
3779  std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupCommandBufferBeginInfo const & deviceGroupCommandBufferBeginInfo ) const VULKAN_HPP_NOEXCEPT
3780  {
3781  std::size_t seed = 0;
3782  VULKAN_HPP_HASH_COMBINE( seed, deviceGroupCommandBufferBeginInfo.sType );
3783  VULKAN_HPP_HASH_COMBINE( seed, deviceGroupCommandBufferBeginInfo.pNext );
3784  VULKAN_HPP_HASH_COMBINE( seed, deviceGroupCommandBufferBeginInfo.deviceMask );
3785  return seed;
3786  }
3787  };
3788 
3789  template <>
3790  struct hash<VULKAN_HPP_NAMESPACE::DeviceGroupDeviceCreateInfo>
3791  {
3792  std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupDeviceCreateInfo const & deviceGroupDeviceCreateInfo ) const VULKAN_HPP_NOEXCEPT
3793  {
3794  std::size_t seed = 0;
3795  VULKAN_HPP_HASH_COMBINE( seed, deviceGroupDeviceCreateInfo.sType );
3796  VULKAN_HPP_HASH_COMBINE( seed, deviceGroupDeviceCreateInfo.pNext );
3797  VULKAN_HPP_HASH_COMBINE( seed, deviceGroupDeviceCreateInfo.physicalDeviceCount );
3798  VULKAN_HPP_HASH_COMBINE( seed, deviceGroupDeviceCreateInfo.pPhysicalDevices );
3799  return seed;
3800  }
3801  };
3802 
3803  template <>
3804  struct hash<VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR>
3805  {
3806  std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR const & deviceGroupPresentCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT
3807  {
3808  std::size_t seed = 0;
3809  VULKAN_HPP_HASH_COMBINE( seed, deviceGroupPresentCapabilitiesKHR.sType );
3810  VULKAN_HPP_HASH_COMBINE( seed, deviceGroupPresentCapabilitiesKHR.pNext );
3811  for ( size_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; ++i )
3812  {
3813  VULKAN_HPP_HASH_COMBINE( seed, deviceGroupPresentCapabilitiesKHR.presentMask[i] );
3814  }
3815  VULKAN_HPP_HASH_COMBINE( seed, deviceGroupPresentCapabilitiesKHR.modes );
3816  return seed;
3817  }
3818  };
3819 
3820  template <>
3821  struct hash<VULKAN_HPP_NAMESPACE::DeviceGroupPresentInfoKHR>
3822  {
3823  std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupPresentInfoKHR const & deviceGroupPresentInfoKHR ) const VULKAN_HPP_NOEXCEPT
3824  {
3825  std::size_t seed = 0;
3826  VULKAN_HPP_HASH_COMBINE( seed, deviceGroupPresentInfoKHR.sType );
3827  VULKAN_HPP_HASH_COMBINE( seed, deviceGroupPresentInfoKHR.pNext );
3828  VULKAN_HPP_HASH_COMBINE( seed, deviceGroupPresentInfoKHR.swapchainCount );
3829  VULKAN_HPP_HASH_COMBINE( seed, deviceGroupPresentInfoKHR.pDeviceMasks );
3830  VULKAN_HPP_HASH_COMBINE( seed, deviceGroupPresentInfoKHR.mode );
3831  return seed;
3832  }
3833  };
3834 
3835  template <>
3836  struct hash<VULKAN_HPP_NAMESPACE::DeviceGroupRenderPassBeginInfo>
3837  {
3838  std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupRenderPassBeginInfo const & deviceGroupRenderPassBeginInfo ) const VULKAN_HPP_NOEXCEPT
3839  {
3840  std::size_t seed = 0;
3841  VULKAN_HPP_HASH_COMBINE( seed, deviceGroupRenderPassBeginInfo.sType );
3842  VULKAN_HPP_HASH_COMBINE( seed, deviceGroupRenderPassBeginInfo.pNext );
3843  VULKAN_HPP_HASH_COMBINE( seed, deviceGroupRenderPassBeginInfo.deviceMask );
3844  VULKAN_HPP_HASH_COMBINE( seed, deviceGroupRenderPassBeginInfo.deviceRenderAreaCount );
3845  VULKAN_HPP_HASH_COMBINE( seed, deviceGroupRenderPassBeginInfo.pDeviceRenderAreas );
3846  return seed;
3847  }
3848  };
3849 
3850  template <>
3851  struct hash<VULKAN_HPP_NAMESPACE::DeviceGroupSubmitInfo>
3852  {
3853  std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupSubmitInfo const & deviceGroupSubmitInfo ) const VULKAN_HPP_NOEXCEPT
3854  {
3855  std::size_t seed = 0;
3856  VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSubmitInfo.sType );
3857  VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSubmitInfo.pNext );
3858  VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSubmitInfo.waitSemaphoreCount );
3859  VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSubmitInfo.pWaitSemaphoreDeviceIndices );
3860  VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSubmitInfo.commandBufferCount );
3861  VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSubmitInfo.pCommandBufferDeviceMasks );
3862  VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSubmitInfo.signalSemaphoreCount );
3863  VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSubmitInfo.pSignalSemaphoreDeviceIndices );
3864  return seed;
3865  }
3866  };
3867 
3868  template <>
3869  struct hash<VULKAN_HPP_NAMESPACE::DeviceGroupSwapchainCreateInfoKHR>
3870  {
3871  std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupSwapchainCreateInfoKHR const & deviceGroupSwapchainCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
3872  {
3873  std::size_t seed = 0;
3874  VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSwapchainCreateInfoKHR.sType );
3875  VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSwapchainCreateInfoKHR.pNext );
3876  VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSwapchainCreateInfoKHR.modes );
3877  return seed;
3878  }
3879  };
3880 
3881  template <>
3882  struct hash<VULKAN_HPP_NAMESPACE::ImageCreateInfo>
3883  {
3884  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageCreateInfo const & imageCreateInfo ) const VULKAN_HPP_NOEXCEPT
3885  {
3886  std::size_t seed = 0;
3887  VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.sType );
3888  VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.pNext );
3889  VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.flags );
3890  VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.imageType );
3891  VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.format );
3892  VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.extent );
3893  VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.mipLevels );
3894  VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.arrayLayers );
3895  VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.samples );
3896  VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.tiling );
3897  VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.usage );
3898  VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.sharingMode );
3899  VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.queueFamilyIndexCount );
3900  VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.pQueueFamilyIndices );
3901  VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.initialLayout );
3902  return seed;
3903  }
3904  };
3905 
3906  template <>
3907  struct hash<VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements>
3908  {
3909  std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements const & deviceImageMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
3910  {
3911  std::size_t seed = 0;
3912  VULKAN_HPP_HASH_COMBINE( seed, deviceImageMemoryRequirements.sType );
3913  VULKAN_HPP_HASH_COMBINE( seed, deviceImageMemoryRequirements.pNext );
3914  VULKAN_HPP_HASH_COMBINE( seed, deviceImageMemoryRequirements.pCreateInfo );
3915  VULKAN_HPP_HASH_COMBINE( seed, deviceImageMemoryRequirements.planeAspect );
3916  return seed;
3917  }
3918  };
3919 
3920  template <>
3921  struct hash<VULKAN_HPP_NAMESPACE::ImageSubresource2KHR>
3922  {
3923  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageSubresource2KHR const & imageSubresource2KHR ) const VULKAN_HPP_NOEXCEPT
3924  {
3925  std::size_t seed = 0;
3926  VULKAN_HPP_HASH_COMBINE( seed, imageSubresource2KHR.sType );
3927  VULKAN_HPP_HASH_COMBINE( seed, imageSubresource2KHR.pNext );
3928  VULKAN_HPP_HASH_COMBINE( seed, imageSubresource2KHR.imageSubresource );
3929  return seed;
3930  }
3931  };
3932 
3933  template <>
3934  struct hash<VULKAN_HPP_NAMESPACE::DeviceImageSubresourceInfoKHR>
3935  {
3936  std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceImageSubresourceInfoKHR const & deviceImageSubresourceInfoKHR ) const VULKAN_HPP_NOEXCEPT
3937  {
3938  std::size_t seed = 0;
3939  VULKAN_HPP_HASH_COMBINE( seed, deviceImageSubresourceInfoKHR.sType );
3940  VULKAN_HPP_HASH_COMBINE( seed, deviceImageSubresourceInfoKHR.pNext );
3941  VULKAN_HPP_HASH_COMBINE( seed, deviceImageSubresourceInfoKHR.pCreateInfo );
3942  VULKAN_HPP_HASH_COMBINE( seed, deviceImageSubresourceInfoKHR.pSubresource );
3943  return seed;
3944  }
3945  };
3946 
3947  template <>
3948  struct hash<VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo>
3949  {
3950  std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo const & deviceMemoryOpaqueCaptureAddressInfo ) const VULKAN_HPP_NOEXCEPT
3951  {
3952  std::size_t seed = 0;
3953  VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryOpaqueCaptureAddressInfo.sType );
3954  VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryOpaqueCaptureAddressInfo.pNext );
3955  VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryOpaqueCaptureAddressInfo.memory );
3956  return seed;
3957  }
3958  };
3959 
3960  template <>
3961  struct hash<VULKAN_HPP_NAMESPACE::DeviceMemoryOverallocationCreateInfoAMD>
3962  {
3963  std::size_t
3964  operator()( VULKAN_HPP_NAMESPACE::DeviceMemoryOverallocationCreateInfoAMD const & deviceMemoryOverallocationCreateInfoAMD ) const VULKAN_HPP_NOEXCEPT
3965  {
3966  std::size_t seed = 0;
3967  VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryOverallocationCreateInfoAMD.sType );
3968  VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryOverallocationCreateInfoAMD.pNext );
3969  VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryOverallocationCreateInfoAMD.overallocationBehavior );
3970  return seed;
3971  }
3972  };
3973 
3974  template <>
3975  struct hash<VULKAN_HPP_NAMESPACE::DeviceMemoryReportCallbackDataEXT>
3976  {
3977  std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceMemoryReportCallbackDataEXT const & deviceMemoryReportCallbackDataEXT ) const VULKAN_HPP_NOEXCEPT
3978  {
3979  std::size_t seed = 0;
3980  VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryReportCallbackDataEXT.sType );
3981  VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryReportCallbackDataEXT.pNext );
3982  VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryReportCallbackDataEXT.flags );
3983  VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryReportCallbackDataEXT.type );
3984  VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryReportCallbackDataEXT.memoryObjectId );
3985  VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryReportCallbackDataEXT.size );
3986  VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryReportCallbackDataEXT.objectType );
3987  VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryReportCallbackDataEXT.objectHandle );
3988  VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryReportCallbackDataEXT.heapIndex );
3989  return seed;
3990  }
3991  };
3992 
3993  template <>
3994  struct hash<VULKAN_HPP_NAMESPACE::DevicePrivateDataCreateInfo>
3995  {
3996  std::size_t operator()( VULKAN_HPP_NAMESPACE::DevicePrivateDataCreateInfo const & devicePrivateDataCreateInfo ) const VULKAN_HPP_NOEXCEPT
3997  {
3998  std::size_t seed = 0;
3999  VULKAN_HPP_HASH_COMBINE( seed, devicePrivateDataCreateInfo.sType );
4000  VULKAN_HPP_HASH_COMBINE( seed, devicePrivateDataCreateInfo.pNext );
4001  VULKAN_HPP_HASH_COMBINE( seed, devicePrivateDataCreateInfo.privateDataSlotRequestCount );
4002  return seed;
4003  }
4004  };
4005 
4006  template <>
4007  struct hash<VULKAN_HPP_NAMESPACE::DeviceQueueGlobalPriorityCreateInfoKHR>
4008  {
4009  std::size_t
4010  operator()( VULKAN_HPP_NAMESPACE::DeviceQueueGlobalPriorityCreateInfoKHR const & deviceQueueGlobalPriorityCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
4011  {
4012  std::size_t seed = 0;
4013  VULKAN_HPP_HASH_COMBINE( seed, deviceQueueGlobalPriorityCreateInfoKHR.sType );
4014  VULKAN_HPP_HASH_COMBINE( seed, deviceQueueGlobalPriorityCreateInfoKHR.pNext );
4015  VULKAN_HPP_HASH_COMBINE( seed, deviceQueueGlobalPriorityCreateInfoKHR.globalPriority );
4016  return seed;
4017  }
4018  };
4019 
4020  template <>
4021  struct hash<VULKAN_HPP_NAMESPACE::DeviceQueueInfo2>
4022  {
4023  std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceQueueInfo2 const & deviceQueueInfo2 ) const VULKAN_HPP_NOEXCEPT
4024  {
4025  std::size_t seed = 0;
4026  VULKAN_HPP_HASH_COMBINE( seed, deviceQueueInfo2.sType );
4027  VULKAN_HPP_HASH_COMBINE( seed, deviceQueueInfo2.pNext );
4028  VULKAN_HPP_HASH_COMBINE( seed, deviceQueueInfo2.flags );
4029  VULKAN_HPP_HASH_COMBINE( seed, deviceQueueInfo2.queueFamilyIndex );
4030  VULKAN_HPP_HASH_COMBINE( seed, deviceQueueInfo2.queueIndex );
4031  return seed;
4032  }
4033  };
4034 
4035  template <>
4036  struct hash<VULKAN_HPP_NAMESPACE::DeviceQueueShaderCoreControlCreateInfoARM>
4037  {
4038  std::size_t
4039  operator()( VULKAN_HPP_NAMESPACE::DeviceQueueShaderCoreControlCreateInfoARM const & deviceQueueShaderCoreControlCreateInfoARM ) const VULKAN_HPP_NOEXCEPT
4040  {
4041  std::size_t seed = 0;
4042  VULKAN_HPP_HASH_COMBINE( seed, deviceQueueShaderCoreControlCreateInfoARM.sType );
4043  VULKAN_HPP_HASH_COMBINE( seed, deviceQueueShaderCoreControlCreateInfoARM.pNext );
4044  VULKAN_HPP_HASH_COMBINE( seed, deviceQueueShaderCoreControlCreateInfoARM.shaderCoreCount );
4045  return seed;
4046  }
4047  };
4048 
4049  template <>
4050  struct hash<VULKAN_HPP_NAMESPACE::DirectDriverLoadingInfoLUNARG>
4051  {
4052  std::size_t operator()( VULKAN_HPP_NAMESPACE::DirectDriverLoadingInfoLUNARG const & directDriverLoadingInfoLUNARG ) const VULKAN_HPP_NOEXCEPT
4053  {
4054  std::size_t seed = 0;
4055  VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingInfoLUNARG.sType );
4056  VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingInfoLUNARG.pNext );
4057  VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingInfoLUNARG.flags );
4058  VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingInfoLUNARG.pfnGetInstanceProcAddr );
4059  return seed;
4060  }
4061  };
4062 
4063  template <>
4064  struct hash<VULKAN_HPP_NAMESPACE::DirectDriverLoadingListLUNARG>
4065  {
4066  std::size_t operator()( VULKAN_HPP_NAMESPACE::DirectDriverLoadingListLUNARG const & directDriverLoadingListLUNARG ) const VULKAN_HPP_NOEXCEPT
4067  {
4068  std::size_t seed = 0;
4069  VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingListLUNARG.sType );
4070  VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingListLUNARG.pNext );
4071  VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingListLUNARG.mode );
4072  VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingListLUNARG.driverCount );
4073  VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingListLUNARG.pDrivers );
4074  return seed;
4075  }
4076  };
4077 
4078 # if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
4079  template <>
4080  struct hash<VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT>
4081  {
4082  std::size_t operator()( VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT const & directFBSurfaceCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
4083  {
4084  std::size_t seed = 0;
4085  VULKAN_HPP_HASH_COMBINE( seed, directFBSurfaceCreateInfoEXT.sType );
4086  VULKAN_HPP_HASH_COMBINE( seed, directFBSurfaceCreateInfoEXT.pNext );
4087  VULKAN_HPP_HASH_COMBINE( seed, directFBSurfaceCreateInfoEXT.flags );
4088  VULKAN_HPP_HASH_COMBINE( seed, directFBSurfaceCreateInfoEXT.dfb );
4089  VULKAN_HPP_HASH_COMBINE( seed, directFBSurfaceCreateInfoEXT.surface );
4090  return seed;
4091  }
4092  };
4093 # endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
4094 
4095  template <>
4096  struct hash<VULKAN_HPP_NAMESPACE::DispatchIndirectCommand>
4097  {
4098  std::size_t operator()( VULKAN_HPP_NAMESPACE::DispatchIndirectCommand const & dispatchIndirectCommand ) const VULKAN_HPP_NOEXCEPT
4099  {
4100  std::size_t seed = 0;
4101  VULKAN_HPP_HASH_COMBINE( seed, dispatchIndirectCommand.x );
4102  VULKAN_HPP_HASH_COMBINE( seed, dispatchIndirectCommand.y );
4103  VULKAN_HPP_HASH_COMBINE( seed, dispatchIndirectCommand.z );
4104  return seed;
4105  }
4106  };
4107 
4108  template <>
4109  struct hash<VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT>
4110  {
4111  std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT const & displayEventInfoEXT ) const VULKAN_HPP_NOEXCEPT
4112  {
4113  std::size_t seed = 0;
4114  VULKAN_HPP_HASH_COMBINE( seed, displayEventInfoEXT.sType );
4115  VULKAN_HPP_HASH_COMBINE( seed, displayEventInfoEXT.pNext );
4116  VULKAN_HPP_HASH_COMBINE( seed, displayEventInfoEXT.displayEvent );
4117  return seed;
4118  }
4119  };
4120 
4121  template <>
4122  struct hash<VULKAN_HPP_NAMESPACE::DisplayModeParametersKHR>
4123  {
4124  std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayModeParametersKHR const & displayModeParametersKHR ) const VULKAN_HPP_NOEXCEPT
4125  {
4126  std::size_t seed = 0;
4127  VULKAN_HPP_HASH_COMBINE( seed, displayModeParametersKHR.visibleRegion );
4128  VULKAN_HPP_HASH_COMBINE( seed, displayModeParametersKHR.refreshRate );
4129  return seed;
4130  }
4131  };
4132 
4133  template <>
4134  struct hash<VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR>
4135  {
4136  std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR const & displayModeCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
4137  {
4138  std::size_t seed = 0;
4139  VULKAN_HPP_HASH_COMBINE( seed, displayModeCreateInfoKHR.sType );
4140  VULKAN_HPP_HASH_COMBINE( seed, displayModeCreateInfoKHR.pNext );
4141  VULKAN_HPP_HASH_COMBINE( seed, displayModeCreateInfoKHR.flags );
4142  VULKAN_HPP_HASH_COMBINE( seed, displayModeCreateInfoKHR.parameters );
4143  return seed;
4144  }
4145  };
4146 
4147  template <>
4148  struct hash<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR>
4149  {
4150  std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR const & displayModePropertiesKHR ) const VULKAN_HPP_NOEXCEPT
4151  {
4152  std::size_t seed = 0;
4153  VULKAN_HPP_HASH_COMBINE( seed, displayModePropertiesKHR.displayMode );
4154  VULKAN_HPP_HASH_COMBINE( seed, displayModePropertiesKHR.parameters );
4155  return seed;
4156  }
4157  };
4158 
4159  template <>
4160  struct hash<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR>
4161  {
4162  std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR const & displayModeProperties2KHR ) const VULKAN_HPP_NOEXCEPT
4163  {
4164  std::size_t seed = 0;
4165  VULKAN_HPP_HASH_COMBINE( seed, displayModeProperties2KHR.sType );
4166  VULKAN_HPP_HASH_COMBINE( seed, displayModeProperties2KHR.pNext );
4167  VULKAN_HPP_HASH_COMBINE( seed, displayModeProperties2KHR.displayModeProperties );
4168  return seed;
4169  }
4170  };
4171 
4172  template <>
4173  struct hash<VULKAN_HPP_NAMESPACE::DisplayNativeHdrSurfaceCapabilitiesAMD>
4174  {
4175  std::size_t
4176  operator()( VULKAN_HPP_NAMESPACE::DisplayNativeHdrSurfaceCapabilitiesAMD const & displayNativeHdrSurfaceCapabilitiesAMD ) const VULKAN_HPP_NOEXCEPT
4177  {
4178  std::size_t seed = 0;
4179  VULKAN_HPP_HASH_COMBINE( seed, displayNativeHdrSurfaceCapabilitiesAMD.sType );
4180  VULKAN_HPP_HASH_COMBINE( seed, displayNativeHdrSurfaceCapabilitiesAMD.pNext );
4181  VULKAN_HPP_HASH_COMBINE( seed, displayNativeHdrSurfaceCapabilitiesAMD.localDimmingSupport );
4182  return seed;
4183  }
4184  };
4185 
4186  template <>
4187  struct hash<VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR>
4188  {
4189  std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR const & displayPlaneCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT
4190  {
4191  std::size_t seed = 0;
4192  VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilitiesKHR.supportedAlpha );
4193  VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilitiesKHR.minSrcPosition );
4194  VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilitiesKHR.maxSrcPosition );
4195  VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilitiesKHR.minSrcExtent );
4196  VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilitiesKHR.maxSrcExtent );
4197  VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilitiesKHR.minDstPosition );
4198  VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilitiesKHR.maxDstPosition );
4199  VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilitiesKHR.minDstExtent );
4200  VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilitiesKHR.maxDstExtent );
4201  return seed;
4202  }
4203  };
4204 
4205  template <>
4206  struct hash<VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR>
4207  {
4208  std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR const & displayPlaneCapabilities2KHR ) const VULKAN_HPP_NOEXCEPT
4209  {
4210  std::size_t seed = 0;
4211  VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilities2KHR.sType );
4212  VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilities2KHR.pNext );
4213  VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilities2KHR.capabilities );
4214  return seed;
4215  }
4216  };
4217 
4218  template <>
4219  struct hash<VULKAN_HPP_NAMESPACE::DisplayPlaneInfo2KHR>
4220  {
4221  std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPlaneInfo2KHR const & displayPlaneInfo2KHR ) const VULKAN_HPP_NOEXCEPT
4222  {
4223  std::size_t seed = 0;
4224  VULKAN_HPP_HASH_COMBINE( seed, displayPlaneInfo2KHR.sType );
4225  VULKAN_HPP_HASH_COMBINE( seed, displayPlaneInfo2KHR.pNext );
4226  VULKAN_HPP_HASH_COMBINE( seed, displayPlaneInfo2KHR.mode );
4227  VULKAN_HPP_HASH_COMBINE( seed, displayPlaneInfo2KHR.planeIndex );
4228  return seed;
4229  }
4230  };
4231 
4232  template <>
4233  struct hash<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR>
4234  {
4235  std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR const & displayPlanePropertiesKHR ) const VULKAN_HPP_NOEXCEPT
4236  {
4237  std::size_t seed = 0;
4238  VULKAN_HPP_HASH_COMBINE( seed, displayPlanePropertiesKHR.currentDisplay );
4239  VULKAN_HPP_HASH_COMBINE( seed, displayPlanePropertiesKHR.currentStackIndex );
4240  return seed;
4241  }
4242  };
4243 
4244  template <>
4245  struct hash<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR>
4246  {
4247  std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR const & displayPlaneProperties2KHR ) const VULKAN_HPP_NOEXCEPT
4248  {
4249  std::size_t seed = 0;
4250  VULKAN_HPP_HASH_COMBINE( seed, displayPlaneProperties2KHR.sType );
4251  VULKAN_HPP_HASH_COMBINE( seed, displayPlaneProperties2KHR.pNext );
4252  VULKAN_HPP_HASH_COMBINE( seed, displayPlaneProperties2KHR.displayPlaneProperties );
4253  return seed;
4254  }
4255  };
4256 
4257  template <>
4258  struct hash<VULKAN_HPP_NAMESPACE::DisplayPowerInfoEXT>
4259  {
4260  std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPowerInfoEXT const & displayPowerInfoEXT ) const VULKAN_HPP_NOEXCEPT
4261  {
4262  std::size_t seed = 0;
4263  VULKAN_HPP_HASH_COMBINE( seed, displayPowerInfoEXT.sType );
4264  VULKAN_HPP_HASH_COMBINE( seed, displayPowerInfoEXT.pNext );
4265  VULKAN_HPP_HASH_COMBINE( seed, displayPowerInfoEXT.powerState );
4266  return seed;
4267  }
4268  };
4269 
4270  template <>
4271  struct hash<VULKAN_HPP_NAMESPACE::DisplayPresentInfoKHR>
4272  {
4273  std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPresentInfoKHR const & displayPresentInfoKHR ) const VULKAN_HPP_NOEXCEPT
4274  {
4275  std::size_t seed = 0;
4276  VULKAN_HPP_HASH_COMBINE( seed, displayPresentInfoKHR.sType );
4277  VULKAN_HPP_HASH_COMBINE( seed, displayPresentInfoKHR.pNext );
4278  VULKAN_HPP_HASH_COMBINE( seed, displayPresentInfoKHR.srcRect );
4279  VULKAN_HPP_HASH_COMBINE( seed, displayPresentInfoKHR.dstRect );
4280  VULKAN_HPP_HASH_COMBINE( seed, displayPresentInfoKHR.persistent );
4281  return seed;
4282  }
4283  };
4284 
4285  template <>
4286  struct hash<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR>
4287  {
4288  std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR const & displayPropertiesKHR ) const VULKAN_HPP_NOEXCEPT
4289  {
4290  std::size_t seed = 0;
4291  VULKAN_HPP_HASH_COMBINE( seed, displayPropertiesKHR.display );
4292  for ( const char * p = displayPropertiesKHR.displayName; *p != '\0'; ++p )
4293  {
4294  VULKAN_HPP_HASH_COMBINE( seed, *p );
4295  }
4296  VULKAN_HPP_HASH_COMBINE( seed, displayPropertiesKHR.physicalDimensions );
4297  VULKAN_HPP_HASH_COMBINE( seed, displayPropertiesKHR.physicalResolution );
4298  VULKAN_HPP_HASH_COMBINE( seed, displayPropertiesKHR.supportedTransforms );
4299  VULKAN_HPP_HASH_COMBINE( seed, displayPropertiesKHR.planeReorderPossible );
4300  VULKAN_HPP_HASH_COMBINE( seed, displayPropertiesKHR.persistentContent );
4301  return seed;
4302  }
4303  };
4304 
4305  template <>
4306  struct hash<VULKAN_HPP_NAMESPACE::DisplayProperties2KHR>
4307  {
4308  std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayProperties2KHR const & displayProperties2KHR ) const VULKAN_HPP_NOEXCEPT
4309  {
4310  std::size_t seed = 0;
4311  VULKAN_HPP_HASH_COMBINE( seed, displayProperties2KHR.sType );
4312  VULKAN_HPP_HASH_COMBINE( seed, displayProperties2KHR.pNext );
4313  VULKAN_HPP_HASH_COMBINE( seed, displayProperties2KHR.displayProperties );
4314  return seed;
4315  }
4316  };
4317 
4318  template <>
4319  struct hash<VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR>
4320  {
4321  std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR const & displaySurfaceCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
4322  {
4323  std::size_t seed = 0;
4324  VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.sType );
4325  VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.pNext );
4326  VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.flags );
4327  VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.displayMode );
4328  VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.planeIndex );
4329  VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.planeStackIndex );
4330  VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.transform );
4331  VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.globalAlpha );
4332  VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.alphaMode );
4333  VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.imageExtent );
4334  return seed;
4335  }
4336  };
4337 
4338  template <>
4339  struct hash<VULKAN_HPP_NAMESPACE::DrawIndexedIndirectCommand>
4340  {
4341  std::size_t operator()( VULKAN_HPP_NAMESPACE::DrawIndexedIndirectCommand const & drawIndexedIndirectCommand ) const VULKAN_HPP_NOEXCEPT
4342  {
4343  std::size_t seed = 0;
4344  VULKAN_HPP_HASH_COMBINE( seed, drawIndexedIndirectCommand.indexCount );
4345  VULKAN_HPP_HASH_COMBINE( seed, drawIndexedIndirectCommand.instanceCount );
4346  VULKAN_HPP_HASH_COMBINE( seed, drawIndexedIndirectCommand.firstIndex );
4347  VULKAN_HPP_HASH_COMBINE( seed, drawIndexedIndirectCommand.vertexOffset );
4348  VULKAN_HPP_HASH_COMBINE( seed, drawIndexedIndirectCommand.firstInstance );
4349  return seed;
4350  }
4351  };
4352 
4353  template <>
4354  struct hash<VULKAN_HPP_NAMESPACE::DrawIndirectCommand>
4355  {
4356  std::size_t operator()( VULKAN_HPP_NAMESPACE::DrawIndirectCommand const & drawIndirectCommand ) const VULKAN_HPP_NOEXCEPT
4357  {
4358  std::size_t seed = 0;
4359  VULKAN_HPP_HASH_COMBINE( seed, drawIndirectCommand.vertexCount );
4360  VULKAN_HPP_HASH_COMBINE( seed, drawIndirectCommand.instanceCount );
4361  VULKAN_HPP_HASH_COMBINE( seed, drawIndirectCommand.firstVertex );
4362  VULKAN_HPP_HASH_COMBINE( seed, drawIndirectCommand.firstInstance );
4363  return seed;
4364  }
4365  };
4366 
4367  template <>
4368  struct hash<VULKAN_HPP_NAMESPACE::DrawMeshTasksIndirectCommandEXT>
4369  {
4370  std::size_t operator()( VULKAN_HPP_NAMESPACE::DrawMeshTasksIndirectCommandEXT const & drawMeshTasksIndirectCommandEXT ) const VULKAN_HPP_NOEXCEPT
4371  {
4372  std::size_t seed = 0;
4373  VULKAN_HPP_HASH_COMBINE( seed, drawMeshTasksIndirectCommandEXT.groupCountX );
4374  VULKAN_HPP_HASH_COMBINE( seed, drawMeshTasksIndirectCommandEXT.groupCountY );
4375  VULKAN_HPP_HASH_COMBINE( seed, drawMeshTasksIndirectCommandEXT.groupCountZ );
4376  return seed;
4377  }
4378  };
4379 
4380  template <>
4381  struct hash<VULKAN_HPP_NAMESPACE::DrawMeshTasksIndirectCommandNV>
4382  {
4383  std::size_t operator()( VULKAN_HPP_NAMESPACE::DrawMeshTasksIndirectCommandNV const & drawMeshTasksIndirectCommandNV ) const VULKAN_HPP_NOEXCEPT
4384  {
4385  std::size_t seed = 0;
4386  VULKAN_HPP_HASH_COMBINE( seed, drawMeshTasksIndirectCommandNV.taskCount );
4387  VULKAN_HPP_HASH_COMBINE( seed, drawMeshTasksIndirectCommandNV.firstTask );
4388  return seed;
4389  }
4390  };
4391 
4392  template <>
4393  struct hash<VULKAN_HPP_NAMESPACE::DrmFormatModifierProperties2EXT>
4394  {
4395  std::size_t operator()( VULKAN_HPP_NAMESPACE::DrmFormatModifierProperties2EXT const & drmFormatModifierProperties2EXT ) const VULKAN_HPP_NOEXCEPT
4396  {
4397  std::size_t seed = 0;
4398  VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierProperties2EXT.drmFormatModifier );
4399  VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierProperties2EXT.drmFormatModifierPlaneCount );
4400  VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierProperties2EXT.drmFormatModifierTilingFeatures );
4401  return seed;
4402  }
4403  };
4404 
4405  template <>
4406  struct hash<VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesEXT>
4407  {
4408  std::size_t operator()( VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesEXT const & drmFormatModifierPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
4409  {
4410  std::size_t seed = 0;
4411  VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesEXT.drmFormatModifier );
4412  VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesEXT.drmFormatModifierPlaneCount );
4413  VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesEXT.drmFormatModifierTilingFeatures );
4414  return seed;
4415  }
4416  };
4417 
4418  template <>
4419  struct hash<VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesList2EXT>
4420  {
4421  std::size_t operator()( VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesList2EXT const & drmFormatModifierPropertiesList2EXT ) const VULKAN_HPP_NOEXCEPT
4422  {
4423  std::size_t seed = 0;
4424  VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesList2EXT.sType );
4425  VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesList2EXT.pNext );
4426  VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesList2EXT.drmFormatModifierCount );
4427  VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesList2EXT.pDrmFormatModifierProperties );
4428  return seed;
4429  }
4430  };
4431 
4432  template <>
4433  struct hash<VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesListEXT>
4434  {
4435  std::size_t operator()( VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesListEXT const & drmFormatModifierPropertiesListEXT ) const VULKAN_HPP_NOEXCEPT
4436  {
4437  std::size_t seed = 0;
4438  VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesListEXT.sType );
4439  VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesListEXT.pNext );
4440  VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesListEXT.drmFormatModifierCount );
4441  VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesListEXT.pDrmFormatModifierProperties );
4442  return seed;
4443  }
4444  };
4445 
4446  template <>
4447  struct hash<VULKAN_HPP_NAMESPACE::EventCreateInfo>
4448  {
4449  std::size_t operator()( VULKAN_HPP_NAMESPACE::EventCreateInfo const & eventCreateInfo ) const VULKAN_HPP_NOEXCEPT
4450  {
4451  std::size_t seed = 0;
4452  VULKAN_HPP_HASH_COMBINE( seed, eventCreateInfo.sType );
4453  VULKAN_HPP_HASH_COMBINE( seed, eventCreateInfo.pNext );
4454  VULKAN_HPP_HASH_COMBINE( seed, eventCreateInfo.flags );
4455  return seed;
4456  }
4457  };
4458 
4459  template <>
4460  struct hash<VULKAN_HPP_NAMESPACE::PipelineLibraryCreateInfoKHR>
4461  {
4462  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineLibraryCreateInfoKHR const & pipelineLibraryCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
4463  {
4464  std::size_t seed = 0;
4465  VULKAN_HPP_HASH_COMBINE( seed, pipelineLibraryCreateInfoKHR.sType );
4466  VULKAN_HPP_HASH_COMBINE( seed, pipelineLibraryCreateInfoKHR.pNext );
4467  VULKAN_HPP_HASH_COMBINE( seed, pipelineLibraryCreateInfoKHR.libraryCount );
4468  VULKAN_HPP_HASH_COMBINE( seed, pipelineLibraryCreateInfoKHR.pLibraries );
4469  return seed;
4470  }
4471  };
4472 
4473 # if defined( VK_ENABLE_BETA_EXTENSIONS )
4474  template <>
4475  struct hash<VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX>
4476  {
4477  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX const & executionGraphPipelineCreateInfoAMDX ) const VULKAN_HPP_NOEXCEPT
4478  {
4479  std::size_t seed = 0;
4480  VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineCreateInfoAMDX.sType );
4481  VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineCreateInfoAMDX.pNext );
4482  VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineCreateInfoAMDX.flags );
4483  VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineCreateInfoAMDX.stageCount );
4484  VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineCreateInfoAMDX.pStages );
4485  VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineCreateInfoAMDX.pLibraryInfo );
4486  VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineCreateInfoAMDX.layout );
4487  VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineCreateInfoAMDX.basePipelineHandle );
4488  VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineCreateInfoAMDX.basePipelineIndex );
4489  return seed;
4490  }
4491  };
4492 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
4493 
4494 # if defined( VK_ENABLE_BETA_EXTENSIONS )
4495  template <>
4496  struct hash<VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineScratchSizeAMDX>
4497  {
4498  std::size_t
4499  operator()( VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineScratchSizeAMDX const & executionGraphPipelineScratchSizeAMDX ) const VULKAN_HPP_NOEXCEPT
4500  {
4501  std::size_t seed = 0;
4502  VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineScratchSizeAMDX.sType );
4503  VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineScratchSizeAMDX.pNext );
4504  VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineScratchSizeAMDX.size );
4505  return seed;
4506  }
4507  };
4508 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
4509 
4510  template <>
4511  struct hash<VULKAN_HPP_NAMESPACE::ExportFenceCreateInfo>
4512  {
4513  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportFenceCreateInfo const & exportFenceCreateInfo ) const VULKAN_HPP_NOEXCEPT
4514  {
4515  std::size_t seed = 0;
4516  VULKAN_HPP_HASH_COMBINE( seed, exportFenceCreateInfo.sType );
4517  VULKAN_HPP_HASH_COMBINE( seed, exportFenceCreateInfo.pNext );
4518  VULKAN_HPP_HASH_COMBINE( seed, exportFenceCreateInfo.handleTypes );
4519  return seed;
4520  }
4521  };
4522 
4523 # if defined( VK_USE_PLATFORM_WIN32_KHR )
4524  template <>
4525  struct hash<VULKAN_HPP_NAMESPACE::ExportFenceWin32HandleInfoKHR>
4526  {
4527  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportFenceWin32HandleInfoKHR const & exportFenceWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT
4528  {
4529  std::size_t seed = 0;
4530  VULKAN_HPP_HASH_COMBINE( seed, exportFenceWin32HandleInfoKHR.sType );
4531  VULKAN_HPP_HASH_COMBINE( seed, exportFenceWin32HandleInfoKHR.pNext );
4532  VULKAN_HPP_HASH_COMBINE( seed, exportFenceWin32HandleInfoKHR.pAttributes );
4533  VULKAN_HPP_HASH_COMBINE( seed, exportFenceWin32HandleInfoKHR.dwAccess );
4534  VULKAN_HPP_HASH_COMBINE( seed, exportFenceWin32HandleInfoKHR.name );
4535  return seed;
4536  }
4537  };
4538 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
4539 
4540  template <>
4541  struct hash<VULKAN_HPP_NAMESPACE::ExportMemoryAllocateInfo>
4542  {
4543  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMemoryAllocateInfo const & exportMemoryAllocateInfo ) const VULKAN_HPP_NOEXCEPT
4544  {
4545  std::size_t seed = 0;
4546  VULKAN_HPP_HASH_COMBINE( seed, exportMemoryAllocateInfo.sType );
4547  VULKAN_HPP_HASH_COMBINE( seed, exportMemoryAllocateInfo.pNext );
4548  VULKAN_HPP_HASH_COMBINE( seed, exportMemoryAllocateInfo.handleTypes );
4549  return seed;
4550  }
4551  };
4552 
4553  template <>
4554  struct hash<VULKAN_HPP_NAMESPACE::ExportMemoryAllocateInfoNV>
4555  {
4556  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMemoryAllocateInfoNV const & exportMemoryAllocateInfoNV ) const VULKAN_HPP_NOEXCEPT
4557  {
4558  std::size_t seed = 0;
4559  VULKAN_HPP_HASH_COMBINE( seed, exportMemoryAllocateInfoNV.sType );
4560  VULKAN_HPP_HASH_COMBINE( seed, exportMemoryAllocateInfoNV.pNext );
4561  VULKAN_HPP_HASH_COMBINE( seed, exportMemoryAllocateInfoNV.handleTypes );
4562  return seed;
4563  }
4564  };
4565 
4566 # if defined( VK_USE_PLATFORM_WIN32_KHR )
4567  template <>
4568  struct hash<VULKAN_HPP_NAMESPACE::ExportMemoryWin32HandleInfoKHR>
4569  {
4570  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMemoryWin32HandleInfoKHR const & exportMemoryWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT
4571  {
4572  std::size_t seed = 0;
4573  VULKAN_HPP_HASH_COMBINE( seed, exportMemoryWin32HandleInfoKHR.sType );
4574  VULKAN_HPP_HASH_COMBINE( seed, exportMemoryWin32HandleInfoKHR.pNext );
4575  VULKAN_HPP_HASH_COMBINE( seed, exportMemoryWin32HandleInfoKHR.pAttributes );
4576  VULKAN_HPP_HASH_COMBINE( seed, exportMemoryWin32HandleInfoKHR.dwAccess );
4577  VULKAN_HPP_HASH_COMBINE( seed, exportMemoryWin32HandleInfoKHR.name );
4578  return seed;
4579  }
4580  };
4581 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
4582 
4583 # if defined( VK_USE_PLATFORM_WIN32_KHR )
4584  template <>
4585  struct hash<VULKAN_HPP_NAMESPACE::ExportMemoryWin32HandleInfoNV>
4586  {
4587  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMemoryWin32HandleInfoNV const & exportMemoryWin32HandleInfoNV ) const VULKAN_HPP_NOEXCEPT
4588  {
4589  std::size_t seed = 0;
4590  VULKAN_HPP_HASH_COMBINE( seed, exportMemoryWin32HandleInfoNV.sType );
4591  VULKAN_HPP_HASH_COMBINE( seed, exportMemoryWin32HandleInfoNV.pNext );
4592  VULKAN_HPP_HASH_COMBINE( seed, exportMemoryWin32HandleInfoNV.pAttributes );
4593  VULKAN_HPP_HASH_COMBINE( seed, exportMemoryWin32HandleInfoNV.dwAccess );
4594  return seed;
4595  }
4596  };
4597 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
4598 
4599 # if defined( VK_USE_PLATFORM_METAL_EXT )
4600  template <>
4601  struct hash<VULKAN_HPP_NAMESPACE::ExportMetalBufferInfoEXT>
4602  {
4603  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMetalBufferInfoEXT const & exportMetalBufferInfoEXT ) const VULKAN_HPP_NOEXCEPT
4604  {
4605  std::size_t seed = 0;
4606  VULKAN_HPP_HASH_COMBINE( seed, exportMetalBufferInfoEXT.sType );
4607  VULKAN_HPP_HASH_COMBINE( seed, exportMetalBufferInfoEXT.pNext );
4608  VULKAN_HPP_HASH_COMBINE( seed, exportMetalBufferInfoEXT.memory );
4609  VULKAN_HPP_HASH_COMBINE( seed, exportMetalBufferInfoEXT.mtlBuffer );
4610  return seed;
4611  }
4612  };
4613 # endif /*VK_USE_PLATFORM_METAL_EXT*/
4614 
4615 # if defined( VK_USE_PLATFORM_METAL_EXT )
4616  template <>
4617  struct hash<VULKAN_HPP_NAMESPACE::ExportMetalCommandQueueInfoEXT>
4618  {
4619  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMetalCommandQueueInfoEXT const & exportMetalCommandQueueInfoEXT ) const VULKAN_HPP_NOEXCEPT
4620  {
4621  std::size_t seed = 0;
4622  VULKAN_HPP_HASH_COMBINE( seed, exportMetalCommandQueueInfoEXT.sType );
4623  VULKAN_HPP_HASH_COMBINE( seed, exportMetalCommandQueueInfoEXT.pNext );
4624  VULKAN_HPP_HASH_COMBINE( seed, exportMetalCommandQueueInfoEXT.queue );
4625  VULKAN_HPP_HASH_COMBINE( seed, exportMetalCommandQueueInfoEXT.mtlCommandQueue );
4626  return seed;
4627  }
4628  };
4629 # endif /*VK_USE_PLATFORM_METAL_EXT*/
4630 
4631 # if defined( VK_USE_PLATFORM_METAL_EXT )
4632  template <>
4633  struct hash<VULKAN_HPP_NAMESPACE::ExportMetalDeviceInfoEXT>
4634  {
4635  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMetalDeviceInfoEXT const & exportMetalDeviceInfoEXT ) const VULKAN_HPP_NOEXCEPT
4636  {
4637  std::size_t seed = 0;
4638  VULKAN_HPP_HASH_COMBINE( seed, exportMetalDeviceInfoEXT.sType );
4639  VULKAN_HPP_HASH_COMBINE( seed, exportMetalDeviceInfoEXT.pNext );
4640  VULKAN_HPP_HASH_COMBINE( seed, exportMetalDeviceInfoEXT.mtlDevice );
4641  return seed;
4642  }
4643  };
4644 # endif /*VK_USE_PLATFORM_METAL_EXT*/
4645 
4646 # if defined( VK_USE_PLATFORM_METAL_EXT )
4647  template <>
4648  struct hash<VULKAN_HPP_NAMESPACE::ExportMetalIOSurfaceInfoEXT>
4649  {
4650  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMetalIOSurfaceInfoEXT const & exportMetalIOSurfaceInfoEXT ) const VULKAN_HPP_NOEXCEPT
4651  {
4652  std::size_t seed = 0;
4653  VULKAN_HPP_HASH_COMBINE( seed, exportMetalIOSurfaceInfoEXT.sType );
4654  VULKAN_HPP_HASH_COMBINE( seed, exportMetalIOSurfaceInfoEXT.pNext );
4655  VULKAN_HPP_HASH_COMBINE( seed, exportMetalIOSurfaceInfoEXT.image );
4656  VULKAN_HPP_HASH_COMBINE( seed, exportMetalIOSurfaceInfoEXT.ioSurface );
4657  return seed;
4658  }
4659  };
4660 # endif /*VK_USE_PLATFORM_METAL_EXT*/
4661 
4662 # if defined( VK_USE_PLATFORM_METAL_EXT )
4663  template <>
4664  struct hash<VULKAN_HPP_NAMESPACE::ExportMetalObjectCreateInfoEXT>
4665  {
4666  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMetalObjectCreateInfoEXT const & exportMetalObjectCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
4667  {
4668  std::size_t seed = 0;
4669  VULKAN_HPP_HASH_COMBINE( seed, exportMetalObjectCreateInfoEXT.sType );
4670  VULKAN_HPP_HASH_COMBINE( seed, exportMetalObjectCreateInfoEXT.pNext );
4671  VULKAN_HPP_HASH_COMBINE( seed, exportMetalObjectCreateInfoEXT.exportObjectType );
4672  return seed;
4673  }
4674  };
4675 # endif /*VK_USE_PLATFORM_METAL_EXT*/
4676 
4677 # if defined( VK_USE_PLATFORM_METAL_EXT )
4678  template <>
4679  struct hash<VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT>
4680  {
4681  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT const & exportMetalObjectsInfoEXT ) const VULKAN_HPP_NOEXCEPT
4682  {
4683  std::size_t seed = 0;
4684  VULKAN_HPP_HASH_COMBINE( seed, exportMetalObjectsInfoEXT.sType );
4685  VULKAN_HPP_HASH_COMBINE( seed, exportMetalObjectsInfoEXT.pNext );
4686  return seed;
4687  }
4688  };
4689 # endif /*VK_USE_PLATFORM_METAL_EXT*/
4690 
4691 # if defined( VK_USE_PLATFORM_METAL_EXT )
4692  template <>
4693  struct hash<VULKAN_HPP_NAMESPACE::ExportMetalSharedEventInfoEXT>
4694  {
4695  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMetalSharedEventInfoEXT const & exportMetalSharedEventInfoEXT ) const VULKAN_HPP_NOEXCEPT
4696  {
4697  std::size_t seed = 0;
4698  VULKAN_HPP_HASH_COMBINE( seed, exportMetalSharedEventInfoEXT.sType );
4699  VULKAN_HPP_HASH_COMBINE( seed, exportMetalSharedEventInfoEXT.pNext );
4700  VULKAN_HPP_HASH_COMBINE( seed, exportMetalSharedEventInfoEXT.semaphore );
4701  VULKAN_HPP_HASH_COMBINE( seed, exportMetalSharedEventInfoEXT.event );
4702  VULKAN_HPP_HASH_COMBINE( seed, exportMetalSharedEventInfoEXT.mtlSharedEvent );
4703  return seed;
4704  }
4705  };
4706 # endif /*VK_USE_PLATFORM_METAL_EXT*/
4707 
4708 # if defined( VK_USE_PLATFORM_METAL_EXT )
4709  template <>
4710  struct hash<VULKAN_HPP_NAMESPACE::ExportMetalTextureInfoEXT>
4711  {
4712  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMetalTextureInfoEXT const & exportMetalTextureInfoEXT ) const VULKAN_HPP_NOEXCEPT
4713  {
4714  std::size_t seed = 0;
4715  VULKAN_HPP_HASH_COMBINE( seed, exportMetalTextureInfoEXT.sType );
4716  VULKAN_HPP_HASH_COMBINE( seed, exportMetalTextureInfoEXT.pNext );
4717  VULKAN_HPP_HASH_COMBINE( seed, exportMetalTextureInfoEXT.image );
4718  VULKAN_HPP_HASH_COMBINE( seed, exportMetalTextureInfoEXT.imageView );
4719  VULKAN_HPP_HASH_COMBINE( seed, exportMetalTextureInfoEXT.bufferView );
4720  VULKAN_HPP_HASH_COMBINE( seed, exportMetalTextureInfoEXT.plane );
4721  VULKAN_HPP_HASH_COMBINE( seed, exportMetalTextureInfoEXT.mtlTexture );
4722  return seed;
4723  }
4724  };
4725 # endif /*VK_USE_PLATFORM_METAL_EXT*/
4726 
4727  template <>
4728  struct hash<VULKAN_HPP_NAMESPACE::ExportSemaphoreCreateInfo>
4729  {
4730  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportSemaphoreCreateInfo const & exportSemaphoreCreateInfo ) const VULKAN_HPP_NOEXCEPT
4731  {
4732  std::size_t seed = 0;
4733  VULKAN_HPP_HASH_COMBINE( seed, exportSemaphoreCreateInfo.sType );
4734  VULKAN_HPP_HASH_COMBINE( seed, exportSemaphoreCreateInfo.pNext );
4735  VULKAN_HPP_HASH_COMBINE( seed, exportSemaphoreCreateInfo.handleTypes );
4736  return seed;
4737  }
4738  };
4739 
4740 # if defined( VK_USE_PLATFORM_WIN32_KHR )
4741  template <>
4742  struct hash<VULKAN_HPP_NAMESPACE::ExportSemaphoreWin32HandleInfoKHR>
4743  {
4744  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportSemaphoreWin32HandleInfoKHR const & exportSemaphoreWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT
4745  {
4746  std::size_t seed = 0;
4747  VULKAN_HPP_HASH_COMBINE( seed, exportSemaphoreWin32HandleInfoKHR.sType );
4748  VULKAN_HPP_HASH_COMBINE( seed, exportSemaphoreWin32HandleInfoKHR.pNext );
4749  VULKAN_HPP_HASH_COMBINE( seed, exportSemaphoreWin32HandleInfoKHR.pAttributes );
4750  VULKAN_HPP_HASH_COMBINE( seed, exportSemaphoreWin32HandleInfoKHR.dwAccess );
4751  VULKAN_HPP_HASH_COMBINE( seed, exportSemaphoreWin32HandleInfoKHR.name );
4752  return seed;
4753  }
4754  };
4755 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
4756 
4757  template <>
4758  struct hash<VULKAN_HPP_NAMESPACE::ExtensionProperties>
4759  {
4760  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExtensionProperties const & extensionProperties ) const VULKAN_HPP_NOEXCEPT
4761  {
4762  std::size_t seed = 0;
4763  for ( size_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i )
4764  {
4765  VULKAN_HPP_HASH_COMBINE( seed, extensionProperties.extensionName[i] );
4766  }
4767  VULKAN_HPP_HASH_COMBINE( seed, extensionProperties.specVersion );
4768  return seed;
4769  }
4770  };
4771 
4772  template <>
4773  struct hash<VULKAN_HPP_NAMESPACE::ExternalMemoryProperties>
4774  {
4775  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalMemoryProperties const & externalMemoryProperties ) const VULKAN_HPP_NOEXCEPT
4776  {
4777  std::size_t seed = 0;
4778  VULKAN_HPP_HASH_COMBINE( seed, externalMemoryProperties.externalMemoryFeatures );
4779  VULKAN_HPP_HASH_COMBINE( seed, externalMemoryProperties.exportFromImportedHandleTypes );
4780  VULKAN_HPP_HASH_COMBINE( seed, externalMemoryProperties.compatibleHandleTypes );
4781  return seed;
4782  }
4783  };
4784 
4785  template <>
4786  struct hash<VULKAN_HPP_NAMESPACE::ExternalBufferProperties>
4787  {
4788  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalBufferProperties const & externalBufferProperties ) const VULKAN_HPP_NOEXCEPT
4789  {
4790  std::size_t seed = 0;
4791  VULKAN_HPP_HASH_COMBINE( seed, externalBufferProperties.sType );
4792  VULKAN_HPP_HASH_COMBINE( seed, externalBufferProperties.pNext );
4793  VULKAN_HPP_HASH_COMBINE( seed, externalBufferProperties.externalMemoryProperties );
4794  return seed;
4795  }
4796  };
4797 
4798  template <>
4799  struct hash<VULKAN_HPP_NAMESPACE::ExternalFenceProperties>
4800  {
4801  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalFenceProperties const & externalFenceProperties ) const VULKAN_HPP_NOEXCEPT
4802  {
4803  std::size_t seed = 0;
4804  VULKAN_HPP_HASH_COMBINE( seed, externalFenceProperties.sType );
4805  VULKAN_HPP_HASH_COMBINE( seed, externalFenceProperties.pNext );
4806  VULKAN_HPP_HASH_COMBINE( seed, externalFenceProperties.exportFromImportedHandleTypes );
4807  VULKAN_HPP_HASH_COMBINE( seed, externalFenceProperties.compatibleHandleTypes );
4808  VULKAN_HPP_HASH_COMBINE( seed, externalFenceProperties.externalFenceFeatures );
4809  return seed;
4810  }
4811  };
4812 
4813 # if defined( VK_USE_PLATFORM_ANDROID_KHR )
4814  template <>
4815  struct hash<VULKAN_HPP_NAMESPACE::ExternalFormatANDROID>
4816  {
4817  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalFormatANDROID const & externalFormatANDROID ) const VULKAN_HPP_NOEXCEPT
4818  {
4819  std::size_t seed = 0;
4820  VULKAN_HPP_HASH_COMBINE( seed, externalFormatANDROID.sType );
4821  VULKAN_HPP_HASH_COMBINE( seed, externalFormatANDROID.pNext );
4822  VULKAN_HPP_HASH_COMBINE( seed, externalFormatANDROID.externalFormat );
4823  return seed;
4824  }
4825  };
4826 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/
4827 
4828 # if defined( VK_USE_PLATFORM_SCREEN_QNX )
4829  template <>
4830  struct hash<VULKAN_HPP_NAMESPACE::ExternalFormatQNX>
4831  {
4832  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalFormatQNX const & externalFormatQNX ) const VULKAN_HPP_NOEXCEPT
4833  {
4834  std::size_t seed = 0;
4835  VULKAN_HPP_HASH_COMBINE( seed, externalFormatQNX.sType );
4836  VULKAN_HPP_HASH_COMBINE( seed, externalFormatQNX.pNext );
4837  VULKAN_HPP_HASH_COMBINE( seed, externalFormatQNX.externalFormat );
4838  return seed;
4839  }
4840  };
4841 # endif /*VK_USE_PLATFORM_SCREEN_QNX*/
4842 
4843  template <>
4844  struct hash<VULKAN_HPP_NAMESPACE::ExternalImageFormatProperties>
4845  {
4846  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalImageFormatProperties const & externalImageFormatProperties ) const VULKAN_HPP_NOEXCEPT
4847  {
4848  std::size_t seed = 0;
4849  VULKAN_HPP_HASH_COMBINE( seed, externalImageFormatProperties.sType );
4850  VULKAN_HPP_HASH_COMBINE( seed, externalImageFormatProperties.pNext );
4851  VULKAN_HPP_HASH_COMBINE( seed, externalImageFormatProperties.externalMemoryProperties );
4852  return seed;
4853  }
4854  };
4855 
4856  template <>
4857  struct hash<VULKAN_HPP_NAMESPACE::ImageFormatProperties>
4858  {
4859  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageFormatProperties const & imageFormatProperties ) const VULKAN_HPP_NOEXCEPT
4860  {
4861  std::size_t seed = 0;
4862  VULKAN_HPP_HASH_COMBINE( seed, imageFormatProperties.maxExtent );
4863  VULKAN_HPP_HASH_COMBINE( seed, imageFormatProperties.maxMipLevels );
4864  VULKAN_HPP_HASH_COMBINE( seed, imageFormatProperties.maxArrayLayers );
4865  VULKAN_HPP_HASH_COMBINE( seed, imageFormatProperties.sampleCounts );
4866  VULKAN_HPP_HASH_COMBINE( seed, imageFormatProperties.maxResourceSize );
4867  return seed;
4868  }
4869  };
4870 
4871  template <>
4872  struct hash<VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV>
4873  {
4874  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV const & externalImageFormatPropertiesNV ) const VULKAN_HPP_NOEXCEPT
4875  {
4876  std::size_t seed = 0;
4877  VULKAN_HPP_HASH_COMBINE( seed, externalImageFormatPropertiesNV.imageFormatProperties );
4878  VULKAN_HPP_HASH_COMBINE( seed, externalImageFormatPropertiesNV.externalMemoryFeatures );
4879  VULKAN_HPP_HASH_COMBINE( seed, externalImageFormatPropertiesNV.exportFromImportedHandleTypes );
4880  VULKAN_HPP_HASH_COMBINE( seed, externalImageFormatPropertiesNV.compatibleHandleTypes );
4881  return seed;
4882  }
4883  };
4884 
4885  template <>
4886  struct hash<VULKAN_HPP_NAMESPACE::ExternalMemoryAcquireUnmodifiedEXT>
4887  {
4888  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalMemoryAcquireUnmodifiedEXT const & externalMemoryAcquireUnmodifiedEXT ) const VULKAN_HPP_NOEXCEPT
4889  {
4890  std::size_t seed = 0;
4891  VULKAN_HPP_HASH_COMBINE( seed, externalMemoryAcquireUnmodifiedEXT.sType );
4892  VULKAN_HPP_HASH_COMBINE( seed, externalMemoryAcquireUnmodifiedEXT.pNext );
4893  VULKAN_HPP_HASH_COMBINE( seed, externalMemoryAcquireUnmodifiedEXT.acquireUnmodifiedMemory );
4894  return seed;
4895  }
4896  };
4897 
4898  template <>
4899  struct hash<VULKAN_HPP_NAMESPACE::ExternalMemoryBufferCreateInfo>
4900  {
4901  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalMemoryBufferCreateInfo const & externalMemoryBufferCreateInfo ) const VULKAN_HPP_NOEXCEPT
4902  {
4903  std::size_t seed = 0;
4904  VULKAN_HPP_HASH_COMBINE( seed, externalMemoryBufferCreateInfo.sType );
4905  VULKAN_HPP_HASH_COMBINE( seed, externalMemoryBufferCreateInfo.pNext );
4906  VULKAN_HPP_HASH_COMBINE( seed, externalMemoryBufferCreateInfo.handleTypes );
4907  return seed;
4908  }
4909  };
4910 
4911  template <>
4912  struct hash<VULKAN_HPP_NAMESPACE::ExternalMemoryImageCreateInfo>
4913  {
4914  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalMemoryImageCreateInfo const & externalMemoryImageCreateInfo ) const VULKAN_HPP_NOEXCEPT
4915  {
4916  std::size_t seed = 0;
4917  VULKAN_HPP_HASH_COMBINE( seed, externalMemoryImageCreateInfo.sType );
4918  VULKAN_HPP_HASH_COMBINE( seed, externalMemoryImageCreateInfo.pNext );
4919  VULKAN_HPP_HASH_COMBINE( seed, externalMemoryImageCreateInfo.handleTypes );
4920  return seed;
4921  }
4922  };
4923 
4924  template <>
4925  struct hash<VULKAN_HPP_NAMESPACE::ExternalMemoryImageCreateInfoNV>
4926  {
4927  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalMemoryImageCreateInfoNV const & externalMemoryImageCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
4928  {
4929  std::size_t seed = 0;
4930  VULKAN_HPP_HASH_COMBINE( seed, externalMemoryImageCreateInfoNV.sType );
4931  VULKAN_HPP_HASH_COMBINE( seed, externalMemoryImageCreateInfoNV.pNext );
4932  VULKAN_HPP_HASH_COMBINE( seed, externalMemoryImageCreateInfoNV.handleTypes );
4933  return seed;
4934  }
4935  };
4936 
4937  template <>
4938  struct hash<VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties>
4939  {
4940  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties const & externalSemaphoreProperties ) const VULKAN_HPP_NOEXCEPT
4941  {
4942  std::size_t seed = 0;
4943  VULKAN_HPP_HASH_COMBINE( seed, externalSemaphoreProperties.sType );
4944  VULKAN_HPP_HASH_COMBINE( seed, externalSemaphoreProperties.pNext );
4945  VULKAN_HPP_HASH_COMBINE( seed, externalSemaphoreProperties.exportFromImportedHandleTypes );
4946  VULKAN_HPP_HASH_COMBINE( seed, externalSemaphoreProperties.compatibleHandleTypes );
4947  VULKAN_HPP_HASH_COMBINE( seed, externalSemaphoreProperties.externalSemaphoreFeatures );
4948  return seed;
4949  }
4950  };
4951 
4952  template <>
4953  struct hash<VULKAN_HPP_NAMESPACE::FenceCreateInfo>
4954  {
4955  std::size_t operator()( VULKAN_HPP_NAMESPACE::FenceCreateInfo const & fenceCreateInfo ) const VULKAN_HPP_NOEXCEPT
4956  {
4957  std::size_t seed = 0;
4958  VULKAN_HPP_HASH_COMBINE( seed, fenceCreateInfo.sType );
4959  VULKAN_HPP_HASH_COMBINE( seed, fenceCreateInfo.pNext );
4960  VULKAN_HPP_HASH_COMBINE( seed, fenceCreateInfo.flags );
4961  return seed;
4962  }
4963  };
4964 
4965  template <>
4966  struct hash<VULKAN_HPP_NAMESPACE::FenceGetFdInfoKHR>
4967  {
4968  std::size_t operator()( VULKAN_HPP_NAMESPACE::FenceGetFdInfoKHR const & fenceGetFdInfoKHR ) const VULKAN_HPP_NOEXCEPT
4969  {
4970  std::size_t seed = 0;
4971  VULKAN_HPP_HASH_COMBINE( seed, fenceGetFdInfoKHR.sType );
4972  VULKAN_HPP_HASH_COMBINE( seed, fenceGetFdInfoKHR.pNext );
4973  VULKAN_HPP_HASH_COMBINE( seed, fenceGetFdInfoKHR.fence );
4974  VULKAN_HPP_HASH_COMBINE( seed, fenceGetFdInfoKHR.handleType );
4975  return seed;
4976  }
4977  };
4978 
4979 # if defined( VK_USE_PLATFORM_WIN32_KHR )
4980  template <>
4981  struct hash<VULKAN_HPP_NAMESPACE::FenceGetWin32HandleInfoKHR>
4982  {
4983  std::size_t operator()( VULKAN_HPP_NAMESPACE::FenceGetWin32HandleInfoKHR const & fenceGetWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT
4984  {
4985  std::size_t seed = 0;
4986  VULKAN_HPP_HASH_COMBINE( seed, fenceGetWin32HandleInfoKHR.sType );
4987  VULKAN_HPP_HASH_COMBINE( seed, fenceGetWin32HandleInfoKHR.pNext );
4988  VULKAN_HPP_HASH_COMBINE( seed, fenceGetWin32HandleInfoKHR.fence );
4989  VULKAN_HPP_HASH_COMBINE( seed, fenceGetWin32HandleInfoKHR.handleType );
4990  return seed;
4991  }
4992  };
4993 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
4994 
4995  template <>
4996  struct hash<VULKAN_HPP_NAMESPACE::FilterCubicImageViewImageFormatPropertiesEXT>
4997  {
4998  std::size_t operator()( VULKAN_HPP_NAMESPACE::FilterCubicImageViewImageFormatPropertiesEXT const & filterCubicImageViewImageFormatPropertiesEXT ) const
4999  VULKAN_HPP_NOEXCEPT
5000  {
5001  std::size_t seed = 0;
5002  VULKAN_HPP_HASH_COMBINE( seed, filterCubicImageViewImageFormatPropertiesEXT.sType );
5003  VULKAN_HPP_HASH_COMBINE( seed, filterCubicImageViewImageFormatPropertiesEXT.pNext );
5004  VULKAN_HPP_HASH_COMBINE( seed, filterCubicImageViewImageFormatPropertiesEXT.filterCubic );
5005  VULKAN_HPP_HASH_COMBINE( seed, filterCubicImageViewImageFormatPropertiesEXT.filterCubicMinmax );
5006  return seed;
5007  }
5008  };
5009 
5010  template <>
5011  struct hash<VULKAN_HPP_NAMESPACE::FormatProperties>
5012  {
5013  std::size_t operator()( VULKAN_HPP_NAMESPACE::FormatProperties const & formatProperties ) const VULKAN_HPP_NOEXCEPT
5014  {
5015  std::size_t seed = 0;
5016  VULKAN_HPP_HASH_COMBINE( seed, formatProperties.linearTilingFeatures );
5017  VULKAN_HPP_HASH_COMBINE( seed, formatProperties.optimalTilingFeatures );
5018  VULKAN_HPP_HASH_COMBINE( seed, formatProperties.bufferFeatures );
5019  return seed;
5020  }
5021  };
5022 
5023  template <>
5024  struct hash<VULKAN_HPP_NAMESPACE::FormatProperties2>
5025  {
5026  std::size_t operator()( VULKAN_HPP_NAMESPACE::FormatProperties2 const & formatProperties2 ) const VULKAN_HPP_NOEXCEPT
5027  {
5028  std::size_t seed = 0;
5029  VULKAN_HPP_HASH_COMBINE( seed, formatProperties2.sType );
5030  VULKAN_HPP_HASH_COMBINE( seed, formatProperties2.pNext );
5031  VULKAN_HPP_HASH_COMBINE( seed, formatProperties2.formatProperties );
5032  return seed;
5033  }
5034  };
5035 
5036  template <>
5037  struct hash<VULKAN_HPP_NAMESPACE::FormatProperties3>
5038  {
5039  std::size_t operator()( VULKAN_HPP_NAMESPACE::FormatProperties3 const & formatProperties3 ) const VULKAN_HPP_NOEXCEPT
5040  {
5041  std::size_t seed = 0;
5042  VULKAN_HPP_HASH_COMBINE( seed, formatProperties3.sType );
5043  VULKAN_HPP_HASH_COMBINE( seed, formatProperties3.pNext );
5044  VULKAN_HPP_HASH_COMBINE( seed, formatProperties3.linearTilingFeatures );
5045  VULKAN_HPP_HASH_COMBINE( seed, formatProperties3.optimalTilingFeatures );
5046  VULKAN_HPP_HASH_COMBINE( seed, formatProperties3.bufferFeatures );
5047  return seed;
5048  }
5049  };
5050 
5051  template <>
5052  struct hash<VULKAN_HPP_NAMESPACE::FragmentShadingRateAttachmentInfoKHR>
5053  {
5054  std::size_t operator()( VULKAN_HPP_NAMESPACE::FragmentShadingRateAttachmentInfoKHR const & fragmentShadingRateAttachmentInfoKHR ) const VULKAN_HPP_NOEXCEPT
5055  {
5056  std::size_t seed = 0;
5057  VULKAN_HPP_HASH_COMBINE( seed, fragmentShadingRateAttachmentInfoKHR.sType );
5058  VULKAN_HPP_HASH_COMBINE( seed, fragmentShadingRateAttachmentInfoKHR.pNext );
5059  VULKAN_HPP_HASH_COMBINE( seed, fragmentShadingRateAttachmentInfoKHR.pFragmentShadingRateAttachment );
5060  VULKAN_HPP_HASH_COMBINE( seed, fragmentShadingRateAttachmentInfoKHR.shadingRateAttachmentTexelSize );
5061  return seed;
5062  }
5063  };
5064 
5065  template <>
5066  struct hash<VULKAN_HPP_NAMESPACE::FrameBoundaryEXT>
5067  {
5068  std::size_t operator()( VULKAN_HPP_NAMESPACE::FrameBoundaryEXT const & frameBoundaryEXT ) const VULKAN_HPP_NOEXCEPT
5069  {
5070  std::size_t seed = 0;
5071  VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.sType );
5072  VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.pNext );
5073  VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.flags );
5074  VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.frameID );
5075  VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.imageCount );
5076  VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.pImages );
5077  VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.bufferCount );
5078  VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.pBuffers );
5079  VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.tagName );
5080  VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.tagSize );
5081  VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.pTag );
5082  return seed;
5083  }
5084  };
5085 
5086  template <>
5087  struct hash<VULKAN_HPP_NAMESPACE::FramebufferAttachmentImageInfo>
5088  {
5089  std::size_t operator()( VULKAN_HPP_NAMESPACE::FramebufferAttachmentImageInfo const & framebufferAttachmentImageInfo ) const VULKAN_HPP_NOEXCEPT
5090  {
5091  std::size_t seed = 0;
5092  VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentImageInfo.sType );
5093  VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentImageInfo.pNext );
5094  VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentImageInfo.flags );
5095  VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentImageInfo.usage );
5096  VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentImageInfo.width );
5097  VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentImageInfo.height );
5098  VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentImageInfo.layerCount );
5099  VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentImageInfo.viewFormatCount );
5100  VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentImageInfo.pViewFormats );
5101  return seed;
5102  }
5103  };
5104 
5105  template <>
5106  struct hash<VULKAN_HPP_NAMESPACE::FramebufferAttachmentsCreateInfo>
5107  {
5108  std::size_t operator()( VULKAN_HPP_NAMESPACE::FramebufferAttachmentsCreateInfo const & framebufferAttachmentsCreateInfo ) const VULKAN_HPP_NOEXCEPT
5109  {
5110  std::size_t seed = 0;
5111  VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentsCreateInfo.sType );
5112  VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentsCreateInfo.pNext );
5113  VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentsCreateInfo.attachmentImageInfoCount );
5114  VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentsCreateInfo.pAttachmentImageInfos );
5115  return seed;
5116  }
5117  };
5118 
5119  template <>
5120  struct hash<VULKAN_HPP_NAMESPACE::FramebufferCreateInfo>
5121  {
5122  std::size_t operator()( VULKAN_HPP_NAMESPACE::FramebufferCreateInfo const & framebufferCreateInfo ) const VULKAN_HPP_NOEXCEPT
5123  {
5124  std::size_t seed = 0;
5125  VULKAN_HPP_HASH_COMBINE( seed, framebufferCreateInfo.sType );
5126  VULKAN_HPP_HASH_COMBINE( seed, framebufferCreateInfo.pNext );
5127  VULKAN_HPP_HASH_COMBINE( seed, framebufferCreateInfo.flags );
5128  VULKAN_HPP_HASH_COMBINE( seed, framebufferCreateInfo.renderPass );
5129  VULKAN_HPP_HASH_COMBINE( seed, framebufferCreateInfo.attachmentCount );
5130  VULKAN_HPP_HASH_COMBINE( seed, framebufferCreateInfo.pAttachments );
5131  VULKAN_HPP_HASH_COMBINE( seed, framebufferCreateInfo.width );
5132  VULKAN_HPP_HASH_COMBINE( seed, framebufferCreateInfo.height );
5133  VULKAN_HPP_HASH_COMBINE( seed, framebufferCreateInfo.layers );
5134  return seed;
5135  }
5136  };
5137 
5138  template <>
5139  struct hash<VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV>
5140  {
5141  std::size_t operator()( VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV const & framebufferMixedSamplesCombinationNV ) const VULKAN_HPP_NOEXCEPT
5142  {
5143  std::size_t seed = 0;
5144  VULKAN_HPP_HASH_COMBINE( seed, framebufferMixedSamplesCombinationNV.sType );
5145  VULKAN_HPP_HASH_COMBINE( seed, framebufferMixedSamplesCombinationNV.pNext );
5146  VULKAN_HPP_HASH_COMBINE( seed, framebufferMixedSamplesCombinationNV.coverageReductionMode );
5147  VULKAN_HPP_HASH_COMBINE( seed, framebufferMixedSamplesCombinationNV.rasterizationSamples );
5148  VULKAN_HPP_HASH_COMBINE( seed, framebufferMixedSamplesCombinationNV.depthStencilSamples );
5149  VULKAN_HPP_HASH_COMBINE( seed, framebufferMixedSamplesCombinationNV.colorSamples );
5150  return seed;
5151  }
5152  };
5153 
5154  template <>
5155  struct hash<VULKAN_HPP_NAMESPACE::IndirectCommandsStreamNV>
5156  {
5157  std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectCommandsStreamNV const & indirectCommandsStreamNV ) const VULKAN_HPP_NOEXCEPT
5158  {
5159  std::size_t seed = 0;
5160  VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsStreamNV.buffer );
5161  VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsStreamNV.offset );
5162  return seed;
5163  }
5164  };
5165 
5166  template <>
5167  struct hash<VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV>
5168  {
5169  std::size_t operator()( VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV const & generatedCommandsInfoNV ) const VULKAN_HPP_NOEXCEPT
5170  {
5171  std::size_t seed = 0;
5172  VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.sType );
5173  VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.pNext );
5174  VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.pipelineBindPoint );
5175  VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.pipeline );
5176  VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.indirectCommandsLayout );
5177  VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.streamCount );
5178  VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.pStreams );
5179  VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.sequencesCount );
5180  VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.preprocessBuffer );
5181  VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.preprocessOffset );
5182  VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.preprocessSize );
5183  VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.sequencesCountBuffer );
5184  VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.sequencesCountOffset );
5185  VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.sequencesIndexBuffer );
5186  VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.sequencesIndexOffset );
5187  return seed;
5188  }
5189  };
5190 
5191  template <>
5192  struct hash<VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV>
5193  {
5194  std::size_t
5195  operator()( VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV const & generatedCommandsMemoryRequirementsInfoNV ) const VULKAN_HPP_NOEXCEPT
5196  {
5197  std::size_t seed = 0;
5198  VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsMemoryRequirementsInfoNV.sType );
5199  VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsMemoryRequirementsInfoNV.pNext );
5200  VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsMemoryRequirementsInfoNV.pipelineBindPoint );
5201  VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsMemoryRequirementsInfoNV.pipeline );
5202  VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsMemoryRequirementsInfoNV.indirectCommandsLayout );
5203  VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsMemoryRequirementsInfoNV.maxSequencesCount );
5204  return seed;
5205  }
5206  };
5207 
5208  template <>
5209  struct hash<VULKAN_HPP_NAMESPACE::LatencyTimingsFrameReportNV>
5210  {
5211  std::size_t operator()( VULKAN_HPP_NAMESPACE::LatencyTimingsFrameReportNV const & latencyTimingsFrameReportNV ) const VULKAN_HPP_NOEXCEPT
5212  {
5213  std::size_t seed = 0;
5214  VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.sType );
5215  VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.pNext );
5216  VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.presentID );
5217  VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.inputSampleTimeUs );
5218  VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.simStartTimeUs );
5219  VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.simEndTimeUs );
5220  VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.renderSubmitStartTimeUs );
5221  VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.renderSubmitEndTimeUs );
5222  VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.presentStartTimeUs );
5223  VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.presentEndTimeUs );
5224  VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.driverStartTimeUs );
5225  VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.driverEndTimeUs );
5226  VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.osRenderQueueStartTimeUs );
5227  VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.osRenderQueueEndTimeUs );
5228  VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.gpuRenderStartTimeUs );
5229  VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.gpuRenderEndTimeUs );
5230  return seed;
5231  }
5232  };
5233 
5234  template <>
5235  struct hash<VULKAN_HPP_NAMESPACE::GetLatencyMarkerInfoNV>
5236  {
5237  std::size_t operator()( VULKAN_HPP_NAMESPACE::GetLatencyMarkerInfoNV const & getLatencyMarkerInfoNV ) const VULKAN_HPP_NOEXCEPT
5238  {
5239  std::size_t seed = 0;
5240  VULKAN_HPP_HASH_COMBINE( seed, getLatencyMarkerInfoNV.sType );
5241  VULKAN_HPP_HASH_COMBINE( seed, getLatencyMarkerInfoNV.pNext );
5242  VULKAN_HPP_HASH_COMBINE( seed, getLatencyMarkerInfoNV.timingCount );
5243  VULKAN_HPP_HASH_COMBINE( seed, getLatencyMarkerInfoNV.pTimings );
5244  return seed;
5245  }
5246  };
5247 
5248  template <>
5249  struct hash<VULKAN_HPP_NAMESPACE::VertexInputBindingDescription>
5250  {
5251  std::size_t operator()( VULKAN_HPP_NAMESPACE::VertexInputBindingDescription const & vertexInputBindingDescription ) const VULKAN_HPP_NOEXCEPT
5252  {
5253  std::size_t seed = 0;
5254  VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDescription.binding );
5255  VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDescription.stride );
5256  VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDescription.inputRate );
5257  return seed;
5258  }
5259  };
5260 
5261  template <>
5262  struct hash<VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription>
5263  {
5264  std::size_t operator()( VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription const & vertexInputAttributeDescription ) const VULKAN_HPP_NOEXCEPT
5265  {
5266  std::size_t seed = 0;
5267  VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription.location );
5268  VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription.binding );
5269  VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription.format );
5270  VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription.offset );
5271  return seed;
5272  }
5273  };
5274 
5275  template <>
5276  struct hash<VULKAN_HPP_NAMESPACE::PipelineVertexInputStateCreateInfo>
5277  {
5278  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineVertexInputStateCreateInfo const & pipelineVertexInputStateCreateInfo ) const VULKAN_HPP_NOEXCEPT
5279  {
5280  std::size_t seed = 0;
5281  VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputStateCreateInfo.sType );
5282  VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputStateCreateInfo.pNext );
5283  VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputStateCreateInfo.flags );
5284  VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputStateCreateInfo.vertexBindingDescriptionCount );
5285  VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputStateCreateInfo.pVertexBindingDescriptions );
5286  VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputStateCreateInfo.vertexAttributeDescriptionCount );
5287  VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputStateCreateInfo.pVertexAttributeDescriptions );
5288  return seed;
5289  }
5290  };
5291 
5292  template <>
5293  struct hash<VULKAN_HPP_NAMESPACE::PipelineInputAssemblyStateCreateInfo>
5294  {
5295  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineInputAssemblyStateCreateInfo const & pipelineInputAssemblyStateCreateInfo ) const VULKAN_HPP_NOEXCEPT
5296  {
5297  std::size_t seed = 0;
5298  VULKAN_HPP_HASH_COMBINE( seed, pipelineInputAssemblyStateCreateInfo.sType );
5299  VULKAN_HPP_HASH_COMBINE( seed, pipelineInputAssemblyStateCreateInfo.pNext );
5300  VULKAN_HPP_HASH_COMBINE( seed, pipelineInputAssemblyStateCreateInfo.flags );
5301  VULKAN_HPP_HASH_COMBINE( seed, pipelineInputAssemblyStateCreateInfo.topology );
5302  VULKAN_HPP_HASH_COMBINE( seed, pipelineInputAssemblyStateCreateInfo.primitiveRestartEnable );
5303  return seed;
5304  }
5305  };
5306 
5307  template <>
5308  struct hash<VULKAN_HPP_NAMESPACE::PipelineTessellationStateCreateInfo>
5309  {
5310  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineTessellationStateCreateInfo const & pipelineTessellationStateCreateInfo ) const VULKAN_HPP_NOEXCEPT
5311  {
5312  std::size_t seed = 0;
5313  VULKAN_HPP_HASH_COMBINE( seed, pipelineTessellationStateCreateInfo.sType );
5314  VULKAN_HPP_HASH_COMBINE( seed, pipelineTessellationStateCreateInfo.pNext );
5315  VULKAN_HPP_HASH_COMBINE( seed, pipelineTessellationStateCreateInfo.flags );
5316  VULKAN_HPP_HASH_COMBINE( seed, pipelineTessellationStateCreateInfo.patchControlPoints );
5317  return seed;
5318  }
5319  };
5320 
5321  template <>
5322  struct hash<VULKAN_HPP_NAMESPACE::PipelineViewportStateCreateInfo>
5323  {
5324  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineViewportStateCreateInfo const & pipelineViewportStateCreateInfo ) const VULKAN_HPP_NOEXCEPT
5325  {
5326  std::size_t seed = 0;
5327  VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportStateCreateInfo.sType );
5328  VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportStateCreateInfo.pNext );
5329  VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportStateCreateInfo.flags );
5330  VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportStateCreateInfo.viewportCount );
5331  VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportStateCreateInfo.pViewports );
5332  VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportStateCreateInfo.scissorCount );
5333  VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportStateCreateInfo.pScissors );
5334  return seed;
5335  }
5336  };
5337 
5338  template <>
5339  struct hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationStateCreateInfo>
5340  {
5341  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationStateCreateInfo const & pipelineRasterizationStateCreateInfo ) const VULKAN_HPP_NOEXCEPT
5342  {
5343  std::size_t seed = 0;
5344  VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.sType );
5345  VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.pNext );
5346  VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.flags );
5347  VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.depthClampEnable );
5348  VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.rasterizerDiscardEnable );
5349  VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.polygonMode );
5350  VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.cullMode );
5351  VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.frontFace );
5352  VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.depthBiasEnable );
5353  VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.depthBiasConstantFactor );
5354  VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.depthBiasClamp );
5355  VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.depthBiasSlopeFactor );
5356  VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.lineWidth );
5357  return seed;
5358  }
5359  };
5360 
5361  template <>
5362  struct hash<VULKAN_HPP_NAMESPACE::PipelineMultisampleStateCreateInfo>
5363  {
5364  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineMultisampleStateCreateInfo const & pipelineMultisampleStateCreateInfo ) const VULKAN_HPP_NOEXCEPT
5365  {
5366  std::size_t seed = 0;
5367  VULKAN_HPP_HASH_COMBINE( seed, pipelineMultisampleStateCreateInfo.sType );
5368  VULKAN_HPP_HASH_COMBINE( seed, pipelineMultisampleStateCreateInfo.pNext );
5369  VULKAN_HPP_HASH_COMBINE( seed, pipelineMultisampleStateCreateInfo.flags );
5370  VULKAN_HPP_HASH_COMBINE( seed, pipelineMultisampleStateCreateInfo.rasterizationSamples );
5371  VULKAN_HPP_HASH_COMBINE( seed, pipelineMultisampleStateCreateInfo.sampleShadingEnable );
5372  VULKAN_HPP_HASH_COMBINE( seed, pipelineMultisampleStateCreateInfo.minSampleShading );
5373  VULKAN_HPP_HASH_COMBINE( seed, pipelineMultisampleStateCreateInfo.pSampleMask );
5374  VULKAN_HPP_HASH_COMBINE( seed, pipelineMultisampleStateCreateInfo.alphaToCoverageEnable );
5375  VULKAN_HPP_HASH_COMBINE( seed, pipelineMultisampleStateCreateInfo.alphaToOneEnable );
5376  return seed;
5377  }
5378  };
5379 
5380  template <>
5381  struct hash<VULKAN_HPP_NAMESPACE::StencilOpState>
5382  {
5383  std::size_t operator()( VULKAN_HPP_NAMESPACE::StencilOpState const & stencilOpState ) const VULKAN_HPP_NOEXCEPT
5384  {
5385  std::size_t seed = 0;
5386  VULKAN_HPP_HASH_COMBINE( seed, stencilOpState.failOp );
5387  VULKAN_HPP_HASH_COMBINE( seed, stencilOpState.passOp );
5388  VULKAN_HPP_HASH_COMBINE( seed, stencilOpState.depthFailOp );
5389  VULKAN_HPP_HASH_COMBINE( seed, stencilOpState.compareOp );
5390  VULKAN_HPP_HASH_COMBINE( seed, stencilOpState.compareMask );
5391  VULKAN_HPP_HASH_COMBINE( seed, stencilOpState.writeMask );
5392  VULKAN_HPP_HASH_COMBINE( seed, stencilOpState.reference );
5393  return seed;
5394  }
5395  };
5396 
5397  template <>
5398  struct hash<VULKAN_HPP_NAMESPACE::PipelineDepthStencilStateCreateInfo>
5399  {
5400  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineDepthStencilStateCreateInfo const & pipelineDepthStencilStateCreateInfo ) const VULKAN_HPP_NOEXCEPT
5401  {
5402  std::size_t seed = 0;
5403  VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.sType );
5404  VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.pNext );
5405  VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.flags );
5406  VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.depthTestEnable );
5407  VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.depthWriteEnable );
5408  VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.depthCompareOp );
5409  VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.depthBoundsTestEnable );
5410  VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.stencilTestEnable );
5411  VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.front );
5412  VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.back );
5413  VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.minDepthBounds );
5414  VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.maxDepthBounds );
5415  return seed;
5416  }
5417  };
5418 
5419  template <>
5420  struct hash<VULKAN_HPP_NAMESPACE::PipelineColorBlendAttachmentState>
5421  {
5422  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineColorBlendAttachmentState const & pipelineColorBlendAttachmentState ) const VULKAN_HPP_NOEXCEPT
5423  {
5424  std::size_t seed = 0;
5425  VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAttachmentState.blendEnable );
5426  VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAttachmentState.srcColorBlendFactor );
5427  VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAttachmentState.dstColorBlendFactor );
5428  VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAttachmentState.colorBlendOp );
5429  VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAttachmentState.srcAlphaBlendFactor );
5430  VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAttachmentState.dstAlphaBlendFactor );
5431  VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAttachmentState.alphaBlendOp );
5432  VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAttachmentState.colorWriteMask );
5433  return seed;
5434  }
5435  };
5436 
5437  template <>
5438  struct hash<VULKAN_HPP_NAMESPACE::PipelineColorBlendStateCreateInfo>
5439  {
5440  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineColorBlendStateCreateInfo const & pipelineColorBlendStateCreateInfo ) const VULKAN_HPP_NOEXCEPT
5441  {
5442  std::size_t seed = 0;
5443  VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendStateCreateInfo.sType );
5444  VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendStateCreateInfo.pNext );
5445  VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendStateCreateInfo.flags );
5446  VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendStateCreateInfo.logicOpEnable );
5447  VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendStateCreateInfo.logicOp );
5448  VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendStateCreateInfo.attachmentCount );
5449  VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendStateCreateInfo.pAttachments );
5450  for ( size_t i = 0; i < 4; ++i )
5451  {
5452  VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendStateCreateInfo.blendConstants[i] );
5453  }
5454  return seed;
5455  }
5456  };
5457 
5458  template <>
5459  struct hash<VULKAN_HPP_NAMESPACE::PipelineDynamicStateCreateInfo>
5460  {
5461  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineDynamicStateCreateInfo const & pipelineDynamicStateCreateInfo ) const VULKAN_HPP_NOEXCEPT
5462  {
5463  std::size_t seed = 0;
5464  VULKAN_HPP_HASH_COMBINE( seed, pipelineDynamicStateCreateInfo.sType );
5465  VULKAN_HPP_HASH_COMBINE( seed, pipelineDynamicStateCreateInfo.pNext );
5466  VULKAN_HPP_HASH_COMBINE( seed, pipelineDynamicStateCreateInfo.flags );
5467  VULKAN_HPP_HASH_COMBINE( seed, pipelineDynamicStateCreateInfo.dynamicStateCount );
5468  VULKAN_HPP_HASH_COMBINE( seed, pipelineDynamicStateCreateInfo.pDynamicStates );
5469  return seed;
5470  }
5471  };
5472 
5473  template <>
5474  struct hash<VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo>
5475  {
5476  std::size_t operator()( VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo const & graphicsPipelineCreateInfo ) const VULKAN_HPP_NOEXCEPT
5477  {
5478  std::size_t seed = 0;
5479  VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.sType );
5480  VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pNext );
5481  VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.flags );
5482  VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.stageCount );
5483  VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pStages );
5484  VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pVertexInputState );
5485  VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pInputAssemblyState );
5486  VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pTessellationState );
5487  VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pViewportState );
5488  VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pRasterizationState );
5489  VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pMultisampleState );
5490  VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pDepthStencilState );
5491  VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pColorBlendState );
5492  VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pDynamicState );
5493  VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.layout );
5494  VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.renderPass );
5495  VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.subpass );
5496  VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.basePipelineHandle );
5497  VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.basePipelineIndex );
5498  return seed;
5499  }
5500  };
5501 
5502  template <>
5503  struct hash<VULKAN_HPP_NAMESPACE::GraphicsPipelineLibraryCreateInfoEXT>
5504  {
5505  std::size_t operator()( VULKAN_HPP_NAMESPACE::GraphicsPipelineLibraryCreateInfoEXT const & graphicsPipelineLibraryCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
5506  {
5507  std::size_t seed = 0;
5508  VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineLibraryCreateInfoEXT.sType );
5509  VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineLibraryCreateInfoEXT.pNext );
5510  VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineLibraryCreateInfoEXT.flags );
5511  return seed;
5512  }
5513  };
5514 
5515  template <>
5516  struct hash<VULKAN_HPP_NAMESPACE::GraphicsShaderGroupCreateInfoNV>
5517  {
5518  std::size_t operator()( VULKAN_HPP_NAMESPACE::GraphicsShaderGroupCreateInfoNV const & graphicsShaderGroupCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
5519  {
5520  std::size_t seed = 0;
5521  VULKAN_HPP_HASH_COMBINE( seed, graphicsShaderGroupCreateInfoNV.sType );
5522  VULKAN_HPP_HASH_COMBINE( seed, graphicsShaderGroupCreateInfoNV.pNext );
5523  VULKAN_HPP_HASH_COMBINE( seed, graphicsShaderGroupCreateInfoNV.stageCount );
5524  VULKAN_HPP_HASH_COMBINE( seed, graphicsShaderGroupCreateInfoNV.pStages );
5525  VULKAN_HPP_HASH_COMBINE( seed, graphicsShaderGroupCreateInfoNV.pVertexInputState );
5526  VULKAN_HPP_HASH_COMBINE( seed, graphicsShaderGroupCreateInfoNV.pTessellationState );
5527  return seed;
5528  }
5529  };
5530 
5531  template <>
5532  struct hash<VULKAN_HPP_NAMESPACE::GraphicsPipelineShaderGroupsCreateInfoNV>
5533  {
5534  std::size_t
5535  operator()( VULKAN_HPP_NAMESPACE::GraphicsPipelineShaderGroupsCreateInfoNV const & graphicsPipelineShaderGroupsCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
5536  {
5537  std::size_t seed = 0;
5538  VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineShaderGroupsCreateInfoNV.sType );
5539  VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineShaderGroupsCreateInfoNV.pNext );
5540  VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineShaderGroupsCreateInfoNV.groupCount );
5541  VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineShaderGroupsCreateInfoNV.pGroups );
5542  VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineShaderGroupsCreateInfoNV.pipelineCount );
5543  VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineShaderGroupsCreateInfoNV.pPipelines );
5544  return seed;
5545  }
5546  };
5547 
5548  template <>
5549  struct hash<VULKAN_HPP_NAMESPACE::XYColorEXT>
5550  {
5551  std::size_t operator()( VULKAN_HPP_NAMESPACE::XYColorEXT const & xYColorEXT ) const VULKAN_HPP_NOEXCEPT
5552  {
5553  std::size_t seed = 0;
5554  VULKAN_HPP_HASH_COMBINE( seed, xYColorEXT.x );
5555  VULKAN_HPP_HASH_COMBINE( seed, xYColorEXT.y );
5556  return seed;
5557  }
5558  };
5559 
5560  template <>
5561  struct hash<VULKAN_HPP_NAMESPACE::HdrMetadataEXT>
5562  {
5563  std::size_t operator()( VULKAN_HPP_NAMESPACE::HdrMetadataEXT const & hdrMetadataEXT ) const VULKAN_HPP_NOEXCEPT
5564  {
5565  std::size_t seed = 0;
5566  VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.sType );
5567  VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.pNext );
5568  VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.displayPrimaryRed );
5569  VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.displayPrimaryGreen );
5570  VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.displayPrimaryBlue );
5571  VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.whitePoint );
5572  VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.maxLuminance );
5573  VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.minLuminance );
5574  VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.maxContentLightLevel );
5575  VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.maxFrameAverageLightLevel );
5576  return seed;
5577  }
5578  };
5579 
5580  template <>
5581  struct hash<VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT>
5582  {
5583  std::size_t operator()( VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT const & headlessSurfaceCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
5584  {
5585  std::size_t seed = 0;
5586  VULKAN_HPP_HASH_COMBINE( seed, headlessSurfaceCreateInfoEXT.sType );
5587  VULKAN_HPP_HASH_COMBINE( seed, headlessSurfaceCreateInfoEXT.pNext );
5588  VULKAN_HPP_HASH_COMBINE( seed, headlessSurfaceCreateInfoEXT.flags );
5589  return seed;
5590  }
5591  };
5592 
5593  template <>
5594  struct hash<VULKAN_HPP_NAMESPACE::HostImageCopyDevicePerformanceQueryEXT>
5595  {
5596  std::size_t
5597  operator()( VULKAN_HPP_NAMESPACE::HostImageCopyDevicePerformanceQueryEXT const & hostImageCopyDevicePerformanceQueryEXT ) const VULKAN_HPP_NOEXCEPT
5598  {
5599  std::size_t seed = 0;
5600  VULKAN_HPP_HASH_COMBINE( seed, hostImageCopyDevicePerformanceQueryEXT.sType );
5601  VULKAN_HPP_HASH_COMBINE( seed, hostImageCopyDevicePerformanceQueryEXT.pNext );
5602  VULKAN_HPP_HASH_COMBINE( seed, hostImageCopyDevicePerformanceQueryEXT.optimalDeviceAccess );
5603  VULKAN_HPP_HASH_COMBINE( seed, hostImageCopyDevicePerformanceQueryEXT.identicalMemoryLayout );
5604  return seed;
5605  }
5606  };
5607 
5608  template <>
5609  struct hash<VULKAN_HPP_NAMESPACE::HostImageLayoutTransitionInfoEXT>
5610  {
5611  std::size_t operator()( VULKAN_HPP_NAMESPACE::HostImageLayoutTransitionInfoEXT const & hostImageLayoutTransitionInfoEXT ) const VULKAN_HPP_NOEXCEPT
5612  {
5613  std::size_t seed = 0;
5614  VULKAN_HPP_HASH_COMBINE( seed, hostImageLayoutTransitionInfoEXT.sType );
5615  VULKAN_HPP_HASH_COMBINE( seed, hostImageLayoutTransitionInfoEXT.pNext );
5616  VULKAN_HPP_HASH_COMBINE( seed, hostImageLayoutTransitionInfoEXT.image );
5617  VULKAN_HPP_HASH_COMBINE( seed, hostImageLayoutTransitionInfoEXT.oldLayout );
5618  VULKAN_HPP_HASH_COMBINE( seed, hostImageLayoutTransitionInfoEXT.newLayout );
5619  VULKAN_HPP_HASH_COMBINE( seed, hostImageLayoutTransitionInfoEXT.subresourceRange );
5620  return seed;
5621  }
5622  };
5623 
5624 # if defined( VK_USE_PLATFORM_IOS_MVK )
5625  template <>
5626  struct hash<VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK>
5627  {
5628  std::size_t operator()( VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK const & iOSSurfaceCreateInfoMVK ) const VULKAN_HPP_NOEXCEPT
5629  {
5630  std::size_t seed = 0;
5631  VULKAN_HPP_HASH_COMBINE( seed, iOSSurfaceCreateInfoMVK.sType );
5632  VULKAN_HPP_HASH_COMBINE( seed, iOSSurfaceCreateInfoMVK.pNext );
5633  VULKAN_HPP_HASH_COMBINE( seed, iOSSurfaceCreateInfoMVK.flags );
5634  VULKAN_HPP_HASH_COMBINE( seed, iOSSurfaceCreateInfoMVK.pView );
5635  return seed;
5636  }
5637  };
5638 # endif /*VK_USE_PLATFORM_IOS_MVK*/
5639 
5640  template <>
5641  struct hash<VULKAN_HPP_NAMESPACE::ImageBlit>
5642  {
5643  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageBlit const & imageBlit ) const VULKAN_HPP_NOEXCEPT
5644  {
5645  std::size_t seed = 0;
5646  VULKAN_HPP_HASH_COMBINE( seed, imageBlit.srcSubresource );
5647  for ( size_t i = 0; i < 2; ++i )
5648  {
5649  VULKAN_HPP_HASH_COMBINE( seed, imageBlit.srcOffsets[i] );
5650  }
5651  VULKAN_HPP_HASH_COMBINE( seed, imageBlit.dstSubresource );
5652  for ( size_t i = 0; i < 2; ++i )
5653  {
5654  VULKAN_HPP_HASH_COMBINE( seed, imageBlit.dstOffsets[i] );
5655  }
5656  return seed;
5657  }
5658  };
5659 
5660  template <>
5661  struct hash<VULKAN_HPP_NAMESPACE::ImageCaptureDescriptorDataInfoEXT>
5662  {
5663  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageCaptureDescriptorDataInfoEXT const & imageCaptureDescriptorDataInfoEXT ) const VULKAN_HPP_NOEXCEPT
5664  {
5665  std::size_t seed = 0;
5666  VULKAN_HPP_HASH_COMBINE( seed, imageCaptureDescriptorDataInfoEXT.sType );
5667  VULKAN_HPP_HASH_COMBINE( seed, imageCaptureDescriptorDataInfoEXT.pNext );
5668  VULKAN_HPP_HASH_COMBINE( seed, imageCaptureDescriptorDataInfoEXT.image );
5669  return seed;
5670  }
5671  };
5672 
5673  template <>
5674  struct hash<VULKAN_HPP_NAMESPACE::ImageCompressionControlEXT>
5675  {
5676  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageCompressionControlEXT const & imageCompressionControlEXT ) const VULKAN_HPP_NOEXCEPT
5677  {
5678  std::size_t seed = 0;
5679  VULKAN_HPP_HASH_COMBINE( seed, imageCompressionControlEXT.sType );
5680  VULKAN_HPP_HASH_COMBINE( seed, imageCompressionControlEXT.pNext );
5681  VULKAN_HPP_HASH_COMBINE( seed, imageCompressionControlEXT.flags );
5682  VULKAN_HPP_HASH_COMBINE( seed, imageCompressionControlEXT.compressionControlPlaneCount );
5683  VULKAN_HPP_HASH_COMBINE( seed, imageCompressionControlEXT.pFixedRateFlags );
5684  return seed;
5685  }
5686  };
5687 
5688  template <>
5689  struct hash<VULKAN_HPP_NAMESPACE::ImageCompressionPropertiesEXT>
5690  {
5691  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageCompressionPropertiesEXT const & imageCompressionPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
5692  {
5693  std::size_t seed = 0;
5694  VULKAN_HPP_HASH_COMBINE( seed, imageCompressionPropertiesEXT.sType );
5695  VULKAN_HPP_HASH_COMBINE( seed, imageCompressionPropertiesEXT.pNext );
5696  VULKAN_HPP_HASH_COMBINE( seed, imageCompressionPropertiesEXT.imageCompressionFlags );
5697  VULKAN_HPP_HASH_COMBINE( seed, imageCompressionPropertiesEXT.imageCompressionFixedRateFlags );
5698  return seed;
5699  }
5700  };
5701 
5702 # if defined( VK_USE_PLATFORM_FUCHSIA )
5703  template <>
5704  struct hash<VULKAN_HPP_NAMESPACE::ImageFormatConstraintsInfoFUCHSIA>
5705  {
5706  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageFormatConstraintsInfoFUCHSIA const & imageFormatConstraintsInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT
5707  {
5708  std::size_t seed = 0;
5709  VULKAN_HPP_HASH_COMBINE( seed, imageFormatConstraintsInfoFUCHSIA.sType );
5710  VULKAN_HPP_HASH_COMBINE( seed, imageFormatConstraintsInfoFUCHSIA.pNext );
5711  VULKAN_HPP_HASH_COMBINE( seed, imageFormatConstraintsInfoFUCHSIA.imageCreateInfo );
5712  VULKAN_HPP_HASH_COMBINE( seed, imageFormatConstraintsInfoFUCHSIA.requiredFormatFeatures );
5713  VULKAN_HPP_HASH_COMBINE( seed, imageFormatConstraintsInfoFUCHSIA.flags );
5714  VULKAN_HPP_HASH_COMBINE( seed, imageFormatConstraintsInfoFUCHSIA.sysmemPixelFormat );
5715  VULKAN_HPP_HASH_COMBINE( seed, imageFormatConstraintsInfoFUCHSIA.colorSpaceCount );
5716  VULKAN_HPP_HASH_COMBINE( seed, imageFormatConstraintsInfoFUCHSIA.pColorSpaces );
5717  return seed;
5718  }
5719  };
5720 # endif /*VK_USE_PLATFORM_FUCHSIA*/
5721 
5722 # if defined( VK_USE_PLATFORM_FUCHSIA )
5723  template <>
5724  struct hash<VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFUCHSIA>
5725  {
5726  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFUCHSIA const & imageConstraintsInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT
5727  {
5728  std::size_t seed = 0;
5729  VULKAN_HPP_HASH_COMBINE( seed, imageConstraintsInfoFUCHSIA.sType );
5730  VULKAN_HPP_HASH_COMBINE( seed, imageConstraintsInfoFUCHSIA.pNext );
5731  VULKAN_HPP_HASH_COMBINE( seed, imageConstraintsInfoFUCHSIA.formatConstraintsCount );
5732  VULKAN_HPP_HASH_COMBINE( seed, imageConstraintsInfoFUCHSIA.pFormatConstraints );
5733  VULKAN_HPP_HASH_COMBINE( seed, imageConstraintsInfoFUCHSIA.bufferCollectionConstraints );
5734  VULKAN_HPP_HASH_COMBINE( seed, imageConstraintsInfoFUCHSIA.flags );
5735  return seed;
5736  }
5737  };
5738 # endif /*VK_USE_PLATFORM_FUCHSIA*/
5739 
5740  template <>
5741  struct hash<VULKAN_HPP_NAMESPACE::ImageCopy>
5742  {
5743  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageCopy const & imageCopy ) const VULKAN_HPP_NOEXCEPT
5744  {
5745  std::size_t seed = 0;
5746  VULKAN_HPP_HASH_COMBINE( seed, imageCopy.srcSubresource );
5747  VULKAN_HPP_HASH_COMBINE( seed, imageCopy.srcOffset );
5748  VULKAN_HPP_HASH_COMBINE( seed, imageCopy.dstSubresource );
5749  VULKAN_HPP_HASH_COMBINE( seed, imageCopy.dstOffset );
5750  VULKAN_HPP_HASH_COMBINE( seed, imageCopy.extent );
5751  return seed;
5752  }
5753  };
5754 
5755  template <>
5756  struct hash<VULKAN_HPP_NAMESPACE::SubresourceLayout>
5757  {
5758  std::size_t operator()( VULKAN_HPP_NAMESPACE::SubresourceLayout const & subresourceLayout ) const VULKAN_HPP_NOEXCEPT
5759  {
5760  std::size_t seed = 0;
5761  VULKAN_HPP_HASH_COMBINE( seed, subresourceLayout.offset );
5762  VULKAN_HPP_HASH_COMBINE( seed, subresourceLayout.size );
5763  VULKAN_HPP_HASH_COMBINE( seed, subresourceLayout.rowPitch );
5764  VULKAN_HPP_HASH_COMBINE( seed, subresourceLayout.arrayPitch );
5765  VULKAN_HPP_HASH_COMBINE( seed, subresourceLayout.depthPitch );
5766  return seed;
5767  }
5768  };
5769 
5770  template <>
5771  struct hash<VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierExplicitCreateInfoEXT>
5772  {
5773  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierExplicitCreateInfoEXT const & imageDrmFormatModifierExplicitCreateInfoEXT ) const
5774  VULKAN_HPP_NOEXCEPT
5775  {
5776  std::size_t seed = 0;
5777  VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierExplicitCreateInfoEXT.sType );
5778  VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierExplicitCreateInfoEXT.pNext );
5779  VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierExplicitCreateInfoEXT.drmFormatModifier );
5780  VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierExplicitCreateInfoEXT.drmFormatModifierPlaneCount );
5781  VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierExplicitCreateInfoEXT.pPlaneLayouts );
5782  return seed;
5783  }
5784  };
5785 
5786  template <>
5787  struct hash<VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierListCreateInfoEXT>
5788  {
5789  std::size_t
5790  operator()( VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierListCreateInfoEXT const & imageDrmFormatModifierListCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
5791  {
5792  std::size_t seed = 0;
5793  VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierListCreateInfoEXT.sType );
5794  VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierListCreateInfoEXT.pNext );
5795  VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierListCreateInfoEXT.drmFormatModifierCount );
5796  VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierListCreateInfoEXT.pDrmFormatModifiers );
5797  return seed;
5798  }
5799  };
5800 
5801  template <>
5802  struct hash<VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT>
5803  {
5804  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT const & imageDrmFormatModifierPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
5805  {
5806  std::size_t seed = 0;
5807  VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierPropertiesEXT.sType );
5808  VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierPropertiesEXT.pNext );
5809  VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierPropertiesEXT.drmFormatModifier );
5810  return seed;
5811  }
5812  };
5813 
5814  template <>
5815  struct hash<VULKAN_HPP_NAMESPACE::ImageFormatListCreateInfo>
5816  {
5817  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageFormatListCreateInfo const & imageFormatListCreateInfo ) const VULKAN_HPP_NOEXCEPT
5818  {
5819  std::size_t seed = 0;
5820  VULKAN_HPP_HASH_COMBINE( seed, imageFormatListCreateInfo.sType );
5821  VULKAN_HPP_HASH_COMBINE( seed, imageFormatListCreateInfo.pNext );
5822  VULKAN_HPP_HASH_COMBINE( seed, imageFormatListCreateInfo.viewFormatCount );
5823  VULKAN_HPP_HASH_COMBINE( seed, imageFormatListCreateInfo.pViewFormats );
5824  return seed;
5825  }
5826  };
5827 
5828  template <>
5829  struct hash<VULKAN_HPP_NAMESPACE::ImageFormatProperties2>
5830  {
5831  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageFormatProperties2 const & imageFormatProperties2 ) const VULKAN_HPP_NOEXCEPT
5832  {
5833  std::size_t seed = 0;
5834  VULKAN_HPP_HASH_COMBINE( seed, imageFormatProperties2.sType );
5835  VULKAN_HPP_HASH_COMBINE( seed, imageFormatProperties2.pNext );
5836  VULKAN_HPP_HASH_COMBINE( seed, imageFormatProperties2.imageFormatProperties );
5837  return seed;
5838  }
5839  };
5840 
5841  template <>
5842  struct hash<VULKAN_HPP_NAMESPACE::ImageMemoryBarrier>
5843  {
5844  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageMemoryBarrier const & imageMemoryBarrier ) const VULKAN_HPP_NOEXCEPT
5845  {
5846  std::size_t seed = 0;
5847  VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.sType );
5848  VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.pNext );
5849  VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.srcAccessMask );
5850  VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.dstAccessMask );
5851  VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.oldLayout );
5852  VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.newLayout );
5853  VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.srcQueueFamilyIndex );
5854  VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.dstQueueFamilyIndex );
5855  VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.image );
5856  VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.subresourceRange );
5857  return seed;
5858  }
5859  };
5860 
5861  template <>
5862  struct hash<VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2>
5863  {
5864  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 const & imageMemoryRequirementsInfo2 ) const VULKAN_HPP_NOEXCEPT
5865  {
5866  std::size_t seed = 0;
5867  VULKAN_HPP_HASH_COMBINE( seed, imageMemoryRequirementsInfo2.sType );
5868  VULKAN_HPP_HASH_COMBINE( seed, imageMemoryRequirementsInfo2.pNext );
5869  VULKAN_HPP_HASH_COMBINE( seed, imageMemoryRequirementsInfo2.image );
5870  return seed;
5871  }
5872  };
5873 
5874 # if defined( VK_USE_PLATFORM_FUCHSIA )
5875  template <>
5876  struct hash<VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA>
5877  {
5878  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA const & imagePipeSurfaceCreateInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT
5879  {
5880  std::size_t seed = 0;
5881  VULKAN_HPP_HASH_COMBINE( seed, imagePipeSurfaceCreateInfoFUCHSIA.sType );
5882  VULKAN_HPP_HASH_COMBINE( seed, imagePipeSurfaceCreateInfoFUCHSIA.pNext );
5883  VULKAN_HPP_HASH_COMBINE( seed, imagePipeSurfaceCreateInfoFUCHSIA.flags );
5884  VULKAN_HPP_HASH_COMBINE( seed, imagePipeSurfaceCreateInfoFUCHSIA.imagePipeHandle );
5885  return seed;
5886  }
5887  };
5888 # endif /*VK_USE_PLATFORM_FUCHSIA*/
5889 
5890  template <>
5891  struct hash<VULKAN_HPP_NAMESPACE::ImagePlaneMemoryRequirementsInfo>
5892  {
5893  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImagePlaneMemoryRequirementsInfo const & imagePlaneMemoryRequirementsInfo ) const VULKAN_HPP_NOEXCEPT
5894  {
5895  std::size_t seed = 0;
5896  VULKAN_HPP_HASH_COMBINE( seed, imagePlaneMemoryRequirementsInfo.sType );
5897  VULKAN_HPP_HASH_COMBINE( seed, imagePlaneMemoryRequirementsInfo.pNext );
5898  VULKAN_HPP_HASH_COMBINE( seed, imagePlaneMemoryRequirementsInfo.planeAspect );
5899  return seed;
5900  }
5901  };
5902 
5903  template <>
5904  struct hash<VULKAN_HPP_NAMESPACE::ImageResolve>
5905  {
5906  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageResolve const & imageResolve ) const VULKAN_HPP_NOEXCEPT
5907  {
5908  std::size_t seed = 0;
5909  VULKAN_HPP_HASH_COMBINE( seed, imageResolve.srcSubresource );
5910  VULKAN_HPP_HASH_COMBINE( seed, imageResolve.srcOffset );
5911  VULKAN_HPP_HASH_COMBINE( seed, imageResolve.dstSubresource );
5912  VULKAN_HPP_HASH_COMBINE( seed, imageResolve.dstOffset );
5913  VULKAN_HPP_HASH_COMBINE( seed, imageResolve.extent );
5914  return seed;
5915  }
5916  };
5917 
5918  template <>
5919  struct hash<VULKAN_HPP_NAMESPACE::ImageResolve2>
5920  {
5921  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageResolve2 const & imageResolve2 ) const VULKAN_HPP_NOEXCEPT
5922  {
5923  std::size_t seed = 0;
5924  VULKAN_HPP_HASH_COMBINE( seed, imageResolve2.sType );
5925  VULKAN_HPP_HASH_COMBINE( seed, imageResolve2.pNext );
5926  VULKAN_HPP_HASH_COMBINE( seed, imageResolve2.srcSubresource );
5927  VULKAN_HPP_HASH_COMBINE( seed, imageResolve2.srcOffset );
5928  VULKAN_HPP_HASH_COMBINE( seed, imageResolve2.dstSubresource );
5929  VULKAN_HPP_HASH_COMBINE( seed, imageResolve2.dstOffset );
5930  VULKAN_HPP_HASH_COMBINE( seed, imageResolve2.extent );
5931  return seed;
5932  }
5933  };
5934 
5935  template <>
5936  struct hash<VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2>
5937  {
5938  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 const & imageSparseMemoryRequirementsInfo2 ) const VULKAN_HPP_NOEXCEPT
5939  {
5940  std::size_t seed = 0;
5941  VULKAN_HPP_HASH_COMBINE( seed, imageSparseMemoryRequirementsInfo2.sType );
5942  VULKAN_HPP_HASH_COMBINE( seed, imageSparseMemoryRequirementsInfo2.pNext );
5943  VULKAN_HPP_HASH_COMBINE( seed, imageSparseMemoryRequirementsInfo2.image );
5944  return seed;
5945  }
5946  };
5947 
5948  template <>
5949  struct hash<VULKAN_HPP_NAMESPACE::ImageStencilUsageCreateInfo>
5950  {
5951  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageStencilUsageCreateInfo const & imageStencilUsageCreateInfo ) const VULKAN_HPP_NOEXCEPT
5952  {
5953  std::size_t seed = 0;
5954  VULKAN_HPP_HASH_COMBINE( seed, imageStencilUsageCreateInfo.sType );
5955  VULKAN_HPP_HASH_COMBINE( seed, imageStencilUsageCreateInfo.pNext );
5956  VULKAN_HPP_HASH_COMBINE( seed, imageStencilUsageCreateInfo.stencilUsage );
5957  return seed;
5958  }
5959  };
5960 
5961  template <>
5962  struct hash<VULKAN_HPP_NAMESPACE::ImageSwapchainCreateInfoKHR>
5963  {
5964  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageSwapchainCreateInfoKHR const & imageSwapchainCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
5965  {
5966  std::size_t seed = 0;
5967  VULKAN_HPP_HASH_COMBINE( seed, imageSwapchainCreateInfoKHR.sType );
5968  VULKAN_HPP_HASH_COMBINE( seed, imageSwapchainCreateInfoKHR.pNext );
5969  VULKAN_HPP_HASH_COMBINE( seed, imageSwapchainCreateInfoKHR.swapchain );
5970  return seed;
5971  }
5972  };
5973 
5974  template <>
5975  struct hash<VULKAN_HPP_NAMESPACE::ImageViewASTCDecodeModeEXT>
5976  {
5977  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewASTCDecodeModeEXT const & imageViewASTCDecodeModeEXT ) const VULKAN_HPP_NOEXCEPT
5978  {
5979  std::size_t seed = 0;
5980  VULKAN_HPP_HASH_COMBINE( seed, imageViewASTCDecodeModeEXT.sType );
5981  VULKAN_HPP_HASH_COMBINE( seed, imageViewASTCDecodeModeEXT.pNext );
5982  VULKAN_HPP_HASH_COMBINE( seed, imageViewASTCDecodeModeEXT.decodeMode );
5983  return seed;
5984  }
5985  };
5986 
5987  template <>
5988  struct hash<VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX>
5989  {
5990  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX const & imageViewAddressPropertiesNVX ) const VULKAN_HPP_NOEXCEPT
5991  {
5992  std::size_t seed = 0;
5993  VULKAN_HPP_HASH_COMBINE( seed, imageViewAddressPropertiesNVX.sType );
5994  VULKAN_HPP_HASH_COMBINE( seed, imageViewAddressPropertiesNVX.pNext );
5995  VULKAN_HPP_HASH_COMBINE( seed, imageViewAddressPropertiesNVX.deviceAddress );
5996  VULKAN_HPP_HASH_COMBINE( seed, imageViewAddressPropertiesNVX.size );
5997  return seed;
5998  }
5999  };
6000 
6001  template <>
6002  struct hash<VULKAN_HPP_NAMESPACE::ImageViewCaptureDescriptorDataInfoEXT>
6003  {
6004  std::size_t
6005  operator()( VULKAN_HPP_NAMESPACE::ImageViewCaptureDescriptorDataInfoEXT const & imageViewCaptureDescriptorDataInfoEXT ) const VULKAN_HPP_NOEXCEPT
6006  {
6007  std::size_t seed = 0;
6008  VULKAN_HPP_HASH_COMBINE( seed, imageViewCaptureDescriptorDataInfoEXT.sType );
6009  VULKAN_HPP_HASH_COMBINE( seed, imageViewCaptureDescriptorDataInfoEXT.pNext );
6010  VULKAN_HPP_HASH_COMBINE( seed, imageViewCaptureDescriptorDataInfoEXT.imageView );
6011  return seed;
6012  }
6013  };
6014 
6015  template <>
6016  struct hash<VULKAN_HPP_NAMESPACE::ImageViewCreateInfo>
6017  {
6018  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewCreateInfo const & imageViewCreateInfo ) const VULKAN_HPP_NOEXCEPT
6019  {
6020  std::size_t seed = 0;
6021  VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.sType );
6022  VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.pNext );
6023  VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.flags );
6024  VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.image );
6025  VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.viewType );
6026  VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.format );
6027  VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.components );
6028  VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.subresourceRange );
6029  return seed;
6030  }
6031  };
6032 
6033  template <>
6034  struct hash<VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX>
6035  {
6036  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX const & imageViewHandleInfoNVX ) const VULKAN_HPP_NOEXCEPT
6037  {
6038  std::size_t seed = 0;
6039  VULKAN_HPP_HASH_COMBINE( seed, imageViewHandleInfoNVX.sType );
6040  VULKAN_HPP_HASH_COMBINE( seed, imageViewHandleInfoNVX.pNext );
6041  VULKAN_HPP_HASH_COMBINE( seed, imageViewHandleInfoNVX.imageView );
6042  VULKAN_HPP_HASH_COMBINE( seed, imageViewHandleInfoNVX.descriptorType );
6043  VULKAN_HPP_HASH_COMBINE( seed, imageViewHandleInfoNVX.sampler );
6044  return seed;
6045  }
6046  };
6047 
6048  template <>
6049  struct hash<VULKAN_HPP_NAMESPACE::ImageViewMinLodCreateInfoEXT>
6050  {
6051  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewMinLodCreateInfoEXT const & imageViewMinLodCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
6052  {
6053  std::size_t seed = 0;
6054  VULKAN_HPP_HASH_COMBINE( seed, imageViewMinLodCreateInfoEXT.sType );
6055  VULKAN_HPP_HASH_COMBINE( seed, imageViewMinLodCreateInfoEXT.pNext );
6056  VULKAN_HPP_HASH_COMBINE( seed, imageViewMinLodCreateInfoEXT.minLod );
6057  return seed;
6058  }
6059  };
6060 
6061  template <>
6062  struct hash<VULKAN_HPP_NAMESPACE::ImageViewSampleWeightCreateInfoQCOM>
6063  {
6064  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewSampleWeightCreateInfoQCOM const & imageViewSampleWeightCreateInfoQCOM ) const VULKAN_HPP_NOEXCEPT
6065  {
6066  std::size_t seed = 0;
6067  VULKAN_HPP_HASH_COMBINE( seed, imageViewSampleWeightCreateInfoQCOM.sType );
6068  VULKAN_HPP_HASH_COMBINE( seed, imageViewSampleWeightCreateInfoQCOM.pNext );
6069  VULKAN_HPP_HASH_COMBINE( seed, imageViewSampleWeightCreateInfoQCOM.filterCenter );
6070  VULKAN_HPP_HASH_COMBINE( seed, imageViewSampleWeightCreateInfoQCOM.filterSize );
6071  VULKAN_HPP_HASH_COMBINE( seed, imageViewSampleWeightCreateInfoQCOM.numPhases );
6072  return seed;
6073  }
6074  };
6075 
6076  template <>
6077  struct hash<VULKAN_HPP_NAMESPACE::ImageViewSlicedCreateInfoEXT>
6078  {
6079  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewSlicedCreateInfoEXT const & imageViewSlicedCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
6080  {
6081  std::size_t seed = 0;
6082  VULKAN_HPP_HASH_COMBINE( seed, imageViewSlicedCreateInfoEXT.sType );
6083  VULKAN_HPP_HASH_COMBINE( seed, imageViewSlicedCreateInfoEXT.pNext );
6084  VULKAN_HPP_HASH_COMBINE( seed, imageViewSlicedCreateInfoEXT.sliceOffset );
6085  VULKAN_HPP_HASH_COMBINE( seed, imageViewSlicedCreateInfoEXT.sliceCount );
6086  return seed;
6087  }
6088  };
6089 
6090  template <>
6091  struct hash<VULKAN_HPP_NAMESPACE::ImageViewUsageCreateInfo>
6092  {
6093  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewUsageCreateInfo const & imageViewUsageCreateInfo ) const VULKAN_HPP_NOEXCEPT
6094  {
6095  std::size_t seed = 0;
6096  VULKAN_HPP_HASH_COMBINE( seed, imageViewUsageCreateInfo.sType );
6097  VULKAN_HPP_HASH_COMBINE( seed, imageViewUsageCreateInfo.pNext );
6098  VULKAN_HPP_HASH_COMBINE( seed, imageViewUsageCreateInfo.usage );
6099  return seed;
6100  }
6101  };
6102 
6103 # if defined( VK_USE_PLATFORM_ANDROID_KHR )
6104  template <>
6105  struct hash<VULKAN_HPP_NAMESPACE::ImportAndroidHardwareBufferInfoANDROID>
6106  {
6107  std::size_t
6108  operator()( VULKAN_HPP_NAMESPACE::ImportAndroidHardwareBufferInfoANDROID const & importAndroidHardwareBufferInfoANDROID ) const VULKAN_HPP_NOEXCEPT
6109  {
6110  std::size_t seed = 0;
6111  VULKAN_HPP_HASH_COMBINE( seed, importAndroidHardwareBufferInfoANDROID.sType );
6112  VULKAN_HPP_HASH_COMBINE( seed, importAndroidHardwareBufferInfoANDROID.pNext );
6113  VULKAN_HPP_HASH_COMBINE( seed, importAndroidHardwareBufferInfoANDROID.buffer );
6114  return seed;
6115  }
6116  };
6117 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/
6118 
6119  template <>
6120  struct hash<VULKAN_HPP_NAMESPACE::ImportFenceFdInfoKHR>
6121  {
6122  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportFenceFdInfoKHR const & importFenceFdInfoKHR ) const VULKAN_HPP_NOEXCEPT
6123  {
6124  std::size_t seed = 0;
6125  VULKAN_HPP_HASH_COMBINE( seed, importFenceFdInfoKHR.sType );
6126  VULKAN_HPP_HASH_COMBINE( seed, importFenceFdInfoKHR.pNext );
6127  VULKAN_HPP_HASH_COMBINE( seed, importFenceFdInfoKHR.fence );
6128  VULKAN_HPP_HASH_COMBINE( seed, importFenceFdInfoKHR.flags );
6129  VULKAN_HPP_HASH_COMBINE( seed, importFenceFdInfoKHR.handleType );
6130  VULKAN_HPP_HASH_COMBINE( seed, importFenceFdInfoKHR.fd );
6131  return seed;
6132  }
6133  };
6134 
6135 # if defined( VK_USE_PLATFORM_WIN32_KHR )
6136  template <>
6137  struct hash<VULKAN_HPP_NAMESPACE::ImportFenceWin32HandleInfoKHR>
6138  {
6139  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportFenceWin32HandleInfoKHR const & importFenceWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT
6140  {
6141  std::size_t seed = 0;
6142  VULKAN_HPP_HASH_COMBINE( seed, importFenceWin32HandleInfoKHR.sType );
6143  VULKAN_HPP_HASH_COMBINE( seed, importFenceWin32HandleInfoKHR.pNext );
6144  VULKAN_HPP_HASH_COMBINE( seed, importFenceWin32HandleInfoKHR.fence );
6145  VULKAN_HPP_HASH_COMBINE( seed, importFenceWin32HandleInfoKHR.flags );
6146  VULKAN_HPP_HASH_COMBINE( seed, importFenceWin32HandleInfoKHR.handleType );
6147  VULKAN_HPP_HASH_COMBINE( seed, importFenceWin32HandleInfoKHR.handle );
6148  VULKAN_HPP_HASH_COMBINE( seed, importFenceWin32HandleInfoKHR.name );
6149  return seed;
6150  }
6151  };
6152 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
6153 
6154 # if defined( VK_USE_PLATFORM_FUCHSIA )
6155  template <>
6156  struct hash<VULKAN_HPP_NAMESPACE::ImportMemoryBufferCollectionFUCHSIA>
6157  {
6158  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMemoryBufferCollectionFUCHSIA const & importMemoryBufferCollectionFUCHSIA ) const VULKAN_HPP_NOEXCEPT
6159  {
6160  std::size_t seed = 0;
6161  VULKAN_HPP_HASH_COMBINE( seed, importMemoryBufferCollectionFUCHSIA.sType );
6162  VULKAN_HPP_HASH_COMBINE( seed, importMemoryBufferCollectionFUCHSIA.pNext );
6163  VULKAN_HPP_HASH_COMBINE( seed, importMemoryBufferCollectionFUCHSIA.collection );
6164  VULKAN_HPP_HASH_COMBINE( seed, importMemoryBufferCollectionFUCHSIA.index );
6165  return seed;
6166  }
6167  };
6168 # endif /*VK_USE_PLATFORM_FUCHSIA*/
6169 
6170  template <>
6171  struct hash<VULKAN_HPP_NAMESPACE::ImportMemoryFdInfoKHR>
6172  {
6173  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMemoryFdInfoKHR const & importMemoryFdInfoKHR ) const VULKAN_HPP_NOEXCEPT
6174  {
6175  std::size_t seed = 0;
6176  VULKAN_HPP_HASH_COMBINE( seed, importMemoryFdInfoKHR.sType );
6177  VULKAN_HPP_HASH_COMBINE( seed, importMemoryFdInfoKHR.pNext );
6178  VULKAN_HPP_HASH_COMBINE( seed, importMemoryFdInfoKHR.handleType );
6179  VULKAN_HPP_HASH_COMBINE( seed, importMemoryFdInfoKHR.fd );
6180  return seed;
6181  }
6182  };
6183 
6184  template <>
6185  struct hash<VULKAN_HPP_NAMESPACE::ImportMemoryHostPointerInfoEXT>
6186  {
6187  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMemoryHostPointerInfoEXT const & importMemoryHostPointerInfoEXT ) const VULKAN_HPP_NOEXCEPT
6188  {
6189  std::size_t seed = 0;
6190  VULKAN_HPP_HASH_COMBINE( seed, importMemoryHostPointerInfoEXT.sType );
6191  VULKAN_HPP_HASH_COMBINE( seed, importMemoryHostPointerInfoEXT.pNext );
6192  VULKAN_HPP_HASH_COMBINE( seed, importMemoryHostPointerInfoEXT.handleType );
6193  VULKAN_HPP_HASH_COMBINE( seed, importMemoryHostPointerInfoEXT.pHostPointer );
6194  return seed;
6195  }
6196  };
6197 
6198 # if defined( VK_USE_PLATFORM_WIN32_KHR )
6199  template <>
6200  struct hash<VULKAN_HPP_NAMESPACE::ImportMemoryWin32HandleInfoKHR>
6201  {
6202  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMemoryWin32HandleInfoKHR const & importMemoryWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT
6203  {
6204  std::size_t seed = 0;
6205  VULKAN_HPP_HASH_COMBINE( seed, importMemoryWin32HandleInfoKHR.sType );
6206  VULKAN_HPP_HASH_COMBINE( seed, importMemoryWin32HandleInfoKHR.pNext );
6207  VULKAN_HPP_HASH_COMBINE( seed, importMemoryWin32HandleInfoKHR.handleType );
6208  VULKAN_HPP_HASH_COMBINE( seed, importMemoryWin32HandleInfoKHR.handle );
6209  VULKAN_HPP_HASH_COMBINE( seed, importMemoryWin32HandleInfoKHR.name );
6210  return seed;
6211  }
6212  };
6213 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
6214 
6215 # if defined( VK_USE_PLATFORM_WIN32_KHR )
6216  template <>
6217  struct hash<VULKAN_HPP_NAMESPACE::ImportMemoryWin32HandleInfoNV>
6218  {
6219  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMemoryWin32HandleInfoNV const & importMemoryWin32HandleInfoNV ) const VULKAN_HPP_NOEXCEPT
6220  {
6221  std::size_t seed = 0;
6222  VULKAN_HPP_HASH_COMBINE( seed, importMemoryWin32HandleInfoNV.sType );
6223  VULKAN_HPP_HASH_COMBINE( seed, importMemoryWin32HandleInfoNV.pNext );
6224  VULKAN_HPP_HASH_COMBINE( seed, importMemoryWin32HandleInfoNV.handleType );
6225  VULKAN_HPP_HASH_COMBINE( seed, importMemoryWin32HandleInfoNV.handle );
6226  return seed;
6227  }
6228  };
6229 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
6230 
6231 # if defined( VK_USE_PLATFORM_FUCHSIA )
6232  template <>
6233  struct hash<VULKAN_HPP_NAMESPACE::ImportMemoryZirconHandleInfoFUCHSIA>
6234  {
6235  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMemoryZirconHandleInfoFUCHSIA const & importMemoryZirconHandleInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT
6236  {
6237  std::size_t seed = 0;
6238  VULKAN_HPP_HASH_COMBINE( seed, importMemoryZirconHandleInfoFUCHSIA.sType );
6239  VULKAN_HPP_HASH_COMBINE( seed, importMemoryZirconHandleInfoFUCHSIA.pNext );
6240  VULKAN_HPP_HASH_COMBINE( seed, importMemoryZirconHandleInfoFUCHSIA.handleType );
6241  VULKAN_HPP_HASH_COMBINE( seed, importMemoryZirconHandleInfoFUCHSIA.handle );
6242  return seed;
6243  }
6244  };
6245 # endif /*VK_USE_PLATFORM_FUCHSIA*/
6246 
6247 # if defined( VK_USE_PLATFORM_METAL_EXT )
6248  template <>
6249  struct hash<VULKAN_HPP_NAMESPACE::ImportMetalBufferInfoEXT>
6250  {
6251  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMetalBufferInfoEXT const & importMetalBufferInfoEXT ) const VULKAN_HPP_NOEXCEPT
6252  {
6253  std::size_t seed = 0;
6254  VULKAN_HPP_HASH_COMBINE( seed, importMetalBufferInfoEXT.sType );
6255  VULKAN_HPP_HASH_COMBINE( seed, importMetalBufferInfoEXT.pNext );
6256  VULKAN_HPP_HASH_COMBINE( seed, importMetalBufferInfoEXT.mtlBuffer );
6257  return seed;
6258  }
6259  };
6260 # endif /*VK_USE_PLATFORM_METAL_EXT*/
6261 
6262 # if defined( VK_USE_PLATFORM_METAL_EXT )
6263  template <>
6264  struct hash<VULKAN_HPP_NAMESPACE::ImportMetalIOSurfaceInfoEXT>
6265  {
6266  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMetalIOSurfaceInfoEXT const & importMetalIOSurfaceInfoEXT ) const VULKAN_HPP_NOEXCEPT
6267  {
6268  std::size_t seed = 0;
6269  VULKAN_HPP_HASH_COMBINE( seed, importMetalIOSurfaceInfoEXT.sType );
6270  VULKAN_HPP_HASH_COMBINE( seed, importMetalIOSurfaceInfoEXT.pNext );
6271  VULKAN_HPP_HASH_COMBINE( seed, importMetalIOSurfaceInfoEXT.ioSurface );
6272  return seed;
6273  }
6274  };
6275 # endif /*VK_USE_PLATFORM_METAL_EXT*/
6276 
6277 # if defined( VK_USE_PLATFORM_METAL_EXT )
6278  template <>
6279  struct hash<VULKAN_HPP_NAMESPACE::ImportMetalSharedEventInfoEXT>
6280  {
6281  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMetalSharedEventInfoEXT const & importMetalSharedEventInfoEXT ) const VULKAN_HPP_NOEXCEPT
6282  {
6283  std::size_t seed = 0;
6284  VULKAN_HPP_HASH_COMBINE( seed, importMetalSharedEventInfoEXT.sType );
6285  VULKAN_HPP_HASH_COMBINE( seed, importMetalSharedEventInfoEXT.pNext );
6286  VULKAN_HPP_HASH_COMBINE( seed, importMetalSharedEventInfoEXT.mtlSharedEvent );
6287  return seed;
6288  }
6289  };
6290 # endif /*VK_USE_PLATFORM_METAL_EXT*/
6291 
6292 # if defined( VK_USE_PLATFORM_METAL_EXT )
6293  template <>
6294  struct hash<VULKAN_HPP_NAMESPACE::ImportMetalTextureInfoEXT>
6295  {
6296  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMetalTextureInfoEXT const & importMetalTextureInfoEXT ) const VULKAN_HPP_NOEXCEPT
6297  {
6298  std::size_t seed = 0;
6299  VULKAN_HPP_HASH_COMBINE( seed, importMetalTextureInfoEXT.sType );
6300  VULKAN_HPP_HASH_COMBINE( seed, importMetalTextureInfoEXT.pNext );
6301  VULKAN_HPP_HASH_COMBINE( seed, importMetalTextureInfoEXT.plane );
6302  VULKAN_HPP_HASH_COMBINE( seed, importMetalTextureInfoEXT.mtlTexture );
6303  return seed;
6304  }
6305  };
6306 # endif /*VK_USE_PLATFORM_METAL_EXT*/
6307 
6308 # if defined( VK_USE_PLATFORM_SCREEN_QNX )
6309  template <>
6310  struct hash<VULKAN_HPP_NAMESPACE::ImportScreenBufferInfoQNX>
6311  {
6312  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportScreenBufferInfoQNX const & importScreenBufferInfoQNX ) const VULKAN_HPP_NOEXCEPT
6313  {
6314  std::size_t seed = 0;
6315  VULKAN_HPP_HASH_COMBINE( seed, importScreenBufferInfoQNX.sType );
6316  VULKAN_HPP_HASH_COMBINE( seed, importScreenBufferInfoQNX.pNext );
6317  VULKAN_HPP_HASH_COMBINE( seed, importScreenBufferInfoQNX.buffer );
6318  return seed;
6319  }
6320  };
6321 # endif /*VK_USE_PLATFORM_SCREEN_QNX*/
6322 
6323  template <>
6324  struct hash<VULKAN_HPP_NAMESPACE::ImportSemaphoreFdInfoKHR>
6325  {
6326  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportSemaphoreFdInfoKHR const & importSemaphoreFdInfoKHR ) const VULKAN_HPP_NOEXCEPT
6327  {
6328  std::size_t seed = 0;
6329  VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreFdInfoKHR.sType );
6330  VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreFdInfoKHR.pNext );
6331  VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreFdInfoKHR.semaphore );
6332  VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreFdInfoKHR.flags );
6333  VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreFdInfoKHR.handleType );
6334  VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreFdInfoKHR.fd );
6335  return seed;
6336  }
6337  };
6338 
6339 # if defined( VK_USE_PLATFORM_WIN32_KHR )
6340  template <>
6341  struct hash<VULKAN_HPP_NAMESPACE::ImportSemaphoreWin32HandleInfoKHR>
6342  {
6343  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportSemaphoreWin32HandleInfoKHR const & importSemaphoreWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT
6344  {
6345  std::size_t seed = 0;
6346  VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreWin32HandleInfoKHR.sType );
6347  VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreWin32HandleInfoKHR.pNext );
6348  VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreWin32HandleInfoKHR.semaphore );
6349  VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreWin32HandleInfoKHR.flags );
6350  VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreWin32HandleInfoKHR.handleType );
6351  VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreWin32HandleInfoKHR.handle );
6352  VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreWin32HandleInfoKHR.name );
6353  return seed;
6354  }
6355  };
6356 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
6357 
6358 # if defined( VK_USE_PLATFORM_FUCHSIA )
6359  template <>
6360  struct hash<VULKAN_HPP_NAMESPACE::ImportSemaphoreZirconHandleInfoFUCHSIA>
6361  {
6362  std::size_t
6363  operator()( VULKAN_HPP_NAMESPACE::ImportSemaphoreZirconHandleInfoFUCHSIA const & importSemaphoreZirconHandleInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT
6364  {
6365  std::size_t seed = 0;
6366  VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreZirconHandleInfoFUCHSIA.sType );
6367  VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreZirconHandleInfoFUCHSIA.pNext );
6368  VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreZirconHandleInfoFUCHSIA.semaphore );
6369  VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreZirconHandleInfoFUCHSIA.flags );
6370  VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreZirconHandleInfoFUCHSIA.handleType );
6371  VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreZirconHandleInfoFUCHSIA.zirconHandle );
6372  return seed;
6373  }
6374  };
6375 # endif /*VK_USE_PLATFORM_FUCHSIA*/
6376 
6377  template <>
6378  struct hash<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutTokenNV>
6379  {
6380  std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutTokenNV const & indirectCommandsLayoutTokenNV ) const VULKAN_HPP_NOEXCEPT
6381  {
6382  std::size_t seed = 0;
6383  VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.sType );
6384  VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.pNext );
6385  VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.tokenType );
6386  VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.stream );
6387  VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.offset );
6388  VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.vertexBindingUnit );
6389  VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.vertexDynamicStride );
6390  VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.pushconstantPipelineLayout );
6391  VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.pushconstantShaderStageFlags );
6392  VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.pushconstantOffset );
6393  VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.pushconstantSize );
6394  VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.indirectStateFlags );
6395  VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.indexTypeCount );
6396  VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.pIndexTypes );
6397  VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.pIndexTypeValues );
6398  return seed;
6399  }
6400  };
6401 
6402  template <>
6403  struct hash<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV>
6404  {
6405  std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV const & indirectCommandsLayoutCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
6406  {
6407  std::size_t seed = 0;
6408  VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoNV.sType );
6409  VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoNV.pNext );
6410  VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoNV.flags );
6411  VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoNV.pipelineBindPoint );
6412  VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoNV.tokenCount );
6413  VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoNV.pTokens );
6414  VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoNV.streamCount );
6415  VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoNV.pStreamStrides );
6416  return seed;
6417  }
6418  };
6419 
6420  template <>
6421  struct hash<VULKAN_HPP_NAMESPACE::InitializePerformanceApiInfoINTEL>
6422  {
6423  std::size_t operator()( VULKAN_HPP_NAMESPACE::InitializePerformanceApiInfoINTEL const & initializePerformanceApiInfoINTEL ) const VULKAN_HPP_NOEXCEPT
6424  {
6425  std::size_t seed = 0;
6426  VULKAN_HPP_HASH_COMBINE( seed, initializePerformanceApiInfoINTEL.sType );
6427  VULKAN_HPP_HASH_COMBINE( seed, initializePerformanceApiInfoINTEL.pNext );
6428  VULKAN_HPP_HASH_COMBINE( seed, initializePerformanceApiInfoINTEL.pUserData );
6429  return seed;
6430  }
6431  };
6432 
6433  template <>
6434  struct hash<VULKAN_HPP_NAMESPACE::InputAttachmentAspectReference>
6435  {
6436  std::size_t operator()( VULKAN_HPP_NAMESPACE::InputAttachmentAspectReference const & inputAttachmentAspectReference ) const VULKAN_HPP_NOEXCEPT
6437  {
6438  std::size_t seed = 0;
6439  VULKAN_HPP_HASH_COMBINE( seed, inputAttachmentAspectReference.subpass );
6440  VULKAN_HPP_HASH_COMBINE( seed, inputAttachmentAspectReference.inputAttachmentIndex );
6441  VULKAN_HPP_HASH_COMBINE( seed, inputAttachmentAspectReference.aspectMask );
6442  return seed;
6443  }
6444  };
6445 
6446  template <>
6447  struct hash<VULKAN_HPP_NAMESPACE::InstanceCreateInfo>
6448  {
6449  std::size_t operator()( VULKAN_HPP_NAMESPACE::InstanceCreateInfo const & instanceCreateInfo ) const VULKAN_HPP_NOEXCEPT
6450  {
6451  std::size_t seed = 0;
6452  VULKAN_HPP_HASH_COMBINE( seed, instanceCreateInfo.sType );
6453  VULKAN_HPP_HASH_COMBINE( seed, instanceCreateInfo.pNext );
6454  VULKAN_HPP_HASH_COMBINE( seed, instanceCreateInfo.flags );
6455  VULKAN_HPP_HASH_COMBINE( seed, instanceCreateInfo.pApplicationInfo );
6456  VULKAN_HPP_HASH_COMBINE( seed, instanceCreateInfo.enabledLayerCount );
6457  for ( size_t i = 0; i < instanceCreateInfo.enabledLayerCount; ++i )
6458  {
6459  for ( const char * p = instanceCreateInfo.ppEnabledLayerNames[i]; *p != '\0'; ++p )
6460  {
6461  VULKAN_HPP_HASH_COMBINE( seed, *p );
6462  }
6463  }
6464  VULKAN_HPP_HASH_COMBINE( seed, instanceCreateInfo.enabledExtensionCount );
6465  for ( size_t i = 0; i < instanceCreateInfo.enabledExtensionCount; ++i )
6466  {
6467  for ( const char * p = instanceCreateInfo.ppEnabledExtensionNames[i]; *p != '\0'; ++p )
6468  {
6469  VULKAN_HPP_HASH_COMBINE( seed, *p );
6470  }
6471  }
6472  return seed;
6473  }
6474  };
6475 
6476  template <>
6477  struct hash<VULKAN_HPP_NAMESPACE::LatencySleepInfoNV>
6478  {
6479  std::size_t operator()( VULKAN_HPP_NAMESPACE::LatencySleepInfoNV const & latencySleepInfoNV ) const VULKAN_HPP_NOEXCEPT
6480  {
6481  std::size_t seed = 0;
6482  VULKAN_HPP_HASH_COMBINE( seed, latencySleepInfoNV.sType );
6483  VULKAN_HPP_HASH_COMBINE( seed, latencySleepInfoNV.pNext );
6484  VULKAN_HPP_HASH_COMBINE( seed, latencySleepInfoNV.signalSemaphore );
6485  VULKAN_HPP_HASH_COMBINE( seed, latencySleepInfoNV.value );
6486  return seed;
6487  }
6488  };
6489 
6490  template <>
6491  struct hash<VULKAN_HPP_NAMESPACE::LatencySleepModeInfoNV>
6492  {
6493  std::size_t operator()( VULKAN_HPP_NAMESPACE::LatencySleepModeInfoNV const & latencySleepModeInfoNV ) const VULKAN_HPP_NOEXCEPT
6494  {
6495  std::size_t seed = 0;
6496  VULKAN_HPP_HASH_COMBINE( seed, latencySleepModeInfoNV.sType );
6497  VULKAN_HPP_HASH_COMBINE( seed, latencySleepModeInfoNV.pNext );
6498  VULKAN_HPP_HASH_COMBINE( seed, latencySleepModeInfoNV.lowLatencyMode );
6499  VULKAN_HPP_HASH_COMBINE( seed, latencySleepModeInfoNV.lowLatencyBoost );
6500  VULKAN_HPP_HASH_COMBINE( seed, latencySleepModeInfoNV.minimumIntervalUs );
6501  return seed;
6502  }
6503  };
6504 
6505  template <>
6506  struct hash<VULKAN_HPP_NAMESPACE::LatencySubmissionPresentIdNV>
6507  {
6508  std::size_t operator()( VULKAN_HPP_NAMESPACE::LatencySubmissionPresentIdNV const & latencySubmissionPresentIdNV ) const VULKAN_HPP_NOEXCEPT
6509  {
6510  std::size_t seed = 0;
6511  VULKAN_HPP_HASH_COMBINE( seed, latencySubmissionPresentIdNV.sType );
6512  VULKAN_HPP_HASH_COMBINE( seed, latencySubmissionPresentIdNV.pNext );
6513  VULKAN_HPP_HASH_COMBINE( seed, latencySubmissionPresentIdNV.presentID );
6514  return seed;
6515  }
6516  };
6517 
6518  template <>
6519  struct hash<VULKAN_HPP_NAMESPACE::LatencySurfaceCapabilitiesNV>
6520  {
6521  std::size_t operator()( VULKAN_HPP_NAMESPACE::LatencySurfaceCapabilitiesNV const & latencySurfaceCapabilitiesNV ) const VULKAN_HPP_NOEXCEPT
6522  {
6523  std::size_t seed = 0;
6524  VULKAN_HPP_HASH_COMBINE( seed, latencySurfaceCapabilitiesNV.sType );
6525  VULKAN_HPP_HASH_COMBINE( seed, latencySurfaceCapabilitiesNV.pNext );
6526  VULKAN_HPP_HASH_COMBINE( seed, latencySurfaceCapabilitiesNV.presentModeCount );
6527  VULKAN_HPP_HASH_COMBINE( seed, latencySurfaceCapabilitiesNV.pPresentModes );
6528  return seed;
6529  }
6530  };
6531 
6532  template <>
6533  struct hash<VULKAN_HPP_NAMESPACE::LayerProperties>
6534  {
6535  std::size_t operator()( VULKAN_HPP_NAMESPACE::LayerProperties const & layerProperties ) const VULKAN_HPP_NOEXCEPT
6536  {
6537  std::size_t seed = 0;
6538  for ( size_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i )
6539  {
6540  VULKAN_HPP_HASH_COMBINE( seed, layerProperties.layerName[i] );
6541  }
6542  VULKAN_HPP_HASH_COMBINE( seed, layerProperties.specVersion );
6543  VULKAN_HPP_HASH_COMBINE( seed, layerProperties.implementationVersion );
6544  for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i )
6545  {
6546  VULKAN_HPP_HASH_COMBINE( seed, layerProperties.description[i] );
6547  }
6548  return seed;
6549  }
6550  };
6551 
6552  template <>
6553  struct hash<VULKAN_HPP_NAMESPACE::LayerSettingEXT>
6554  {
6555  std::size_t operator()( VULKAN_HPP_NAMESPACE::LayerSettingEXT const & layerSettingEXT ) const VULKAN_HPP_NOEXCEPT
6556  {
6557  std::size_t seed = 0;
6558  for ( const char * p = layerSettingEXT.pLayerName; *p != '\0'; ++p )
6559  {
6560  VULKAN_HPP_HASH_COMBINE( seed, *p );
6561  }
6562  for ( const char * p = layerSettingEXT.pSettingName; *p != '\0'; ++p )
6563  {
6564  VULKAN_HPP_HASH_COMBINE( seed, *p );
6565  }
6566  VULKAN_HPP_HASH_COMBINE( seed, layerSettingEXT.type );
6567  VULKAN_HPP_HASH_COMBINE( seed, layerSettingEXT.valueCount );
6568  VULKAN_HPP_HASH_COMBINE( seed, layerSettingEXT.pValues );
6569  return seed;
6570  }
6571  };
6572 
6573  template <>
6574  struct hash<VULKAN_HPP_NAMESPACE::LayerSettingsCreateInfoEXT>
6575  {
6576  std::size_t operator()( VULKAN_HPP_NAMESPACE::LayerSettingsCreateInfoEXT const & layerSettingsCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
6577  {
6578  std::size_t seed = 0;
6579  VULKAN_HPP_HASH_COMBINE( seed, layerSettingsCreateInfoEXT.sType );
6580  VULKAN_HPP_HASH_COMBINE( seed, layerSettingsCreateInfoEXT.pNext );
6581  VULKAN_HPP_HASH_COMBINE( seed, layerSettingsCreateInfoEXT.settingCount );
6582  VULKAN_HPP_HASH_COMBINE( seed, layerSettingsCreateInfoEXT.pSettings );
6583  return seed;
6584  }
6585  };
6586 
6587 # if defined( VK_USE_PLATFORM_MACOS_MVK )
6588  template <>
6589  struct hash<VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK>
6590  {
6591  std::size_t operator()( VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK const & macOSSurfaceCreateInfoMVK ) const VULKAN_HPP_NOEXCEPT
6592  {
6593  std::size_t seed = 0;
6594  VULKAN_HPP_HASH_COMBINE( seed, macOSSurfaceCreateInfoMVK.sType );
6595  VULKAN_HPP_HASH_COMBINE( seed, macOSSurfaceCreateInfoMVK.pNext );
6596  VULKAN_HPP_HASH_COMBINE( seed, macOSSurfaceCreateInfoMVK.flags );
6597  VULKAN_HPP_HASH_COMBINE( seed, macOSSurfaceCreateInfoMVK.pView );
6598  return seed;
6599  }
6600  };
6601 # endif /*VK_USE_PLATFORM_MACOS_MVK*/
6602 
6603  template <>
6604  struct hash<VULKAN_HPP_NAMESPACE::MappedMemoryRange>
6605  {
6606  std::size_t operator()( VULKAN_HPP_NAMESPACE::MappedMemoryRange const & mappedMemoryRange ) const VULKAN_HPP_NOEXCEPT
6607  {
6608  std::size_t seed = 0;
6609  VULKAN_HPP_HASH_COMBINE( seed, mappedMemoryRange.sType );
6610  VULKAN_HPP_HASH_COMBINE( seed, mappedMemoryRange.pNext );
6611  VULKAN_HPP_HASH_COMBINE( seed, mappedMemoryRange.memory );
6612  VULKAN_HPP_HASH_COMBINE( seed, mappedMemoryRange.offset );
6613  VULKAN_HPP_HASH_COMBINE( seed, mappedMemoryRange.size );
6614  return seed;
6615  }
6616  };
6617 
6618  template <>
6619  struct hash<VULKAN_HPP_NAMESPACE::MemoryAllocateFlagsInfo>
6620  {
6621  std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryAllocateFlagsInfo const & memoryAllocateFlagsInfo ) const VULKAN_HPP_NOEXCEPT
6622  {
6623  std::size_t seed = 0;
6624  VULKAN_HPP_HASH_COMBINE( seed, memoryAllocateFlagsInfo.sType );
6625  VULKAN_HPP_HASH_COMBINE( seed, memoryAllocateFlagsInfo.pNext );
6626  VULKAN_HPP_HASH_COMBINE( seed, memoryAllocateFlagsInfo.flags );
6627  VULKAN_HPP_HASH_COMBINE( seed, memoryAllocateFlagsInfo.deviceMask );
6628  return seed;
6629  }
6630  };
6631 
6632  template <>
6633  struct hash<VULKAN_HPP_NAMESPACE::MemoryAllocateInfo>
6634  {
6635  std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryAllocateInfo const & memoryAllocateInfo ) const VULKAN_HPP_NOEXCEPT
6636  {
6637  std::size_t seed = 0;
6638  VULKAN_HPP_HASH_COMBINE( seed, memoryAllocateInfo.sType );
6639  VULKAN_HPP_HASH_COMBINE( seed, memoryAllocateInfo.pNext );
6640  VULKAN_HPP_HASH_COMBINE( seed, memoryAllocateInfo.allocationSize );
6641  VULKAN_HPP_HASH_COMBINE( seed, memoryAllocateInfo.memoryTypeIndex );
6642  return seed;
6643  }
6644  };
6645 
6646  template <>
6647  struct hash<VULKAN_HPP_NAMESPACE::MemoryBarrier>
6648  {
6649  std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryBarrier const & memoryBarrier ) const VULKAN_HPP_NOEXCEPT
6650  {
6651  std::size_t seed = 0;
6652  VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier.sType );
6653  VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier.pNext );
6654  VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier.srcAccessMask );
6655  VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier.dstAccessMask );
6656  return seed;
6657  }
6658  };
6659 
6660  template <>
6661  struct hash<VULKAN_HPP_NAMESPACE::MemoryDedicatedAllocateInfo>
6662  {
6663  std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryDedicatedAllocateInfo const & memoryDedicatedAllocateInfo ) const VULKAN_HPP_NOEXCEPT
6664  {
6665  std::size_t seed = 0;
6666  VULKAN_HPP_HASH_COMBINE( seed, memoryDedicatedAllocateInfo.sType );
6667  VULKAN_HPP_HASH_COMBINE( seed, memoryDedicatedAllocateInfo.pNext );
6668  VULKAN_HPP_HASH_COMBINE( seed, memoryDedicatedAllocateInfo.image );
6669  VULKAN_HPP_HASH_COMBINE( seed, memoryDedicatedAllocateInfo.buffer );
6670  return seed;
6671  }
6672  };
6673 
6674  template <>
6675  struct hash<VULKAN_HPP_NAMESPACE::MemoryDedicatedRequirements>
6676  {
6677  std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryDedicatedRequirements const & memoryDedicatedRequirements ) const VULKAN_HPP_NOEXCEPT
6678  {
6679  std::size_t seed = 0;
6680  VULKAN_HPP_HASH_COMBINE( seed, memoryDedicatedRequirements.sType );
6681  VULKAN_HPP_HASH_COMBINE( seed, memoryDedicatedRequirements.pNext );
6682  VULKAN_HPP_HASH_COMBINE( seed, memoryDedicatedRequirements.prefersDedicatedAllocation );
6683  VULKAN_HPP_HASH_COMBINE( seed, memoryDedicatedRequirements.requiresDedicatedAllocation );
6684  return seed;
6685  }
6686  };
6687 
6688  template <>
6689  struct hash<VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR>
6690  {
6691  std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR const & memoryFdPropertiesKHR ) const VULKAN_HPP_NOEXCEPT
6692  {
6693  std::size_t seed = 0;
6694  VULKAN_HPP_HASH_COMBINE( seed, memoryFdPropertiesKHR.sType );
6695  VULKAN_HPP_HASH_COMBINE( seed, memoryFdPropertiesKHR.pNext );
6696  VULKAN_HPP_HASH_COMBINE( seed, memoryFdPropertiesKHR.memoryTypeBits );
6697  return seed;
6698  }
6699  };
6700 
6701 # if defined( VK_USE_PLATFORM_ANDROID_KHR )
6702  template <>
6703  struct hash<VULKAN_HPP_NAMESPACE::MemoryGetAndroidHardwareBufferInfoANDROID>
6704  {
6705  std::size_t
6706  operator()( VULKAN_HPP_NAMESPACE::MemoryGetAndroidHardwareBufferInfoANDROID const & memoryGetAndroidHardwareBufferInfoANDROID ) const VULKAN_HPP_NOEXCEPT
6707  {
6708  std::size_t seed = 0;
6709  VULKAN_HPP_HASH_COMBINE( seed, memoryGetAndroidHardwareBufferInfoANDROID.sType );
6710  VULKAN_HPP_HASH_COMBINE( seed, memoryGetAndroidHardwareBufferInfoANDROID.pNext );
6711  VULKAN_HPP_HASH_COMBINE( seed, memoryGetAndroidHardwareBufferInfoANDROID.memory );
6712  return seed;
6713  }
6714  };
6715 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/
6716 
6717  template <>
6718  struct hash<VULKAN_HPP_NAMESPACE::MemoryGetFdInfoKHR>
6719  {
6720  std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryGetFdInfoKHR const & memoryGetFdInfoKHR ) const VULKAN_HPP_NOEXCEPT
6721  {
6722  std::size_t seed = 0;
6723  VULKAN_HPP_HASH_COMBINE( seed, memoryGetFdInfoKHR.sType );
6724  VULKAN_HPP_HASH_COMBINE( seed, memoryGetFdInfoKHR.pNext );
6725  VULKAN_HPP_HASH_COMBINE( seed, memoryGetFdInfoKHR.memory );
6726  VULKAN_HPP_HASH_COMBINE( seed, memoryGetFdInfoKHR.handleType );
6727  return seed;
6728  }
6729  };
6730 
6731  template <>
6732  struct hash<VULKAN_HPP_NAMESPACE::MemoryGetRemoteAddressInfoNV>
6733  {
6734  std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryGetRemoteAddressInfoNV const & memoryGetRemoteAddressInfoNV ) const VULKAN_HPP_NOEXCEPT
6735  {
6736  std::size_t seed = 0;
6737  VULKAN_HPP_HASH_COMBINE( seed, memoryGetRemoteAddressInfoNV.sType );
6738  VULKAN_HPP_HASH_COMBINE( seed, memoryGetRemoteAddressInfoNV.pNext );
6739  VULKAN_HPP_HASH_COMBINE( seed, memoryGetRemoteAddressInfoNV.memory );
6740  VULKAN_HPP_HASH_COMBINE( seed, memoryGetRemoteAddressInfoNV.handleType );
6741  return seed;
6742  }
6743  };
6744 
6745 # if defined( VK_USE_PLATFORM_WIN32_KHR )
6746  template <>
6747  struct hash<VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR>
6748  {
6749  std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR const & memoryGetWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT
6750  {
6751  std::size_t seed = 0;
6752  VULKAN_HPP_HASH_COMBINE( seed, memoryGetWin32HandleInfoKHR.sType );
6753  VULKAN_HPP_HASH_COMBINE( seed, memoryGetWin32HandleInfoKHR.pNext );
6754  VULKAN_HPP_HASH_COMBINE( seed, memoryGetWin32HandleInfoKHR.memory );
6755  VULKAN_HPP_HASH_COMBINE( seed, memoryGetWin32HandleInfoKHR.handleType );
6756  return seed;
6757  }
6758  };
6759 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
6760 
6761 # if defined( VK_USE_PLATFORM_FUCHSIA )
6762  template <>
6763  struct hash<VULKAN_HPP_NAMESPACE::MemoryGetZirconHandleInfoFUCHSIA>
6764  {
6765  std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryGetZirconHandleInfoFUCHSIA const & memoryGetZirconHandleInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT
6766  {
6767  std::size_t seed = 0;
6768  VULKAN_HPP_HASH_COMBINE( seed, memoryGetZirconHandleInfoFUCHSIA.sType );
6769  VULKAN_HPP_HASH_COMBINE( seed, memoryGetZirconHandleInfoFUCHSIA.pNext );
6770  VULKAN_HPP_HASH_COMBINE( seed, memoryGetZirconHandleInfoFUCHSIA.memory );
6771  VULKAN_HPP_HASH_COMBINE( seed, memoryGetZirconHandleInfoFUCHSIA.handleType );
6772  return seed;
6773  }
6774  };
6775 # endif /*VK_USE_PLATFORM_FUCHSIA*/
6776 
6777  template <>
6778  struct hash<VULKAN_HPP_NAMESPACE::MemoryHeap>
6779  {
6780  std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryHeap const & memoryHeap ) const VULKAN_HPP_NOEXCEPT
6781  {
6782  std::size_t seed = 0;
6783  VULKAN_HPP_HASH_COMBINE( seed, memoryHeap.size );
6784  VULKAN_HPP_HASH_COMBINE( seed, memoryHeap.flags );
6785  return seed;
6786  }
6787  };
6788 
6789  template <>
6790  struct hash<VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT>
6791  {
6792  std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT const & memoryHostPointerPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
6793  {
6794  std::size_t seed = 0;
6795  VULKAN_HPP_HASH_COMBINE( seed, memoryHostPointerPropertiesEXT.sType );
6796  VULKAN_HPP_HASH_COMBINE( seed, memoryHostPointerPropertiesEXT.pNext );
6797  VULKAN_HPP_HASH_COMBINE( seed, memoryHostPointerPropertiesEXT.memoryTypeBits );
6798  return seed;
6799  }
6800  };
6801 
6802  template <>
6803  struct hash<VULKAN_HPP_NAMESPACE::MemoryMapInfoKHR>
6804  {
6805  std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryMapInfoKHR const & memoryMapInfoKHR ) const VULKAN_HPP_NOEXCEPT
6806  {
6807  std::size_t seed = 0;
6808  VULKAN_HPP_HASH_COMBINE( seed, memoryMapInfoKHR.sType );
6809  VULKAN_HPP_HASH_COMBINE( seed, memoryMapInfoKHR.pNext );
6810  VULKAN_HPP_HASH_COMBINE( seed, memoryMapInfoKHR.flags );
6811  VULKAN_HPP_HASH_COMBINE( seed, memoryMapInfoKHR.memory );
6812  VULKAN_HPP_HASH_COMBINE( seed, memoryMapInfoKHR.offset );
6813  VULKAN_HPP_HASH_COMBINE( seed, memoryMapInfoKHR.size );
6814  return seed;
6815  }
6816  };
6817 
6818  template <>
6819  struct hash<VULKAN_HPP_NAMESPACE::MemoryOpaqueCaptureAddressAllocateInfo>
6820  {
6821  std::size_t
6822  operator()( VULKAN_HPP_NAMESPACE::MemoryOpaqueCaptureAddressAllocateInfo const & memoryOpaqueCaptureAddressAllocateInfo ) const VULKAN_HPP_NOEXCEPT
6823  {
6824  std::size_t seed = 0;
6825  VULKAN_HPP_HASH_COMBINE( seed, memoryOpaqueCaptureAddressAllocateInfo.sType );
6826  VULKAN_HPP_HASH_COMBINE( seed, memoryOpaqueCaptureAddressAllocateInfo.pNext );
6827  VULKAN_HPP_HASH_COMBINE( seed, memoryOpaqueCaptureAddressAllocateInfo.opaqueCaptureAddress );
6828  return seed;
6829  }
6830  };
6831 
6832  template <>
6833  struct hash<VULKAN_HPP_NAMESPACE::MemoryPriorityAllocateInfoEXT>
6834  {
6835  std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryPriorityAllocateInfoEXT const & memoryPriorityAllocateInfoEXT ) const VULKAN_HPP_NOEXCEPT
6836  {
6837  std::size_t seed = 0;
6838  VULKAN_HPP_HASH_COMBINE( seed, memoryPriorityAllocateInfoEXT.sType );
6839  VULKAN_HPP_HASH_COMBINE( seed, memoryPriorityAllocateInfoEXT.pNext );
6840  VULKAN_HPP_HASH_COMBINE( seed, memoryPriorityAllocateInfoEXT.priority );
6841  return seed;
6842  }
6843  };
6844 
6845  template <>
6846  struct hash<VULKAN_HPP_NAMESPACE::MemoryRequirements>
6847  {
6848  std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryRequirements const & memoryRequirements ) const VULKAN_HPP_NOEXCEPT
6849  {
6850  std::size_t seed = 0;
6851  VULKAN_HPP_HASH_COMBINE( seed, memoryRequirements.size );
6852  VULKAN_HPP_HASH_COMBINE( seed, memoryRequirements.alignment );
6853  VULKAN_HPP_HASH_COMBINE( seed, memoryRequirements.memoryTypeBits );
6854  return seed;
6855  }
6856  };
6857 
6858  template <>
6859  struct hash<VULKAN_HPP_NAMESPACE::MemoryRequirements2>
6860  {
6861  std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryRequirements2 const & memoryRequirements2 ) const VULKAN_HPP_NOEXCEPT
6862  {
6863  std::size_t seed = 0;
6864  VULKAN_HPP_HASH_COMBINE( seed, memoryRequirements2.sType );
6865  VULKAN_HPP_HASH_COMBINE( seed, memoryRequirements2.pNext );
6866  VULKAN_HPP_HASH_COMBINE( seed, memoryRequirements2.memoryRequirements );
6867  return seed;
6868  }
6869  };
6870 
6871  template <>
6872  struct hash<VULKAN_HPP_NAMESPACE::MemoryType>
6873  {
6874  std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryType const & memoryType ) const VULKAN_HPP_NOEXCEPT
6875  {
6876  std::size_t seed = 0;
6877  VULKAN_HPP_HASH_COMBINE( seed, memoryType.propertyFlags );
6878  VULKAN_HPP_HASH_COMBINE( seed, memoryType.heapIndex );
6879  return seed;
6880  }
6881  };
6882 
6883  template <>
6884  struct hash<VULKAN_HPP_NAMESPACE::MemoryUnmapInfoKHR>
6885  {
6886  std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryUnmapInfoKHR const & memoryUnmapInfoKHR ) const VULKAN_HPP_NOEXCEPT
6887  {
6888  std::size_t seed = 0;
6889  VULKAN_HPP_HASH_COMBINE( seed, memoryUnmapInfoKHR.sType );
6890  VULKAN_HPP_HASH_COMBINE( seed, memoryUnmapInfoKHR.pNext );
6891  VULKAN_HPP_HASH_COMBINE( seed, memoryUnmapInfoKHR.flags );
6892  VULKAN_HPP_HASH_COMBINE( seed, memoryUnmapInfoKHR.memory );
6893  return seed;
6894  }
6895  };
6896 
6897 # if defined( VK_USE_PLATFORM_WIN32_KHR )
6898  template <>
6899  struct hash<VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR>
6900  {
6901  std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR const & memoryWin32HandlePropertiesKHR ) const VULKAN_HPP_NOEXCEPT
6902  {
6903  std::size_t seed = 0;
6904  VULKAN_HPP_HASH_COMBINE( seed, memoryWin32HandlePropertiesKHR.sType );
6905  VULKAN_HPP_HASH_COMBINE( seed, memoryWin32HandlePropertiesKHR.pNext );
6906  VULKAN_HPP_HASH_COMBINE( seed, memoryWin32HandlePropertiesKHR.memoryTypeBits );
6907  return seed;
6908  }
6909  };
6910 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
6911 
6912 # if defined( VK_USE_PLATFORM_FUCHSIA )
6913  template <>
6914  struct hash<VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA>
6915  {
6916  std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA const & memoryZirconHandlePropertiesFUCHSIA ) const VULKAN_HPP_NOEXCEPT
6917  {
6918  std::size_t seed = 0;
6919  VULKAN_HPP_HASH_COMBINE( seed, memoryZirconHandlePropertiesFUCHSIA.sType );
6920  VULKAN_HPP_HASH_COMBINE( seed, memoryZirconHandlePropertiesFUCHSIA.pNext );
6921  VULKAN_HPP_HASH_COMBINE( seed, memoryZirconHandlePropertiesFUCHSIA.memoryTypeBits );
6922  return seed;
6923  }
6924  };
6925 # endif /*VK_USE_PLATFORM_FUCHSIA*/
6926 
6927 # if defined( VK_USE_PLATFORM_METAL_EXT )
6928  template <>
6929  struct hash<VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT>
6930  {
6931  std::size_t operator()( VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT const & metalSurfaceCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
6932  {
6933  std::size_t seed = 0;
6934  VULKAN_HPP_HASH_COMBINE( seed, metalSurfaceCreateInfoEXT.sType );
6935  VULKAN_HPP_HASH_COMBINE( seed, metalSurfaceCreateInfoEXT.pNext );
6936  VULKAN_HPP_HASH_COMBINE( seed, metalSurfaceCreateInfoEXT.flags );
6937  VULKAN_HPP_HASH_COMBINE( seed, metalSurfaceCreateInfoEXT.pLayer );
6938  return seed;
6939  }
6940  };
6941 # endif /*VK_USE_PLATFORM_METAL_EXT*/
6942 
6943  template <>
6944  struct hash<VULKAN_HPP_NAMESPACE::MicromapBuildSizesInfoEXT>
6945  {
6946  std::size_t operator()( VULKAN_HPP_NAMESPACE::MicromapBuildSizesInfoEXT const & micromapBuildSizesInfoEXT ) const VULKAN_HPP_NOEXCEPT
6947  {
6948  std::size_t seed = 0;
6949  VULKAN_HPP_HASH_COMBINE( seed, micromapBuildSizesInfoEXT.sType );
6950  VULKAN_HPP_HASH_COMBINE( seed, micromapBuildSizesInfoEXT.pNext );
6951  VULKAN_HPP_HASH_COMBINE( seed, micromapBuildSizesInfoEXT.micromapSize );
6952  VULKAN_HPP_HASH_COMBINE( seed, micromapBuildSizesInfoEXT.buildScratchSize );
6953  VULKAN_HPP_HASH_COMBINE( seed, micromapBuildSizesInfoEXT.discardable );
6954  return seed;
6955  }
6956  };
6957 
6958  template <>
6959  struct hash<VULKAN_HPP_NAMESPACE::MicromapCreateInfoEXT>
6960  {
6961  std::size_t operator()( VULKAN_HPP_NAMESPACE::MicromapCreateInfoEXT const & micromapCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
6962  {
6963  std::size_t seed = 0;
6964  VULKAN_HPP_HASH_COMBINE( seed, micromapCreateInfoEXT.sType );
6965  VULKAN_HPP_HASH_COMBINE( seed, micromapCreateInfoEXT.pNext );
6966  VULKAN_HPP_HASH_COMBINE( seed, micromapCreateInfoEXT.createFlags );
6967  VULKAN_HPP_HASH_COMBINE( seed, micromapCreateInfoEXT.buffer );
6968  VULKAN_HPP_HASH_COMBINE( seed, micromapCreateInfoEXT.offset );
6969  VULKAN_HPP_HASH_COMBINE( seed, micromapCreateInfoEXT.size );
6970  VULKAN_HPP_HASH_COMBINE( seed, micromapCreateInfoEXT.type );
6971  VULKAN_HPP_HASH_COMBINE( seed, micromapCreateInfoEXT.deviceAddress );
6972  return seed;
6973  }
6974  };
6975 
6976  template <>
6977  struct hash<VULKAN_HPP_NAMESPACE::MicromapTriangleEXT>
6978  {
6979  std::size_t operator()( VULKAN_HPP_NAMESPACE::MicromapTriangleEXT const & micromapTriangleEXT ) const VULKAN_HPP_NOEXCEPT
6980  {
6981  std::size_t seed = 0;
6982  VULKAN_HPP_HASH_COMBINE( seed, micromapTriangleEXT.dataOffset );
6983  VULKAN_HPP_HASH_COMBINE( seed, micromapTriangleEXT.subdivisionLevel );
6984  VULKAN_HPP_HASH_COMBINE( seed, micromapTriangleEXT.format );
6985  return seed;
6986  }
6987  };
6988 
6989  template <>
6990  struct hash<VULKAN_HPP_NAMESPACE::MicromapVersionInfoEXT>
6991  {
6992  std::size_t operator()( VULKAN_HPP_NAMESPACE::MicromapVersionInfoEXT const & micromapVersionInfoEXT ) const VULKAN_HPP_NOEXCEPT
6993  {
6994  std::size_t seed = 0;
6995  VULKAN_HPP_HASH_COMBINE( seed, micromapVersionInfoEXT.sType );
6996  VULKAN_HPP_HASH_COMBINE( seed, micromapVersionInfoEXT.pNext );
6997  VULKAN_HPP_HASH_COMBINE( seed, micromapVersionInfoEXT.pVersionData );
6998  return seed;
6999  }
7000  };
7001 
7002  template <>
7003  struct hash<VULKAN_HPP_NAMESPACE::MultiDrawIndexedInfoEXT>
7004  {
7005  std::size_t operator()( VULKAN_HPP_NAMESPACE::MultiDrawIndexedInfoEXT const & multiDrawIndexedInfoEXT ) const VULKAN_HPP_NOEXCEPT
7006  {
7007  std::size_t seed = 0;
7008  VULKAN_HPP_HASH_COMBINE( seed, multiDrawIndexedInfoEXT.firstIndex );
7009  VULKAN_HPP_HASH_COMBINE( seed, multiDrawIndexedInfoEXT.indexCount );
7010  VULKAN_HPP_HASH_COMBINE( seed, multiDrawIndexedInfoEXT.vertexOffset );
7011  return seed;
7012  }
7013  };
7014 
7015  template <>
7016  struct hash<VULKAN_HPP_NAMESPACE::MultiDrawInfoEXT>
7017  {
7018  std::size_t operator()( VULKAN_HPP_NAMESPACE::MultiDrawInfoEXT const & multiDrawInfoEXT ) const VULKAN_HPP_NOEXCEPT
7019  {
7020  std::size_t seed = 0;
7021  VULKAN_HPP_HASH_COMBINE( seed, multiDrawInfoEXT.firstVertex );
7022  VULKAN_HPP_HASH_COMBINE( seed, multiDrawInfoEXT.vertexCount );
7023  return seed;
7024  }
7025  };
7026 
7027  template <>
7028  struct hash<VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT>
7029  {
7030  std::size_t operator()( VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT const & multisamplePropertiesEXT ) const VULKAN_HPP_NOEXCEPT
7031  {
7032  std::size_t seed = 0;
7033  VULKAN_HPP_HASH_COMBINE( seed, multisamplePropertiesEXT.sType );
7034  VULKAN_HPP_HASH_COMBINE( seed, multisamplePropertiesEXT.pNext );
7035  VULKAN_HPP_HASH_COMBINE( seed, multisamplePropertiesEXT.maxSampleLocationGridSize );
7036  return seed;
7037  }
7038  };
7039 
7040  template <>
7041  struct hash<VULKAN_HPP_NAMESPACE::MultisampledRenderToSingleSampledInfoEXT>
7042  {
7043  std::size_t
7044  operator()( VULKAN_HPP_NAMESPACE::MultisampledRenderToSingleSampledInfoEXT const & multisampledRenderToSingleSampledInfoEXT ) const VULKAN_HPP_NOEXCEPT
7045  {
7046  std::size_t seed = 0;
7047  VULKAN_HPP_HASH_COMBINE( seed, multisampledRenderToSingleSampledInfoEXT.sType );
7048  VULKAN_HPP_HASH_COMBINE( seed, multisampledRenderToSingleSampledInfoEXT.pNext );
7049  VULKAN_HPP_HASH_COMBINE( seed, multisampledRenderToSingleSampledInfoEXT.multisampledRenderToSingleSampledEnable );
7050  VULKAN_HPP_HASH_COMBINE( seed, multisampledRenderToSingleSampledInfoEXT.rasterizationSamples );
7051  return seed;
7052  }
7053  };
7054 
7055  template <>
7056  struct hash<VULKAN_HPP_NAMESPACE::MultiviewPerViewAttributesInfoNVX>
7057  {
7058  std::size_t operator()( VULKAN_HPP_NAMESPACE::MultiviewPerViewAttributesInfoNVX const & multiviewPerViewAttributesInfoNVX ) const VULKAN_HPP_NOEXCEPT
7059  {
7060  std::size_t seed = 0;
7061  VULKAN_HPP_HASH_COMBINE( seed, multiviewPerViewAttributesInfoNVX.sType );
7062  VULKAN_HPP_HASH_COMBINE( seed, multiviewPerViewAttributesInfoNVX.pNext );
7063  VULKAN_HPP_HASH_COMBINE( seed, multiviewPerViewAttributesInfoNVX.perViewAttributes );
7064  VULKAN_HPP_HASH_COMBINE( seed, multiviewPerViewAttributesInfoNVX.perViewAttributesPositionXOnly );
7065  return seed;
7066  }
7067  };
7068 
7069  template <>
7070  struct hash<VULKAN_HPP_NAMESPACE::MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM>
7071  {
7072  std::size_t
7073  operator()( VULKAN_HPP_NAMESPACE::MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM const & multiviewPerViewRenderAreasRenderPassBeginInfoQCOM ) const
7074  VULKAN_HPP_NOEXCEPT
7075  {
7076  std::size_t seed = 0;
7077  VULKAN_HPP_HASH_COMBINE( seed, multiviewPerViewRenderAreasRenderPassBeginInfoQCOM.sType );
7078  VULKAN_HPP_HASH_COMBINE( seed, multiviewPerViewRenderAreasRenderPassBeginInfoQCOM.pNext );
7079  VULKAN_HPP_HASH_COMBINE( seed, multiviewPerViewRenderAreasRenderPassBeginInfoQCOM.perViewRenderAreaCount );
7080  VULKAN_HPP_HASH_COMBINE( seed, multiviewPerViewRenderAreasRenderPassBeginInfoQCOM.pPerViewRenderAreas );
7081  return seed;
7082  }
7083  };
7084 
7085  template <>
7086  struct hash<VULKAN_HPP_NAMESPACE::MutableDescriptorTypeListEXT>
7087  {
7088  std::size_t operator()( VULKAN_HPP_NAMESPACE::MutableDescriptorTypeListEXT const & mutableDescriptorTypeListEXT ) const VULKAN_HPP_NOEXCEPT
7089  {
7090  std::size_t seed = 0;
7091  VULKAN_HPP_HASH_COMBINE( seed, mutableDescriptorTypeListEXT.descriptorTypeCount );
7092  VULKAN_HPP_HASH_COMBINE( seed, mutableDescriptorTypeListEXT.pDescriptorTypes );
7093  return seed;
7094  }
7095  };
7096 
7097  template <>
7098  struct hash<VULKAN_HPP_NAMESPACE::MutableDescriptorTypeCreateInfoEXT>
7099  {
7100  std::size_t operator()( VULKAN_HPP_NAMESPACE::MutableDescriptorTypeCreateInfoEXT const & mutableDescriptorTypeCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
7101  {
7102  std::size_t seed = 0;
7103  VULKAN_HPP_HASH_COMBINE( seed, mutableDescriptorTypeCreateInfoEXT.sType );
7104  VULKAN_HPP_HASH_COMBINE( seed, mutableDescriptorTypeCreateInfoEXT.pNext );
7105  VULKAN_HPP_HASH_COMBINE( seed, mutableDescriptorTypeCreateInfoEXT.mutableDescriptorTypeListCount );
7106  VULKAN_HPP_HASH_COMBINE( seed, mutableDescriptorTypeCreateInfoEXT.pMutableDescriptorTypeLists );
7107  return seed;
7108  }
7109  };
7110 
7111  template <>
7112  struct hash<VULKAN_HPP_NAMESPACE::OpaqueCaptureDescriptorDataCreateInfoEXT>
7113  {
7114  std::size_t
7115  operator()( VULKAN_HPP_NAMESPACE::OpaqueCaptureDescriptorDataCreateInfoEXT const & opaqueCaptureDescriptorDataCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
7116  {
7117  std::size_t seed = 0;
7118  VULKAN_HPP_HASH_COMBINE( seed, opaqueCaptureDescriptorDataCreateInfoEXT.sType );
7119  VULKAN_HPP_HASH_COMBINE( seed, opaqueCaptureDescriptorDataCreateInfoEXT.pNext );
7120  VULKAN_HPP_HASH_COMBINE( seed, opaqueCaptureDescriptorDataCreateInfoEXT.opaqueCaptureDescriptorData );
7121  return seed;
7122  }
7123  };
7124 
7125  template <>
7126  struct hash<VULKAN_HPP_NAMESPACE::OpticalFlowExecuteInfoNV>
7127  {
7128  std::size_t operator()( VULKAN_HPP_NAMESPACE::OpticalFlowExecuteInfoNV const & opticalFlowExecuteInfoNV ) const VULKAN_HPP_NOEXCEPT
7129  {
7130  std::size_t seed = 0;
7131  VULKAN_HPP_HASH_COMBINE( seed, opticalFlowExecuteInfoNV.sType );
7132  VULKAN_HPP_HASH_COMBINE( seed, opticalFlowExecuteInfoNV.pNext );
7133  VULKAN_HPP_HASH_COMBINE( seed, opticalFlowExecuteInfoNV.flags );
7134  VULKAN_HPP_HASH_COMBINE( seed, opticalFlowExecuteInfoNV.regionCount );
7135  VULKAN_HPP_HASH_COMBINE( seed, opticalFlowExecuteInfoNV.pRegions );
7136  return seed;
7137  }
7138  };
7139 
7140  template <>
7141  struct hash<VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatInfoNV>
7142  {
7143  std::size_t operator()( VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatInfoNV const & opticalFlowImageFormatInfoNV ) const VULKAN_HPP_NOEXCEPT
7144  {
7145  std::size_t seed = 0;
7146  VULKAN_HPP_HASH_COMBINE( seed, opticalFlowImageFormatInfoNV.sType );
7147  VULKAN_HPP_HASH_COMBINE( seed, opticalFlowImageFormatInfoNV.pNext );
7148  VULKAN_HPP_HASH_COMBINE( seed, opticalFlowImageFormatInfoNV.usage );
7149  return seed;
7150  }
7151  };
7152 
7153  template <>
7154  struct hash<VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV>
7155  {
7156  std::size_t operator()( VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV const & opticalFlowImageFormatPropertiesNV ) const VULKAN_HPP_NOEXCEPT
7157  {
7158  std::size_t seed = 0;
7159  VULKAN_HPP_HASH_COMBINE( seed, opticalFlowImageFormatPropertiesNV.sType );
7160  VULKAN_HPP_HASH_COMBINE( seed, opticalFlowImageFormatPropertiesNV.pNext );
7161  VULKAN_HPP_HASH_COMBINE( seed, opticalFlowImageFormatPropertiesNV.format );
7162  return seed;
7163  }
7164  };
7165 
7166  template <>
7167  struct hash<VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreateInfoNV>
7168  {
7169  std::size_t operator()( VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreateInfoNV const & opticalFlowSessionCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
7170  {
7171  std::size_t seed = 0;
7172  VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.sType );
7173  VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.pNext );
7174  VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.width );
7175  VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.height );
7176  VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.imageFormat );
7177  VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.flowVectorFormat );
7178  VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.costFormat );
7179  VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.outputGridSize );
7180  VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.hintGridSize );
7181  VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.performanceLevel );
7182  VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.flags );
7183  return seed;
7184  }
7185  };
7186 
7187  template <>
7188  struct hash<VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreatePrivateDataInfoNV>
7189  {
7190  std::size_t
7191  operator()( VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreatePrivateDataInfoNV const & opticalFlowSessionCreatePrivateDataInfoNV ) const VULKAN_HPP_NOEXCEPT
7192  {
7193  std::size_t seed = 0;
7194  VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreatePrivateDataInfoNV.sType );
7195  VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreatePrivateDataInfoNV.pNext );
7196  VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreatePrivateDataInfoNV.id );
7197  VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreatePrivateDataInfoNV.size );
7198  VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreatePrivateDataInfoNV.pPrivateData );
7199  return seed;
7200  }
7201  };
7202 
7203  template <>
7204  struct hash<VULKAN_HPP_NAMESPACE::OutOfBandQueueTypeInfoNV>
7205  {
7206  std::size_t operator()( VULKAN_HPP_NAMESPACE::OutOfBandQueueTypeInfoNV const & outOfBandQueueTypeInfoNV ) const VULKAN_HPP_NOEXCEPT
7207  {
7208  std::size_t seed = 0;
7209  VULKAN_HPP_HASH_COMBINE( seed, outOfBandQueueTypeInfoNV.sType );
7210  VULKAN_HPP_HASH_COMBINE( seed, outOfBandQueueTypeInfoNV.pNext );
7211  VULKAN_HPP_HASH_COMBINE( seed, outOfBandQueueTypeInfoNV.queueType );
7212  return seed;
7213  }
7214  };
7215 
7216  template <>
7217  struct hash<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE>
7218  {
7219  std::size_t operator()( VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE const & pastPresentationTimingGOOGLE ) const VULKAN_HPP_NOEXCEPT
7220  {
7221  std::size_t seed = 0;
7222  VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingGOOGLE.presentID );
7223  VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingGOOGLE.desiredPresentTime );
7224  VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingGOOGLE.actualPresentTime );
7225  VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingGOOGLE.earliestPresentTime );
7226  VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingGOOGLE.presentMargin );
7227  return seed;
7228  }
7229  };
7230 
7231  template <>
7232  struct hash<VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL>
7233  {
7234  std::size_t
7235  operator()( VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL const & performanceConfigurationAcquireInfoINTEL ) const VULKAN_HPP_NOEXCEPT
7236  {
7237  std::size_t seed = 0;
7238  VULKAN_HPP_HASH_COMBINE( seed, performanceConfigurationAcquireInfoINTEL.sType );
7239  VULKAN_HPP_HASH_COMBINE( seed, performanceConfigurationAcquireInfoINTEL.pNext );
7240  VULKAN_HPP_HASH_COMBINE( seed, performanceConfigurationAcquireInfoINTEL.type );
7241  return seed;
7242  }
7243  };
7244 
7245  template <>
7246  struct hash<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR>
7247  {
7248  std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR const & performanceCounterDescriptionKHR ) const VULKAN_HPP_NOEXCEPT
7249  {
7250  std::size_t seed = 0;
7251  VULKAN_HPP_HASH_COMBINE( seed, performanceCounterDescriptionKHR.sType );
7252  VULKAN_HPP_HASH_COMBINE( seed, performanceCounterDescriptionKHR.pNext );
7253  VULKAN_HPP_HASH_COMBINE( seed, performanceCounterDescriptionKHR.flags );
7254  for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i )
7255  {
7256  VULKAN_HPP_HASH_COMBINE( seed, performanceCounterDescriptionKHR.name[i] );
7257  }
7258  for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i )
7259  {
7260  VULKAN_HPP_HASH_COMBINE( seed, performanceCounterDescriptionKHR.category[i] );
7261  }
7262  for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i )
7263  {
7264  VULKAN_HPP_HASH_COMBINE( seed, performanceCounterDescriptionKHR.description[i] );
7265  }
7266  return seed;
7267  }
7268  };
7269 
7270  template <>
7271  struct hash<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR>
7272  {
7273  std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceCounterKHR const & performanceCounterKHR ) const VULKAN_HPP_NOEXCEPT
7274  {
7275  std::size_t seed = 0;
7276  VULKAN_HPP_HASH_COMBINE( seed, performanceCounterKHR.sType );
7277  VULKAN_HPP_HASH_COMBINE( seed, performanceCounterKHR.pNext );
7278  VULKAN_HPP_HASH_COMBINE( seed, performanceCounterKHR.unit );
7279  VULKAN_HPP_HASH_COMBINE( seed, performanceCounterKHR.scope );
7280  VULKAN_HPP_HASH_COMBINE( seed, performanceCounterKHR.storage );
7281  for ( size_t i = 0; i < VK_UUID_SIZE; ++i )
7282  {
7283  VULKAN_HPP_HASH_COMBINE( seed, performanceCounterKHR.uuid[i] );
7284  }
7285  return seed;
7286  }
7287  };
7288 
7289  template <>
7290  struct hash<VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL>
7291  {
7292  std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL const & performanceMarkerInfoINTEL ) const VULKAN_HPP_NOEXCEPT
7293  {
7294  std::size_t seed = 0;
7295  VULKAN_HPP_HASH_COMBINE( seed, performanceMarkerInfoINTEL.sType );
7296  VULKAN_HPP_HASH_COMBINE( seed, performanceMarkerInfoINTEL.pNext );
7297  VULKAN_HPP_HASH_COMBINE( seed, performanceMarkerInfoINTEL.marker );
7298  return seed;
7299  }
7300  };
7301 
7302  template <>
7303  struct hash<VULKAN_HPP_NAMESPACE::PerformanceOverrideInfoINTEL>
7304  {
7305  std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceOverrideInfoINTEL const & performanceOverrideInfoINTEL ) const VULKAN_HPP_NOEXCEPT
7306  {
7307  std::size_t seed = 0;
7308  VULKAN_HPP_HASH_COMBINE( seed, performanceOverrideInfoINTEL.sType );
7309  VULKAN_HPP_HASH_COMBINE( seed, performanceOverrideInfoINTEL.pNext );
7310  VULKAN_HPP_HASH_COMBINE( seed, performanceOverrideInfoINTEL.type );
7311  VULKAN_HPP_HASH_COMBINE( seed, performanceOverrideInfoINTEL.enable );
7312  VULKAN_HPP_HASH_COMBINE( seed, performanceOverrideInfoINTEL.parameter );
7313  return seed;
7314  }
7315  };
7316 
7317  template <>
7318  struct hash<VULKAN_HPP_NAMESPACE::PerformanceQuerySubmitInfoKHR>
7319  {
7320  std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceQuerySubmitInfoKHR const & performanceQuerySubmitInfoKHR ) const VULKAN_HPP_NOEXCEPT
7321  {
7322  std::size_t seed = 0;
7323  VULKAN_HPP_HASH_COMBINE( seed, performanceQuerySubmitInfoKHR.sType );
7324  VULKAN_HPP_HASH_COMBINE( seed, performanceQuerySubmitInfoKHR.pNext );
7325  VULKAN_HPP_HASH_COMBINE( seed, performanceQuerySubmitInfoKHR.counterPassIndex );
7326  return seed;
7327  }
7328  };
7329 
7330  template <>
7331  struct hash<VULKAN_HPP_NAMESPACE::PerformanceStreamMarkerInfoINTEL>
7332  {
7333  std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceStreamMarkerInfoINTEL const & performanceStreamMarkerInfoINTEL ) const VULKAN_HPP_NOEXCEPT
7334  {
7335  std::size_t seed = 0;
7336  VULKAN_HPP_HASH_COMBINE( seed, performanceStreamMarkerInfoINTEL.sType );
7337  VULKAN_HPP_HASH_COMBINE( seed, performanceStreamMarkerInfoINTEL.pNext );
7338  VULKAN_HPP_HASH_COMBINE( seed, performanceStreamMarkerInfoINTEL.marker );
7339  return seed;
7340  }
7341  };
7342 
7343  template <>
7344  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevice16BitStorageFeatures>
7345  {
7346  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevice16BitStorageFeatures const & physicalDevice16BitStorageFeatures ) const VULKAN_HPP_NOEXCEPT
7347  {
7348  std::size_t seed = 0;
7349  VULKAN_HPP_HASH_COMBINE( seed, physicalDevice16BitStorageFeatures.sType );
7350  VULKAN_HPP_HASH_COMBINE( seed, physicalDevice16BitStorageFeatures.pNext );
7351  VULKAN_HPP_HASH_COMBINE( seed, physicalDevice16BitStorageFeatures.storageBuffer16BitAccess );
7352  VULKAN_HPP_HASH_COMBINE( seed, physicalDevice16BitStorageFeatures.uniformAndStorageBuffer16BitAccess );
7353  VULKAN_HPP_HASH_COMBINE( seed, physicalDevice16BitStorageFeatures.storagePushConstant16 );
7354  VULKAN_HPP_HASH_COMBINE( seed, physicalDevice16BitStorageFeatures.storageInputOutput16 );
7355  return seed;
7356  }
7357  };
7358 
7359  template <>
7360  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevice4444FormatsFeaturesEXT>
7361  {
7362  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevice4444FormatsFeaturesEXT const & physicalDevice4444FormatsFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
7363  {
7364  std::size_t seed = 0;
7365  VULKAN_HPP_HASH_COMBINE( seed, physicalDevice4444FormatsFeaturesEXT.sType );
7366  VULKAN_HPP_HASH_COMBINE( seed, physicalDevice4444FormatsFeaturesEXT.pNext );
7367  VULKAN_HPP_HASH_COMBINE( seed, physicalDevice4444FormatsFeaturesEXT.formatA4R4G4B4 );
7368  VULKAN_HPP_HASH_COMBINE( seed, physicalDevice4444FormatsFeaturesEXT.formatA4B4G4R4 );
7369  return seed;
7370  }
7371  };
7372 
7373  template <>
7374  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevice8BitStorageFeatures>
7375  {
7376  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevice8BitStorageFeatures const & physicalDevice8BitStorageFeatures ) const VULKAN_HPP_NOEXCEPT
7377  {
7378  std::size_t seed = 0;
7379  VULKAN_HPP_HASH_COMBINE( seed, physicalDevice8BitStorageFeatures.sType );
7380  VULKAN_HPP_HASH_COMBINE( seed, physicalDevice8BitStorageFeatures.pNext );
7381  VULKAN_HPP_HASH_COMBINE( seed, physicalDevice8BitStorageFeatures.storageBuffer8BitAccess );
7382  VULKAN_HPP_HASH_COMBINE( seed, physicalDevice8BitStorageFeatures.uniformAndStorageBuffer8BitAccess );
7383  VULKAN_HPP_HASH_COMBINE( seed, physicalDevice8BitStorageFeatures.storagePushConstant8 );
7384  return seed;
7385  }
7386  };
7387 
7388  template <>
7389  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceASTCDecodeFeaturesEXT>
7390  {
7391  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceASTCDecodeFeaturesEXT const & physicalDeviceASTCDecodeFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
7392  {
7393  std::size_t seed = 0;
7394  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceASTCDecodeFeaturesEXT.sType );
7395  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceASTCDecodeFeaturesEXT.pNext );
7396  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceASTCDecodeFeaturesEXT.decodeModeSharedExponent );
7397  return seed;
7398  }
7399  };
7400 
7401  template <>
7402  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceAccelerationStructureFeaturesKHR>
7403  {
7404  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceAccelerationStructureFeaturesKHR const & physicalDeviceAccelerationStructureFeaturesKHR ) const
7405  VULKAN_HPP_NOEXCEPT
7406  {
7407  std::size_t seed = 0;
7408  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructureFeaturesKHR.sType );
7409  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructureFeaturesKHR.pNext );
7410  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructureFeaturesKHR.accelerationStructure );
7411  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructureFeaturesKHR.accelerationStructureCaptureReplay );
7412  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructureFeaturesKHR.accelerationStructureIndirectBuild );
7413  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructureFeaturesKHR.accelerationStructureHostCommands );
7414  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructureFeaturesKHR.descriptorBindingAccelerationStructureUpdateAfterBind );
7415  return seed;
7416  }
7417  };
7418 
7419  template <>
7420  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceAccelerationStructurePropertiesKHR>
7421  {
7422  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceAccelerationStructurePropertiesKHR const & physicalDeviceAccelerationStructurePropertiesKHR )
7423  const VULKAN_HPP_NOEXCEPT
7424  {
7425  std::size_t seed = 0;
7426  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.sType );
7427  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.pNext );
7428  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.maxGeometryCount );
7429  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.maxInstanceCount );
7430  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.maxPrimitiveCount );
7431  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.maxPerStageDescriptorAccelerationStructures );
7432  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.maxPerStageDescriptorUpdateAfterBindAccelerationStructures );
7433  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.maxDescriptorSetAccelerationStructures );
7434  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.maxDescriptorSetUpdateAfterBindAccelerationStructures );
7435  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.minAccelerationStructureScratchOffsetAlignment );
7436  return seed;
7437  }
7438  };
7439 
7440  template <>
7441  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceAddressBindingReportFeaturesEXT>
7442  {
7443  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceAddressBindingReportFeaturesEXT const & physicalDeviceAddressBindingReportFeaturesEXT ) const
7444  VULKAN_HPP_NOEXCEPT
7445  {
7446  std::size_t seed = 0;
7447  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAddressBindingReportFeaturesEXT.sType );
7448  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAddressBindingReportFeaturesEXT.pNext );
7449  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAddressBindingReportFeaturesEXT.reportAddressBinding );
7450  return seed;
7451  }
7452  };
7453 
7454  template <>
7455  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceAmigoProfilingFeaturesSEC>
7456  {
7457  std::size_t
7458  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceAmigoProfilingFeaturesSEC const & physicalDeviceAmigoProfilingFeaturesSEC ) const VULKAN_HPP_NOEXCEPT
7459  {
7460  std::size_t seed = 0;
7461  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAmigoProfilingFeaturesSEC.sType );
7462  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAmigoProfilingFeaturesSEC.pNext );
7463  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAmigoProfilingFeaturesSEC.amigoProfiling );
7464  return seed;
7465  }
7466  };
7467 
7468  template <>
7469  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT>
7470  {
7471  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT const &
7472  physicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
7473  {
7474  std::size_t seed = 0;
7475  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT.sType );
7476  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT.pNext );
7477  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT.attachmentFeedbackLoopDynamicState );
7478  return seed;
7479  }
7480  };
7481 
7482  template <>
7483  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT>
7484  {
7485  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT const &
7486  physicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
7487  {
7488  std::size_t seed = 0;
7489  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT.sType );
7490  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT.pNext );
7491  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT.attachmentFeedbackLoopLayout );
7492  return seed;
7493  }
7494  };
7495 
7496  template <>
7497  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceBlendOperationAdvancedFeaturesEXT>
7498  {
7499  std::size_t operator()(
7500  VULKAN_HPP_NAMESPACE::PhysicalDeviceBlendOperationAdvancedFeaturesEXT const & physicalDeviceBlendOperationAdvancedFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
7501  {
7502  std::size_t seed = 0;
7503  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedFeaturesEXT.sType );
7504  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedFeaturesEXT.pNext );
7505  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedFeaturesEXT.advancedBlendCoherentOperations );
7506  return seed;
7507  }
7508  };
7509 
7510  template <>
7511  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceBlendOperationAdvancedPropertiesEXT>
7512  {
7513  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceBlendOperationAdvancedPropertiesEXT const & physicalDeviceBlendOperationAdvancedPropertiesEXT )
7514  const VULKAN_HPP_NOEXCEPT
7515  {
7516  std::size_t seed = 0;
7517  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.sType );
7518  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.pNext );
7519  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendMaxColorAttachments );
7520  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendIndependentBlend );
7521  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendNonPremultipliedSrcColor );
7522  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendNonPremultipliedDstColor );
7523  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendCorrelatedOverlap );
7524  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendAllOperations );
7525  return seed;
7526  }
7527  };
7528 
7529  template <>
7530  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceBorderColorSwizzleFeaturesEXT>
7531  {
7532  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceBorderColorSwizzleFeaturesEXT const & physicalDeviceBorderColorSwizzleFeaturesEXT ) const
7533  VULKAN_HPP_NOEXCEPT
7534  {
7535  std::size_t seed = 0;
7536  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBorderColorSwizzleFeaturesEXT.sType );
7537  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBorderColorSwizzleFeaturesEXT.pNext );
7538  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBorderColorSwizzleFeaturesEXT.borderColorSwizzle );
7539  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBorderColorSwizzleFeaturesEXT.borderColorSwizzleFromImage );
7540  return seed;
7541  }
7542  };
7543 
7544  template <>
7545  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceBufferDeviceAddressFeatures>
7546  {
7547  std::size_t
7548  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceBufferDeviceAddressFeatures const & physicalDeviceBufferDeviceAddressFeatures ) const VULKAN_HPP_NOEXCEPT
7549  {
7550  std::size_t seed = 0;
7551  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeatures.sType );
7552  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeatures.pNext );
7553  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeatures.bufferDeviceAddress );
7554  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeatures.bufferDeviceAddressCaptureReplay );
7555  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeatures.bufferDeviceAddressMultiDevice );
7556  return seed;
7557  }
7558  };
7559 
7560  template <>
7561  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceBufferDeviceAddressFeaturesEXT>
7562  {
7563  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceBufferDeviceAddressFeaturesEXT const & physicalDeviceBufferDeviceAddressFeaturesEXT ) const
7564  VULKAN_HPP_NOEXCEPT
7565  {
7566  std::size_t seed = 0;
7567  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeaturesEXT.sType );
7568  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeaturesEXT.pNext );
7569  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeaturesEXT.bufferDeviceAddress );
7570  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeaturesEXT.bufferDeviceAddressCaptureReplay );
7571  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeaturesEXT.bufferDeviceAddressMultiDevice );
7572  return seed;
7573  }
7574  };
7575 
7576  template <>
7577  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterCullingShaderFeaturesHUAWEI>
7578  {
7579  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterCullingShaderFeaturesHUAWEI const & physicalDeviceClusterCullingShaderFeaturesHUAWEI )
7580  const VULKAN_HPP_NOEXCEPT
7581  {
7582  std::size_t seed = 0;
7583  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderFeaturesHUAWEI.sType );
7584  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderFeaturesHUAWEI.pNext );
7585  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderFeaturesHUAWEI.clustercullingShader );
7586  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderFeaturesHUAWEI.multiviewClusterCullingShader );
7587  return seed;
7588  }
7589  };
7590 
7591  template <>
7592  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterCullingShaderPropertiesHUAWEI>
7593  {
7594  std::size_t
7595  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterCullingShaderPropertiesHUAWEI const & physicalDeviceClusterCullingShaderPropertiesHUAWEI ) const
7596  VULKAN_HPP_NOEXCEPT
7597  {
7598  std::size_t seed = 0;
7599  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderPropertiesHUAWEI.sType );
7600  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderPropertiesHUAWEI.pNext );
7601  for ( size_t i = 0; i < 3; ++i )
7602  {
7603  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderPropertiesHUAWEI.maxWorkGroupCount[i] );
7604  }
7605  for ( size_t i = 0; i < 3; ++i )
7606  {
7607  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderPropertiesHUAWEI.maxWorkGroupSize[i] );
7608  }
7609  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderPropertiesHUAWEI.maxOutputClusterCount );
7610  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderPropertiesHUAWEI.indirectBufferOffsetAlignment );
7611  return seed;
7612  }
7613  };
7614 
7615  template <>
7616  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI>
7617  {
7618  std::size_t
7619  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI const & physicalDeviceClusterCullingShaderVrsFeaturesHUAWEI ) const
7620  VULKAN_HPP_NOEXCEPT
7621  {
7622  std::size_t seed = 0;
7623  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderVrsFeaturesHUAWEI.sType );
7624  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderVrsFeaturesHUAWEI.pNext );
7625  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderVrsFeaturesHUAWEI.clusterShadingRate );
7626  return seed;
7627  }
7628  };
7629 
7630  template <>
7631  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCoherentMemoryFeaturesAMD>
7632  {
7633  std::size_t
7634  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCoherentMemoryFeaturesAMD const & physicalDeviceCoherentMemoryFeaturesAMD ) const VULKAN_HPP_NOEXCEPT
7635  {
7636  std::size_t seed = 0;
7637  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCoherentMemoryFeaturesAMD.sType );
7638  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCoherentMemoryFeaturesAMD.pNext );
7639  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCoherentMemoryFeaturesAMD.deviceCoherentMemory );
7640  return seed;
7641  }
7642  };
7643 
7644  template <>
7645  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceColorWriteEnableFeaturesEXT>
7646  {
7647  std::size_t
7648  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceColorWriteEnableFeaturesEXT const & physicalDeviceColorWriteEnableFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
7649  {
7650  std::size_t seed = 0;
7651  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceColorWriteEnableFeaturesEXT.sType );
7652  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceColorWriteEnableFeaturesEXT.pNext );
7653  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceColorWriteEnableFeaturesEXT.colorWriteEnable );
7654  return seed;
7655  }
7656  };
7657 
7658  template <>
7659  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceComputeShaderDerivativesFeaturesNV>
7660  {
7661  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceComputeShaderDerivativesFeaturesNV const & physicalDeviceComputeShaderDerivativesFeaturesNV )
7662  const VULKAN_HPP_NOEXCEPT
7663  {
7664  std::size_t seed = 0;
7665  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceComputeShaderDerivativesFeaturesNV.sType );
7666  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceComputeShaderDerivativesFeaturesNV.pNext );
7667  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceComputeShaderDerivativesFeaturesNV.computeDerivativeGroupQuads );
7668  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceComputeShaderDerivativesFeaturesNV.computeDerivativeGroupLinear );
7669  return seed;
7670  }
7671  };
7672 
7673  template <>
7674  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceConditionalRenderingFeaturesEXT>
7675  {
7676  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceConditionalRenderingFeaturesEXT const & physicalDeviceConditionalRenderingFeaturesEXT ) const
7677  VULKAN_HPP_NOEXCEPT
7678  {
7679  std::size_t seed = 0;
7680  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConditionalRenderingFeaturesEXT.sType );
7681  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConditionalRenderingFeaturesEXT.pNext );
7682  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConditionalRenderingFeaturesEXT.conditionalRendering );
7683  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConditionalRenderingFeaturesEXT.inheritedConditionalRendering );
7684  return seed;
7685  }
7686  };
7687 
7688  template <>
7689  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceConservativeRasterizationPropertiesEXT>
7690  {
7691  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceConservativeRasterizationPropertiesEXT const &
7692  physicalDeviceConservativeRasterizationPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
7693  {
7694  std::size_t seed = 0;
7695  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.sType );
7696  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.pNext );
7697  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.primitiveOverestimationSize );
7698  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.maxExtraPrimitiveOverestimationSize );
7699  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.extraPrimitiveOverestimationSizeGranularity );
7700  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.primitiveUnderestimation );
7701  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.conservativePointAndLineRasterization );
7702  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.degenerateTrianglesRasterized );
7703  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.degenerateLinesRasterized );
7704  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.fullyCoveredFragmentShaderInputVariable );
7705  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.conservativeRasterizationPostDepthCoverage );
7706  return seed;
7707  }
7708  };
7709 
7710  template <>
7711  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixFeaturesKHR>
7712  {
7713  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixFeaturesKHR const & physicalDeviceCooperativeMatrixFeaturesKHR ) const
7714  VULKAN_HPP_NOEXCEPT
7715  {
7716  std::size_t seed = 0;
7717  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixFeaturesKHR.sType );
7718  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixFeaturesKHR.pNext );
7719  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixFeaturesKHR.cooperativeMatrix );
7720  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixFeaturesKHR.cooperativeMatrixRobustBufferAccess );
7721  return seed;
7722  }
7723  };
7724 
7725  template <>
7726  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixFeaturesNV>
7727  {
7728  std::size_t
7729  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixFeaturesNV const & physicalDeviceCooperativeMatrixFeaturesNV ) const VULKAN_HPP_NOEXCEPT
7730  {
7731  std::size_t seed = 0;
7732  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixFeaturesNV.sType );
7733  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixFeaturesNV.pNext );
7734  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixFeaturesNV.cooperativeMatrix );
7735  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixFeaturesNV.cooperativeMatrixRobustBufferAccess );
7736  return seed;
7737  }
7738  };
7739 
7740  template <>
7741  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixPropertiesKHR>
7742  {
7743  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixPropertiesKHR const & physicalDeviceCooperativeMatrixPropertiesKHR ) const
7744  VULKAN_HPP_NOEXCEPT
7745  {
7746  std::size_t seed = 0;
7747  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixPropertiesKHR.sType );
7748  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixPropertiesKHR.pNext );
7749  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixPropertiesKHR.cooperativeMatrixSupportedStages );
7750  return seed;
7751  }
7752  };
7753 
7754  template <>
7755  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixPropertiesNV>
7756  {
7757  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixPropertiesNV const & physicalDeviceCooperativeMatrixPropertiesNV ) const
7758  VULKAN_HPP_NOEXCEPT
7759  {
7760  std::size_t seed = 0;
7761  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixPropertiesNV.sType );
7762  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixPropertiesNV.pNext );
7763  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixPropertiesNV.cooperativeMatrixSupportedStages );
7764  return seed;
7765  }
7766  };
7767 
7768  template <>
7769  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectFeaturesNV>
7770  {
7771  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectFeaturesNV const & physicalDeviceCopyMemoryIndirectFeaturesNV ) const
7772  VULKAN_HPP_NOEXCEPT
7773  {
7774  std::size_t seed = 0;
7775  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCopyMemoryIndirectFeaturesNV.sType );
7776  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCopyMemoryIndirectFeaturesNV.pNext );
7777  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCopyMemoryIndirectFeaturesNV.indirectCopy );
7778  return seed;
7779  }
7780  };
7781 
7782  template <>
7783  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectPropertiesNV>
7784  {
7785  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectPropertiesNV const & physicalDeviceCopyMemoryIndirectPropertiesNV ) const
7786  VULKAN_HPP_NOEXCEPT
7787  {
7788  std::size_t seed = 0;
7789  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCopyMemoryIndirectPropertiesNV.sType );
7790  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCopyMemoryIndirectPropertiesNV.pNext );
7791  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCopyMemoryIndirectPropertiesNV.supportedQueues );
7792  return seed;
7793  }
7794  };
7795 
7796  template <>
7797  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCornerSampledImageFeaturesNV>
7798  {
7799  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCornerSampledImageFeaturesNV const & physicalDeviceCornerSampledImageFeaturesNV ) const
7800  VULKAN_HPP_NOEXCEPT
7801  {
7802  std::size_t seed = 0;
7803  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCornerSampledImageFeaturesNV.sType );
7804  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCornerSampledImageFeaturesNV.pNext );
7805  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCornerSampledImageFeaturesNV.cornerSampledImage );
7806  return seed;
7807  }
7808  };
7809 
7810  template <>
7811  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCoverageReductionModeFeaturesNV>
7812  {
7813  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCoverageReductionModeFeaturesNV const & physicalDeviceCoverageReductionModeFeaturesNV ) const
7814  VULKAN_HPP_NOEXCEPT
7815  {
7816  std::size_t seed = 0;
7817  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCoverageReductionModeFeaturesNV.sType );
7818  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCoverageReductionModeFeaturesNV.pNext );
7819  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCoverageReductionModeFeaturesNV.coverageReductionMode );
7820  return seed;
7821  }
7822  };
7823 
7824  template <>
7825  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCubicClampFeaturesQCOM>
7826  {
7827  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCubicClampFeaturesQCOM const & physicalDeviceCubicClampFeaturesQCOM ) const VULKAN_HPP_NOEXCEPT
7828  {
7829  std::size_t seed = 0;
7830  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCubicClampFeaturesQCOM.sType );
7831  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCubicClampFeaturesQCOM.pNext );
7832  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCubicClampFeaturesQCOM.cubicRangeClamp );
7833  return seed;
7834  }
7835  };
7836 
7837  template <>
7838  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCubicWeightsFeaturesQCOM>
7839  {
7840  std::size_t
7841  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCubicWeightsFeaturesQCOM const & physicalDeviceCubicWeightsFeaturesQCOM ) const VULKAN_HPP_NOEXCEPT
7842  {
7843  std::size_t seed = 0;
7844  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCubicWeightsFeaturesQCOM.sType );
7845  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCubicWeightsFeaturesQCOM.pNext );
7846  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCubicWeightsFeaturesQCOM.selectableCubicWeights );
7847  return seed;
7848  }
7849  };
7850 
7851 # if defined( VK_ENABLE_BETA_EXTENSIONS )
7852  template <>
7853  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCudaKernelLaunchFeaturesNV>
7854  {
7855  std::size_t
7856  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCudaKernelLaunchFeaturesNV const & physicalDeviceCudaKernelLaunchFeaturesNV ) const VULKAN_HPP_NOEXCEPT
7857  {
7858  std::size_t seed = 0;
7859  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCudaKernelLaunchFeaturesNV.sType );
7860  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCudaKernelLaunchFeaturesNV.pNext );
7861  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCudaKernelLaunchFeaturesNV.cudaKernelLaunchFeatures );
7862  return seed;
7863  }
7864  };
7865 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
7866 
7867 # if defined( VK_ENABLE_BETA_EXTENSIONS )
7868  template <>
7869  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCudaKernelLaunchPropertiesNV>
7870  {
7871  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCudaKernelLaunchPropertiesNV const & physicalDeviceCudaKernelLaunchPropertiesNV ) const
7872  VULKAN_HPP_NOEXCEPT
7873  {
7874  std::size_t seed = 0;
7875  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCudaKernelLaunchPropertiesNV.sType );
7876  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCudaKernelLaunchPropertiesNV.pNext );
7877  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCudaKernelLaunchPropertiesNV.computeCapabilityMinor );
7878  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCudaKernelLaunchPropertiesNV.computeCapabilityMajor );
7879  return seed;
7880  }
7881  };
7882 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
7883 
7884  template <>
7885  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomBorderColorFeaturesEXT>
7886  {
7887  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomBorderColorFeaturesEXT const & physicalDeviceCustomBorderColorFeaturesEXT ) const
7888  VULKAN_HPP_NOEXCEPT
7889  {
7890  std::size_t seed = 0;
7891  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCustomBorderColorFeaturesEXT.sType );
7892  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCustomBorderColorFeaturesEXT.pNext );
7893  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCustomBorderColorFeaturesEXT.customBorderColors );
7894  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCustomBorderColorFeaturesEXT.customBorderColorWithoutFormat );
7895  return seed;
7896  }
7897  };
7898 
7899  template <>
7900  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomBorderColorPropertiesEXT>
7901  {
7902  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomBorderColorPropertiesEXT const & physicalDeviceCustomBorderColorPropertiesEXT ) const
7903  VULKAN_HPP_NOEXCEPT
7904  {
7905  std::size_t seed = 0;
7906  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCustomBorderColorPropertiesEXT.sType );
7907  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCustomBorderColorPropertiesEXT.pNext );
7908  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCustomBorderColorPropertiesEXT.maxCustomBorderColorSamplers );
7909  return seed;
7910  }
7911  };
7912 
7913  template <>
7914  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV>
7915  {
7916  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const &
7917  physicalDeviceDedicatedAllocationImageAliasingFeaturesNV ) const VULKAN_HPP_NOEXCEPT
7918  {
7919  std::size_t seed = 0;
7920  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDedicatedAllocationImageAliasingFeaturesNV.sType );
7921  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDedicatedAllocationImageAliasingFeaturesNV.pNext );
7922  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDedicatedAllocationImageAliasingFeaturesNV.dedicatedAllocationImageAliasing );
7923  return seed;
7924  }
7925  };
7926 
7927  template <>
7928  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthBiasControlFeaturesEXT>
7929  {
7930  std::size_t
7931  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthBiasControlFeaturesEXT const & physicalDeviceDepthBiasControlFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
7932  {
7933  std::size_t seed = 0;
7934  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthBiasControlFeaturesEXT.sType );
7935  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthBiasControlFeaturesEXT.pNext );
7936  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthBiasControlFeaturesEXT.depthBiasControl );
7937  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthBiasControlFeaturesEXT.leastRepresentableValueForceUnormRepresentation );
7938  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthBiasControlFeaturesEXT.floatRepresentation );
7939  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthBiasControlFeaturesEXT.depthBiasExact );
7940  return seed;
7941  }
7942  };
7943 
7944  template <>
7945  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClampZeroOneFeaturesEXT>
7946  {
7947  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClampZeroOneFeaturesEXT const & physicalDeviceDepthClampZeroOneFeaturesEXT ) const
7948  VULKAN_HPP_NOEXCEPT
7949  {
7950  std::size_t seed = 0;
7951  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClampZeroOneFeaturesEXT.sType );
7952  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClampZeroOneFeaturesEXT.pNext );
7953  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClampZeroOneFeaturesEXT.depthClampZeroOne );
7954  return seed;
7955  }
7956  };
7957 
7958  template <>
7959  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClipControlFeaturesEXT>
7960  {
7961  std::size_t
7962  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClipControlFeaturesEXT const & physicalDeviceDepthClipControlFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
7963  {
7964  std::size_t seed = 0;
7965  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClipControlFeaturesEXT.sType );
7966  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClipControlFeaturesEXT.pNext );
7967  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClipControlFeaturesEXT.depthClipControl );
7968  return seed;
7969  }
7970  };
7971 
7972  template <>
7973  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClipEnableFeaturesEXT>
7974  {
7975  std::size_t
7976  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClipEnableFeaturesEXT const & physicalDeviceDepthClipEnableFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
7977  {
7978  std::size_t seed = 0;
7979  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClipEnableFeaturesEXT.sType );
7980  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClipEnableFeaturesEXT.pNext );
7981  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClipEnableFeaturesEXT.depthClipEnable );
7982  return seed;
7983  }
7984  };
7985 
7986  template <>
7987  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthStencilResolveProperties>
7988  {
7989  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthStencilResolveProperties const & physicalDeviceDepthStencilResolveProperties ) const
7990  VULKAN_HPP_NOEXCEPT
7991  {
7992  std::size_t seed = 0;
7993  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthStencilResolveProperties.sType );
7994  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthStencilResolveProperties.pNext );
7995  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthStencilResolveProperties.supportedDepthResolveModes );
7996  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthStencilResolveProperties.supportedStencilResolveModes );
7997  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthStencilResolveProperties.independentResolveNone );
7998  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthStencilResolveProperties.independentResolve );
7999  return seed;
8000  }
8001  };
8002 
8003  template <>
8004  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT>
8005  {
8006  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT const &
8007  physicalDeviceDescriptorBufferDensityMapPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
8008  {
8009  std::size_t seed = 0;
8010  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferDensityMapPropertiesEXT.sType );
8011  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferDensityMapPropertiesEXT.pNext );
8012  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferDensityMapPropertiesEXT.combinedImageSamplerDensityMapDescriptorSize );
8013  return seed;
8014  }
8015  };
8016 
8017  template <>
8018  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferFeaturesEXT>
8019  {
8020  std::size_t
8021  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferFeaturesEXT const & physicalDeviceDescriptorBufferFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
8022  {
8023  std::size_t seed = 0;
8024  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferFeaturesEXT.sType );
8025  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferFeaturesEXT.pNext );
8026  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferFeaturesEXT.descriptorBuffer );
8027  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferFeaturesEXT.descriptorBufferCaptureReplay );
8028  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferFeaturesEXT.descriptorBufferImageLayoutIgnored );
8029  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferFeaturesEXT.descriptorBufferPushDescriptors );
8030  return seed;
8031  }
8032  };
8033 
8034  template <>
8035  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferPropertiesEXT>
8036  {
8037  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferPropertiesEXT const & physicalDeviceDescriptorBufferPropertiesEXT ) const
8038  VULKAN_HPP_NOEXCEPT
8039  {
8040  std::size_t seed = 0;
8041  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.sType );
8042  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.pNext );
8043  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.combinedImageSamplerDescriptorSingleArray );
8044  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.bufferlessPushDescriptors );
8045  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.allowSamplerImageViewPostSubmitCreation );
8046  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.descriptorBufferOffsetAlignment );
8047  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.maxDescriptorBufferBindings );
8048  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.maxResourceDescriptorBufferBindings );
8049  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.maxSamplerDescriptorBufferBindings );
8050  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.maxEmbeddedImmutableSamplerBindings );
8051  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.maxEmbeddedImmutableSamplers );
8052  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.bufferCaptureReplayDescriptorDataSize );
8053  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.imageCaptureReplayDescriptorDataSize );
8054  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.imageViewCaptureReplayDescriptorDataSize );
8055  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.samplerCaptureReplayDescriptorDataSize );
8056  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.accelerationStructureCaptureReplayDescriptorDataSize );
8057  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.samplerDescriptorSize );
8058  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.combinedImageSamplerDescriptorSize );
8059  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.sampledImageDescriptorSize );
8060  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.storageImageDescriptorSize );
8061  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.uniformTexelBufferDescriptorSize );
8062  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.robustUniformTexelBufferDescriptorSize );
8063  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.storageTexelBufferDescriptorSize );
8064  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.robustStorageTexelBufferDescriptorSize );
8065  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.uniformBufferDescriptorSize );
8066  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.robustUniformBufferDescriptorSize );
8067  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.storageBufferDescriptorSize );
8068  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.robustStorageBufferDescriptorSize );
8069  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.inputAttachmentDescriptorSize );
8070  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.accelerationStructureDescriptorSize );
8071  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.maxSamplerDescriptorBufferRange );
8072  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.maxResourceDescriptorBufferRange );
8073  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.samplerDescriptorBufferAddressSpaceSize );
8074  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.resourceDescriptorBufferAddressSpaceSize );
8075  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.descriptorBufferAddressSpaceSize );
8076  return seed;
8077  }
8078  };
8079 
8080  template <>
8081  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorIndexingFeatures>
8082  {
8083  std::size_t
8084  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorIndexingFeatures const & physicalDeviceDescriptorIndexingFeatures ) const VULKAN_HPP_NOEXCEPT
8085  {
8086  std::size_t seed = 0;
8087  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.sType );
8088  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.pNext );
8089  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderInputAttachmentArrayDynamicIndexing );
8090  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderUniformTexelBufferArrayDynamicIndexing );
8091  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderStorageTexelBufferArrayDynamicIndexing );
8092  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderUniformBufferArrayNonUniformIndexing );
8093  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderSampledImageArrayNonUniformIndexing );
8094  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderStorageBufferArrayNonUniformIndexing );
8095  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderStorageImageArrayNonUniformIndexing );
8096  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderInputAttachmentArrayNonUniformIndexing );
8097  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderUniformTexelBufferArrayNonUniformIndexing );
8098  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderStorageTexelBufferArrayNonUniformIndexing );
8099  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingUniformBufferUpdateAfterBind );
8100  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingSampledImageUpdateAfterBind );
8101  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingStorageImageUpdateAfterBind );
8102  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingStorageBufferUpdateAfterBind );
8103  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingUniformTexelBufferUpdateAfterBind );
8104  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingStorageTexelBufferUpdateAfterBind );
8105  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingUpdateUnusedWhilePending );
8106  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingPartiallyBound );
8107  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingVariableDescriptorCount );
8108  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.runtimeDescriptorArray );
8109  return seed;
8110  }
8111  };
8112 
8113  template <>
8114  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorIndexingProperties>
8115  {
8116  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorIndexingProperties const & physicalDeviceDescriptorIndexingProperties ) const
8117  VULKAN_HPP_NOEXCEPT
8118  {
8119  std::size_t seed = 0;
8120  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.sType );
8121  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.pNext );
8122  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxUpdateAfterBindDescriptorsInAllPools );
8123  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.shaderUniformBufferArrayNonUniformIndexingNative );
8124  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.shaderSampledImageArrayNonUniformIndexingNative );
8125  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.shaderStorageBufferArrayNonUniformIndexingNative );
8126  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.shaderStorageImageArrayNonUniformIndexingNative );
8127  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.shaderInputAttachmentArrayNonUniformIndexingNative );
8128  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.robustBufferAccessUpdateAfterBind );
8129  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.quadDivergentImplicitLod );
8130  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindSamplers );
8131  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindUniformBuffers );
8132  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindStorageBuffers );
8133  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindSampledImages );
8134  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindStorageImages );
8135  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindInputAttachments );
8136  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxPerStageUpdateAfterBindResources );
8137  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindSamplers );
8138  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindUniformBuffers );
8139  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic );
8140  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindStorageBuffers );
8141  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic );
8142  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindSampledImages );
8143  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindStorageImages );
8144  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindInputAttachments );
8145  return seed;
8146  }
8147  };
8148 
8149  template <>
8150  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorPoolOverallocationFeaturesNV>
8151  {
8152  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorPoolOverallocationFeaturesNV const &
8153  physicalDeviceDescriptorPoolOverallocationFeaturesNV ) const VULKAN_HPP_NOEXCEPT
8154  {
8155  std::size_t seed = 0;
8156  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorPoolOverallocationFeaturesNV.sType );
8157  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorPoolOverallocationFeaturesNV.pNext );
8158  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorPoolOverallocationFeaturesNV.descriptorPoolOverallocation );
8159  return seed;
8160  }
8161  };
8162 
8163  template <>
8164  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE>
8165  {
8166  std::size_t
8167  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE const & physicalDeviceDescriptorSetHostMappingFeaturesVALVE ) const
8168  VULKAN_HPP_NOEXCEPT
8169  {
8170  std::size_t seed = 0;
8171  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorSetHostMappingFeaturesVALVE.sType );
8172  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorSetHostMappingFeaturesVALVE.pNext );
8173  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorSetHostMappingFeaturesVALVE.descriptorSetHostMapping );
8174  return seed;
8175  }
8176  };
8177 
8178  template <>
8179  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV>
8180  {
8181  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV const &
8182  physicalDeviceDeviceGeneratedCommandsComputeFeaturesNV ) const VULKAN_HPP_NOEXCEPT
8183  {
8184  std::size_t seed = 0;
8185  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsComputeFeaturesNV.sType );
8186  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsComputeFeaturesNV.pNext );
8187  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsComputeFeaturesNV.deviceGeneratedCompute );
8188  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsComputeFeaturesNV.deviceGeneratedComputePipelines );
8189  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsComputeFeaturesNV.deviceGeneratedComputeCaptureReplay );
8190  return seed;
8191  }
8192  };
8193 
8194  template <>
8195  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsFeaturesNV>
8196  {
8197  std::size_t operator()(
8198  VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsFeaturesNV const & physicalDeviceDeviceGeneratedCommandsFeaturesNV ) const VULKAN_HPP_NOEXCEPT
8199  {
8200  std::size_t seed = 0;
8201  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsFeaturesNV.sType );
8202  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsFeaturesNV.pNext );
8203  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsFeaturesNV.deviceGeneratedCommands );
8204  return seed;
8205  }
8206  };
8207 
8208  template <>
8209  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsPropertiesNV>
8210  {
8211  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsPropertiesNV const & physicalDeviceDeviceGeneratedCommandsPropertiesNV )
8212  const VULKAN_HPP_NOEXCEPT
8213  {
8214  std::size_t seed = 0;
8215  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.sType );
8216  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.pNext );
8217  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxGraphicsShaderGroupCount );
8218  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxIndirectSequenceCount );
8219  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxIndirectCommandsTokenCount );
8220  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxIndirectCommandsStreamCount );
8221  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxIndirectCommandsTokenOffset );
8222  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxIndirectCommandsStreamStride );
8223  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.minSequencesCountBufferOffsetAlignment );
8224  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.minSequencesIndexBufferOffsetAlignment );
8225  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.minIndirectCommandsBufferOffsetAlignment );
8226  return seed;
8227  }
8228  };
8229 
8230  template <>
8231  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceMemoryReportFeaturesEXT>
8232  {
8233  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceMemoryReportFeaturesEXT const & physicalDeviceDeviceMemoryReportFeaturesEXT ) const
8234  VULKAN_HPP_NOEXCEPT
8235  {
8236  std::size_t seed = 0;
8237  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceMemoryReportFeaturesEXT.sType );
8238  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceMemoryReportFeaturesEXT.pNext );
8239  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceMemoryReportFeaturesEXT.deviceMemoryReport );
8240  return seed;
8241  }
8242  };
8243 
8244  template <>
8245  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDiagnosticsConfigFeaturesNV>
8246  {
8247  std::size_t
8248  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDiagnosticsConfigFeaturesNV const & physicalDeviceDiagnosticsConfigFeaturesNV ) const VULKAN_HPP_NOEXCEPT
8249  {
8250  std::size_t seed = 0;
8251  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDiagnosticsConfigFeaturesNV.sType );
8252  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDiagnosticsConfigFeaturesNV.pNext );
8253  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDiagnosticsConfigFeaturesNV.diagnosticsConfig );
8254  return seed;
8255  }
8256  };
8257 
8258  template <>
8259  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDiscardRectanglePropertiesEXT>
8260  {
8261  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDiscardRectanglePropertiesEXT const & physicalDeviceDiscardRectanglePropertiesEXT ) const
8262  VULKAN_HPP_NOEXCEPT
8263  {
8264  std::size_t seed = 0;
8265  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDiscardRectanglePropertiesEXT.sType );
8266  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDiscardRectanglePropertiesEXT.pNext );
8267  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDiscardRectanglePropertiesEXT.maxDiscardRectangles );
8268  return seed;
8269  }
8270  };
8271 
8272 # if defined( VK_ENABLE_BETA_EXTENSIONS )
8273  template <>
8274  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDisplacementMicromapFeaturesNV>
8275  {
8276  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDisplacementMicromapFeaturesNV const & physicalDeviceDisplacementMicromapFeaturesNV ) const
8277  VULKAN_HPP_NOEXCEPT
8278  {
8279  std::size_t seed = 0;
8280  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDisplacementMicromapFeaturesNV.sType );
8281  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDisplacementMicromapFeaturesNV.pNext );
8282  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDisplacementMicromapFeaturesNV.displacementMicromap );
8283  return seed;
8284  }
8285  };
8286 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
8287 
8288 # if defined( VK_ENABLE_BETA_EXTENSIONS )
8289  template <>
8290  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDisplacementMicromapPropertiesNV>
8291  {
8292  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDisplacementMicromapPropertiesNV const & physicalDeviceDisplacementMicromapPropertiesNV ) const
8293  VULKAN_HPP_NOEXCEPT
8294  {
8295  std::size_t seed = 0;
8296  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDisplacementMicromapPropertiesNV.sType );
8297  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDisplacementMicromapPropertiesNV.pNext );
8298  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDisplacementMicromapPropertiesNV.maxDisplacementMicromapSubdivisionLevel );
8299  return seed;
8300  }
8301  };
8302 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
8303 
8304  template <>
8305  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDriverProperties>
8306  {
8307  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDriverProperties const & physicalDeviceDriverProperties ) const VULKAN_HPP_NOEXCEPT
8308  {
8309  std::size_t seed = 0;
8310  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDriverProperties.sType );
8311  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDriverProperties.pNext );
8312  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDriverProperties.driverID );
8313  for ( size_t i = 0; i < VK_MAX_DRIVER_NAME_SIZE; ++i )
8314  {
8315  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDriverProperties.driverName[i] );
8316  }
8317  for ( size_t i = 0; i < VK_MAX_DRIVER_INFO_SIZE; ++i )
8318  {
8319  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDriverProperties.driverInfo[i] );
8320  }
8321  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDriverProperties.conformanceVersion );
8322  return seed;
8323  }
8324  };
8325 
8326  template <>
8327  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDrmPropertiesEXT>
8328  {
8329  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDrmPropertiesEXT const & physicalDeviceDrmPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
8330  {
8331  std::size_t seed = 0;
8332  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDrmPropertiesEXT.sType );
8333  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDrmPropertiesEXT.pNext );
8334  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDrmPropertiesEXT.hasPrimary );
8335  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDrmPropertiesEXT.hasRender );
8336  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDrmPropertiesEXT.primaryMajor );
8337  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDrmPropertiesEXT.primaryMinor );
8338  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDrmPropertiesEXT.renderMajor );
8339  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDrmPropertiesEXT.renderMinor );
8340  return seed;
8341  }
8342  };
8343 
8344  template <>
8345  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingFeatures>
8346  {
8347  std::size_t
8348  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingFeatures const & physicalDeviceDynamicRenderingFeatures ) const VULKAN_HPP_NOEXCEPT
8349  {
8350  std::size_t seed = 0;
8351  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDynamicRenderingFeatures.sType );
8352  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDynamicRenderingFeatures.pNext );
8353  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDynamicRenderingFeatures.dynamicRendering );
8354  return seed;
8355  }
8356  };
8357 
8358  template <>
8359  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT>
8360  {
8361  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT const &
8362  physicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
8363  {
8364  std::size_t seed = 0;
8365  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT.sType );
8366  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT.pNext );
8367  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT.dynamicRenderingUnusedAttachments );
8368  return seed;
8369  }
8370  };
8371 
8372  template <>
8373  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExclusiveScissorFeaturesNV>
8374  {
8375  std::size_t
8376  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExclusiveScissorFeaturesNV const & physicalDeviceExclusiveScissorFeaturesNV ) const VULKAN_HPP_NOEXCEPT
8377  {
8378  std::size_t seed = 0;
8379  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExclusiveScissorFeaturesNV.sType );
8380  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExclusiveScissorFeaturesNV.pNext );
8381  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExclusiveScissorFeaturesNV.exclusiveScissor );
8382  return seed;
8383  }
8384  };
8385 
8386  template <>
8387  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState2FeaturesEXT>
8388  {
8389  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState2FeaturesEXT const & physicalDeviceExtendedDynamicState2FeaturesEXT ) const
8390  VULKAN_HPP_NOEXCEPT
8391  {
8392  std::size_t seed = 0;
8393  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState2FeaturesEXT.sType );
8394  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState2FeaturesEXT.pNext );
8395  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState2FeaturesEXT.extendedDynamicState2 );
8396  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState2FeaturesEXT.extendedDynamicState2LogicOp );
8397  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState2FeaturesEXT.extendedDynamicState2PatchControlPoints );
8398  return seed;
8399  }
8400  };
8401 
8402  template <>
8403  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState3FeaturesEXT>
8404  {
8405  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState3FeaturesEXT const & physicalDeviceExtendedDynamicState3FeaturesEXT ) const
8406  VULKAN_HPP_NOEXCEPT
8407  {
8408  std::size_t seed = 0;
8409  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.sType );
8410  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.pNext );
8411  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3TessellationDomainOrigin );
8412  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3DepthClampEnable );
8413  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3PolygonMode );
8414  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3RasterizationSamples );
8415  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3SampleMask );
8416  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3AlphaToCoverageEnable );
8417  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3AlphaToOneEnable );
8418  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3LogicOpEnable );
8419  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ColorBlendEnable );
8420  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ColorBlendEquation );
8421  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ColorWriteMask );
8422  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3RasterizationStream );
8423  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ConservativeRasterizationMode );
8424  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ExtraPrimitiveOverestimationSize );
8425  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3DepthClipEnable );
8426  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3SampleLocationsEnable );
8427  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ColorBlendAdvanced );
8428  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ProvokingVertexMode );
8429  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3LineRasterizationMode );
8430  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3LineStippleEnable );
8431  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3DepthClipNegativeOneToOne );
8432  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ViewportWScalingEnable );
8433  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ViewportSwizzle );
8434  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3CoverageToColorEnable );
8435  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3CoverageToColorLocation );
8436  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3CoverageModulationMode );
8437  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3CoverageModulationTableEnable );
8438  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3CoverageModulationTable );
8439  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3CoverageReductionMode );
8440  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3RepresentativeFragmentTestEnable );
8441  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ShadingRateImageEnable );
8442  return seed;
8443  }
8444  };
8445 
8446  template <>
8447  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState3PropertiesEXT>
8448  {
8449  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState3PropertiesEXT const & physicalDeviceExtendedDynamicState3PropertiesEXT )
8450  const VULKAN_HPP_NOEXCEPT
8451  {
8452  std::size_t seed = 0;
8453  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3PropertiesEXT.sType );
8454  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3PropertiesEXT.pNext );
8455  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3PropertiesEXT.dynamicPrimitiveTopologyUnrestricted );
8456  return seed;
8457  }
8458  };
8459 
8460  template <>
8461  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicStateFeaturesEXT>
8462  {
8463  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicStateFeaturesEXT const & physicalDeviceExtendedDynamicStateFeaturesEXT ) const
8464  VULKAN_HPP_NOEXCEPT
8465  {
8466  std::size_t seed = 0;
8467  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicStateFeaturesEXT.sType );
8468  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicStateFeaturesEXT.pNext );
8469  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicStateFeaturesEXT.extendedDynamicState );
8470  return seed;
8471  }
8472  };
8473 
8474  template <>
8475  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV>
8476  {
8477  std::size_t
8478  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV const & physicalDeviceExtendedSparseAddressSpaceFeaturesNV ) const
8479  VULKAN_HPP_NOEXCEPT
8480  {
8481  std::size_t seed = 0;
8482  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedSparseAddressSpaceFeaturesNV.sType );
8483  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedSparseAddressSpaceFeaturesNV.pNext );
8484  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedSparseAddressSpaceFeaturesNV.extendedSparseAddressSpace );
8485  return seed;
8486  }
8487  };
8488 
8489  template <>
8490  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedSparseAddressSpacePropertiesNV>
8491  {
8492  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedSparseAddressSpacePropertiesNV const &
8493  physicalDeviceExtendedSparseAddressSpacePropertiesNV ) const VULKAN_HPP_NOEXCEPT
8494  {
8495  std::size_t seed = 0;
8496  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedSparseAddressSpacePropertiesNV.sType );
8497  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedSparseAddressSpacePropertiesNV.pNext );
8498  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedSparseAddressSpacePropertiesNV.extendedSparseAddressSpaceSize );
8499  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedSparseAddressSpacePropertiesNV.extendedSparseImageUsageFlags );
8500  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedSparseAddressSpacePropertiesNV.extendedSparseBufferUsageFlags );
8501  return seed;
8502  }
8503  };
8504 
8505  template <>
8506  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo>
8507  {
8508  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo const & physicalDeviceExternalBufferInfo ) const VULKAN_HPP_NOEXCEPT
8509  {
8510  std::size_t seed = 0;
8511  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalBufferInfo.sType );
8512  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalBufferInfo.pNext );
8513  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalBufferInfo.flags );
8514  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalBufferInfo.usage );
8515  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalBufferInfo.handleType );
8516  return seed;
8517  }
8518  };
8519 
8520  template <>
8521  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo>
8522  {
8523  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo const & physicalDeviceExternalFenceInfo ) const VULKAN_HPP_NOEXCEPT
8524  {
8525  std::size_t seed = 0;
8526  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFenceInfo.sType );
8527  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFenceInfo.pNext );
8528  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFenceInfo.handleType );
8529  return seed;
8530  }
8531  };
8532 
8533 # if defined( VK_USE_PLATFORM_ANDROID_KHR )
8534  template <>
8535  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFormatResolveFeaturesANDROID>
8536  {
8537  std::size_t
8538  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFormatResolveFeaturesANDROID const & physicalDeviceExternalFormatResolveFeaturesANDROID ) const
8539  VULKAN_HPP_NOEXCEPT
8540  {
8541  std::size_t seed = 0;
8542  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFormatResolveFeaturesANDROID.sType );
8543  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFormatResolveFeaturesANDROID.pNext );
8544  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFormatResolveFeaturesANDROID.externalFormatResolve );
8545  return seed;
8546  }
8547  };
8548 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/
8549 
8550 # if defined( VK_USE_PLATFORM_ANDROID_KHR )
8551  template <>
8552  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFormatResolvePropertiesANDROID>
8553  {
8554  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFormatResolvePropertiesANDROID const &
8555  physicalDeviceExternalFormatResolvePropertiesANDROID ) const VULKAN_HPP_NOEXCEPT
8556  {
8557  std::size_t seed = 0;
8558  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFormatResolvePropertiesANDROID.sType );
8559  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFormatResolvePropertiesANDROID.pNext );
8560  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFormatResolvePropertiesANDROID.nullColorAttachmentWithExternalFormatResolve );
8561  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFormatResolvePropertiesANDROID.externalFormatResolveChromaOffsetX );
8562  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFormatResolvePropertiesANDROID.externalFormatResolveChromaOffsetY );
8563  return seed;
8564  }
8565  };
8566 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/
8567 
8568  template <>
8569  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalImageFormatInfo>
8570  {
8571  std::size_t
8572  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalImageFormatInfo const & physicalDeviceExternalImageFormatInfo ) const VULKAN_HPP_NOEXCEPT
8573  {
8574  std::size_t seed = 0;
8575  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalImageFormatInfo.sType );
8576  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalImageFormatInfo.pNext );
8577  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalImageFormatInfo.handleType );
8578  return seed;
8579  }
8580  };
8581 
8582  template <>
8583  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryHostPropertiesEXT>
8584  {
8585  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryHostPropertiesEXT const & physicalDeviceExternalMemoryHostPropertiesEXT ) const
8586  VULKAN_HPP_NOEXCEPT
8587  {
8588  std::size_t seed = 0;
8589  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalMemoryHostPropertiesEXT.sType );
8590  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalMemoryHostPropertiesEXT.pNext );
8591  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalMemoryHostPropertiesEXT.minImportedHostPointerAlignment );
8592  return seed;
8593  }
8594  };
8595 
8596  template <>
8597  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryRDMAFeaturesNV>
8598  {
8599  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryRDMAFeaturesNV const & physicalDeviceExternalMemoryRDMAFeaturesNV ) const
8600  VULKAN_HPP_NOEXCEPT
8601  {
8602  std::size_t seed = 0;
8603  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalMemoryRDMAFeaturesNV.sType );
8604  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalMemoryRDMAFeaturesNV.pNext );
8605  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalMemoryRDMAFeaturesNV.externalMemoryRDMA );
8606  return seed;
8607  }
8608  };
8609 
8610 # if defined( VK_USE_PLATFORM_SCREEN_QNX )
8611  template <>
8612  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX>
8613  {
8614  std::size_t
8615  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX const & physicalDeviceExternalMemoryScreenBufferFeaturesQNX ) const
8616  VULKAN_HPP_NOEXCEPT
8617  {
8618  std::size_t seed = 0;
8619  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalMemoryScreenBufferFeaturesQNX.sType );
8620  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalMemoryScreenBufferFeaturesQNX.pNext );
8621  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalMemoryScreenBufferFeaturesQNX.screenBufferImport );
8622  return seed;
8623  }
8624  };
8625 # endif /*VK_USE_PLATFORM_SCREEN_QNX*/
8626 
8627  template <>
8628  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo>
8629  {
8630  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo const & physicalDeviceExternalSemaphoreInfo ) const VULKAN_HPP_NOEXCEPT
8631  {
8632  std::size_t seed = 0;
8633  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalSemaphoreInfo.sType );
8634  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalSemaphoreInfo.pNext );
8635  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalSemaphoreInfo.handleType );
8636  return seed;
8637  }
8638  };
8639 
8640  template <>
8641  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFaultFeaturesEXT>
8642  {
8643  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFaultFeaturesEXT const & physicalDeviceFaultFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
8644  {
8645  std::size_t seed = 0;
8646  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFaultFeaturesEXT.sType );
8647  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFaultFeaturesEXT.pNext );
8648  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFaultFeaturesEXT.deviceFault );
8649  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFaultFeaturesEXT.deviceFaultVendorBinary );
8650  return seed;
8651  }
8652  };
8653 
8654  template <>
8655  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2>
8656  {
8657  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 const & physicalDeviceFeatures2 ) const VULKAN_HPP_NOEXCEPT
8658  {
8659  std::size_t seed = 0;
8660  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures2.sType );
8661  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures2.pNext );
8662  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures2.features );
8663  return seed;
8664  }
8665  };
8666 
8667  template <>
8668  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFloatControlsProperties>
8669  {
8670  std::size_t
8671  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFloatControlsProperties const & physicalDeviceFloatControlsProperties ) const VULKAN_HPP_NOEXCEPT
8672  {
8673  std::size_t seed = 0;
8674  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.sType );
8675  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.pNext );
8676  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.denormBehaviorIndependence );
8677  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.roundingModeIndependence );
8678  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderSignedZeroInfNanPreserveFloat16 );
8679  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderSignedZeroInfNanPreserveFloat32 );
8680  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderSignedZeroInfNanPreserveFloat64 );
8681  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderDenormPreserveFloat16 );
8682  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderDenormPreserveFloat32 );
8683  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderDenormPreserveFloat64 );
8684  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderDenormFlushToZeroFloat16 );
8685  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderDenormFlushToZeroFloat32 );
8686  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderDenormFlushToZeroFloat64 );
8687  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTEFloat16 );
8688  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTEFloat32 );
8689  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTEFloat64 );
8690  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTZFloat16 );
8691  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTZFloat32 );
8692  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTZFloat64 );
8693  return seed;
8694  }
8695  };
8696 
8697  template <>
8698  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMap2FeaturesEXT>
8699  {
8700  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMap2FeaturesEXT const & physicalDeviceFragmentDensityMap2FeaturesEXT ) const
8701  VULKAN_HPP_NOEXCEPT
8702  {
8703  std::size_t seed = 0;
8704  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMap2FeaturesEXT.sType );
8705  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMap2FeaturesEXT.pNext );
8706  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMap2FeaturesEXT.fragmentDensityMapDeferred );
8707  return seed;
8708  }
8709  };
8710 
8711  template <>
8712  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMap2PropertiesEXT>
8713  {
8714  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMap2PropertiesEXT const & physicalDeviceFragmentDensityMap2PropertiesEXT ) const
8715  VULKAN_HPP_NOEXCEPT
8716  {
8717  std::size_t seed = 0;
8718  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMap2PropertiesEXT.sType );
8719  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMap2PropertiesEXT.pNext );
8720  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMap2PropertiesEXT.subsampledLoads );
8721  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMap2PropertiesEXT.subsampledCoarseReconstructionEarlyAccess );
8722  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMap2PropertiesEXT.maxSubsampledArrayLayers );
8723  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMap2PropertiesEXT.maxDescriptorSetSubsampledSamplers );
8724  return seed;
8725  }
8726  };
8727 
8728  template <>
8729  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapFeaturesEXT>
8730  {
8731  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapFeaturesEXT const & physicalDeviceFragmentDensityMapFeaturesEXT ) const
8732  VULKAN_HPP_NOEXCEPT
8733  {
8734  std::size_t seed = 0;
8735  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapFeaturesEXT.sType );
8736  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapFeaturesEXT.pNext );
8737  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapFeaturesEXT.fragmentDensityMap );
8738  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapFeaturesEXT.fragmentDensityMapDynamic );
8739  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapFeaturesEXT.fragmentDensityMapNonSubsampledImages );
8740  return seed;
8741  }
8742  };
8743 
8744  template <>
8745  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM>
8746  {
8747  std::size_t
8748  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM const & physicalDeviceFragmentDensityMapOffsetFeaturesQCOM ) const
8749  VULKAN_HPP_NOEXCEPT
8750  {
8751  std::size_t seed = 0;
8752  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetFeaturesQCOM.sType );
8753  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetFeaturesQCOM.pNext );
8754  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetFeaturesQCOM.fragmentDensityMapOffset );
8755  return seed;
8756  }
8757  };
8758 
8759  template <>
8760  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM>
8761  {
8762  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM const &
8763  physicalDeviceFragmentDensityMapOffsetPropertiesQCOM ) const VULKAN_HPP_NOEXCEPT
8764  {
8765  std::size_t seed = 0;
8766  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetPropertiesQCOM.sType );
8767  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetPropertiesQCOM.pNext );
8768  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetPropertiesQCOM.fragmentDensityOffsetGranularity );
8769  return seed;
8770  }
8771  };
8772 
8773  template <>
8774  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapPropertiesEXT>
8775  {
8776  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapPropertiesEXT const & physicalDeviceFragmentDensityMapPropertiesEXT ) const
8777  VULKAN_HPP_NOEXCEPT
8778  {
8779  std::size_t seed = 0;
8780  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapPropertiesEXT.sType );
8781  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapPropertiesEXT.pNext );
8782  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapPropertiesEXT.minFragmentDensityTexelSize );
8783  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapPropertiesEXT.maxFragmentDensityTexelSize );
8784  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapPropertiesEXT.fragmentDensityInvocations );
8785  return seed;
8786  }
8787  };
8788 
8789  template <>
8790  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderBarycentricFeaturesKHR>
8791  {
8792  std::size_t
8793  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderBarycentricFeaturesKHR const & physicalDeviceFragmentShaderBarycentricFeaturesKHR ) const
8794  VULKAN_HPP_NOEXCEPT
8795  {
8796  std::size_t seed = 0;
8797  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderBarycentricFeaturesKHR.sType );
8798  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderBarycentricFeaturesKHR.pNext );
8799  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderBarycentricFeaturesKHR.fragmentShaderBarycentric );
8800  return seed;
8801  }
8802  };
8803 
8804  template <>
8805  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderBarycentricPropertiesKHR>
8806  {
8807  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderBarycentricPropertiesKHR const &
8808  physicalDeviceFragmentShaderBarycentricPropertiesKHR ) const VULKAN_HPP_NOEXCEPT
8809  {
8810  std::size_t seed = 0;
8811  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderBarycentricPropertiesKHR.sType );
8812  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderBarycentricPropertiesKHR.pNext );
8813  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderBarycentricPropertiesKHR.triStripVertexOrderIndependentOfProvokingVertex );
8814  return seed;
8815  }
8816  };
8817 
8818  template <>
8819  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderInterlockFeaturesEXT>
8820  {
8821  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderInterlockFeaturesEXT const & physicalDeviceFragmentShaderInterlockFeaturesEXT )
8822  const VULKAN_HPP_NOEXCEPT
8823  {
8824  std::size_t seed = 0;
8825  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderInterlockFeaturesEXT.sType );
8826  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderInterlockFeaturesEXT.pNext );
8827  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderInterlockFeaturesEXT.fragmentShaderSampleInterlock );
8828  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderInterlockFeaturesEXT.fragmentShaderPixelInterlock );
8829  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderInterlockFeaturesEXT.fragmentShaderShadingRateInterlock );
8830  return seed;
8831  }
8832  };
8833 
8834  template <>
8835  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateEnumsFeaturesNV>
8836  {
8837  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateEnumsFeaturesNV const & physicalDeviceFragmentShadingRateEnumsFeaturesNV )
8838  const VULKAN_HPP_NOEXCEPT
8839  {
8840  std::size_t seed = 0;
8841  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateEnumsFeaturesNV.sType );
8842  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateEnumsFeaturesNV.pNext );
8843  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateEnumsFeaturesNV.fragmentShadingRateEnums );
8844  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateEnumsFeaturesNV.supersampleFragmentShadingRates );
8845  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateEnumsFeaturesNV.noInvocationFragmentShadingRates );
8846  return seed;
8847  }
8848  };
8849 
8850  template <>
8851  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateEnumsPropertiesNV>
8852  {
8853  std::size_t
8854  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateEnumsPropertiesNV const & physicalDeviceFragmentShadingRateEnumsPropertiesNV ) const
8855  VULKAN_HPP_NOEXCEPT
8856  {
8857  std::size_t seed = 0;
8858  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateEnumsPropertiesNV.sType );
8859  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateEnumsPropertiesNV.pNext );
8860  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateEnumsPropertiesNV.maxFragmentShadingRateInvocationCount );
8861  return seed;
8862  }
8863  };
8864 
8865  template <>
8866  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateFeaturesKHR>
8867  {
8868  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateFeaturesKHR const & physicalDeviceFragmentShadingRateFeaturesKHR ) const
8869  VULKAN_HPP_NOEXCEPT
8870  {
8871  std::size_t seed = 0;
8872  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateFeaturesKHR.sType );
8873  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateFeaturesKHR.pNext );
8874  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateFeaturesKHR.pipelineFragmentShadingRate );
8875  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateFeaturesKHR.primitiveFragmentShadingRate );
8876  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateFeaturesKHR.attachmentFragmentShadingRate );
8877  return seed;
8878  }
8879  };
8880 
8881  template <>
8882  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR>
8883  {
8884  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR const & physicalDeviceFragmentShadingRateKHR ) const VULKAN_HPP_NOEXCEPT
8885  {
8886  std::size_t seed = 0;
8887  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateKHR.sType );
8888  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateKHR.pNext );
8889  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateKHR.sampleCounts );
8890  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateKHR.fragmentSize );
8891  return seed;
8892  }
8893  };
8894 
8895  template <>
8896  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRatePropertiesKHR>
8897  {
8898  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRatePropertiesKHR const & physicalDeviceFragmentShadingRatePropertiesKHR ) const
8899  VULKAN_HPP_NOEXCEPT
8900  {
8901  std::size_t seed = 0;
8902  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.sType );
8903  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.pNext );
8904  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.minFragmentShadingRateAttachmentTexelSize );
8905  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentShadingRateAttachmentTexelSize );
8906  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentShadingRateAttachmentTexelSizeAspectRatio );
8907  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.primitiveFragmentShadingRateWithMultipleViewports );
8908  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.layeredShadingRateAttachments );
8909  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateNonTrivialCombinerOps );
8910  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentSize );
8911  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentSizeAspectRatio );
8912  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentShadingRateCoverageSamples );
8913  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentShadingRateRasterizationSamples );
8914  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithShaderDepthStencilWrites );
8915  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithSampleMask );
8916  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithShaderSampleMask );
8917  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithConservativeRasterization );
8918  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithFragmentShaderInterlock );
8919  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithCustomSampleLocations );
8920  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateStrictMultiplyCombiner );
8921  return seed;
8922  }
8923  };
8924 
8925  template <>
8926  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFrameBoundaryFeaturesEXT>
8927  {
8928  std::size_t
8929  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFrameBoundaryFeaturesEXT const & physicalDeviceFrameBoundaryFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
8930  {
8931  std::size_t seed = 0;
8932  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFrameBoundaryFeaturesEXT.sType );
8933  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFrameBoundaryFeaturesEXT.pNext );
8934  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFrameBoundaryFeaturesEXT.frameBoundary );
8935  return seed;
8936  }
8937  };
8938 
8939  template <>
8940  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceGlobalPriorityQueryFeaturesKHR>
8941  {
8942  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceGlobalPriorityQueryFeaturesKHR const & physicalDeviceGlobalPriorityQueryFeaturesKHR ) const
8943  VULKAN_HPP_NOEXCEPT
8944  {
8945  std::size_t seed = 0;
8946  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGlobalPriorityQueryFeaturesKHR.sType );
8947  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGlobalPriorityQueryFeaturesKHR.pNext );
8948  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGlobalPriorityQueryFeaturesKHR.globalPriorityQuery );
8949  return seed;
8950  }
8951  };
8952 
8953  template <>
8954  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT>
8955  {
8956  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT const & physicalDeviceGraphicsPipelineLibraryFeaturesEXT )
8957  const VULKAN_HPP_NOEXCEPT
8958  {
8959  std::size_t seed = 0;
8960  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGraphicsPipelineLibraryFeaturesEXT.sType );
8961  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGraphicsPipelineLibraryFeaturesEXT.pNext );
8962  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGraphicsPipelineLibraryFeaturesEXT.graphicsPipelineLibrary );
8963  return seed;
8964  }
8965  };
8966 
8967  template <>
8968  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT>
8969  {
8970  std::size_t
8971  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT const & physicalDeviceGraphicsPipelineLibraryPropertiesEXT ) const
8972  VULKAN_HPP_NOEXCEPT
8973  {
8974  std::size_t seed = 0;
8975  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGraphicsPipelineLibraryPropertiesEXT.sType );
8976  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGraphicsPipelineLibraryPropertiesEXT.pNext );
8977  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGraphicsPipelineLibraryPropertiesEXT.graphicsPipelineLibraryFastLinking );
8978  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGraphicsPipelineLibraryPropertiesEXT.graphicsPipelineLibraryIndependentInterpolationDecoration );
8979  return seed;
8980  }
8981  };
8982 
8983  template <>
8984  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties>
8985  {
8986  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties const & physicalDeviceGroupProperties ) const VULKAN_HPP_NOEXCEPT
8987  {
8988  std::size_t seed = 0;
8989  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGroupProperties.sType );
8990  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGroupProperties.pNext );
8991  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGroupProperties.physicalDeviceCount );
8992  for ( size_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; ++i )
8993  {
8994  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGroupProperties.physicalDevices[i] );
8995  }
8996  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGroupProperties.subsetAllocation );
8997  return seed;
8998  }
8999  };
9000 
9001  template <>
9002  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceHostImageCopyFeaturesEXT>
9003  {
9004  std::size_t
9005  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceHostImageCopyFeaturesEXT const & physicalDeviceHostImageCopyFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
9006  {
9007  std::size_t seed = 0;
9008  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyFeaturesEXT.sType );
9009  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyFeaturesEXT.pNext );
9010  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyFeaturesEXT.hostImageCopy );
9011  return seed;
9012  }
9013  };
9014 
9015  template <>
9016  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceHostImageCopyPropertiesEXT>
9017  {
9018  std::size_t
9019  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceHostImageCopyPropertiesEXT const & physicalDeviceHostImageCopyPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
9020  {
9021  std::size_t seed = 0;
9022  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyPropertiesEXT.sType );
9023  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyPropertiesEXT.pNext );
9024  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyPropertiesEXT.copySrcLayoutCount );
9025  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyPropertiesEXT.pCopySrcLayouts );
9026  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyPropertiesEXT.copyDstLayoutCount );
9027  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyPropertiesEXT.pCopyDstLayouts );
9028  for ( size_t i = 0; i < VK_UUID_SIZE; ++i )
9029  {
9030  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyPropertiesEXT.optimalTilingLayoutUUID[i] );
9031  }
9032  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyPropertiesEXT.identicalMemoryTypeRequirements );
9033  return seed;
9034  }
9035  };
9036 
9037  template <>
9038  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceHostQueryResetFeatures>
9039  {
9040  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceHostQueryResetFeatures const & physicalDeviceHostQueryResetFeatures ) const VULKAN_HPP_NOEXCEPT
9041  {
9042  std::size_t seed = 0;
9043  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostQueryResetFeatures.sType );
9044  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostQueryResetFeatures.pNext );
9045  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostQueryResetFeatures.hostQueryReset );
9046  return seed;
9047  }
9048  };
9049 
9050  template <>
9051  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceIDProperties>
9052  {
9053  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceIDProperties const & physicalDeviceIDProperties ) const VULKAN_HPP_NOEXCEPT
9054  {
9055  std::size_t seed = 0;
9056  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIDProperties.sType );
9057  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIDProperties.pNext );
9058  for ( size_t i = 0; i < VK_UUID_SIZE; ++i )
9059  {
9060  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIDProperties.deviceUUID[i] );
9061  }
9062  for ( size_t i = 0; i < VK_UUID_SIZE; ++i )
9063  {
9064  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIDProperties.driverUUID[i] );
9065  }
9066  for ( size_t i = 0; i < VK_LUID_SIZE; ++i )
9067  {
9068  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIDProperties.deviceLUID[i] );
9069  }
9070  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIDProperties.deviceNodeMask );
9071  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIDProperties.deviceLUIDValid );
9072  return seed;
9073  }
9074  };
9075 
9076  template <>
9077  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImage2DViewOf3DFeaturesEXT>
9078  {
9079  std::size_t
9080  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImage2DViewOf3DFeaturesEXT const & physicalDeviceImage2DViewOf3DFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
9081  {
9082  std::size_t seed = 0;
9083  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImage2DViewOf3DFeaturesEXT.sType );
9084  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImage2DViewOf3DFeaturesEXT.pNext );
9085  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImage2DViewOf3DFeaturesEXT.image2DViewOf3D );
9086  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImage2DViewOf3DFeaturesEXT.sampler2DViewOf3D );
9087  return seed;
9088  }
9089  };
9090 
9091  template <>
9092  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageCompressionControlFeaturesEXT>
9093  {
9094  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageCompressionControlFeaturesEXT const & physicalDeviceImageCompressionControlFeaturesEXT )
9095  const VULKAN_HPP_NOEXCEPT
9096  {
9097  std::size_t seed = 0;
9098  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageCompressionControlFeaturesEXT.sType );
9099  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageCompressionControlFeaturesEXT.pNext );
9100  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageCompressionControlFeaturesEXT.imageCompressionControl );
9101  return seed;
9102  }
9103  };
9104 
9105  template <>
9106  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT>
9107  {
9108  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT const &
9109  physicalDeviceImageCompressionControlSwapchainFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
9110  {
9111  std::size_t seed = 0;
9112  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageCompressionControlSwapchainFeaturesEXT.sType );
9113  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageCompressionControlSwapchainFeaturesEXT.pNext );
9114  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageCompressionControlSwapchainFeaturesEXT.imageCompressionControlSwapchain );
9115  return seed;
9116  }
9117  };
9118 
9119  template <>
9120  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageDrmFormatModifierInfoEXT>
9121  {
9122  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageDrmFormatModifierInfoEXT const & physicalDeviceImageDrmFormatModifierInfoEXT ) const
9123  VULKAN_HPP_NOEXCEPT
9124  {
9125  std::size_t seed = 0;
9126  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageDrmFormatModifierInfoEXT.sType );
9127  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageDrmFormatModifierInfoEXT.pNext );
9128  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageDrmFormatModifierInfoEXT.drmFormatModifier );
9129  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageDrmFormatModifierInfoEXT.sharingMode );
9130  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageDrmFormatModifierInfoEXT.queueFamilyIndexCount );
9131  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageDrmFormatModifierInfoEXT.pQueueFamilyIndices );
9132  return seed;
9133  }
9134  };
9135 
9136  template <>
9137  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2>
9138  {
9139  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 const & physicalDeviceImageFormatInfo2 ) const VULKAN_HPP_NOEXCEPT
9140  {
9141  std::size_t seed = 0;
9142  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageFormatInfo2.sType );
9143  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageFormatInfo2.pNext );
9144  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageFormatInfo2.format );
9145  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageFormatInfo2.type );
9146  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageFormatInfo2.tiling );
9147  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageFormatInfo2.usage );
9148  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageFormatInfo2.flags );
9149  return seed;
9150  }
9151  };
9152 
9153  template <>
9154  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessing2FeaturesQCOM>
9155  {
9156  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessing2FeaturesQCOM const & physicalDeviceImageProcessing2FeaturesQCOM ) const
9157  VULKAN_HPP_NOEXCEPT
9158  {
9159  std::size_t seed = 0;
9160  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessing2FeaturesQCOM.sType );
9161  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessing2FeaturesQCOM.pNext );
9162  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessing2FeaturesQCOM.textureBlockMatch2 );
9163  return seed;
9164  }
9165  };
9166 
9167  template <>
9168  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessing2PropertiesQCOM>
9169  {
9170  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessing2PropertiesQCOM const & physicalDeviceImageProcessing2PropertiesQCOM ) const
9171  VULKAN_HPP_NOEXCEPT
9172  {
9173  std::size_t seed = 0;
9174  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessing2PropertiesQCOM.sType );
9175  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessing2PropertiesQCOM.pNext );
9176  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessing2PropertiesQCOM.maxBlockMatchWindow );
9177  return seed;
9178  }
9179  };
9180 
9181  template <>
9182  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessingFeaturesQCOM>
9183  {
9184  std::size_t
9185  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessingFeaturesQCOM const & physicalDeviceImageProcessingFeaturesQCOM ) const VULKAN_HPP_NOEXCEPT
9186  {
9187  std::size_t seed = 0;
9188  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingFeaturesQCOM.sType );
9189  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingFeaturesQCOM.pNext );
9190  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingFeaturesQCOM.textureSampleWeighted );
9191  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingFeaturesQCOM.textureBoxFilter );
9192  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingFeaturesQCOM.textureBlockMatch );
9193  return seed;
9194  }
9195  };
9196 
9197  template <>
9198  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessingPropertiesQCOM>
9199  {
9200  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessingPropertiesQCOM const & physicalDeviceImageProcessingPropertiesQCOM ) const
9201  VULKAN_HPP_NOEXCEPT
9202  {
9203  std::size_t seed = 0;
9204  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingPropertiesQCOM.sType );
9205  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingPropertiesQCOM.pNext );
9206  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingPropertiesQCOM.maxWeightFilterPhases );
9207  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingPropertiesQCOM.maxWeightFilterDimension );
9208  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingPropertiesQCOM.maxBlockMatchRegion );
9209  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingPropertiesQCOM.maxBoxFilterBlockSize );
9210  return seed;
9211  }
9212  };
9213 
9214  template <>
9215  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageRobustnessFeatures>
9216  {
9217  std::size_t
9218  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageRobustnessFeatures const & physicalDeviceImageRobustnessFeatures ) const VULKAN_HPP_NOEXCEPT
9219  {
9220  std::size_t seed = 0;
9221  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageRobustnessFeatures.sType );
9222  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageRobustnessFeatures.pNext );
9223  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageRobustnessFeatures.robustImageAccess );
9224  return seed;
9225  }
9226  };
9227 
9228  template <>
9229  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageSlicedViewOf3DFeaturesEXT>
9230  {
9231  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageSlicedViewOf3DFeaturesEXT const & physicalDeviceImageSlicedViewOf3DFeaturesEXT ) const
9232  VULKAN_HPP_NOEXCEPT
9233  {
9234  std::size_t seed = 0;
9235  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageSlicedViewOf3DFeaturesEXT.sType );
9236  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageSlicedViewOf3DFeaturesEXT.pNext );
9237  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageSlicedViewOf3DFeaturesEXT.imageSlicedViewOf3D );
9238  return seed;
9239  }
9240  };
9241 
9242  template <>
9243  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageViewImageFormatInfoEXT>
9244  {
9245  std::size_t
9246  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageViewImageFormatInfoEXT const & physicalDeviceImageViewImageFormatInfoEXT ) const VULKAN_HPP_NOEXCEPT
9247  {
9248  std::size_t seed = 0;
9249  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageViewImageFormatInfoEXT.sType );
9250  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageViewImageFormatInfoEXT.pNext );
9251  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageViewImageFormatInfoEXT.imageViewType );
9252  return seed;
9253  }
9254  };
9255 
9256  template <>
9257  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageViewMinLodFeaturesEXT>
9258  {
9259  std::size_t
9260  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageViewMinLodFeaturesEXT const & physicalDeviceImageViewMinLodFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
9261  {
9262  std::size_t seed = 0;
9263  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageViewMinLodFeaturesEXT.sType );
9264  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageViewMinLodFeaturesEXT.pNext );
9265  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageViewMinLodFeaturesEXT.minLod );
9266  return seed;
9267  }
9268  };
9269 
9270  template <>
9271  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImagelessFramebufferFeatures>
9272  {
9273  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImagelessFramebufferFeatures const & physicalDeviceImagelessFramebufferFeatures ) const
9274  VULKAN_HPP_NOEXCEPT
9275  {
9276  std::size_t seed = 0;
9277  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImagelessFramebufferFeatures.sType );
9278  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImagelessFramebufferFeatures.pNext );
9279  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImagelessFramebufferFeatures.imagelessFramebuffer );
9280  return seed;
9281  }
9282  };
9283 
9284  template <>
9285  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceIndexTypeUint8FeaturesEXT>
9286  {
9287  std::size_t
9288  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceIndexTypeUint8FeaturesEXT const & physicalDeviceIndexTypeUint8FeaturesEXT ) const VULKAN_HPP_NOEXCEPT
9289  {
9290  std::size_t seed = 0;
9291  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIndexTypeUint8FeaturesEXT.sType );
9292  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIndexTypeUint8FeaturesEXT.pNext );
9293  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIndexTypeUint8FeaturesEXT.indexTypeUint8 );
9294  return seed;
9295  }
9296  };
9297 
9298  template <>
9299  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceInheritedViewportScissorFeaturesNV>
9300  {
9301  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceInheritedViewportScissorFeaturesNV const & physicalDeviceInheritedViewportScissorFeaturesNV )
9302  const VULKAN_HPP_NOEXCEPT
9303  {
9304  std::size_t seed = 0;
9305  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInheritedViewportScissorFeaturesNV.sType );
9306  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInheritedViewportScissorFeaturesNV.pNext );
9307  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInheritedViewportScissorFeaturesNV.inheritedViewportScissor2D );
9308  return seed;
9309  }
9310  };
9311 
9312  template <>
9313  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceInlineUniformBlockFeatures>
9314  {
9315  std::size_t
9316  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceInlineUniformBlockFeatures const & physicalDeviceInlineUniformBlockFeatures ) const VULKAN_HPP_NOEXCEPT
9317  {
9318  std::size_t seed = 0;
9319  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockFeatures.sType );
9320  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockFeatures.pNext );
9321  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockFeatures.inlineUniformBlock );
9322  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockFeatures.descriptorBindingInlineUniformBlockUpdateAfterBind );
9323  return seed;
9324  }
9325  };
9326 
9327  template <>
9328  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceInlineUniformBlockProperties>
9329  {
9330  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceInlineUniformBlockProperties const & physicalDeviceInlineUniformBlockProperties ) const
9331  VULKAN_HPP_NOEXCEPT
9332  {
9333  std::size_t seed = 0;
9334  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockProperties.sType );
9335  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockProperties.pNext );
9336  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockProperties.maxInlineUniformBlockSize );
9337  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockProperties.maxPerStageDescriptorInlineUniformBlocks );
9338  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockProperties.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks );
9339  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockProperties.maxDescriptorSetInlineUniformBlocks );
9340  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockProperties.maxDescriptorSetUpdateAfterBindInlineUniformBlocks );
9341  return seed;
9342  }
9343  };
9344 
9345  template <>
9346  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceInvocationMaskFeaturesHUAWEI>
9347  {
9348  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceInvocationMaskFeaturesHUAWEI const & physicalDeviceInvocationMaskFeaturesHUAWEI ) const
9349  VULKAN_HPP_NOEXCEPT
9350  {
9351  std::size_t seed = 0;
9352  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInvocationMaskFeaturesHUAWEI.sType );
9353  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInvocationMaskFeaturesHUAWEI.pNext );
9354  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInvocationMaskFeaturesHUAWEI.invocationMask );
9355  return seed;
9356  }
9357  };
9358 
9359  template <>
9360  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredDriverPropertiesMSFT>
9361  {
9362  std::size_t
9363  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredDriverPropertiesMSFT const & physicalDeviceLayeredDriverPropertiesMSFT ) const VULKAN_HPP_NOEXCEPT
9364  {
9365  std::size_t seed = 0;
9366  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredDriverPropertiesMSFT.sType );
9367  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredDriverPropertiesMSFT.pNext );
9368  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredDriverPropertiesMSFT.underlyingAPI );
9369  return seed;
9370  }
9371  };
9372 
9373  template <>
9374  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLegacyDitheringFeaturesEXT>
9375  {
9376  std::size_t
9377  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLegacyDitheringFeaturesEXT const & physicalDeviceLegacyDitheringFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
9378  {
9379  std::size_t seed = 0;
9380  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyDitheringFeaturesEXT.sType );
9381  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyDitheringFeaturesEXT.pNext );
9382  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyDitheringFeaturesEXT.legacyDithering );
9383  return seed;
9384  }
9385  };
9386 
9387  template <>
9388  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLimits>
9389  {
9390  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLimits const & physicalDeviceLimits ) const VULKAN_HPP_NOEXCEPT
9391  {
9392  std::size_t seed = 0;
9393  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxImageDimension1D );
9394  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxImageDimension2D );
9395  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxImageDimension3D );
9396  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxImageDimensionCube );
9397  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxImageArrayLayers );
9398  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTexelBufferElements );
9399  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxUniformBufferRange );
9400  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxStorageBufferRange );
9401  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxPushConstantsSize );
9402  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxMemoryAllocationCount );
9403  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxSamplerAllocationCount );
9404  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.bufferImageGranularity );
9405  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.sparseAddressSpaceSize );
9406  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxBoundDescriptorSets );
9407  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxPerStageDescriptorSamplers );
9408  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxPerStageDescriptorUniformBuffers );
9409  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxPerStageDescriptorStorageBuffers );
9410  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxPerStageDescriptorSampledImages );
9411  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxPerStageDescriptorStorageImages );
9412  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxPerStageDescriptorInputAttachments );
9413  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxPerStageResources );
9414  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDescriptorSetSamplers );
9415  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDescriptorSetUniformBuffers );
9416  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDescriptorSetUniformBuffersDynamic );
9417  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDescriptorSetStorageBuffers );
9418  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDescriptorSetStorageBuffersDynamic );
9419  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDescriptorSetSampledImages );
9420  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDescriptorSetStorageImages );
9421  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDescriptorSetInputAttachments );
9422  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxVertexInputAttributes );
9423  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxVertexInputBindings );
9424  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxVertexInputAttributeOffset );
9425  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxVertexInputBindingStride );
9426  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxVertexOutputComponents );
9427  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTessellationGenerationLevel );
9428  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTessellationPatchSize );
9429  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTessellationControlPerVertexInputComponents );
9430  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTessellationControlPerVertexOutputComponents );
9431  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTessellationControlPerPatchOutputComponents );
9432  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTessellationControlTotalOutputComponents );
9433  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTessellationEvaluationInputComponents );
9434  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTessellationEvaluationOutputComponents );
9435  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxGeometryShaderInvocations );
9436  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxGeometryInputComponents );
9437  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxGeometryOutputComponents );
9438  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxGeometryOutputVertices );
9439  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxGeometryTotalOutputComponents );
9440  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxFragmentInputComponents );
9441  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxFragmentOutputAttachments );
9442  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxFragmentDualSrcAttachments );
9443  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxFragmentCombinedOutputResources );
9444  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxComputeSharedMemorySize );
9445  for ( size_t i = 0; i < 3; ++i )
9446  {
9447  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxComputeWorkGroupCount[i] );
9448  }
9449  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxComputeWorkGroupInvocations );
9450  for ( size_t i = 0; i < 3; ++i )
9451  {
9452  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxComputeWorkGroupSize[i] );
9453  }
9454  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.subPixelPrecisionBits );
9455  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.subTexelPrecisionBits );
9456  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.mipmapPrecisionBits );
9457  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDrawIndexedIndexValue );
9458  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDrawIndirectCount );
9459  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxSamplerLodBias );
9460  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxSamplerAnisotropy );
9461  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxViewports );
9462  for ( size_t i = 0; i < 2; ++i )
9463  {
9464  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxViewportDimensions[i] );
9465  }
9466  for ( size_t i = 0; i < 2; ++i )
9467  {
9468  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.viewportBoundsRange[i] );
9469  }
9470  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.viewportSubPixelBits );
9471  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.minMemoryMapAlignment );
9472  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.minTexelBufferOffsetAlignment );
9473  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.minUniformBufferOffsetAlignment );
9474  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.minStorageBufferOffsetAlignment );
9475  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.minTexelOffset );
9476  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTexelOffset );
9477  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.minTexelGatherOffset );
9478  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTexelGatherOffset );
9479  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.minInterpolationOffset );
9480  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxInterpolationOffset );
9481  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.subPixelInterpolationOffsetBits );
9482  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxFramebufferWidth );
9483  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxFramebufferHeight );
9484  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxFramebufferLayers );
9485  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.framebufferColorSampleCounts );
9486  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.framebufferDepthSampleCounts );
9487  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.framebufferStencilSampleCounts );
9488  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.framebufferNoAttachmentsSampleCounts );
9489  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxColorAttachments );
9490  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.sampledImageColorSampleCounts );
9491  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.sampledImageIntegerSampleCounts );
9492  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.sampledImageDepthSampleCounts );
9493  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.sampledImageStencilSampleCounts );
9494  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.storageImageSampleCounts );
9495  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxSampleMaskWords );
9496  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.timestampComputeAndGraphics );
9497  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.timestampPeriod );
9498  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxClipDistances );
9499  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxCullDistances );
9500  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxCombinedClipAndCullDistances );
9501  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.discreteQueuePriorities );
9502  for ( size_t i = 0; i < 2; ++i )
9503  {
9504  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.pointSizeRange[i] );
9505  }
9506  for ( size_t i = 0; i < 2; ++i )
9507  {
9508  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.lineWidthRange[i] );
9509  }
9510  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.pointSizeGranularity );
9511  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.lineWidthGranularity );
9512  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.strictLines );
9513  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.standardSampleLocations );
9514  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.optimalBufferCopyOffsetAlignment );
9515  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.optimalBufferCopyRowPitchAlignment );
9516  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.nonCoherentAtomSize );
9517  return seed;
9518  }
9519  };
9520 
9521  template <>
9522  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationFeaturesEXT>
9523  {
9524  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationFeaturesEXT const & physicalDeviceLineRasterizationFeaturesEXT ) const
9525  VULKAN_HPP_NOEXCEPT
9526  {
9527  std::size_t seed = 0;
9528  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeaturesEXT.sType );
9529  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeaturesEXT.pNext );
9530  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeaturesEXT.rectangularLines );
9531  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeaturesEXT.bresenhamLines );
9532  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeaturesEXT.smoothLines );
9533  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeaturesEXT.stippledRectangularLines );
9534  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeaturesEXT.stippledBresenhamLines );
9535  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeaturesEXT.stippledSmoothLines );
9536  return seed;
9537  }
9538  };
9539 
9540  template <>
9541  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationPropertiesEXT>
9542  {
9543  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationPropertiesEXT const & physicalDeviceLineRasterizationPropertiesEXT ) const
9544  VULKAN_HPP_NOEXCEPT
9545  {
9546  std::size_t seed = 0;
9547  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationPropertiesEXT.sType );
9548  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationPropertiesEXT.pNext );
9549  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationPropertiesEXT.lineSubPixelPrecisionBits );
9550  return seed;
9551  }
9552  };
9553 
9554  template <>
9555  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLinearColorAttachmentFeaturesNV>
9556  {
9557  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLinearColorAttachmentFeaturesNV const & physicalDeviceLinearColorAttachmentFeaturesNV ) const
9558  VULKAN_HPP_NOEXCEPT
9559  {
9560  std::size_t seed = 0;
9561  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLinearColorAttachmentFeaturesNV.sType );
9562  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLinearColorAttachmentFeaturesNV.pNext );
9563  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLinearColorAttachmentFeaturesNV.linearColorAttachment );
9564  return seed;
9565  }
9566  };
9567 
9568  template <>
9569  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance3Properties>
9570  {
9571  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance3Properties const & physicalDeviceMaintenance3Properties ) const VULKAN_HPP_NOEXCEPT
9572  {
9573  std::size_t seed = 0;
9574  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance3Properties.sType );
9575  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance3Properties.pNext );
9576  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance3Properties.maxPerSetDescriptors );
9577  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance3Properties.maxMemoryAllocationSize );
9578  return seed;
9579  }
9580  };
9581 
9582  template <>
9583  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance4Features>
9584  {
9585  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance4Features const & physicalDeviceMaintenance4Features ) const VULKAN_HPP_NOEXCEPT
9586  {
9587  std::size_t seed = 0;
9588  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance4Features.sType );
9589  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance4Features.pNext );
9590  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance4Features.maintenance4 );
9591  return seed;
9592  }
9593  };
9594 
9595  template <>
9596  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance4Properties>
9597  {
9598  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance4Properties const & physicalDeviceMaintenance4Properties ) const VULKAN_HPP_NOEXCEPT
9599  {
9600  std::size_t seed = 0;
9601  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance4Properties.sType );
9602  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance4Properties.pNext );
9603  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance4Properties.maxBufferSize );
9604  return seed;
9605  }
9606  };
9607 
9608  template <>
9609  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance5FeaturesKHR>
9610  {
9611  std::size_t
9612  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance5FeaturesKHR const & physicalDeviceMaintenance5FeaturesKHR ) const VULKAN_HPP_NOEXCEPT
9613  {
9614  std::size_t seed = 0;
9615  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5FeaturesKHR.sType );
9616  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5FeaturesKHR.pNext );
9617  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5FeaturesKHR.maintenance5 );
9618  return seed;
9619  }
9620  };
9621 
9622  template <>
9623  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance5PropertiesKHR>
9624  {
9625  std::size_t
9626  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance5PropertiesKHR const & physicalDeviceMaintenance5PropertiesKHR ) const VULKAN_HPP_NOEXCEPT
9627  {
9628  std::size_t seed = 0;
9629  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5PropertiesKHR.sType );
9630  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5PropertiesKHR.pNext );
9631  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5PropertiesKHR.earlyFragmentMultisampleCoverageAfterSampleCounting );
9632  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5PropertiesKHR.earlyFragmentSampleMaskTestBeforeSampleCounting );
9633  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5PropertiesKHR.depthStencilSwizzleOneSupport );
9634  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5PropertiesKHR.polygonModePointSize );
9635  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5PropertiesKHR.nonStrictSinglePixelWideLinesUseParallelogram );
9636  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5PropertiesKHR.nonStrictWideLinesUseParallelogram );
9637  return seed;
9638  }
9639  };
9640 
9641  template <>
9642  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance6FeaturesKHR>
9643  {
9644  std::size_t
9645  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance6FeaturesKHR const & physicalDeviceMaintenance6FeaturesKHR ) const VULKAN_HPP_NOEXCEPT
9646  {
9647  std::size_t seed = 0;
9648  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance6FeaturesKHR.sType );
9649  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance6FeaturesKHR.pNext );
9650  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance6FeaturesKHR.maintenance6 );
9651  return seed;
9652  }
9653  };
9654 
9655  template <>
9656  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance6PropertiesKHR>
9657  {
9658  std::size_t
9659  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance6PropertiesKHR const & physicalDeviceMaintenance6PropertiesKHR ) const VULKAN_HPP_NOEXCEPT
9660  {
9661  std::size_t seed = 0;
9662  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance6PropertiesKHR.sType );
9663  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance6PropertiesKHR.pNext );
9664  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance6PropertiesKHR.blockTexelViewCompatibleMultipleLayers );
9665  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance6PropertiesKHR.maxCombinedImageSamplerDescriptorCount );
9666  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance6PropertiesKHR.fragmentShadingRateClampCombinerInputs );
9667  return seed;
9668  }
9669  };
9670 
9671  template <>
9672  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryBudgetPropertiesEXT>
9673  {
9674  std::size_t
9675  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryBudgetPropertiesEXT const & physicalDeviceMemoryBudgetPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
9676  {
9677  std::size_t seed = 0;
9678  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryBudgetPropertiesEXT.sType );
9679  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryBudgetPropertiesEXT.pNext );
9680  for ( size_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i )
9681  {
9682  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryBudgetPropertiesEXT.heapBudget[i] );
9683  }
9684  for ( size_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i )
9685  {
9686  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryBudgetPropertiesEXT.heapUsage[i] );
9687  }
9688  return seed;
9689  }
9690  };
9691 
9692  template <>
9693  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryDecompressionFeaturesNV>
9694  {
9695  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryDecompressionFeaturesNV const & physicalDeviceMemoryDecompressionFeaturesNV ) const
9696  VULKAN_HPP_NOEXCEPT
9697  {
9698  std::size_t seed = 0;
9699  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionFeaturesNV.sType );
9700  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionFeaturesNV.pNext );
9701  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionFeaturesNV.memoryDecompression );
9702  return seed;
9703  }
9704  };
9705 
9706  template <>
9707  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryDecompressionPropertiesNV>
9708  {
9709  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryDecompressionPropertiesNV const & physicalDeviceMemoryDecompressionPropertiesNV ) const
9710  VULKAN_HPP_NOEXCEPT
9711  {
9712  std::size_t seed = 0;
9713  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionPropertiesNV.sType );
9714  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionPropertiesNV.pNext );
9715  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionPropertiesNV.decompressionMethods );
9716  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionPropertiesNV.maxDecompressionIndirectCount );
9717  return seed;
9718  }
9719  };
9720 
9721  template <>
9722  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryPriorityFeaturesEXT>
9723  {
9724  std::size_t
9725  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryPriorityFeaturesEXT const & physicalDeviceMemoryPriorityFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
9726  {
9727  std::size_t seed = 0;
9728  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryPriorityFeaturesEXT.sType );
9729  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryPriorityFeaturesEXT.pNext );
9730  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryPriorityFeaturesEXT.memoryPriority );
9731  return seed;
9732  }
9733  };
9734 
9735  template <>
9736  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties>
9737  {
9738  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties const & physicalDeviceMemoryProperties ) const VULKAN_HPP_NOEXCEPT
9739  {
9740  std::size_t seed = 0;
9741  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryProperties.memoryTypeCount );
9742  for ( size_t i = 0; i < VK_MAX_MEMORY_TYPES; ++i )
9743  {
9744  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryProperties.memoryTypes[i] );
9745  }
9746  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryProperties.memoryHeapCount );
9747  for ( size_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i )
9748  {
9749  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryProperties.memoryHeaps[i] );
9750  }
9751  return seed;
9752  }
9753  };
9754 
9755  template <>
9756  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2>
9757  {
9758  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 const & physicalDeviceMemoryProperties2 ) const VULKAN_HPP_NOEXCEPT
9759  {
9760  std::size_t seed = 0;
9761  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryProperties2.sType );
9762  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryProperties2.pNext );
9763  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryProperties2.memoryProperties );
9764  return seed;
9765  }
9766  };
9767 
9768  template <>
9769  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderFeaturesEXT>
9770  {
9771  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderFeaturesEXT const & physicalDeviceMeshShaderFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
9772  {
9773  std::size_t seed = 0;
9774  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesEXT.sType );
9775  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesEXT.pNext );
9776  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesEXT.taskShader );
9777  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesEXT.meshShader );
9778  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesEXT.multiviewMeshShader );
9779  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesEXT.primitiveFragmentShadingRateMeshShader );
9780  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesEXT.meshShaderQueries );
9781  return seed;
9782  }
9783  };
9784 
9785  template <>
9786  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderFeaturesNV>
9787  {
9788  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderFeaturesNV const & physicalDeviceMeshShaderFeaturesNV ) const VULKAN_HPP_NOEXCEPT
9789  {
9790  std::size_t seed = 0;
9791  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesNV.sType );
9792  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesNV.pNext );
9793  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesNV.taskShader );
9794  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesNV.meshShader );
9795  return seed;
9796  }
9797  };
9798 
9799  template <>
9800  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderPropertiesEXT>
9801  {
9802  std::size_t
9803  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderPropertiesEXT const & physicalDeviceMeshShaderPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
9804  {
9805  std::size_t seed = 0;
9806  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.sType );
9807  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.pNext );
9808  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxTaskWorkGroupTotalCount );
9809  for ( size_t i = 0; i < 3; ++i )
9810  {
9811  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxTaskWorkGroupCount[i] );
9812  }
9813  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxTaskWorkGroupInvocations );
9814  for ( size_t i = 0; i < 3; ++i )
9815  {
9816  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxTaskWorkGroupSize[i] );
9817  }
9818  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxTaskPayloadSize );
9819  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxTaskSharedMemorySize );
9820  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxTaskPayloadAndSharedMemorySize );
9821  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshWorkGroupTotalCount );
9822  for ( size_t i = 0; i < 3; ++i )
9823  {
9824  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshWorkGroupCount[i] );
9825  }
9826  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshWorkGroupInvocations );
9827  for ( size_t i = 0; i < 3; ++i )
9828  {
9829  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshWorkGroupSize[i] );
9830  }
9831  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshSharedMemorySize );
9832  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshPayloadAndSharedMemorySize );
9833  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshOutputMemorySize );
9834  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshPayloadAndOutputMemorySize );
9835  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshOutputComponents );
9836  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshOutputVertices );
9837  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshOutputPrimitives );
9838  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshOutputLayers );
9839  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshMultiviewViewCount );
9840  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.meshOutputPerVertexGranularity );
9841  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.meshOutputPerPrimitiveGranularity );
9842  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxPreferredTaskWorkGroupInvocations );
9843  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxPreferredMeshWorkGroupInvocations );
9844  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.prefersLocalInvocationVertexOutput );
9845  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.prefersLocalInvocationPrimitiveOutput );
9846  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.prefersCompactVertexOutput );
9847  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.prefersCompactPrimitiveOutput );
9848  return seed;
9849  }
9850  };
9851 
9852  template <>
9853  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderPropertiesNV>
9854  {
9855  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderPropertiesNV const & physicalDeviceMeshShaderPropertiesNV ) const VULKAN_HPP_NOEXCEPT
9856  {
9857  std::size_t seed = 0;
9858  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.sType );
9859  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.pNext );
9860  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxDrawMeshTasksCount );
9861  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxTaskWorkGroupInvocations );
9862  for ( size_t i = 0; i < 3; ++i )
9863  {
9864  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxTaskWorkGroupSize[i] );
9865  }
9866  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxTaskTotalMemorySize );
9867  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxTaskOutputCount );
9868  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxMeshWorkGroupInvocations );
9869  for ( size_t i = 0; i < 3; ++i )
9870  {
9871  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxMeshWorkGroupSize[i] );
9872  }
9873  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxMeshTotalMemorySize );
9874  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxMeshOutputVertices );
9875  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxMeshOutputPrimitives );
9876  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxMeshMultiviewViewCount );
9877  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.meshOutputPerVertexGranularity );
9878  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.meshOutputPerPrimitiveGranularity );
9879  return seed;
9880  }
9881  };
9882 
9883  template <>
9884  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiDrawFeaturesEXT>
9885  {
9886  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiDrawFeaturesEXT const & physicalDeviceMultiDrawFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
9887  {
9888  std::size_t seed = 0;
9889  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiDrawFeaturesEXT.sType );
9890  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiDrawFeaturesEXT.pNext );
9891  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiDrawFeaturesEXT.multiDraw );
9892  return seed;
9893  }
9894  };
9895 
9896  template <>
9897  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiDrawPropertiesEXT>
9898  {
9899  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiDrawPropertiesEXT const & physicalDeviceMultiDrawPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
9900  {
9901  std::size_t seed = 0;
9902  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiDrawPropertiesEXT.sType );
9903  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiDrawPropertiesEXT.pNext );
9904  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiDrawPropertiesEXT.maxMultiDrawCount );
9905  return seed;
9906  }
9907  };
9908 
9909  template <>
9910  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT>
9911  {
9912  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT const &
9913  physicalDeviceMultisampledRenderToSingleSampledFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
9914  {
9915  std::size_t seed = 0;
9916  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultisampledRenderToSingleSampledFeaturesEXT.sType );
9917  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultisampledRenderToSingleSampledFeaturesEXT.pNext );
9918  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultisampledRenderToSingleSampledFeaturesEXT.multisampledRenderToSingleSampled );
9919  return seed;
9920  }
9921  };
9922 
9923  template <>
9924  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewFeatures>
9925  {
9926  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewFeatures const & physicalDeviceMultiviewFeatures ) const VULKAN_HPP_NOEXCEPT
9927  {
9928  std::size_t seed = 0;
9929  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewFeatures.sType );
9930  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewFeatures.pNext );
9931  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewFeatures.multiview );
9932  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewFeatures.multiviewGeometryShader );
9933  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewFeatures.multiviewTessellationShader );
9934  return seed;
9935  }
9936  };
9937 
9938  template <>
9939  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX>
9940  {
9941  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const &
9942  physicalDeviceMultiviewPerViewAttributesPropertiesNVX ) const VULKAN_HPP_NOEXCEPT
9943  {
9944  std::size_t seed = 0;
9945  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewAttributesPropertiesNVX.sType );
9946  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewAttributesPropertiesNVX.pNext );
9947  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewAttributesPropertiesNVX.perViewPositionAllComponents );
9948  return seed;
9949  }
9950  };
9951 
9952  template <>
9953  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM>
9954  {
9955  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM const &
9956  physicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM ) const VULKAN_HPP_NOEXCEPT
9957  {
9958  std::size_t seed = 0;
9959  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM.sType );
9960  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM.pNext );
9961  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM.multiviewPerViewRenderAreas );
9962  return seed;
9963  }
9964  };
9965 
9966  template <>
9967  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM>
9968  {
9969  std::size_t
9970  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM const & physicalDeviceMultiviewPerViewViewportsFeaturesQCOM ) const
9971  VULKAN_HPP_NOEXCEPT
9972  {
9973  std::size_t seed = 0;
9974  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewViewportsFeaturesQCOM.sType );
9975  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewViewportsFeaturesQCOM.pNext );
9976  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewViewportsFeaturesQCOM.multiviewPerViewViewports );
9977  return seed;
9978  }
9979  };
9980 
9981  template <>
9982  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewProperties>
9983  {
9984  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewProperties const & physicalDeviceMultiviewProperties ) const VULKAN_HPP_NOEXCEPT
9985  {
9986  std::size_t seed = 0;
9987  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewProperties.sType );
9988  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewProperties.pNext );
9989  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewProperties.maxMultiviewViewCount );
9990  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewProperties.maxMultiviewInstanceIndex );
9991  return seed;
9992  }
9993  };
9994 
9995  template <>
9996  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMutableDescriptorTypeFeaturesEXT>
9997  {
9998  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMutableDescriptorTypeFeaturesEXT const & physicalDeviceMutableDescriptorTypeFeaturesEXT ) const
9999  VULKAN_HPP_NOEXCEPT
10000  {
10001  std::size_t seed = 0;
10002  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMutableDescriptorTypeFeaturesEXT.sType );
10003  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMutableDescriptorTypeFeaturesEXT.pNext );
10004  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMutableDescriptorTypeFeaturesEXT.mutableDescriptorType );
10005  return seed;
10006  }
10007  };
10008 
10009  template <>
10010  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceNestedCommandBufferFeaturesEXT>
10011  {
10012  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceNestedCommandBufferFeaturesEXT const & physicalDeviceNestedCommandBufferFeaturesEXT ) const
10013  VULKAN_HPP_NOEXCEPT
10014  {
10015  std::size_t seed = 0;
10016  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNestedCommandBufferFeaturesEXT.sType );
10017  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNestedCommandBufferFeaturesEXT.pNext );
10018  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNestedCommandBufferFeaturesEXT.nestedCommandBuffer );
10019  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNestedCommandBufferFeaturesEXT.nestedCommandBufferRendering );
10020  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNestedCommandBufferFeaturesEXT.nestedCommandBufferSimultaneousUse );
10021  return seed;
10022  }
10023  };
10024 
10025  template <>
10026  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceNestedCommandBufferPropertiesEXT>
10027  {
10028  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceNestedCommandBufferPropertiesEXT const & physicalDeviceNestedCommandBufferPropertiesEXT ) const
10029  VULKAN_HPP_NOEXCEPT
10030  {
10031  std::size_t seed = 0;
10032  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNestedCommandBufferPropertiesEXT.sType );
10033  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNestedCommandBufferPropertiesEXT.pNext );
10034  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNestedCommandBufferPropertiesEXT.maxCommandBufferNestingLevel );
10035  return seed;
10036  }
10037  };
10038 
10039  template <>
10040  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceNonSeamlessCubeMapFeaturesEXT>
10041  {
10042  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceNonSeamlessCubeMapFeaturesEXT const & physicalDeviceNonSeamlessCubeMapFeaturesEXT ) const
10043  VULKAN_HPP_NOEXCEPT
10044  {
10045  std::size_t seed = 0;
10046  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNonSeamlessCubeMapFeaturesEXT.sType );
10047  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNonSeamlessCubeMapFeaturesEXT.pNext );
10048  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNonSeamlessCubeMapFeaturesEXT.nonSeamlessCubeMap );
10049  return seed;
10050  }
10051  };
10052 
10053  template <>
10054  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceOpacityMicromapFeaturesEXT>
10055  {
10056  std::size_t
10057  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceOpacityMicromapFeaturesEXT const & physicalDeviceOpacityMicromapFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
10058  {
10059  std::size_t seed = 0;
10060  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapFeaturesEXT.sType );
10061  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapFeaturesEXT.pNext );
10062  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapFeaturesEXT.micromap );
10063  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapFeaturesEXT.micromapCaptureReplay );
10064  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapFeaturesEXT.micromapHostCommands );
10065  return seed;
10066  }
10067  };
10068 
10069  template <>
10070  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceOpacityMicromapPropertiesEXT>
10071  {
10072  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceOpacityMicromapPropertiesEXT const & physicalDeviceOpacityMicromapPropertiesEXT ) const
10073  VULKAN_HPP_NOEXCEPT
10074  {
10075  std::size_t seed = 0;
10076  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapPropertiesEXT.sType );
10077  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapPropertiesEXT.pNext );
10078  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapPropertiesEXT.maxOpacity2StateSubdivisionLevel );
10079  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapPropertiesEXT.maxOpacity4StateSubdivisionLevel );
10080  return seed;
10081  }
10082  };
10083 
10084  template <>
10085  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceOpticalFlowFeaturesNV>
10086  {
10087  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceOpticalFlowFeaturesNV const & physicalDeviceOpticalFlowFeaturesNV ) const VULKAN_HPP_NOEXCEPT
10088  {
10089  std::size_t seed = 0;
10090  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowFeaturesNV.sType );
10091  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowFeaturesNV.pNext );
10092  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowFeaturesNV.opticalFlow );
10093  return seed;
10094  }
10095  };
10096 
10097  template <>
10098  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceOpticalFlowPropertiesNV>
10099  {
10100  std::size_t
10101  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceOpticalFlowPropertiesNV const & physicalDeviceOpticalFlowPropertiesNV ) const VULKAN_HPP_NOEXCEPT
10102  {
10103  std::size_t seed = 0;
10104  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.sType );
10105  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.pNext );
10106  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.supportedOutputGridSizes );
10107  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.supportedHintGridSizes );
10108  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.hintSupported );
10109  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.costSupported );
10110  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.bidirectionalFlowSupported );
10111  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.globalFlowSupported );
10112  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.minWidth );
10113  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.minHeight );
10114  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.maxWidth );
10115  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.maxHeight );
10116  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.maxNumRegionsOfInterest );
10117  return seed;
10118  }
10119  };
10120 
10121  template <>
10122  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePCIBusInfoPropertiesEXT>
10123  {
10124  std::size_t
10125  operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePCIBusInfoPropertiesEXT const & physicalDevicePCIBusInfoPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
10126  {
10127  std::size_t seed = 0;
10128  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePCIBusInfoPropertiesEXT.sType );
10129  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePCIBusInfoPropertiesEXT.pNext );
10130  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePCIBusInfoPropertiesEXT.pciDomain );
10131  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePCIBusInfoPropertiesEXT.pciBus );
10132  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePCIBusInfoPropertiesEXT.pciDevice );
10133  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePCIBusInfoPropertiesEXT.pciFunction );
10134  return seed;
10135  }
10136  };
10137 
10138  template <>
10139  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT>
10140  {
10141  std::size_t
10142  operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT const & physicalDevicePageableDeviceLocalMemoryFeaturesEXT ) const
10143  VULKAN_HPP_NOEXCEPT
10144  {
10145  std::size_t seed = 0;
10146  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePageableDeviceLocalMemoryFeaturesEXT.sType );
10147  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePageableDeviceLocalMemoryFeaturesEXT.pNext );
10148  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePageableDeviceLocalMemoryFeaturesEXT.pageableDeviceLocalMemory );
10149  return seed;
10150  }
10151  };
10152 
10153  template <>
10154  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePerStageDescriptorSetFeaturesNV>
10155  {
10156  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePerStageDescriptorSetFeaturesNV const & physicalDevicePerStageDescriptorSetFeaturesNV ) const
10157  VULKAN_HPP_NOEXCEPT
10158  {
10159  std::size_t seed = 0;
10160  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerStageDescriptorSetFeaturesNV.sType );
10161  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerStageDescriptorSetFeaturesNV.pNext );
10162  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerStageDescriptorSetFeaturesNV.perStageDescriptorSet );
10163  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerStageDescriptorSetFeaturesNV.dynamicPipelineLayout );
10164  return seed;
10165  }
10166  };
10167 
10168  template <>
10169  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceQueryFeaturesKHR>
10170  {
10171  std::size_t
10172  operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceQueryFeaturesKHR const & physicalDevicePerformanceQueryFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
10173  {
10174  std::size_t seed = 0;
10175  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceQueryFeaturesKHR.sType );
10176  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceQueryFeaturesKHR.pNext );
10177  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceQueryFeaturesKHR.performanceCounterQueryPools );
10178  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceQueryFeaturesKHR.performanceCounterMultipleQueryPools );
10179  return seed;
10180  }
10181  };
10182 
10183  template <>
10184  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceQueryPropertiesKHR>
10185  {
10186  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceQueryPropertiesKHR const & physicalDevicePerformanceQueryPropertiesKHR ) const
10187  VULKAN_HPP_NOEXCEPT
10188  {
10189  std::size_t seed = 0;
10190  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceQueryPropertiesKHR.sType );
10191  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceQueryPropertiesKHR.pNext );
10192  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceQueryPropertiesKHR.allowCommandBufferQueryCopies );
10193  return seed;
10194  }
10195  };
10196 
10197  template <>
10198  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineCreationCacheControlFeatures>
10199  {
10200  std::size_t
10201  operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineCreationCacheControlFeatures const & physicalDevicePipelineCreationCacheControlFeatures ) const
10202  VULKAN_HPP_NOEXCEPT
10203  {
10204  std::size_t seed = 0;
10205  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineCreationCacheControlFeatures.sType );
10206  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineCreationCacheControlFeatures.pNext );
10207  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineCreationCacheControlFeatures.pipelineCreationCacheControl );
10208  return seed;
10209  }
10210  };
10211 
10212  template <>
10213  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR>
10214  {
10215  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR const &
10216  physicalDevicePipelineExecutablePropertiesFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
10217  {
10218  std::size_t seed = 0;
10219  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineExecutablePropertiesFeaturesKHR.sType );
10220  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineExecutablePropertiesFeaturesKHR.pNext );
10221  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineExecutablePropertiesFeaturesKHR.pipelineExecutableInfo );
10222  return seed;
10223  }
10224  };
10225 
10226  template <>
10227  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT>
10228  {
10229  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT const &
10230  physicalDevicePipelineLibraryGroupHandlesFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
10231  {
10232  std::size_t seed = 0;
10233  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineLibraryGroupHandlesFeaturesEXT.sType );
10234  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineLibraryGroupHandlesFeaturesEXT.pNext );
10235  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineLibraryGroupHandlesFeaturesEXT.pipelineLibraryGroupHandles );
10236  return seed;
10237  }
10238  };
10239 
10240  template <>
10241  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelinePropertiesFeaturesEXT>
10242  {
10243  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelinePropertiesFeaturesEXT const & physicalDevicePipelinePropertiesFeaturesEXT ) const
10244  VULKAN_HPP_NOEXCEPT
10245  {
10246  std::size_t seed = 0;
10247  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelinePropertiesFeaturesEXT.sType );
10248  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelinePropertiesFeaturesEXT.pNext );
10249  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelinePropertiesFeaturesEXT.pipelinePropertiesIdentifier );
10250  return seed;
10251  }
10252  };
10253 
10254  template <>
10255  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineProtectedAccessFeaturesEXT>
10256  {
10257  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineProtectedAccessFeaturesEXT const & physicalDevicePipelineProtectedAccessFeaturesEXT )
10258  const VULKAN_HPP_NOEXCEPT
10259  {
10260  std::size_t seed = 0;
10261  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineProtectedAccessFeaturesEXT.sType );
10262  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineProtectedAccessFeaturesEXT.pNext );
10263  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineProtectedAccessFeaturesEXT.pipelineProtectedAccess );
10264  return seed;
10265  }
10266  };
10267 
10268  template <>
10269  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineRobustnessFeaturesEXT>
10270  {
10271  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineRobustnessFeaturesEXT const & physicalDevicePipelineRobustnessFeaturesEXT ) const
10272  VULKAN_HPP_NOEXCEPT
10273  {
10274  std::size_t seed = 0;
10275  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineRobustnessFeaturesEXT.sType );
10276  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineRobustnessFeaturesEXT.pNext );
10277  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineRobustnessFeaturesEXT.pipelineRobustness );
10278  return seed;
10279  }
10280  };
10281 
10282  template <>
10283  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineRobustnessPropertiesEXT>
10284  {
10285  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineRobustnessPropertiesEXT const & physicalDevicePipelineRobustnessPropertiesEXT ) const
10286  VULKAN_HPP_NOEXCEPT
10287  {
10288  std::size_t seed = 0;
10289  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineRobustnessPropertiesEXT.sType );
10290  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineRobustnessPropertiesEXT.pNext );
10291  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineRobustnessPropertiesEXT.defaultRobustnessStorageBuffers );
10292  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineRobustnessPropertiesEXT.defaultRobustnessUniformBuffers );
10293  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineRobustnessPropertiesEXT.defaultRobustnessVertexInputs );
10294  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineRobustnessPropertiesEXT.defaultRobustnessImages );
10295  return seed;
10296  }
10297  };
10298 
10299  template <>
10300  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePointClippingProperties>
10301  {
10302  std::size_t
10303  operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePointClippingProperties const & physicalDevicePointClippingProperties ) const VULKAN_HPP_NOEXCEPT
10304  {
10305  std::size_t seed = 0;
10306  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePointClippingProperties.sType );
10307  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePointClippingProperties.pNext );
10308  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePointClippingProperties.pointClippingBehavior );
10309  return seed;
10310  }
10311  };
10312 
10313 # if defined( VK_ENABLE_BETA_EXTENSIONS )
10314  template <>
10315  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePortabilitySubsetFeaturesKHR>
10316  {
10317  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePortabilitySubsetFeaturesKHR const & physicalDevicePortabilitySubsetFeaturesKHR ) const
10318  VULKAN_HPP_NOEXCEPT
10319  {
10320  std::size_t seed = 0;
10321  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.sType );
10322  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.pNext );
10323  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.constantAlphaColorBlendFactors );
10324  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.events );
10325  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.imageViewFormatReinterpretation );
10326  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.imageViewFormatSwizzle );
10327  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.imageView2DOn3DImage );
10328  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.multisampleArrayImage );
10329  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.mutableComparisonSamplers );
10330  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.pointPolygons );
10331  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.samplerMipLodBias );
10332  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.separateStencilMaskRef );
10333  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.shaderSampleRateInterpolationFunctions );
10334  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.tessellationIsolines );
10335  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.tessellationPointMode );
10336  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.triangleFans );
10337  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.vertexAttributeAccessBeyondStride );
10338  return seed;
10339  }
10340  };
10341 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
10342 
10343 # if defined( VK_ENABLE_BETA_EXTENSIONS )
10344  template <>
10345  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePortabilitySubsetPropertiesKHR>
10346  {
10347  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePortabilitySubsetPropertiesKHR const & physicalDevicePortabilitySubsetPropertiesKHR ) const
10348  VULKAN_HPP_NOEXCEPT
10349  {
10350  std::size_t seed = 0;
10351  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetPropertiesKHR.sType );
10352  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetPropertiesKHR.pNext );
10353  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetPropertiesKHR.minVertexInputBindingStrideAlignment );
10354  return seed;
10355  }
10356  };
10357 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
10358 
10359  template <>
10360  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePresentBarrierFeaturesNV>
10361  {
10362  std::size_t
10363  operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePresentBarrierFeaturesNV const & physicalDevicePresentBarrierFeaturesNV ) const VULKAN_HPP_NOEXCEPT
10364  {
10365  std::size_t seed = 0;
10366  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentBarrierFeaturesNV.sType );
10367  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentBarrierFeaturesNV.pNext );
10368  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentBarrierFeaturesNV.presentBarrier );
10369  return seed;
10370  }
10371  };
10372 
10373  template <>
10374  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePresentIdFeaturesKHR>
10375  {
10376  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePresentIdFeaturesKHR const & physicalDevicePresentIdFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
10377  {
10378  std::size_t seed = 0;
10379  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentIdFeaturesKHR.sType );
10380  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentIdFeaturesKHR.pNext );
10381  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentIdFeaturesKHR.presentId );
10382  return seed;
10383  }
10384  };
10385 
10386  template <>
10387  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePresentWaitFeaturesKHR>
10388  {
10389  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePresentWaitFeaturesKHR const & physicalDevicePresentWaitFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
10390  {
10391  std::size_t seed = 0;
10392  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentWaitFeaturesKHR.sType );
10393  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentWaitFeaturesKHR.pNext );
10394  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentWaitFeaturesKHR.presentWait );
10395  return seed;
10396  }
10397  };
10398 
10399  template <>
10400  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT>
10401  {
10402  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT const &
10403  physicalDevicePrimitiveTopologyListRestartFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
10404  {
10405  std::size_t seed = 0;
10406  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrimitiveTopologyListRestartFeaturesEXT.sType );
10407  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrimitiveTopologyListRestartFeaturesEXT.pNext );
10408  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrimitiveTopologyListRestartFeaturesEXT.primitiveTopologyListRestart );
10409  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrimitiveTopologyListRestartFeaturesEXT.primitiveTopologyPatchListRestart );
10410  return seed;
10411  }
10412  };
10413 
10414  template <>
10415  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT>
10416  {
10417  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT const & physicalDevicePrimitivesGeneratedQueryFeaturesEXT )
10418  const VULKAN_HPP_NOEXCEPT
10419  {
10420  std::size_t seed = 0;
10421  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrimitivesGeneratedQueryFeaturesEXT.sType );
10422  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrimitivesGeneratedQueryFeaturesEXT.pNext );
10423  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrimitivesGeneratedQueryFeaturesEXT.primitivesGeneratedQuery );
10424  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrimitivesGeneratedQueryFeaturesEXT.primitivesGeneratedQueryWithRasterizerDiscard );
10425  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrimitivesGeneratedQueryFeaturesEXT.primitivesGeneratedQueryWithNonZeroStreams );
10426  return seed;
10427  }
10428  };
10429 
10430  template <>
10431  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePrivateDataFeatures>
10432  {
10433  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePrivateDataFeatures const & physicalDevicePrivateDataFeatures ) const VULKAN_HPP_NOEXCEPT
10434  {
10435  std::size_t seed = 0;
10436  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrivateDataFeatures.sType );
10437  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrivateDataFeatures.pNext );
10438  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrivateDataFeatures.privateData );
10439  return seed;
10440  }
10441  };
10442 
10443  template <>
10444  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseProperties>
10445  {
10446  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseProperties const & physicalDeviceSparseProperties ) const VULKAN_HPP_NOEXCEPT
10447  {
10448  std::size_t seed = 0;
10449  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseProperties.residencyStandard2DBlockShape );
10450  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseProperties.residencyStandard2DMultisampleBlockShape );
10451  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseProperties.residencyStandard3DBlockShape );
10452  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseProperties.residencyAlignedMipSize );
10453  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseProperties.residencyNonResidentStrict );
10454  return seed;
10455  }
10456  };
10457 
10458  template <>
10459  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties>
10460  {
10461  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties const & physicalDeviceProperties ) const VULKAN_HPP_NOEXCEPT
10462  {
10463  std::size_t seed = 0;
10464  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.apiVersion );
10465  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.driverVersion );
10466  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.vendorID );
10467  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.deviceID );
10468  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.deviceType );
10469  for ( size_t i = 0; i < VK_MAX_PHYSICAL_DEVICE_NAME_SIZE; ++i )
10470  {
10471  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.deviceName[i] );
10472  }
10473  for ( size_t i = 0; i < VK_UUID_SIZE; ++i )
10474  {
10475  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.pipelineCacheUUID[i] );
10476  }
10477  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.limits );
10478  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.sparseProperties );
10479  return seed;
10480  }
10481  };
10482 
10483  template <>
10484  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2>
10485  {
10486  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 const & physicalDeviceProperties2 ) const VULKAN_HPP_NOEXCEPT
10487  {
10488  std::size_t seed = 0;
10489  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties2.sType );
10490  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties2.pNext );
10491  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties2.properties );
10492  return seed;
10493  }
10494  };
10495 
10496  template <>
10497  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceProtectedMemoryFeatures>
10498  {
10499  std::size_t
10500  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProtectedMemoryFeatures const & physicalDeviceProtectedMemoryFeatures ) const VULKAN_HPP_NOEXCEPT
10501  {
10502  std::size_t seed = 0;
10503  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProtectedMemoryFeatures.sType );
10504  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProtectedMemoryFeatures.pNext );
10505  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProtectedMemoryFeatures.protectedMemory );
10506  return seed;
10507  }
10508  };
10509 
10510  template <>
10511  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceProtectedMemoryProperties>
10512  {
10513  std::size_t
10514  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProtectedMemoryProperties const & physicalDeviceProtectedMemoryProperties ) const VULKAN_HPP_NOEXCEPT
10515  {
10516  std::size_t seed = 0;
10517  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProtectedMemoryProperties.sType );
10518  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProtectedMemoryProperties.pNext );
10519  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProtectedMemoryProperties.protectedNoFault );
10520  return seed;
10521  }
10522  };
10523 
10524  template <>
10525  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceProvokingVertexFeaturesEXT>
10526  {
10527  std::size_t
10528  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProvokingVertexFeaturesEXT const & physicalDeviceProvokingVertexFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
10529  {
10530  std::size_t seed = 0;
10531  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProvokingVertexFeaturesEXT.sType );
10532  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProvokingVertexFeaturesEXT.pNext );
10533  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProvokingVertexFeaturesEXT.provokingVertexLast );
10534  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProvokingVertexFeaturesEXT.transformFeedbackPreservesProvokingVertex );
10535  return seed;
10536  }
10537  };
10538 
10539  template <>
10540  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceProvokingVertexPropertiesEXT>
10541  {
10542  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProvokingVertexPropertiesEXT const & physicalDeviceProvokingVertexPropertiesEXT ) const
10543  VULKAN_HPP_NOEXCEPT
10544  {
10545  std::size_t seed = 0;
10546  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProvokingVertexPropertiesEXT.sType );
10547  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProvokingVertexPropertiesEXT.pNext );
10548  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProvokingVertexPropertiesEXT.provokingVertexModePerPipeline );
10549  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProvokingVertexPropertiesEXT.transformFeedbackPreservesTriangleFanProvokingVertex );
10550  return seed;
10551  }
10552  };
10553 
10554  template <>
10555  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePushDescriptorPropertiesKHR>
10556  {
10557  std::size_t
10558  operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePushDescriptorPropertiesKHR const & physicalDevicePushDescriptorPropertiesKHR ) const VULKAN_HPP_NOEXCEPT
10559  {
10560  std::size_t seed = 0;
10561  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePushDescriptorPropertiesKHR.sType );
10562  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePushDescriptorPropertiesKHR.pNext );
10563  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePushDescriptorPropertiesKHR.maxPushDescriptors );
10564  return seed;
10565  }
10566  };
10567 
10568  template <>
10569  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRGBA10X6FormatsFeaturesEXT>
10570  {
10571  std::size_t
10572  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRGBA10X6FormatsFeaturesEXT const & physicalDeviceRGBA10X6FormatsFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
10573  {
10574  std::size_t seed = 0;
10575  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRGBA10X6FormatsFeaturesEXT.sType );
10576  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRGBA10X6FormatsFeaturesEXT.pNext );
10577  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRGBA10X6FormatsFeaturesEXT.formatRgba10x6WithoutYCbCrSampler );
10578  return seed;
10579  }
10580  };
10581 
10582  template <>
10583  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT>
10584  {
10585  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT const &
10586  physicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
10587  {
10588  std::size_t seed = 0;
10589  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT.sType );
10590  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT.pNext );
10591  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT.rasterizationOrderColorAttachmentAccess );
10592  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT.rasterizationOrderDepthAttachmentAccess );
10593  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT.rasterizationOrderStencilAttachmentAccess );
10594  return seed;
10595  }
10596  };
10597 
10598  template <>
10599  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayQueryFeaturesKHR>
10600  {
10601  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayQueryFeaturesKHR const & physicalDeviceRayQueryFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
10602  {
10603  std::size_t seed = 0;
10604  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayQueryFeaturesKHR.sType );
10605  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayQueryFeaturesKHR.pNext );
10606  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayQueryFeaturesKHR.rayQuery );
10607  return seed;
10608  }
10609  };
10610 
10611  template <>
10612  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderFeaturesNV>
10613  {
10614  std::size_t
10615  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderFeaturesNV const & physicalDeviceRayTracingInvocationReorderFeaturesNV ) const
10616  VULKAN_HPP_NOEXCEPT
10617  {
10618  std::size_t seed = 0;
10619  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderFeaturesNV.sType );
10620  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderFeaturesNV.pNext );
10621  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderFeaturesNV.rayTracingInvocationReorder );
10622  return seed;
10623  }
10624  };
10625 
10626  template <>
10627  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderPropertiesNV>
10628  {
10629  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderPropertiesNV const &
10630  physicalDeviceRayTracingInvocationReorderPropertiesNV ) const VULKAN_HPP_NOEXCEPT
10631  {
10632  std::size_t seed = 0;
10633  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderPropertiesNV.sType );
10634  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderPropertiesNV.pNext );
10635  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderPropertiesNV.rayTracingInvocationReorderReorderingHint );
10636  return seed;
10637  }
10638  };
10639 
10640  template <>
10641  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingMaintenance1FeaturesKHR>
10642  {
10643  std::size_t operator()(
10644  VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingMaintenance1FeaturesKHR const & physicalDeviceRayTracingMaintenance1FeaturesKHR ) const VULKAN_HPP_NOEXCEPT
10645  {
10646  std::size_t seed = 0;
10647  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingMaintenance1FeaturesKHR.sType );
10648  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingMaintenance1FeaturesKHR.pNext );
10649  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingMaintenance1FeaturesKHR.rayTracingMaintenance1 );
10650  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingMaintenance1FeaturesKHR.rayTracingPipelineTraceRaysIndirect2 );
10651  return seed;
10652  }
10653  };
10654 
10655  template <>
10656  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingMotionBlurFeaturesNV>
10657  {
10658  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingMotionBlurFeaturesNV const & physicalDeviceRayTracingMotionBlurFeaturesNV ) const
10659  VULKAN_HPP_NOEXCEPT
10660  {
10661  std::size_t seed = 0;
10662  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingMotionBlurFeaturesNV.sType );
10663  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingMotionBlurFeaturesNV.pNext );
10664  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingMotionBlurFeaturesNV.rayTracingMotionBlur );
10665  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingMotionBlurFeaturesNV.rayTracingMotionBlurPipelineTraceRaysIndirect );
10666  return seed;
10667  }
10668  };
10669 
10670  template <>
10671  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPipelineFeaturesKHR>
10672  {
10673  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPipelineFeaturesKHR const & physicalDeviceRayTracingPipelineFeaturesKHR ) const
10674  VULKAN_HPP_NOEXCEPT
10675  {
10676  std::size_t seed = 0;
10677  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelineFeaturesKHR.sType );
10678  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelineFeaturesKHR.pNext );
10679  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelineFeaturesKHR.rayTracingPipeline );
10680  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelineFeaturesKHR.rayTracingPipelineShaderGroupHandleCaptureReplay );
10681  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelineFeaturesKHR.rayTracingPipelineShaderGroupHandleCaptureReplayMixed );
10682  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelineFeaturesKHR.rayTracingPipelineTraceRaysIndirect );
10683  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelineFeaturesKHR.rayTraversalPrimitiveCulling );
10684  return seed;
10685  }
10686  };
10687 
10688  template <>
10689  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPipelinePropertiesKHR>
10690  {
10691  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPipelinePropertiesKHR const & physicalDeviceRayTracingPipelinePropertiesKHR ) const
10692  VULKAN_HPP_NOEXCEPT
10693  {
10694  std::size_t seed = 0;
10695  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.sType );
10696  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.pNext );
10697  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.shaderGroupHandleSize );
10698  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.maxRayRecursionDepth );
10699  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.maxShaderGroupStride );
10700  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.shaderGroupBaseAlignment );
10701  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.shaderGroupHandleCaptureReplaySize );
10702  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.maxRayDispatchInvocationCount );
10703  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.shaderGroupHandleAlignment );
10704  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.maxRayHitAttributeSize );
10705  return seed;
10706  }
10707  };
10708 
10709  template <>
10710  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPositionFetchFeaturesKHR>
10711  {
10712  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPositionFetchFeaturesKHR const & physicalDeviceRayTracingPositionFetchFeaturesKHR )
10713  const VULKAN_HPP_NOEXCEPT
10714  {
10715  std::size_t seed = 0;
10716  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPositionFetchFeaturesKHR.sType );
10717  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPositionFetchFeaturesKHR.pNext );
10718  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPositionFetchFeaturesKHR.rayTracingPositionFetch );
10719  return seed;
10720  }
10721  };
10722 
10723  template <>
10724  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPropertiesNV>
10725  {
10726  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPropertiesNV const & physicalDeviceRayTracingPropertiesNV ) const VULKAN_HPP_NOEXCEPT
10727  {
10728  std::size_t seed = 0;
10729  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.sType );
10730  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.pNext );
10731  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.shaderGroupHandleSize );
10732  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.maxRecursionDepth );
10733  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.maxShaderGroupStride );
10734  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.shaderGroupBaseAlignment );
10735  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.maxGeometryCount );
10736  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.maxInstanceCount );
10737  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.maxTriangleCount );
10738  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.maxDescriptorSetAccelerationStructures );
10739  return seed;
10740  }
10741  };
10742 
10743  template <>
10744  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRelaxedLineRasterizationFeaturesIMG>
10745  {
10746  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRelaxedLineRasterizationFeaturesIMG const & physicalDeviceRelaxedLineRasterizationFeaturesIMG )
10747  const VULKAN_HPP_NOEXCEPT
10748  {
10749  std::size_t seed = 0;
10750  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRelaxedLineRasterizationFeaturesIMG.sType );
10751  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRelaxedLineRasterizationFeaturesIMG.pNext );
10752  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRelaxedLineRasterizationFeaturesIMG.relaxedLineRasterization );
10753  return seed;
10754  }
10755  };
10756 
10757  template <>
10758  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRenderPassStripedFeaturesARM>
10759  {
10760  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRenderPassStripedFeaturesARM const & physicalDeviceRenderPassStripedFeaturesARM ) const
10761  VULKAN_HPP_NOEXCEPT
10762  {
10763  std::size_t seed = 0;
10764  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRenderPassStripedFeaturesARM.sType );
10765  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRenderPassStripedFeaturesARM.pNext );
10766  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRenderPassStripedFeaturesARM.renderPassStriped );
10767  return seed;
10768  }
10769  };
10770 
10771  template <>
10772  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRenderPassStripedPropertiesARM>
10773  {
10774  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRenderPassStripedPropertiesARM const & physicalDeviceRenderPassStripedPropertiesARM ) const
10775  VULKAN_HPP_NOEXCEPT
10776  {
10777  std::size_t seed = 0;
10778  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRenderPassStripedPropertiesARM.sType );
10779  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRenderPassStripedPropertiesARM.pNext );
10780  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRenderPassStripedPropertiesARM.renderPassStripeGranularity );
10781  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRenderPassStripedPropertiesARM.maxRenderPassStripes );
10782  return seed;
10783  }
10784  };
10785 
10786  template <>
10787  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRepresentativeFragmentTestFeaturesNV>
10788  {
10789  std::size_t
10790  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRepresentativeFragmentTestFeaturesNV const & physicalDeviceRepresentativeFragmentTestFeaturesNV ) const
10791  VULKAN_HPP_NOEXCEPT
10792  {
10793  std::size_t seed = 0;
10794  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRepresentativeFragmentTestFeaturesNV.sType );
10795  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRepresentativeFragmentTestFeaturesNV.pNext );
10796  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRepresentativeFragmentTestFeaturesNV.representativeFragmentTest );
10797  return seed;
10798  }
10799  };
10800 
10801  template <>
10802  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2FeaturesEXT>
10803  {
10804  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2FeaturesEXT const & physicalDeviceRobustness2FeaturesEXT ) const VULKAN_HPP_NOEXCEPT
10805  {
10806  std::size_t seed = 0;
10807  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2FeaturesEXT.sType );
10808  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2FeaturesEXT.pNext );
10809  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2FeaturesEXT.robustBufferAccess2 );
10810  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2FeaturesEXT.robustImageAccess2 );
10811  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2FeaturesEXT.nullDescriptor );
10812  return seed;
10813  }
10814  };
10815 
10816  template <>
10817  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2PropertiesEXT>
10818  {
10819  std::size_t
10820  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2PropertiesEXT const & physicalDeviceRobustness2PropertiesEXT ) const VULKAN_HPP_NOEXCEPT
10821  {
10822  std::size_t seed = 0;
10823  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2PropertiesEXT.sType );
10824  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2PropertiesEXT.pNext );
10825  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2PropertiesEXT.robustStorageBufferAccessSizeAlignment );
10826  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2PropertiesEXT.robustUniformBufferAccessSizeAlignment );
10827  return seed;
10828  }
10829  };
10830 
10831  template <>
10832  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSampleLocationsPropertiesEXT>
10833  {
10834  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSampleLocationsPropertiesEXT const & physicalDeviceSampleLocationsPropertiesEXT ) const
10835  VULKAN_HPP_NOEXCEPT
10836  {
10837  std::size_t seed = 0;
10838  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSampleLocationsPropertiesEXT.sType );
10839  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSampleLocationsPropertiesEXT.pNext );
10840  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSampleLocationsPropertiesEXT.sampleLocationSampleCounts );
10841  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSampleLocationsPropertiesEXT.maxSampleLocationGridSize );
10842  for ( size_t i = 0; i < 2; ++i )
10843  {
10844  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSampleLocationsPropertiesEXT.sampleLocationCoordinateRange[i] );
10845  }
10846  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSampleLocationsPropertiesEXT.sampleLocationSubPixelBits );
10847  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSampleLocationsPropertiesEXT.variableSampleLocations );
10848  return seed;
10849  }
10850  };
10851 
10852  template <>
10853  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSamplerFilterMinmaxProperties>
10854  {
10855  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSamplerFilterMinmaxProperties const & physicalDeviceSamplerFilterMinmaxProperties ) const
10856  VULKAN_HPP_NOEXCEPT
10857  {
10858  std::size_t seed = 0;
10859  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSamplerFilterMinmaxProperties.sType );
10860  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSamplerFilterMinmaxProperties.pNext );
10861  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSamplerFilterMinmaxProperties.filterMinmaxSingleComponentFormats );
10862  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSamplerFilterMinmaxProperties.filterMinmaxImageComponentMapping );
10863  return seed;
10864  }
10865  };
10866 
10867  template <>
10868  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSamplerYcbcrConversionFeatures>
10869  {
10870  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSamplerYcbcrConversionFeatures const & physicalDeviceSamplerYcbcrConversionFeatures ) const
10871  VULKAN_HPP_NOEXCEPT
10872  {
10873  std::size_t seed = 0;
10874  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSamplerYcbcrConversionFeatures.sType );
10875  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSamplerYcbcrConversionFeatures.pNext );
10876  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSamplerYcbcrConversionFeatures.samplerYcbcrConversion );
10877  return seed;
10878  }
10879  };
10880 
10881  template <>
10882  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceScalarBlockLayoutFeatures>
10883  {
10884  std::size_t
10885  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceScalarBlockLayoutFeatures const & physicalDeviceScalarBlockLayoutFeatures ) const VULKAN_HPP_NOEXCEPT
10886  {
10887  std::size_t seed = 0;
10888  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceScalarBlockLayoutFeatures.sType );
10889  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceScalarBlockLayoutFeatures.pNext );
10890  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceScalarBlockLayoutFeatures.scalarBlockLayout );
10891  return seed;
10892  }
10893  };
10894 
10895  template <>
10896  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSchedulingControlsFeaturesARM>
10897  {
10898  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSchedulingControlsFeaturesARM const & physicalDeviceSchedulingControlsFeaturesARM ) const
10899  VULKAN_HPP_NOEXCEPT
10900  {
10901  std::size_t seed = 0;
10902  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSchedulingControlsFeaturesARM.sType );
10903  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSchedulingControlsFeaturesARM.pNext );
10904  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSchedulingControlsFeaturesARM.schedulingControls );
10905  return seed;
10906  }
10907  };
10908 
10909  template <>
10910  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSchedulingControlsPropertiesARM>
10911  {
10912  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSchedulingControlsPropertiesARM const & physicalDeviceSchedulingControlsPropertiesARM ) const
10913  VULKAN_HPP_NOEXCEPT
10914  {
10915  std::size_t seed = 0;
10916  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSchedulingControlsPropertiesARM.sType );
10917  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSchedulingControlsPropertiesARM.pNext );
10918  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSchedulingControlsPropertiesARM.schedulingControlsFlags );
10919  return seed;
10920  }
10921  };
10922 
10923  template <>
10924  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSeparateDepthStencilLayoutsFeatures>
10925  {
10926  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSeparateDepthStencilLayoutsFeatures const & physicalDeviceSeparateDepthStencilLayoutsFeatures )
10927  const VULKAN_HPP_NOEXCEPT
10928  {
10929  std::size_t seed = 0;
10930  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSeparateDepthStencilLayoutsFeatures.sType );
10931  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSeparateDepthStencilLayoutsFeatures.pNext );
10932  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSeparateDepthStencilLayoutsFeatures.separateDepthStencilLayouts );
10933  return seed;
10934  }
10935  };
10936 
10937  template <>
10938  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloat2FeaturesEXT>
10939  {
10940  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloat2FeaturesEXT const & physicalDeviceShaderAtomicFloat2FeaturesEXT ) const
10941  VULKAN_HPP_NOEXCEPT
10942  {
10943  std::size_t seed = 0;
10944  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.sType );
10945  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.pNext );
10946  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderBufferFloat16Atomics );
10947  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderBufferFloat16AtomicAdd );
10948  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderBufferFloat16AtomicMinMax );
10949  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderBufferFloat32AtomicMinMax );
10950  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderBufferFloat64AtomicMinMax );
10951  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderSharedFloat16Atomics );
10952  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderSharedFloat16AtomicAdd );
10953  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderSharedFloat16AtomicMinMax );
10954  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderSharedFloat32AtomicMinMax );
10955  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderSharedFloat64AtomicMinMax );
10956  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderImageFloat32AtomicMinMax );
10957  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.sparseImageFloat32AtomicMinMax );
10958  return seed;
10959  }
10960  };
10961 
10962  template <>
10963  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloatFeaturesEXT>
10964  {
10965  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloatFeaturesEXT const & physicalDeviceShaderAtomicFloatFeaturesEXT ) const
10966  VULKAN_HPP_NOEXCEPT
10967  {
10968  std::size_t seed = 0;
10969  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.sType );
10970  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.pNext );
10971  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderBufferFloat32Atomics );
10972  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderBufferFloat32AtomicAdd );
10973  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderBufferFloat64Atomics );
10974  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderBufferFloat64AtomicAdd );
10975  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderSharedFloat32Atomics );
10976  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderSharedFloat32AtomicAdd );
10977  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderSharedFloat64Atomics );
10978  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderSharedFloat64AtomicAdd );
10979  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderImageFloat32Atomics );
10980  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderImageFloat32AtomicAdd );
10981  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.sparseImageFloat32Atomics );
10982  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.sparseImageFloat32AtomicAdd );
10983  return seed;
10984  }
10985  };
10986 
10987  template <>
10988  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicInt64Features>
10989  {
10990  std::size_t
10991  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicInt64Features const & physicalDeviceShaderAtomicInt64Features ) const VULKAN_HPP_NOEXCEPT
10992  {
10993  std::size_t seed = 0;
10994  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicInt64Features.sType );
10995  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicInt64Features.pNext );
10996  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicInt64Features.shaderBufferInt64Atomics );
10997  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicInt64Features.shaderSharedInt64Atomics );
10998  return seed;
10999  }
11000  };
11001 
11002  template <>
11003  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderClockFeaturesKHR>
11004  {
11005  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderClockFeaturesKHR const & physicalDeviceShaderClockFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
11006  {
11007  std::size_t seed = 0;
11008  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderClockFeaturesKHR.sType );
11009  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderClockFeaturesKHR.pNext );
11010  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderClockFeaturesKHR.shaderSubgroupClock );
11011  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderClockFeaturesKHR.shaderDeviceClock );
11012  return seed;
11013  }
11014  };
11015 
11016  template <>
11017  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCoreBuiltinsFeaturesARM>
11018  {
11019  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCoreBuiltinsFeaturesARM const & physicalDeviceShaderCoreBuiltinsFeaturesARM ) const
11020  VULKAN_HPP_NOEXCEPT
11021  {
11022  std::size_t seed = 0;
11023  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreBuiltinsFeaturesARM.sType );
11024  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreBuiltinsFeaturesARM.pNext );
11025  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreBuiltinsFeaturesARM.shaderCoreBuiltins );
11026  return seed;
11027  }
11028  };
11029 
11030  template <>
11031  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCoreBuiltinsPropertiesARM>
11032  {
11033  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCoreBuiltinsPropertiesARM const & physicalDeviceShaderCoreBuiltinsPropertiesARM ) const
11034  VULKAN_HPP_NOEXCEPT
11035  {
11036  std::size_t seed = 0;
11037  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreBuiltinsPropertiesARM.sType );
11038  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreBuiltinsPropertiesARM.pNext );
11039  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreBuiltinsPropertiesARM.shaderCoreMask );
11040  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreBuiltinsPropertiesARM.shaderCoreCount );
11041  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreBuiltinsPropertiesARM.shaderWarpsPerCore );
11042  return seed;
11043  }
11044  };
11045 
11046  template <>
11047  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCoreProperties2AMD>
11048  {
11049  std::size_t
11050  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCoreProperties2AMD const & physicalDeviceShaderCoreProperties2AMD ) const VULKAN_HPP_NOEXCEPT
11051  {
11052  std::size_t seed = 0;
11053  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreProperties2AMD.sType );
11054  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreProperties2AMD.pNext );
11055  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreProperties2AMD.shaderCoreFeatures );
11056  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreProperties2AMD.activeComputeUnitCount );
11057  return seed;
11058  }
11059  };
11060 
11061  template <>
11062  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCorePropertiesAMD>
11063  {
11064  std::size_t
11065  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCorePropertiesAMD const & physicalDeviceShaderCorePropertiesAMD ) const VULKAN_HPP_NOEXCEPT
11066  {
11067  std::size_t seed = 0;
11068  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.sType );
11069  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.pNext );
11070  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.shaderEngineCount );
11071  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.shaderArraysPerEngineCount );
11072  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.computeUnitsPerShaderArray );
11073  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.simdPerComputeUnit );
11074  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.wavefrontsPerSimd );
11075  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.wavefrontSize );
11076  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.sgprsPerSimd );
11077  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.minSgprAllocation );
11078  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.maxSgprAllocation );
11079  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.sgprAllocationGranularity );
11080  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.vgprsPerSimd );
11081  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.minVgprAllocation );
11082  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.maxVgprAllocation );
11083  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.vgprAllocationGranularity );
11084  return seed;
11085  }
11086  };
11087 
11088  template <>
11089  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCorePropertiesARM>
11090  {
11091  std::size_t
11092  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCorePropertiesARM const & physicalDeviceShaderCorePropertiesARM ) const VULKAN_HPP_NOEXCEPT
11093  {
11094  std::size_t seed = 0;
11095  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesARM.sType );
11096  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesARM.pNext );
11097  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesARM.pixelRate );
11098  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesARM.texelRate );
11099  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesARM.fmaRate );
11100  return seed;
11101  }
11102  };
11103 
11104  template <>
11105  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderDemoteToHelperInvocationFeatures>
11106  {
11107  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderDemoteToHelperInvocationFeatures const &
11108  physicalDeviceShaderDemoteToHelperInvocationFeatures ) const VULKAN_HPP_NOEXCEPT
11109  {
11110  std::size_t seed = 0;
11111  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderDemoteToHelperInvocationFeatures.sType );
11112  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderDemoteToHelperInvocationFeatures.pNext );
11113  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderDemoteToHelperInvocationFeatures.shaderDemoteToHelperInvocation );
11114  return seed;
11115  }
11116  };
11117 
11118  template <>
11119  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderDrawParametersFeatures>
11120  {
11121  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderDrawParametersFeatures const & physicalDeviceShaderDrawParametersFeatures ) const
11122  VULKAN_HPP_NOEXCEPT
11123  {
11124  std::size_t seed = 0;
11125  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderDrawParametersFeatures.sType );
11126  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderDrawParametersFeatures.pNext );
11127  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderDrawParametersFeatures.shaderDrawParameters );
11128  return seed;
11129  }
11130  };
11131 
11132  template <>
11133  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD>
11134  {
11135  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD const &
11136  physicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD ) const VULKAN_HPP_NOEXCEPT
11137  {
11138  std::size_t seed = 0;
11139  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD.sType );
11140  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD.pNext );
11141  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD.shaderEarlyAndLateFragmentTests );
11142  return seed;
11143  }
11144  };
11145 
11146 # if defined( VK_ENABLE_BETA_EXTENSIONS )
11147  template <>
11148  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderEnqueueFeaturesAMDX>
11149  {
11150  std::size_t
11151  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderEnqueueFeaturesAMDX const & physicalDeviceShaderEnqueueFeaturesAMDX ) const VULKAN_HPP_NOEXCEPT
11152  {
11153  std::size_t seed = 0;
11154  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueueFeaturesAMDX.sType );
11155  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueueFeaturesAMDX.pNext );
11156  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueueFeaturesAMDX.shaderEnqueue );
11157  return seed;
11158  }
11159  };
11160 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
11161 
11162 # if defined( VK_ENABLE_BETA_EXTENSIONS )
11163  template <>
11164  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderEnqueuePropertiesAMDX>
11165  {
11166  std::size_t
11167  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderEnqueuePropertiesAMDX const & physicalDeviceShaderEnqueuePropertiesAMDX ) const VULKAN_HPP_NOEXCEPT
11168  {
11169  std::size_t seed = 0;
11170  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueuePropertiesAMDX.sType );
11171  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueuePropertiesAMDX.pNext );
11172  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueuePropertiesAMDX.maxExecutionGraphDepth );
11173  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueuePropertiesAMDX.maxExecutionGraphShaderOutputNodes );
11174  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueuePropertiesAMDX.maxExecutionGraphShaderPayloadSize );
11175  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueuePropertiesAMDX.maxExecutionGraphShaderPayloadCount );
11176  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueuePropertiesAMDX.executionGraphDispatchAddressAlignment );
11177  return seed;
11178  }
11179  };
11180 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
11181 
11182  template <>
11183  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFloat16Int8Features>
11184  {
11185  std::size_t
11186  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFloat16Int8Features const & physicalDeviceShaderFloat16Int8Features ) const VULKAN_HPP_NOEXCEPT
11187  {
11188  std::size_t seed = 0;
11189  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFloat16Int8Features.sType );
11190  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFloat16Int8Features.pNext );
11191  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFloat16Int8Features.shaderFloat16 );
11192  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFloat16Int8Features.shaderInt8 );
11193  return seed;
11194  }
11195  };
11196 
11197  template <>
11198  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderImageAtomicInt64FeaturesEXT>
11199  {
11200  std::size_t operator()(
11201  VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderImageAtomicInt64FeaturesEXT const & physicalDeviceShaderImageAtomicInt64FeaturesEXT ) const VULKAN_HPP_NOEXCEPT
11202  {
11203  std::size_t seed = 0;
11204  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderImageAtomicInt64FeaturesEXT.sType );
11205  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderImageAtomicInt64FeaturesEXT.pNext );
11206  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderImageAtomicInt64FeaturesEXT.shaderImageInt64Atomics );
11207  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderImageAtomicInt64FeaturesEXT.sparseImageInt64Atomics );
11208  return seed;
11209  }
11210  };
11211 
11212  template <>
11213  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderImageFootprintFeaturesNV>
11214  {
11215  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderImageFootprintFeaturesNV const & physicalDeviceShaderImageFootprintFeaturesNV ) const
11216  VULKAN_HPP_NOEXCEPT
11217  {
11218  std::size_t seed = 0;
11219  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderImageFootprintFeaturesNV.sType );
11220  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderImageFootprintFeaturesNV.pNext );
11221  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderImageFootprintFeaturesNV.imageFootprint );
11222  return seed;
11223  }
11224  };
11225 
11226  template <>
11227  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerDotProductFeatures>
11228  {
11229  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerDotProductFeatures const & physicalDeviceShaderIntegerDotProductFeatures ) const
11230  VULKAN_HPP_NOEXCEPT
11231  {
11232  std::size_t seed = 0;
11233  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductFeatures.sType );
11234  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductFeatures.pNext );
11235  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductFeatures.shaderIntegerDotProduct );
11236  return seed;
11237  }
11238  };
11239 
11240  template <>
11241  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerDotProductProperties>
11242  {
11243  std::size_t operator()(
11244  VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerDotProductProperties const & physicalDeviceShaderIntegerDotProductProperties ) const VULKAN_HPP_NOEXCEPT
11245  {
11246  std::size_t seed = 0;
11247  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.sType );
11248  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.pNext );
11249  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct8BitUnsignedAccelerated );
11250  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct8BitSignedAccelerated );
11251  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct8BitMixedSignednessAccelerated );
11252  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct4x8BitPackedUnsignedAccelerated );
11253  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct4x8BitPackedSignedAccelerated );
11254  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct4x8BitPackedMixedSignednessAccelerated );
11255  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct16BitUnsignedAccelerated );
11256  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct16BitSignedAccelerated );
11257  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct16BitMixedSignednessAccelerated );
11258  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct32BitUnsignedAccelerated );
11259  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct32BitSignedAccelerated );
11260  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct32BitMixedSignednessAccelerated );
11261  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct64BitUnsignedAccelerated );
11262  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct64BitSignedAccelerated );
11263  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct64BitMixedSignednessAccelerated );
11264  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating8BitUnsignedAccelerated );
11265  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating8BitSignedAccelerated );
11266  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated );
11267  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated );
11268  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated );
11269  VULKAN_HPP_HASH_COMBINE( seed,
11270  physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated );
11271  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating16BitUnsignedAccelerated );
11272  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating16BitSignedAccelerated );
11273  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated );
11274  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating32BitUnsignedAccelerated );
11275  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating32BitSignedAccelerated );
11276  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated );
11277  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating64BitUnsignedAccelerated );
11278  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating64BitSignedAccelerated );
11279  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated );
11280  return seed;
11281  }
11282  };
11283 
11284  template <>
11285  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL>
11286  {
11287  std::size_t
11288  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const & physicalDeviceShaderIntegerFunctions2FeaturesINTEL ) const
11289  VULKAN_HPP_NOEXCEPT
11290  {
11291  std::size_t seed = 0;
11292  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerFunctions2FeaturesINTEL.sType );
11293  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerFunctions2FeaturesINTEL.pNext );
11294  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerFunctions2FeaturesINTEL.shaderIntegerFunctions2 );
11295  return seed;
11296  }
11297  };
11298 
11299  template <>
11300  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderModuleIdentifierFeaturesEXT>
11301  {
11302  std::size_t operator()(
11303  VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderModuleIdentifierFeaturesEXT const & physicalDeviceShaderModuleIdentifierFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
11304  {
11305  std::size_t seed = 0;
11306  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderModuleIdentifierFeaturesEXT.sType );
11307  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderModuleIdentifierFeaturesEXT.pNext );
11308  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderModuleIdentifierFeaturesEXT.shaderModuleIdentifier );
11309  return seed;
11310  }
11311  };
11312 
11313  template <>
11314  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderModuleIdentifierPropertiesEXT>
11315  {
11316  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderModuleIdentifierPropertiesEXT const & physicalDeviceShaderModuleIdentifierPropertiesEXT )
11317  const VULKAN_HPP_NOEXCEPT
11318  {
11319  std::size_t seed = 0;
11320  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderModuleIdentifierPropertiesEXT.sType );
11321  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderModuleIdentifierPropertiesEXT.pNext );
11322  for ( size_t i = 0; i < VK_UUID_SIZE; ++i )
11323  {
11324  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderModuleIdentifierPropertiesEXT.shaderModuleIdentifierAlgorithmUUID[i] );
11325  }
11326  return seed;
11327  }
11328  };
11329 
11330  template <>
11331  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderObjectFeaturesEXT>
11332  {
11333  std::size_t
11334  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderObjectFeaturesEXT const & physicalDeviceShaderObjectFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
11335  {
11336  std::size_t seed = 0;
11337  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderObjectFeaturesEXT.sType );
11338  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderObjectFeaturesEXT.pNext );
11339  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderObjectFeaturesEXT.shaderObject );
11340  return seed;
11341  }
11342  };
11343 
11344  template <>
11345  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderObjectPropertiesEXT>
11346  {
11347  std::size_t
11348  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderObjectPropertiesEXT const & physicalDeviceShaderObjectPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
11349  {
11350  std::size_t seed = 0;
11351  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderObjectPropertiesEXT.sType );
11352  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderObjectPropertiesEXT.pNext );
11353  for ( size_t i = 0; i < VK_UUID_SIZE; ++i )
11354  {
11355  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderObjectPropertiesEXT.shaderBinaryUUID[i] );
11356  }
11357  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderObjectPropertiesEXT.shaderBinaryVersion );
11358  return seed;
11359  }
11360  };
11361 
11362  template <>
11363  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSMBuiltinsFeaturesNV>
11364  {
11365  std::size_t
11366  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSMBuiltinsFeaturesNV const & physicalDeviceShaderSMBuiltinsFeaturesNV ) const VULKAN_HPP_NOEXCEPT
11367  {
11368  std::size_t seed = 0;
11369  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSMBuiltinsFeaturesNV.sType );
11370  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSMBuiltinsFeaturesNV.pNext );
11371  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSMBuiltinsFeaturesNV.shaderSMBuiltins );
11372  return seed;
11373  }
11374  };
11375 
11376  template <>
11377  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSMBuiltinsPropertiesNV>
11378  {
11379  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSMBuiltinsPropertiesNV const & physicalDeviceShaderSMBuiltinsPropertiesNV ) const
11380  VULKAN_HPP_NOEXCEPT
11381  {
11382  std::size_t seed = 0;
11383  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSMBuiltinsPropertiesNV.sType );
11384  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSMBuiltinsPropertiesNV.pNext );
11385  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSMBuiltinsPropertiesNV.shaderSMCount );
11386  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSMBuiltinsPropertiesNV.shaderWarpsPerSM );
11387  return seed;
11388  }
11389  };
11390 
11391  template <>
11392  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupExtendedTypesFeatures>
11393  {
11394  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupExtendedTypesFeatures const & physicalDeviceShaderSubgroupExtendedTypesFeatures )
11395  const VULKAN_HPP_NOEXCEPT
11396  {
11397  std::size_t seed = 0;
11398  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupExtendedTypesFeatures.sType );
11399  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupExtendedTypesFeatures.pNext );
11400  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupExtendedTypesFeatures.shaderSubgroupExtendedTypes );
11401  return seed;
11402  }
11403  };
11404 
11405  template <>
11406  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR>
11407  {
11408  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR const &
11409  physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
11410  {
11411  std::size_t seed = 0;
11412  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR.sType );
11413  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR.pNext );
11414  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR.shaderSubgroupUniformControlFlow );
11415  return seed;
11416  }
11417  };
11418 
11419  template <>
11420  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderTerminateInvocationFeatures>
11421  {
11422  std::size_t operator()(
11423  VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderTerminateInvocationFeatures const & physicalDeviceShaderTerminateInvocationFeatures ) const VULKAN_HPP_NOEXCEPT
11424  {
11425  std::size_t seed = 0;
11426  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTerminateInvocationFeatures.sType );
11427  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTerminateInvocationFeatures.pNext );
11428  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTerminateInvocationFeatures.shaderTerminateInvocation );
11429  return seed;
11430  }
11431  };
11432 
11433  template <>
11434  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderTileImageFeaturesEXT>
11435  {
11436  std::size_t
11437  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderTileImageFeaturesEXT const & physicalDeviceShaderTileImageFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
11438  {
11439  std::size_t seed = 0;
11440  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImageFeaturesEXT.sType );
11441  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImageFeaturesEXT.pNext );
11442  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImageFeaturesEXT.shaderTileImageColorReadAccess );
11443  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImageFeaturesEXT.shaderTileImageDepthReadAccess );
11444  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImageFeaturesEXT.shaderTileImageStencilReadAccess );
11445  return seed;
11446  }
11447  };
11448 
11449  template <>
11450  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderTileImagePropertiesEXT>
11451  {
11452  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderTileImagePropertiesEXT const & physicalDeviceShaderTileImagePropertiesEXT ) const
11453  VULKAN_HPP_NOEXCEPT
11454  {
11455  std::size_t seed = 0;
11456  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImagePropertiesEXT.sType );
11457  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImagePropertiesEXT.pNext );
11458  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImagePropertiesEXT.shaderTileImageCoherentReadAccelerated );
11459  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImagePropertiesEXT.shaderTileImageReadSampleFromPixelRateInvocation );
11460  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImagePropertiesEXT.shaderTileImageReadFromHelperInvocation );
11461  return seed;
11462  }
11463  };
11464 
11465  template <>
11466  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShadingRateImageFeaturesNV>
11467  {
11468  std::size_t
11469  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShadingRateImageFeaturesNV const & physicalDeviceShadingRateImageFeaturesNV ) const VULKAN_HPP_NOEXCEPT
11470  {
11471  std::size_t seed = 0;
11472  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShadingRateImageFeaturesNV.sType );
11473  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShadingRateImageFeaturesNV.pNext );
11474  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShadingRateImageFeaturesNV.shadingRateImage );
11475  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShadingRateImageFeaturesNV.shadingRateCoarseSampleOrder );
11476  return seed;
11477  }
11478  };
11479 
11480  template <>
11481  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShadingRateImagePropertiesNV>
11482  {
11483  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShadingRateImagePropertiesNV const & physicalDeviceShadingRateImagePropertiesNV ) const
11484  VULKAN_HPP_NOEXCEPT
11485  {
11486  std::size_t seed = 0;
11487  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShadingRateImagePropertiesNV.sType );
11488  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShadingRateImagePropertiesNV.pNext );
11489  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShadingRateImagePropertiesNV.shadingRateTexelSize );
11490  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShadingRateImagePropertiesNV.shadingRatePaletteSize );
11491  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShadingRateImagePropertiesNV.shadingRateMaxCoarseSamples );
11492  return seed;
11493  }
11494  };
11495 
11496  template <>
11497  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2>
11498  {
11499  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 const & physicalDeviceSparseImageFormatInfo2 ) const VULKAN_HPP_NOEXCEPT
11500  {
11501  std::size_t seed = 0;
11502  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseImageFormatInfo2.sType );
11503  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseImageFormatInfo2.pNext );
11504  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseImageFormatInfo2.format );
11505  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseImageFormatInfo2.type );
11506  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseImageFormatInfo2.samples );
11507  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseImageFormatInfo2.usage );
11508  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseImageFormatInfo2.tiling );
11509  return seed;
11510  }
11511  };
11512 
11513  template <>
11514  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupProperties>
11515  {
11516  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupProperties const & physicalDeviceSubgroupProperties ) const VULKAN_HPP_NOEXCEPT
11517  {
11518  std::size_t seed = 0;
11519  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupProperties.sType );
11520  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupProperties.pNext );
11521  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupProperties.subgroupSize );
11522  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupProperties.supportedStages );
11523  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupProperties.supportedOperations );
11524  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupProperties.quadOperationsInAllStages );
11525  return seed;
11526  }
11527  };
11528 
11529  template <>
11530  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupSizeControlFeatures>
11531  {
11532  std::size_t
11533  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupSizeControlFeatures const & physicalDeviceSubgroupSizeControlFeatures ) const VULKAN_HPP_NOEXCEPT
11534  {
11535  std::size_t seed = 0;
11536  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlFeatures.sType );
11537  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlFeatures.pNext );
11538  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlFeatures.subgroupSizeControl );
11539  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlFeatures.computeFullSubgroups );
11540  return seed;
11541  }
11542  };
11543 
11544  template <>
11545  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupSizeControlProperties>
11546  {
11547  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupSizeControlProperties const & physicalDeviceSubgroupSizeControlProperties ) const
11548  VULKAN_HPP_NOEXCEPT
11549  {
11550  std::size_t seed = 0;
11551  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlProperties.sType );
11552  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlProperties.pNext );
11553  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlProperties.minSubgroupSize );
11554  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlProperties.maxSubgroupSize );
11555  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlProperties.maxComputeWorkgroupSubgroups );
11556  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlProperties.requiredSubgroupSizeStages );
11557  return seed;
11558  }
11559  };
11560 
11561  template <>
11562  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassMergeFeedbackFeaturesEXT>
11563  {
11564  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassMergeFeedbackFeaturesEXT const & physicalDeviceSubpassMergeFeedbackFeaturesEXT ) const
11565  VULKAN_HPP_NOEXCEPT
11566  {
11567  std::size_t seed = 0;
11568  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubpassMergeFeedbackFeaturesEXT.sType );
11569  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubpassMergeFeedbackFeaturesEXT.pNext );
11570  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubpassMergeFeedbackFeaturesEXT.subpassMergeFeedback );
11571  return seed;
11572  }
11573  };
11574 
11575  template <>
11576  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassShadingFeaturesHUAWEI>
11577  {
11578  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassShadingFeaturesHUAWEI const & physicalDeviceSubpassShadingFeaturesHUAWEI ) const
11579  VULKAN_HPP_NOEXCEPT
11580  {
11581  std::size_t seed = 0;
11582  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubpassShadingFeaturesHUAWEI.sType );
11583  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubpassShadingFeaturesHUAWEI.pNext );
11584  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubpassShadingFeaturesHUAWEI.subpassShading );
11585  return seed;
11586  }
11587  };
11588 
11589  template <>
11590  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassShadingPropertiesHUAWEI>
11591  {
11592  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassShadingPropertiesHUAWEI const & physicalDeviceSubpassShadingPropertiesHUAWEI ) const
11593  VULKAN_HPP_NOEXCEPT
11594  {
11595  std::size_t seed = 0;
11596  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubpassShadingPropertiesHUAWEI.sType );
11597  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubpassShadingPropertiesHUAWEI.pNext );
11598  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubpassShadingPropertiesHUAWEI.maxSubpassShadingWorkgroupSizeAspectRatio );
11599  return seed;
11600  }
11601  };
11602 
11603  template <>
11604  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR>
11605  {
11606  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR const & physicalDeviceSurfaceInfo2KHR ) const VULKAN_HPP_NOEXCEPT
11607  {
11608  std::size_t seed = 0;
11609  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSurfaceInfo2KHR.sType );
11610  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSurfaceInfo2KHR.pNext );
11611  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSurfaceInfo2KHR.surface );
11612  return seed;
11613  }
11614  };
11615 
11616  template <>
11617  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSwapchainMaintenance1FeaturesEXT>
11618  {
11619  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSwapchainMaintenance1FeaturesEXT const & physicalDeviceSwapchainMaintenance1FeaturesEXT ) const
11620  VULKAN_HPP_NOEXCEPT
11621  {
11622  std::size_t seed = 0;
11623  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSwapchainMaintenance1FeaturesEXT.sType );
11624  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSwapchainMaintenance1FeaturesEXT.pNext );
11625  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSwapchainMaintenance1FeaturesEXT.swapchainMaintenance1 );
11626  return seed;
11627  }
11628  };
11629 
11630  template <>
11631  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSynchronization2Features>
11632  {
11633  std::size_t
11634  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSynchronization2Features const & physicalDeviceSynchronization2Features ) const VULKAN_HPP_NOEXCEPT
11635  {
11636  std::size_t seed = 0;
11637  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSynchronization2Features.sType );
11638  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSynchronization2Features.pNext );
11639  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSynchronization2Features.synchronization2 );
11640  return seed;
11641  }
11642  };
11643 
11644  template <>
11645  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTexelBufferAlignmentFeaturesEXT>
11646  {
11647  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTexelBufferAlignmentFeaturesEXT const & physicalDeviceTexelBufferAlignmentFeaturesEXT ) const
11648  VULKAN_HPP_NOEXCEPT
11649  {
11650  std::size_t seed = 0;
11651  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTexelBufferAlignmentFeaturesEXT.sType );
11652  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTexelBufferAlignmentFeaturesEXT.pNext );
11653  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTexelBufferAlignmentFeaturesEXT.texelBufferAlignment );
11654  return seed;
11655  }
11656  };
11657 
11658  template <>
11659  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTexelBufferAlignmentProperties>
11660  {
11661  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTexelBufferAlignmentProperties const & physicalDeviceTexelBufferAlignmentProperties ) const
11662  VULKAN_HPP_NOEXCEPT
11663  {
11664  std::size_t seed = 0;
11665  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTexelBufferAlignmentProperties.sType );
11666  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTexelBufferAlignmentProperties.pNext );
11667  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTexelBufferAlignmentProperties.storageTexelBufferOffsetAlignmentBytes );
11668  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTexelBufferAlignmentProperties.storageTexelBufferOffsetSingleTexelAlignment );
11669  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTexelBufferAlignmentProperties.uniformTexelBufferOffsetAlignmentBytes );
11670  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTexelBufferAlignmentProperties.uniformTexelBufferOffsetSingleTexelAlignment );
11671  return seed;
11672  }
11673  };
11674 
11675  template <>
11676  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTextureCompressionASTCHDRFeatures>
11677  {
11678  std::size_t operator()(
11679  VULKAN_HPP_NAMESPACE::PhysicalDeviceTextureCompressionASTCHDRFeatures const & physicalDeviceTextureCompressionASTCHDRFeatures ) const VULKAN_HPP_NOEXCEPT
11680  {
11681  std::size_t seed = 0;
11682  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTextureCompressionASTCHDRFeatures.sType );
11683  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTextureCompressionASTCHDRFeatures.pNext );
11684  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTextureCompressionASTCHDRFeatures.textureCompressionASTC_HDR );
11685  return seed;
11686  }
11687  };
11688 
11689  template <>
11690  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTilePropertiesFeaturesQCOM>
11691  {
11692  std::size_t
11693  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTilePropertiesFeaturesQCOM const & physicalDeviceTilePropertiesFeaturesQCOM ) const VULKAN_HPP_NOEXCEPT
11694  {
11695  std::size_t seed = 0;
11696  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTilePropertiesFeaturesQCOM.sType );
11697  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTilePropertiesFeaturesQCOM.pNext );
11698  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTilePropertiesFeaturesQCOM.tileProperties );
11699  return seed;
11700  }
11701  };
11702 
11703  template <>
11704  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTimelineSemaphoreFeatures>
11705  {
11706  std::size_t
11707  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTimelineSemaphoreFeatures const & physicalDeviceTimelineSemaphoreFeatures ) const VULKAN_HPP_NOEXCEPT
11708  {
11709  std::size_t seed = 0;
11710  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTimelineSemaphoreFeatures.sType );
11711  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTimelineSemaphoreFeatures.pNext );
11712  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTimelineSemaphoreFeatures.timelineSemaphore );
11713  return seed;
11714  }
11715  };
11716 
11717  template <>
11718  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTimelineSemaphoreProperties>
11719  {
11720  std::size_t
11721  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTimelineSemaphoreProperties const & physicalDeviceTimelineSemaphoreProperties ) const VULKAN_HPP_NOEXCEPT
11722  {
11723  std::size_t seed = 0;
11724  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTimelineSemaphoreProperties.sType );
11725  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTimelineSemaphoreProperties.pNext );
11726  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTimelineSemaphoreProperties.maxTimelineSemaphoreValueDifference );
11727  return seed;
11728  }
11729  };
11730 
11731  template <>
11732  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties>
11733  {
11734  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties const & physicalDeviceToolProperties ) const VULKAN_HPP_NOEXCEPT
11735  {
11736  std::size_t seed = 0;
11737  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceToolProperties.sType );
11738  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceToolProperties.pNext );
11739  for ( size_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i )
11740  {
11741  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceToolProperties.name[i] );
11742  }
11743  for ( size_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i )
11744  {
11745  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceToolProperties.version[i] );
11746  }
11747  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceToolProperties.purposes );
11748  for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i )
11749  {
11750  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceToolProperties.description[i] );
11751  }
11752  for ( size_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i )
11753  {
11754  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceToolProperties.layer[i] );
11755  }
11756  return seed;
11757  }
11758  };
11759 
11760  template <>
11761  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTransformFeedbackFeaturesEXT>
11762  {
11763  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTransformFeedbackFeaturesEXT const & physicalDeviceTransformFeedbackFeaturesEXT ) const
11764  VULKAN_HPP_NOEXCEPT
11765  {
11766  std::size_t seed = 0;
11767  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackFeaturesEXT.sType );
11768  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackFeaturesEXT.pNext );
11769  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackFeaturesEXT.transformFeedback );
11770  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackFeaturesEXT.geometryStreams );
11771  return seed;
11772  }
11773  };
11774 
11775  template <>
11776  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTransformFeedbackPropertiesEXT>
11777  {
11778  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTransformFeedbackPropertiesEXT const & physicalDeviceTransformFeedbackPropertiesEXT ) const
11779  VULKAN_HPP_NOEXCEPT
11780  {
11781  std::size_t seed = 0;
11782  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.sType );
11783  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.pNext );
11784  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackStreams );
11785  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackBuffers );
11786  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackBufferSize );
11787  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackStreamDataSize );
11788  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackBufferDataSize );
11789  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackBufferDataStride );
11790  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.transformFeedbackQueries );
11791  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.transformFeedbackStreamsLinesTriangles );
11792  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.transformFeedbackRasterizationStreamSelect );
11793  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.transformFeedbackDraw );
11794  return seed;
11795  }
11796  };
11797 
11798  template <>
11799  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceUniformBufferStandardLayoutFeatures>
11800  {
11801  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceUniformBufferStandardLayoutFeatures const & physicalDeviceUniformBufferStandardLayoutFeatures )
11802  const VULKAN_HPP_NOEXCEPT
11803  {
11804  std::size_t seed = 0;
11805  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceUniformBufferStandardLayoutFeatures.sType );
11806  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceUniformBufferStandardLayoutFeatures.pNext );
11807  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceUniformBufferStandardLayoutFeatures.uniformBufferStandardLayout );
11808  return seed;
11809  }
11810  };
11811 
11812  template <>
11813  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVariablePointersFeatures>
11814  {
11815  std::size_t
11816  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVariablePointersFeatures const & physicalDeviceVariablePointersFeatures ) const VULKAN_HPP_NOEXCEPT
11817  {
11818  std::size_t seed = 0;
11819  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVariablePointersFeatures.sType );
11820  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVariablePointersFeatures.pNext );
11821  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVariablePointersFeatures.variablePointersStorageBuffer );
11822  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVariablePointersFeatures.variablePointers );
11823  return seed;
11824  }
11825  };
11826 
11827  template <>
11828  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorFeaturesKHR>
11829  {
11830  std::size_t operator()(
11831  VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorFeaturesKHR const & physicalDeviceVertexAttributeDivisorFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
11832  {
11833  std::size_t seed = 0;
11834  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorFeaturesKHR.sType );
11835  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorFeaturesKHR.pNext );
11836  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorFeaturesKHR.vertexAttributeInstanceRateDivisor );
11837  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorFeaturesKHR.vertexAttributeInstanceRateZeroDivisor );
11838  return seed;
11839  }
11840  };
11841 
11842  template <>
11843  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorPropertiesEXT>
11844  {
11845  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorPropertiesEXT const & physicalDeviceVertexAttributeDivisorPropertiesEXT )
11846  const VULKAN_HPP_NOEXCEPT
11847  {
11848  std::size_t seed = 0;
11849  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorPropertiesEXT.sType );
11850  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorPropertiesEXT.pNext );
11851  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorPropertiesEXT.maxVertexAttribDivisor );
11852  return seed;
11853  }
11854  };
11855 
11856  template <>
11857  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorPropertiesKHR>
11858  {
11859  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorPropertiesKHR const & physicalDeviceVertexAttributeDivisorPropertiesKHR )
11860  const VULKAN_HPP_NOEXCEPT
11861  {
11862  std::size_t seed = 0;
11863  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorPropertiesKHR.sType );
11864  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorPropertiesKHR.pNext );
11865  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorPropertiesKHR.maxVertexAttribDivisor );
11866  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorPropertiesKHR.supportsNonZeroFirstInstance );
11867  return seed;
11868  }
11869  };
11870 
11871  template <>
11872  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexInputDynamicStateFeaturesEXT>
11873  {
11874  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexInputDynamicStateFeaturesEXT const & physicalDeviceVertexInputDynamicStateFeaturesEXT )
11875  const VULKAN_HPP_NOEXCEPT
11876  {
11877  std::size_t seed = 0;
11878  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexInputDynamicStateFeaturesEXT.sType );
11879  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexInputDynamicStateFeaturesEXT.pNext );
11880  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexInputDynamicStateFeaturesEXT.vertexInputDynamicState );
11881  return seed;
11882  }
11883  };
11884 
11885  template <>
11886  struct hash<VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR>
11887  {
11888  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR const & videoProfileInfoKHR ) const VULKAN_HPP_NOEXCEPT
11889  {
11890  std::size_t seed = 0;
11891  VULKAN_HPP_HASH_COMBINE( seed, videoProfileInfoKHR.sType );
11892  VULKAN_HPP_HASH_COMBINE( seed, videoProfileInfoKHR.pNext );
11893  VULKAN_HPP_HASH_COMBINE( seed, videoProfileInfoKHR.videoCodecOperation );
11894  VULKAN_HPP_HASH_COMBINE( seed, videoProfileInfoKHR.chromaSubsampling );
11895  VULKAN_HPP_HASH_COMBINE( seed, videoProfileInfoKHR.lumaBitDepth );
11896  VULKAN_HPP_HASH_COMBINE( seed, videoProfileInfoKHR.chromaBitDepth );
11897  return seed;
11898  }
11899  };
11900 
11901  template <>
11902  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeQualityLevelInfoKHR>
11903  {
11904  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeQualityLevelInfoKHR const & physicalDeviceVideoEncodeQualityLevelInfoKHR ) const
11905  VULKAN_HPP_NOEXCEPT
11906  {
11907  std::size_t seed = 0;
11908  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoEncodeQualityLevelInfoKHR.sType );
11909  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoEncodeQualityLevelInfoKHR.pNext );
11910  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoEncodeQualityLevelInfoKHR.pVideoProfile );
11911  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoEncodeQualityLevelInfoKHR.qualityLevel );
11912  return seed;
11913  }
11914  };
11915 
11916  template <>
11917  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR>
11918  {
11919  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR const & physicalDeviceVideoFormatInfoKHR ) const VULKAN_HPP_NOEXCEPT
11920  {
11921  std::size_t seed = 0;
11922  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoFormatInfoKHR.sType );
11923  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoFormatInfoKHR.pNext );
11924  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoFormatInfoKHR.imageUsage );
11925  return seed;
11926  }
11927  };
11928 
11929  template <>
11930  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoMaintenance1FeaturesKHR>
11931  {
11932  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoMaintenance1FeaturesKHR const & physicalDeviceVideoMaintenance1FeaturesKHR ) const
11933  VULKAN_HPP_NOEXCEPT
11934  {
11935  std::size_t seed = 0;
11936  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoMaintenance1FeaturesKHR.sType );
11937  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoMaintenance1FeaturesKHR.pNext );
11938  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoMaintenance1FeaturesKHR.videoMaintenance1 );
11939  return seed;
11940  }
11941  };
11942 
11943  template <>
11944  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan11Features>
11945  {
11946  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan11Features const & physicalDeviceVulkan11Features ) const VULKAN_HPP_NOEXCEPT
11947  {
11948  std::size_t seed = 0;
11949  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.sType );
11950  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.pNext );
11951  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.storageBuffer16BitAccess );
11952  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.uniformAndStorageBuffer16BitAccess );
11953  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.storagePushConstant16 );
11954  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.storageInputOutput16 );
11955  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.multiview );
11956  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.multiviewGeometryShader );
11957  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.multiviewTessellationShader );
11958  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.variablePointersStorageBuffer );
11959  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.variablePointers );
11960  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.protectedMemory );
11961  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.samplerYcbcrConversion );
11962  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.shaderDrawParameters );
11963  return seed;
11964  }
11965  };
11966 
11967  template <>
11968  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan11Properties>
11969  {
11970  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan11Properties const & physicalDeviceVulkan11Properties ) const VULKAN_HPP_NOEXCEPT
11971  {
11972  std::size_t seed = 0;
11973  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.sType );
11974  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.pNext );
11975  for ( size_t i = 0; i < VK_UUID_SIZE; ++i )
11976  {
11977  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.deviceUUID[i] );
11978  }
11979  for ( size_t i = 0; i < VK_UUID_SIZE; ++i )
11980  {
11981  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.driverUUID[i] );
11982  }
11983  for ( size_t i = 0; i < VK_LUID_SIZE; ++i )
11984  {
11985  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.deviceLUID[i] );
11986  }
11987  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.deviceNodeMask );
11988  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.deviceLUIDValid );
11989  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.subgroupSize );
11990  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.subgroupSupportedStages );
11991  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.subgroupSupportedOperations );
11992  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.subgroupQuadOperationsInAllStages );
11993  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.pointClippingBehavior );
11994  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.maxMultiviewViewCount );
11995  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.maxMultiviewInstanceIndex );
11996  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.protectedNoFault );
11997  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.maxPerSetDescriptors );
11998  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.maxMemoryAllocationSize );
11999  return seed;
12000  }
12001  };
12002 
12003  template <>
12004  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan12Features>
12005  {
12006  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan12Features const & physicalDeviceVulkan12Features ) const VULKAN_HPP_NOEXCEPT
12007  {
12008  std::size_t seed = 0;
12009  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.sType );
12010  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.pNext );
12011  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.samplerMirrorClampToEdge );
12012  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.drawIndirectCount );
12013  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.storageBuffer8BitAccess );
12014  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.uniformAndStorageBuffer8BitAccess );
12015  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.storagePushConstant8 );
12016  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderBufferInt64Atomics );
12017  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderSharedInt64Atomics );
12018  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderFloat16 );
12019  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderInt8 );
12020  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorIndexing );
12021  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderInputAttachmentArrayDynamicIndexing );
12022  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderUniformTexelBufferArrayDynamicIndexing );
12023  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderStorageTexelBufferArrayDynamicIndexing );
12024  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderUniformBufferArrayNonUniformIndexing );
12025  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderSampledImageArrayNonUniformIndexing );
12026  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderStorageBufferArrayNonUniformIndexing );
12027  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderStorageImageArrayNonUniformIndexing );
12028  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderInputAttachmentArrayNonUniformIndexing );
12029  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderUniformTexelBufferArrayNonUniformIndexing );
12030  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderStorageTexelBufferArrayNonUniformIndexing );
12031  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorBindingUniformBufferUpdateAfterBind );
12032  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorBindingSampledImageUpdateAfterBind );
12033  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorBindingStorageImageUpdateAfterBind );
12034  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorBindingStorageBufferUpdateAfterBind );
12035  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorBindingUniformTexelBufferUpdateAfterBind );
12036  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorBindingStorageTexelBufferUpdateAfterBind );
12037  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorBindingUpdateUnusedWhilePending );
12038  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorBindingPartiallyBound );
12039  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorBindingVariableDescriptorCount );
12040  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.runtimeDescriptorArray );
12041  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.samplerFilterMinmax );
12042  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.scalarBlockLayout );
12043  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.imagelessFramebuffer );
12044  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.uniformBufferStandardLayout );
12045  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderSubgroupExtendedTypes );
12046  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.separateDepthStencilLayouts );
12047  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.hostQueryReset );
12048  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.timelineSemaphore );
12049  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.bufferDeviceAddress );
12050  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.bufferDeviceAddressCaptureReplay );
12051  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.bufferDeviceAddressMultiDevice );
12052  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.vulkanMemoryModel );
12053  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.vulkanMemoryModelDeviceScope );
12054  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.vulkanMemoryModelAvailabilityVisibilityChains );
12055  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderOutputViewportIndex );
12056  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderOutputLayer );
12057  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.subgroupBroadcastDynamicId );
12058  return seed;
12059  }
12060  };
12061 
12062  template <>
12063  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan12Properties>
12064  {
12065  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan12Properties const & physicalDeviceVulkan12Properties ) const VULKAN_HPP_NOEXCEPT
12066  {
12067  std::size_t seed = 0;
12068  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.sType );
12069  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.pNext );
12070  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.driverID );
12071  for ( size_t i = 0; i < VK_MAX_DRIVER_NAME_SIZE; ++i )
12072  {
12073  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.driverName[i] );
12074  }
12075  for ( size_t i = 0; i < VK_MAX_DRIVER_INFO_SIZE; ++i )
12076  {
12077  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.driverInfo[i] );
12078  }
12079  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.conformanceVersion );
12080  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.denormBehaviorIndependence );
12081  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.roundingModeIndependence );
12082  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderSignedZeroInfNanPreserveFloat16 );
12083  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderSignedZeroInfNanPreserveFloat32 );
12084  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderSignedZeroInfNanPreserveFloat64 );
12085  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderDenormPreserveFloat16 );
12086  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderDenormPreserveFloat32 );
12087  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderDenormPreserveFloat64 );
12088  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderDenormFlushToZeroFloat16 );
12089  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderDenormFlushToZeroFloat32 );
12090  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderDenormFlushToZeroFloat64 );
12091  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTEFloat16 );
12092  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTEFloat32 );
12093  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTEFloat64 );
12094  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTZFloat16 );
12095  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTZFloat32 );
12096  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTZFloat64 );
12097  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxUpdateAfterBindDescriptorsInAllPools );
12098  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderUniformBufferArrayNonUniformIndexingNative );
12099  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderSampledImageArrayNonUniformIndexingNative );
12100  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderStorageBufferArrayNonUniformIndexingNative );
12101  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderStorageImageArrayNonUniformIndexingNative );
12102  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderInputAttachmentArrayNonUniformIndexingNative );
12103  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.robustBufferAccessUpdateAfterBind );
12104  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.quadDivergentImplicitLod );
12105  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindSamplers );
12106  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindUniformBuffers );
12107  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindStorageBuffers );
12108  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindSampledImages );
12109  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindStorageImages );
12110  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindInputAttachments );
12111  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxPerStageUpdateAfterBindResources );
12112  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindSamplers );
12113  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindUniformBuffers );
12114  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic );
12115  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindStorageBuffers );
12116  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic );
12117  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindSampledImages );
12118  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindStorageImages );
12119  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindInputAttachments );
12120  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.supportedDepthResolveModes );
12121  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.supportedStencilResolveModes );
12122  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.independentResolveNone );
12123  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.independentResolve );
12124  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.filterMinmaxSingleComponentFormats );
12125  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.filterMinmaxImageComponentMapping );
12126  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxTimelineSemaphoreValueDifference );
12127  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.framebufferIntegerColorSampleCounts );
12128  return seed;
12129  }
12130  };
12131 
12132  template <>
12133  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan13Features>
12134  {
12135  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan13Features const & physicalDeviceVulkan13Features ) const VULKAN_HPP_NOEXCEPT
12136  {
12137  std::size_t seed = 0;
12138  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.sType );
12139  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.pNext );
12140  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.robustImageAccess );
12141  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.inlineUniformBlock );
12142  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.descriptorBindingInlineUniformBlockUpdateAfterBind );
12143  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.pipelineCreationCacheControl );
12144  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.privateData );
12145  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.shaderDemoteToHelperInvocation );
12146  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.shaderTerminateInvocation );
12147  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.subgroupSizeControl );
12148  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.computeFullSubgroups );
12149  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.synchronization2 );
12150  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.textureCompressionASTC_HDR );
12151  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.shaderZeroInitializeWorkgroupMemory );
12152  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.dynamicRendering );
12153  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.shaderIntegerDotProduct );
12154  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.maintenance4 );
12155  return seed;
12156  }
12157  };
12158 
12159  template <>
12160  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan13Properties>
12161  {
12162  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan13Properties const & physicalDeviceVulkan13Properties ) const VULKAN_HPP_NOEXCEPT
12163  {
12164  std::size_t seed = 0;
12165  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.sType );
12166  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.pNext );
12167  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.minSubgroupSize );
12168  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.maxSubgroupSize );
12169  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.maxComputeWorkgroupSubgroups );
12170  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.requiredSubgroupSizeStages );
12171  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.maxInlineUniformBlockSize );
12172  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.maxPerStageDescriptorInlineUniformBlocks );
12173  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks );
12174  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.maxDescriptorSetInlineUniformBlocks );
12175  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.maxDescriptorSetUpdateAfterBindInlineUniformBlocks );
12176  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.maxInlineUniformTotalSize );
12177  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct8BitUnsignedAccelerated );
12178  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct8BitSignedAccelerated );
12179  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct8BitMixedSignednessAccelerated );
12180  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct4x8BitPackedUnsignedAccelerated );
12181  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct4x8BitPackedSignedAccelerated );
12182  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct4x8BitPackedMixedSignednessAccelerated );
12183  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct16BitUnsignedAccelerated );
12184  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct16BitSignedAccelerated );
12185  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct16BitMixedSignednessAccelerated );
12186  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct32BitUnsignedAccelerated );
12187  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct32BitSignedAccelerated );
12188  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct32BitMixedSignednessAccelerated );
12189  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct64BitUnsignedAccelerated );
12190  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct64BitSignedAccelerated );
12191  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct64BitMixedSignednessAccelerated );
12192  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating8BitUnsignedAccelerated );
12193  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating8BitSignedAccelerated );
12194  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated );
12195  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated );
12196  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated );
12197  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated );
12198  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating16BitUnsignedAccelerated );
12199  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating16BitSignedAccelerated );
12200  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated );
12201  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating32BitUnsignedAccelerated );
12202  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating32BitSignedAccelerated );
12203  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated );
12204  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating64BitUnsignedAccelerated );
12205  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating64BitSignedAccelerated );
12206  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated );
12207  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.storageTexelBufferOffsetAlignmentBytes );
12208  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.storageTexelBufferOffsetSingleTexelAlignment );
12209  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.uniformTexelBufferOffsetAlignmentBytes );
12210  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.uniformTexelBufferOffsetSingleTexelAlignment );
12211  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.maxBufferSize );
12212  return seed;
12213  }
12214  };
12215 
12216  template <>
12217  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkanMemoryModelFeatures>
12218  {
12219  std::size_t
12220  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkanMemoryModelFeatures const & physicalDeviceVulkanMemoryModelFeatures ) const VULKAN_HPP_NOEXCEPT
12221  {
12222  std::size_t seed = 0;
12223  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkanMemoryModelFeatures.sType );
12224  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkanMemoryModelFeatures.pNext );
12225  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkanMemoryModelFeatures.vulkanMemoryModel );
12226  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkanMemoryModelFeatures.vulkanMemoryModelDeviceScope );
12227  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkanMemoryModelFeatures.vulkanMemoryModelAvailabilityVisibilityChains );
12228  return seed;
12229  }
12230  };
12231 
12232  template <>
12233  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR>
12234  {
12235  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR const &
12236  physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
12237  {
12238  std::size_t seed = 0;
12239  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.sType );
12240  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.pNext );
12241  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.workgroupMemoryExplicitLayout );
12242  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.workgroupMemoryExplicitLayoutScalarBlockLayout );
12243  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.workgroupMemoryExplicitLayout8BitAccess );
12244  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.workgroupMemoryExplicitLayout16BitAccess );
12245  return seed;
12246  }
12247  };
12248 
12249  template <>
12250  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT>
12251  {
12252  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT const & physicalDeviceYcbcr2Plane444FormatsFeaturesEXT ) const
12253  VULKAN_HPP_NOEXCEPT
12254  {
12255  std::size_t seed = 0;
12256  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceYcbcr2Plane444FormatsFeaturesEXT.sType );
12257  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceYcbcr2Plane444FormatsFeaturesEXT.pNext );
12258  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceYcbcr2Plane444FormatsFeaturesEXT.ycbcr2plane444Formats );
12259  return seed;
12260  }
12261  };
12262 
12263  template <>
12264  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcrDegammaFeaturesQCOM>
12265  {
12266  std::size_t
12267  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcrDegammaFeaturesQCOM const & physicalDeviceYcbcrDegammaFeaturesQCOM ) const VULKAN_HPP_NOEXCEPT
12268  {
12269  std::size_t seed = 0;
12270  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceYcbcrDegammaFeaturesQCOM.sType );
12271  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceYcbcrDegammaFeaturesQCOM.pNext );
12272  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceYcbcrDegammaFeaturesQCOM.ycbcrDegamma );
12273  return seed;
12274  }
12275  };
12276 
12277  template <>
12278  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcrImageArraysFeaturesEXT>
12279  {
12280  std::size_t
12281  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcrImageArraysFeaturesEXT const & physicalDeviceYcbcrImageArraysFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
12282  {
12283  std::size_t seed = 0;
12284  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceYcbcrImageArraysFeaturesEXT.sType );
12285  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceYcbcrImageArraysFeaturesEXT.pNext );
12286  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceYcbcrImageArraysFeaturesEXT.ycbcrImageArrays );
12287  return seed;
12288  }
12289  };
12290 
12291  template <>
12292  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures>
12293  {
12294  std::size_t
12295  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures const & physicalDeviceZeroInitializeWorkgroupMemoryFeatures ) const
12296  VULKAN_HPP_NOEXCEPT
12297  {
12298  std::size_t seed = 0;
12299  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceZeroInitializeWorkgroupMemoryFeatures.sType );
12300  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceZeroInitializeWorkgroupMemoryFeatures.pNext );
12301  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceZeroInitializeWorkgroupMemoryFeatures.shaderZeroInitializeWorkgroupMemory );
12302  return seed;
12303  }
12304  };
12305 
12306  template <>
12307  struct hash<VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo>
12308  {
12309  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo const & pipelineCacheCreateInfo ) const VULKAN_HPP_NOEXCEPT
12310  {
12311  std::size_t seed = 0;
12312  VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheCreateInfo.sType );
12313  VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheCreateInfo.pNext );
12314  VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheCreateInfo.flags );
12315  VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheCreateInfo.initialDataSize );
12316  VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheCreateInfo.pInitialData );
12317  return seed;
12318  }
12319  };
12320 
12321  template <>
12322  struct hash<VULKAN_HPP_NAMESPACE::PipelineCacheHeaderVersionOne>
12323  {
12324  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCacheHeaderVersionOne const & pipelineCacheHeaderVersionOne ) const VULKAN_HPP_NOEXCEPT
12325  {
12326  std::size_t seed = 0;
12327  VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheHeaderVersionOne.headerSize );
12328  VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheHeaderVersionOne.headerVersion );
12329  VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheHeaderVersionOne.vendorID );
12330  VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheHeaderVersionOne.deviceID );
12331  for ( size_t i = 0; i < VK_UUID_SIZE; ++i )
12332  {
12333  VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheHeaderVersionOne.pipelineCacheUUID[i] );
12334  }
12335  return seed;
12336  }
12337  };
12338 
12339  template <>
12340  struct hash<VULKAN_HPP_NAMESPACE::PipelineColorBlendAdvancedStateCreateInfoEXT>
12341  {
12342  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineColorBlendAdvancedStateCreateInfoEXT const & pipelineColorBlendAdvancedStateCreateInfoEXT ) const
12343  VULKAN_HPP_NOEXCEPT
12344  {
12345  std::size_t seed = 0;
12346  VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAdvancedStateCreateInfoEXT.sType );
12347  VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAdvancedStateCreateInfoEXT.pNext );
12348  VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAdvancedStateCreateInfoEXT.srcPremultiplied );
12349  VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAdvancedStateCreateInfoEXT.dstPremultiplied );
12350  VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAdvancedStateCreateInfoEXT.blendOverlap );
12351  return seed;
12352  }
12353  };
12354 
12355  template <>
12356  struct hash<VULKAN_HPP_NAMESPACE::PipelineColorWriteCreateInfoEXT>
12357  {
12358  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineColorWriteCreateInfoEXT const & pipelineColorWriteCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
12359  {
12360  std::size_t seed = 0;
12361  VULKAN_HPP_HASH_COMBINE( seed, pipelineColorWriteCreateInfoEXT.sType );
12362  VULKAN_HPP_HASH_COMBINE( seed, pipelineColorWriteCreateInfoEXT.pNext );
12363  VULKAN_HPP_HASH_COMBINE( seed, pipelineColorWriteCreateInfoEXT.attachmentCount );
12364  VULKAN_HPP_HASH_COMBINE( seed, pipelineColorWriteCreateInfoEXT.pColorWriteEnables );
12365  return seed;
12366  }
12367  };
12368 
12369  template <>
12370  struct hash<VULKAN_HPP_NAMESPACE::PipelineCompilerControlCreateInfoAMD>
12371  {
12372  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCompilerControlCreateInfoAMD const & pipelineCompilerControlCreateInfoAMD ) const VULKAN_HPP_NOEXCEPT
12373  {
12374  std::size_t seed = 0;
12375  VULKAN_HPP_HASH_COMBINE( seed, pipelineCompilerControlCreateInfoAMD.sType );
12376  VULKAN_HPP_HASH_COMBINE( seed, pipelineCompilerControlCreateInfoAMD.pNext );
12377  VULKAN_HPP_HASH_COMBINE( seed, pipelineCompilerControlCreateInfoAMD.compilerControlFlags );
12378  return seed;
12379  }
12380  };
12381 
12382  template <>
12383  struct hash<VULKAN_HPP_NAMESPACE::PipelineCoverageModulationStateCreateInfoNV>
12384  {
12385  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCoverageModulationStateCreateInfoNV const & pipelineCoverageModulationStateCreateInfoNV ) const
12386  VULKAN_HPP_NOEXCEPT
12387  {
12388  std::size_t seed = 0;
12389  VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageModulationStateCreateInfoNV.sType );
12390  VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageModulationStateCreateInfoNV.pNext );
12391  VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageModulationStateCreateInfoNV.flags );
12392  VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageModulationStateCreateInfoNV.coverageModulationMode );
12393  VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageModulationStateCreateInfoNV.coverageModulationTableEnable );
12394  VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageModulationStateCreateInfoNV.coverageModulationTableCount );
12395  VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageModulationStateCreateInfoNV.pCoverageModulationTable );
12396  return seed;
12397  }
12398  };
12399 
12400  template <>
12401  struct hash<VULKAN_HPP_NAMESPACE::PipelineCoverageReductionStateCreateInfoNV>
12402  {
12403  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCoverageReductionStateCreateInfoNV const & pipelineCoverageReductionStateCreateInfoNV ) const
12404  VULKAN_HPP_NOEXCEPT
12405  {
12406  std::size_t seed = 0;
12407  VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageReductionStateCreateInfoNV.sType );
12408  VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageReductionStateCreateInfoNV.pNext );
12409  VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageReductionStateCreateInfoNV.flags );
12410  VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageReductionStateCreateInfoNV.coverageReductionMode );
12411  return seed;
12412  }
12413  };
12414 
12415  template <>
12416  struct hash<VULKAN_HPP_NAMESPACE::PipelineCoverageToColorStateCreateInfoNV>
12417  {
12418  std::size_t
12419  operator()( VULKAN_HPP_NAMESPACE::PipelineCoverageToColorStateCreateInfoNV const & pipelineCoverageToColorStateCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
12420  {
12421  std::size_t seed = 0;
12422  VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageToColorStateCreateInfoNV.sType );
12423  VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageToColorStateCreateInfoNV.pNext );
12424  VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageToColorStateCreateInfoNV.flags );
12425  VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageToColorStateCreateInfoNV.coverageToColorEnable );
12426  VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageToColorStateCreateInfoNV.coverageToColorLocation );
12427  return seed;
12428  }
12429  };
12430 
12431  template <>
12432  struct hash<VULKAN_HPP_NAMESPACE::PipelineCreateFlags2CreateInfoKHR>
12433  {
12434  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCreateFlags2CreateInfoKHR const & pipelineCreateFlags2CreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
12435  {
12436  std::size_t seed = 0;
12437  VULKAN_HPP_HASH_COMBINE( seed, pipelineCreateFlags2CreateInfoKHR.sType );
12438  VULKAN_HPP_HASH_COMBINE( seed, pipelineCreateFlags2CreateInfoKHR.pNext );
12439  VULKAN_HPP_HASH_COMBINE( seed, pipelineCreateFlags2CreateInfoKHR.flags );
12440  return seed;
12441  }
12442  };
12443 
12444  template <>
12445  struct hash<VULKAN_HPP_NAMESPACE::PipelineCreationFeedback>
12446  {
12447  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCreationFeedback const & pipelineCreationFeedback ) const VULKAN_HPP_NOEXCEPT
12448  {
12449  std::size_t seed = 0;
12450  VULKAN_HPP_HASH_COMBINE( seed, pipelineCreationFeedback.flags );
12451  VULKAN_HPP_HASH_COMBINE( seed, pipelineCreationFeedback.duration );
12452  return seed;
12453  }
12454  };
12455 
12456  template <>
12457  struct hash<VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackCreateInfo>
12458  {
12459  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackCreateInfo const & pipelineCreationFeedbackCreateInfo ) const VULKAN_HPP_NOEXCEPT
12460  {
12461  std::size_t seed = 0;
12462  VULKAN_HPP_HASH_COMBINE( seed, pipelineCreationFeedbackCreateInfo.sType );
12463  VULKAN_HPP_HASH_COMBINE( seed, pipelineCreationFeedbackCreateInfo.pNext );
12464  VULKAN_HPP_HASH_COMBINE( seed, pipelineCreationFeedbackCreateInfo.pPipelineCreationFeedback );
12465  VULKAN_HPP_HASH_COMBINE( seed, pipelineCreationFeedbackCreateInfo.pipelineStageCreationFeedbackCount );
12466  VULKAN_HPP_HASH_COMBINE( seed, pipelineCreationFeedbackCreateInfo.pPipelineStageCreationFeedbacks );
12467  return seed;
12468  }
12469  };
12470 
12471  template <>
12472  struct hash<VULKAN_HPP_NAMESPACE::PipelineDiscardRectangleStateCreateInfoEXT>
12473  {
12474  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineDiscardRectangleStateCreateInfoEXT const & pipelineDiscardRectangleStateCreateInfoEXT ) const
12475  VULKAN_HPP_NOEXCEPT
12476  {
12477  std::size_t seed = 0;
12478  VULKAN_HPP_HASH_COMBINE( seed, pipelineDiscardRectangleStateCreateInfoEXT.sType );
12479  VULKAN_HPP_HASH_COMBINE( seed, pipelineDiscardRectangleStateCreateInfoEXT.pNext );
12480  VULKAN_HPP_HASH_COMBINE( seed, pipelineDiscardRectangleStateCreateInfoEXT.flags );
12481  VULKAN_HPP_HASH_COMBINE( seed, pipelineDiscardRectangleStateCreateInfoEXT.discardRectangleMode );
12482  VULKAN_HPP_HASH_COMBINE( seed, pipelineDiscardRectangleStateCreateInfoEXT.discardRectangleCount );
12483  VULKAN_HPP_HASH_COMBINE( seed, pipelineDiscardRectangleStateCreateInfoEXT.pDiscardRectangles );
12484  return seed;
12485  }
12486  };
12487 
12488  template <>
12489  struct hash<VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR>
12490  {
12491  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR const & pipelineExecutableInfoKHR ) const VULKAN_HPP_NOEXCEPT
12492  {
12493  std::size_t seed = 0;
12494  VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInfoKHR.sType );
12495  VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInfoKHR.pNext );
12496  VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInfoKHR.pipeline );
12497  VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInfoKHR.executableIndex );
12498  return seed;
12499  }
12500  };
12501 
12502  template <>
12503  struct hash<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR>
12504  {
12505  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR const & pipelineExecutableInternalRepresentationKHR ) const
12506  VULKAN_HPP_NOEXCEPT
12507  {
12508  std::size_t seed = 0;
12509  VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInternalRepresentationKHR.sType );
12510  VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInternalRepresentationKHR.pNext );
12511  for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i )
12512  {
12513  VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInternalRepresentationKHR.name[i] );
12514  }
12515  for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i )
12516  {
12517  VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInternalRepresentationKHR.description[i] );
12518  }
12519  VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInternalRepresentationKHR.isText );
12520  VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInternalRepresentationKHR.dataSize );
12521  VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInternalRepresentationKHR.pData );
12522  return seed;
12523  }
12524  };
12525 
12526  template <>
12527  struct hash<VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR>
12528  {
12529  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR const & pipelineExecutablePropertiesKHR ) const VULKAN_HPP_NOEXCEPT
12530  {
12531  std::size_t seed = 0;
12532  VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutablePropertiesKHR.sType );
12533  VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutablePropertiesKHR.pNext );
12534  VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutablePropertiesKHR.stages );
12535  for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i )
12536  {
12537  VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutablePropertiesKHR.name[i] );
12538  }
12539  for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i )
12540  {
12541  VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutablePropertiesKHR.description[i] );
12542  }
12543  VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutablePropertiesKHR.subgroupSize );
12544  return seed;
12545  }
12546  };
12547 
12548  template <>
12549  struct hash<VULKAN_HPP_NAMESPACE::PipelineFragmentShadingRateEnumStateCreateInfoNV>
12550  {
12551  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineFragmentShadingRateEnumStateCreateInfoNV const & pipelineFragmentShadingRateEnumStateCreateInfoNV )
12552  const VULKAN_HPP_NOEXCEPT
12553  {
12554  std::size_t seed = 0;
12555  VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentShadingRateEnumStateCreateInfoNV.sType );
12556  VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentShadingRateEnumStateCreateInfoNV.pNext );
12557  VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentShadingRateEnumStateCreateInfoNV.shadingRateType );
12558  VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentShadingRateEnumStateCreateInfoNV.shadingRate );
12559  for ( size_t i = 0; i < 2; ++i )
12560  {
12561  VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentShadingRateEnumStateCreateInfoNV.combinerOps[i] );
12562  }
12563  return seed;
12564  }
12565  };
12566 
12567  template <>
12568  struct hash<VULKAN_HPP_NAMESPACE::PipelineFragmentShadingRateStateCreateInfoKHR>
12569  {
12570  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineFragmentShadingRateStateCreateInfoKHR const & pipelineFragmentShadingRateStateCreateInfoKHR ) const
12571  VULKAN_HPP_NOEXCEPT
12572  {
12573  std::size_t seed = 0;
12574  VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentShadingRateStateCreateInfoKHR.sType );
12575  VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentShadingRateStateCreateInfoKHR.pNext );
12576  VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentShadingRateStateCreateInfoKHR.fragmentSize );
12577  for ( size_t i = 0; i < 2; ++i )
12578  {
12579  VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentShadingRateStateCreateInfoKHR.combinerOps[i] );
12580  }
12581  return seed;
12582  }
12583  };
12584 
12585  template <>
12586  struct hash<VULKAN_HPP_NAMESPACE::PipelineIndirectDeviceAddressInfoNV>
12587  {
12588  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineIndirectDeviceAddressInfoNV const & pipelineIndirectDeviceAddressInfoNV ) const VULKAN_HPP_NOEXCEPT
12589  {
12590  std::size_t seed = 0;
12591  VULKAN_HPP_HASH_COMBINE( seed, pipelineIndirectDeviceAddressInfoNV.sType );
12592  VULKAN_HPP_HASH_COMBINE( seed, pipelineIndirectDeviceAddressInfoNV.pNext );
12593  VULKAN_HPP_HASH_COMBINE( seed, pipelineIndirectDeviceAddressInfoNV.pipelineBindPoint );
12594  VULKAN_HPP_HASH_COMBINE( seed, pipelineIndirectDeviceAddressInfoNV.pipeline );
12595  return seed;
12596  }
12597  };
12598 
12599  template <>
12600  struct hash<VULKAN_HPP_NAMESPACE::PipelineInfoKHR>
12601  {
12602  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineInfoKHR const & pipelineInfoKHR ) const VULKAN_HPP_NOEXCEPT
12603  {
12604  std::size_t seed = 0;
12605  VULKAN_HPP_HASH_COMBINE( seed, pipelineInfoKHR.sType );
12606  VULKAN_HPP_HASH_COMBINE( seed, pipelineInfoKHR.pNext );
12607  VULKAN_HPP_HASH_COMBINE( seed, pipelineInfoKHR.pipeline );
12608  return seed;
12609  }
12610  };
12611 
12612  template <>
12613  struct hash<VULKAN_HPP_NAMESPACE::PushConstantRange>
12614  {
12615  std::size_t operator()( VULKAN_HPP_NAMESPACE::PushConstantRange const & pushConstantRange ) const VULKAN_HPP_NOEXCEPT
12616  {
12617  std::size_t seed = 0;
12618  VULKAN_HPP_HASH_COMBINE( seed, pushConstantRange.stageFlags );
12619  VULKAN_HPP_HASH_COMBINE( seed, pushConstantRange.offset );
12620  VULKAN_HPP_HASH_COMBINE( seed, pushConstantRange.size );
12621  return seed;
12622  }
12623  };
12624 
12625  template <>
12626  struct hash<VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo>
12627  {
12628  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo const & pipelineLayoutCreateInfo ) const VULKAN_HPP_NOEXCEPT
12629  {
12630  std::size_t seed = 0;
12631  VULKAN_HPP_HASH_COMBINE( seed, pipelineLayoutCreateInfo.sType );
12632  VULKAN_HPP_HASH_COMBINE( seed, pipelineLayoutCreateInfo.pNext );
12633  VULKAN_HPP_HASH_COMBINE( seed, pipelineLayoutCreateInfo.flags );
12634  VULKAN_HPP_HASH_COMBINE( seed, pipelineLayoutCreateInfo.setLayoutCount );
12635  VULKAN_HPP_HASH_COMBINE( seed, pipelineLayoutCreateInfo.pSetLayouts );
12636  VULKAN_HPP_HASH_COMBINE( seed, pipelineLayoutCreateInfo.pushConstantRangeCount );
12637  VULKAN_HPP_HASH_COMBINE( seed, pipelineLayoutCreateInfo.pPushConstantRanges );
12638  return seed;
12639  }
12640  };
12641 
12642  template <>
12643  struct hash<VULKAN_HPP_NAMESPACE::PipelinePropertiesIdentifierEXT>
12644  {
12645  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelinePropertiesIdentifierEXT const & pipelinePropertiesIdentifierEXT ) const VULKAN_HPP_NOEXCEPT
12646  {
12647  std::size_t seed = 0;
12648  VULKAN_HPP_HASH_COMBINE( seed, pipelinePropertiesIdentifierEXT.sType );
12649  VULKAN_HPP_HASH_COMBINE( seed, pipelinePropertiesIdentifierEXT.pNext );
12650  for ( size_t i = 0; i < VK_UUID_SIZE; ++i )
12651  {
12652  VULKAN_HPP_HASH_COMBINE( seed, pipelinePropertiesIdentifierEXT.pipelineIdentifier[i] );
12653  }
12654  return seed;
12655  }
12656  };
12657 
12658  template <>
12659  struct hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationConservativeStateCreateInfoEXT>
12660  {
12661  std::size_t
12662  operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationConservativeStateCreateInfoEXT const & pipelineRasterizationConservativeStateCreateInfoEXT ) const
12663  VULKAN_HPP_NOEXCEPT
12664  {
12665  std::size_t seed = 0;
12666  VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationConservativeStateCreateInfoEXT.sType );
12667  VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationConservativeStateCreateInfoEXT.pNext );
12668  VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationConservativeStateCreateInfoEXT.flags );
12669  VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationConservativeStateCreateInfoEXT.conservativeRasterizationMode );
12670  VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationConservativeStateCreateInfoEXT.extraPrimitiveOverestimationSize );
12671  return seed;
12672  }
12673  };
12674 
12675  template <>
12676  struct hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationDepthClipStateCreateInfoEXT>
12677  {
12678  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationDepthClipStateCreateInfoEXT const & pipelineRasterizationDepthClipStateCreateInfoEXT )
12679  const VULKAN_HPP_NOEXCEPT
12680  {
12681  std::size_t seed = 0;
12682  VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationDepthClipStateCreateInfoEXT.sType );
12683  VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationDepthClipStateCreateInfoEXT.pNext );
12684  VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationDepthClipStateCreateInfoEXT.flags );
12685  VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationDepthClipStateCreateInfoEXT.depthClipEnable );
12686  return seed;
12687  }
12688  };
12689 
12690  template <>
12691  struct hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationLineStateCreateInfoEXT>
12692  {
12693  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationLineStateCreateInfoEXT const & pipelineRasterizationLineStateCreateInfoEXT ) const
12694  VULKAN_HPP_NOEXCEPT
12695  {
12696  std::size_t seed = 0;
12697  VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfoEXT.sType );
12698  VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfoEXT.pNext );
12699  VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfoEXT.lineRasterizationMode );
12700  VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfoEXT.stippledLineEnable );
12701  VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfoEXT.lineStippleFactor );
12702  VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfoEXT.lineStipplePattern );
12703  return seed;
12704  }
12705  };
12706 
12707  template <>
12708  struct hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationProvokingVertexStateCreateInfoEXT>
12709  {
12710  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationProvokingVertexStateCreateInfoEXT const &
12711  pipelineRasterizationProvokingVertexStateCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
12712  {
12713  std::size_t seed = 0;
12714  VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationProvokingVertexStateCreateInfoEXT.sType );
12715  VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationProvokingVertexStateCreateInfoEXT.pNext );
12716  VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationProvokingVertexStateCreateInfoEXT.provokingVertexMode );
12717  return seed;
12718  }
12719  };
12720 
12721  template <>
12722  struct hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationStateRasterizationOrderAMD>
12723  {
12724  std::size_t operator()(
12725  VULKAN_HPP_NAMESPACE::PipelineRasterizationStateRasterizationOrderAMD const & pipelineRasterizationStateRasterizationOrderAMD ) const VULKAN_HPP_NOEXCEPT
12726  {
12727  std::size_t seed = 0;
12728  VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateRasterizationOrderAMD.sType );
12729  VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateRasterizationOrderAMD.pNext );
12730  VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateRasterizationOrderAMD.rasterizationOrder );
12731  return seed;
12732  }
12733  };
12734 
12735  template <>
12736  struct hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationStateStreamCreateInfoEXT>
12737  {
12738  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationStateStreamCreateInfoEXT const & pipelineRasterizationStateStreamCreateInfoEXT ) const
12739  VULKAN_HPP_NOEXCEPT
12740  {
12741  std::size_t seed = 0;
12742  VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateStreamCreateInfoEXT.sType );
12743  VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateStreamCreateInfoEXT.pNext );
12744  VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateStreamCreateInfoEXT.flags );
12745  VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateStreamCreateInfoEXT.rasterizationStream );
12746  return seed;
12747  }
12748  };
12749 
12750  template <>
12751  struct hash<VULKAN_HPP_NAMESPACE::PipelineRenderingCreateInfo>
12752  {
12753  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRenderingCreateInfo const & pipelineRenderingCreateInfo ) const VULKAN_HPP_NOEXCEPT
12754  {
12755  std::size_t seed = 0;
12756  VULKAN_HPP_HASH_COMBINE( seed, pipelineRenderingCreateInfo.sType );
12757  VULKAN_HPP_HASH_COMBINE( seed, pipelineRenderingCreateInfo.pNext );
12758  VULKAN_HPP_HASH_COMBINE( seed, pipelineRenderingCreateInfo.viewMask );
12759  VULKAN_HPP_HASH_COMBINE( seed, pipelineRenderingCreateInfo.colorAttachmentCount );
12760  VULKAN_HPP_HASH_COMBINE( seed, pipelineRenderingCreateInfo.pColorAttachmentFormats );
12761  VULKAN_HPP_HASH_COMBINE( seed, pipelineRenderingCreateInfo.depthAttachmentFormat );
12762  VULKAN_HPP_HASH_COMBINE( seed, pipelineRenderingCreateInfo.stencilAttachmentFormat );
12763  return seed;
12764  }
12765  };
12766 
12767  template <>
12768  struct hash<VULKAN_HPP_NAMESPACE::PipelineRepresentativeFragmentTestStateCreateInfoNV>
12769  {
12770  std::size_t
12771  operator()( VULKAN_HPP_NAMESPACE::PipelineRepresentativeFragmentTestStateCreateInfoNV const & pipelineRepresentativeFragmentTestStateCreateInfoNV ) const
12772  VULKAN_HPP_NOEXCEPT
12773  {
12774  std::size_t seed = 0;
12775  VULKAN_HPP_HASH_COMBINE( seed, pipelineRepresentativeFragmentTestStateCreateInfoNV.sType );
12776  VULKAN_HPP_HASH_COMBINE( seed, pipelineRepresentativeFragmentTestStateCreateInfoNV.pNext );
12777  VULKAN_HPP_HASH_COMBINE( seed, pipelineRepresentativeFragmentTestStateCreateInfoNV.representativeFragmentTestEnable );
12778  return seed;
12779  }
12780  };
12781 
12782  template <>
12783  struct hash<VULKAN_HPP_NAMESPACE::PipelineRobustnessCreateInfoEXT>
12784  {
12785  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRobustnessCreateInfoEXT const & pipelineRobustnessCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
12786  {
12787  std::size_t seed = 0;
12788  VULKAN_HPP_HASH_COMBINE( seed, pipelineRobustnessCreateInfoEXT.sType );
12789  VULKAN_HPP_HASH_COMBINE( seed, pipelineRobustnessCreateInfoEXT.pNext );
12790  VULKAN_HPP_HASH_COMBINE( seed, pipelineRobustnessCreateInfoEXT.storageBuffers );
12791  VULKAN_HPP_HASH_COMBINE( seed, pipelineRobustnessCreateInfoEXT.uniformBuffers );
12792  VULKAN_HPP_HASH_COMBINE( seed, pipelineRobustnessCreateInfoEXT.vertexInputs );
12793  VULKAN_HPP_HASH_COMBINE( seed, pipelineRobustnessCreateInfoEXT.images );
12794  return seed;
12795  }
12796  };
12797 
12798  template <>
12799  struct hash<VULKAN_HPP_NAMESPACE::PipelineSampleLocationsStateCreateInfoEXT>
12800  {
12801  std::size_t
12802  operator()( VULKAN_HPP_NAMESPACE::PipelineSampleLocationsStateCreateInfoEXT const & pipelineSampleLocationsStateCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
12803  {
12804  std::size_t seed = 0;
12805  VULKAN_HPP_HASH_COMBINE( seed, pipelineSampleLocationsStateCreateInfoEXT.sType );
12806  VULKAN_HPP_HASH_COMBINE( seed, pipelineSampleLocationsStateCreateInfoEXT.pNext );
12807  VULKAN_HPP_HASH_COMBINE( seed, pipelineSampleLocationsStateCreateInfoEXT.sampleLocationsEnable );
12808  VULKAN_HPP_HASH_COMBINE( seed, pipelineSampleLocationsStateCreateInfoEXT.sampleLocationsInfo );
12809  return seed;
12810  }
12811  };
12812 
12813  template <>
12814  struct hash<VULKAN_HPP_NAMESPACE::PipelineShaderStageModuleIdentifierCreateInfoEXT>
12815  {
12816  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineShaderStageModuleIdentifierCreateInfoEXT const & pipelineShaderStageModuleIdentifierCreateInfoEXT )
12817  const VULKAN_HPP_NOEXCEPT
12818  {
12819  std::size_t seed = 0;
12820  VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageModuleIdentifierCreateInfoEXT.sType );
12821  VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageModuleIdentifierCreateInfoEXT.pNext );
12822  VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageModuleIdentifierCreateInfoEXT.identifierSize );
12823  VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageModuleIdentifierCreateInfoEXT.pIdentifier );
12824  return seed;
12825  }
12826  };
12827 
12828 # if defined( VK_ENABLE_BETA_EXTENSIONS )
12829  template <>
12830  struct hash<VULKAN_HPP_NAMESPACE::PipelineShaderStageNodeCreateInfoAMDX>
12831  {
12832  std::size_t
12833  operator()( VULKAN_HPP_NAMESPACE::PipelineShaderStageNodeCreateInfoAMDX const & pipelineShaderStageNodeCreateInfoAMDX ) const VULKAN_HPP_NOEXCEPT
12834  {
12835  std::size_t seed = 0;
12836  VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageNodeCreateInfoAMDX.sType );
12837  VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageNodeCreateInfoAMDX.pNext );
12838  for ( const char * p = pipelineShaderStageNodeCreateInfoAMDX.pName; *p != '\0'; ++p )
12839  {
12840  VULKAN_HPP_HASH_COMBINE( seed, *p );
12841  }
12842  VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageNodeCreateInfoAMDX.index );
12843  return seed;
12844  }
12845  };
12846 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
12847 
12848  template <>
12849  struct hash<VULKAN_HPP_NAMESPACE::PipelineShaderStageRequiredSubgroupSizeCreateInfo>
12850  {
12851  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineShaderStageRequiredSubgroupSizeCreateInfo const & pipelineShaderStageRequiredSubgroupSizeCreateInfo )
12852  const VULKAN_HPP_NOEXCEPT
12853  {
12854  std::size_t seed = 0;
12855  VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageRequiredSubgroupSizeCreateInfo.sType );
12856  VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageRequiredSubgroupSizeCreateInfo.pNext );
12857  VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageRequiredSubgroupSizeCreateInfo.requiredSubgroupSize );
12858  return seed;
12859  }
12860  };
12861 
12862  template <>
12863  struct hash<VULKAN_HPP_NAMESPACE::PipelineTessellationDomainOriginStateCreateInfo>
12864  {
12865  std::size_t operator()(
12866  VULKAN_HPP_NAMESPACE::PipelineTessellationDomainOriginStateCreateInfo const & pipelineTessellationDomainOriginStateCreateInfo ) const VULKAN_HPP_NOEXCEPT
12867  {
12868  std::size_t seed = 0;
12869  VULKAN_HPP_HASH_COMBINE( seed, pipelineTessellationDomainOriginStateCreateInfo.sType );
12870  VULKAN_HPP_HASH_COMBINE( seed, pipelineTessellationDomainOriginStateCreateInfo.pNext );
12871  VULKAN_HPP_HASH_COMBINE( seed, pipelineTessellationDomainOriginStateCreateInfo.domainOrigin );
12872  return seed;
12873  }
12874  };
12875 
12876  template <>
12877  struct hash<VULKAN_HPP_NAMESPACE::VertexInputBindingDivisorDescriptionKHR>
12878  {
12879  std::size_t
12880  operator()( VULKAN_HPP_NAMESPACE::VertexInputBindingDivisorDescriptionKHR const & vertexInputBindingDivisorDescriptionKHR ) const VULKAN_HPP_NOEXCEPT
12881  {
12882  std::size_t seed = 0;
12883  VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDivisorDescriptionKHR.binding );
12884  VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDivisorDescriptionKHR.divisor );
12885  return seed;
12886  }
12887  };
12888 
12889  template <>
12890  struct hash<VULKAN_HPP_NAMESPACE::PipelineVertexInputDivisorStateCreateInfoKHR>
12891  {
12892  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineVertexInputDivisorStateCreateInfoKHR const & pipelineVertexInputDivisorStateCreateInfoKHR ) const
12893  VULKAN_HPP_NOEXCEPT
12894  {
12895  std::size_t seed = 0;
12896  VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputDivisorStateCreateInfoKHR.sType );
12897  VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputDivisorStateCreateInfoKHR.pNext );
12898  VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputDivisorStateCreateInfoKHR.vertexBindingDivisorCount );
12899  VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputDivisorStateCreateInfoKHR.pVertexBindingDivisors );
12900  return seed;
12901  }
12902  };
12903 
12904  template <>
12905  struct hash<VULKAN_HPP_NAMESPACE::PipelineViewportCoarseSampleOrderStateCreateInfoNV>
12906  {
12907  std::size_t
12908  operator()( VULKAN_HPP_NAMESPACE::PipelineViewportCoarseSampleOrderStateCreateInfoNV const & pipelineViewportCoarseSampleOrderStateCreateInfoNV ) const
12909  VULKAN_HPP_NOEXCEPT
12910  {
12911  std::size_t seed = 0;
12912  VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportCoarseSampleOrderStateCreateInfoNV.sType );
12913  VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportCoarseSampleOrderStateCreateInfoNV.pNext );
12914  VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportCoarseSampleOrderStateCreateInfoNV.sampleOrderType );
12915  VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportCoarseSampleOrderStateCreateInfoNV.customSampleOrderCount );
12916  VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportCoarseSampleOrderStateCreateInfoNV.pCustomSampleOrders );
12917  return seed;
12918  }
12919  };
12920 
12921  template <>
12922  struct hash<VULKAN_HPP_NAMESPACE::PipelineViewportDepthClipControlCreateInfoEXT>
12923  {
12924  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineViewportDepthClipControlCreateInfoEXT const & pipelineViewportDepthClipControlCreateInfoEXT ) const
12925  VULKAN_HPP_NOEXCEPT
12926  {
12927  std::size_t seed = 0;
12928  VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportDepthClipControlCreateInfoEXT.sType );
12929  VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportDepthClipControlCreateInfoEXT.pNext );
12930  VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportDepthClipControlCreateInfoEXT.negativeOneToOne );
12931  return seed;
12932  }
12933  };
12934 
12935  template <>
12936  struct hash<VULKAN_HPP_NAMESPACE::PipelineViewportExclusiveScissorStateCreateInfoNV>
12937  {
12938  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineViewportExclusiveScissorStateCreateInfoNV const & pipelineViewportExclusiveScissorStateCreateInfoNV )
12939  const VULKAN_HPP_NOEXCEPT
12940  {
12941  std::size_t seed = 0;
12942  VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportExclusiveScissorStateCreateInfoNV.sType );
12943  VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportExclusiveScissorStateCreateInfoNV.pNext );
12944  VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportExclusiveScissorStateCreateInfoNV.exclusiveScissorCount );
12945  VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportExclusiveScissorStateCreateInfoNV.pExclusiveScissors );
12946  return seed;
12947  }
12948  };
12949 
12950  template <>
12951  struct hash<VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV>
12952  {
12953  std::size_t operator()( VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV const & shadingRatePaletteNV ) const VULKAN_HPP_NOEXCEPT
12954  {
12955  std::size_t seed = 0;
12956  VULKAN_HPP_HASH_COMBINE( seed, shadingRatePaletteNV.shadingRatePaletteEntryCount );
12957  VULKAN_HPP_HASH_COMBINE( seed, shadingRatePaletteNV.pShadingRatePaletteEntries );
12958  return seed;
12959  }
12960  };
12961 
12962  template <>
12963  struct hash<VULKAN_HPP_NAMESPACE::PipelineViewportShadingRateImageStateCreateInfoNV>
12964  {
12965  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineViewportShadingRateImageStateCreateInfoNV const & pipelineViewportShadingRateImageStateCreateInfoNV )
12966  const VULKAN_HPP_NOEXCEPT
12967  {
12968  std::size_t seed = 0;
12969  VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportShadingRateImageStateCreateInfoNV.sType );
12970  VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportShadingRateImageStateCreateInfoNV.pNext );
12971  VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportShadingRateImageStateCreateInfoNV.shadingRateImageEnable );
12972  VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportShadingRateImageStateCreateInfoNV.viewportCount );
12973  VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportShadingRateImageStateCreateInfoNV.pShadingRatePalettes );
12974  return seed;
12975  }
12976  };
12977 
12978  template <>
12979  struct hash<VULKAN_HPP_NAMESPACE::ViewportSwizzleNV>
12980  {
12981  std::size_t operator()( VULKAN_HPP_NAMESPACE::ViewportSwizzleNV const & viewportSwizzleNV ) const VULKAN_HPP_NOEXCEPT
12982  {
12983  std::size_t seed = 0;
12984  VULKAN_HPP_HASH_COMBINE( seed, viewportSwizzleNV.x );
12985  VULKAN_HPP_HASH_COMBINE( seed, viewportSwizzleNV.y );
12986  VULKAN_HPP_HASH_COMBINE( seed, viewportSwizzleNV.z );
12987  VULKAN_HPP_HASH_COMBINE( seed, viewportSwizzleNV.w );
12988  return seed;
12989  }
12990  };
12991 
12992  template <>
12993  struct hash<VULKAN_HPP_NAMESPACE::PipelineViewportSwizzleStateCreateInfoNV>
12994  {
12995  std::size_t
12996  operator()( VULKAN_HPP_NAMESPACE::PipelineViewportSwizzleStateCreateInfoNV const & pipelineViewportSwizzleStateCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
12997  {
12998  std::size_t seed = 0;
12999  VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportSwizzleStateCreateInfoNV.sType );
13000  VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportSwizzleStateCreateInfoNV.pNext );
13001  VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportSwizzleStateCreateInfoNV.flags );
13002  VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportSwizzleStateCreateInfoNV.viewportCount );
13003  VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportSwizzleStateCreateInfoNV.pViewportSwizzles );
13004  return seed;
13005  }
13006  };
13007 
13008  template <>
13009  struct hash<VULKAN_HPP_NAMESPACE::ViewportWScalingNV>
13010  {
13011  std::size_t operator()( VULKAN_HPP_NAMESPACE::ViewportWScalingNV const & viewportWScalingNV ) const VULKAN_HPP_NOEXCEPT
13012  {
13013  std::size_t seed = 0;
13014  VULKAN_HPP_HASH_COMBINE( seed, viewportWScalingNV.xcoeff );
13015  VULKAN_HPP_HASH_COMBINE( seed, viewportWScalingNV.ycoeff );
13016  return seed;
13017  }
13018  };
13019 
13020  template <>
13021  struct hash<VULKAN_HPP_NAMESPACE::PipelineViewportWScalingStateCreateInfoNV>
13022  {
13023  std::size_t
13024  operator()( VULKAN_HPP_NAMESPACE::PipelineViewportWScalingStateCreateInfoNV const & pipelineViewportWScalingStateCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
13025  {
13026  std::size_t seed = 0;
13027  VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportWScalingStateCreateInfoNV.sType );
13028  VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportWScalingStateCreateInfoNV.pNext );
13029  VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportWScalingStateCreateInfoNV.viewportWScalingEnable );
13030  VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportWScalingStateCreateInfoNV.viewportCount );
13031  VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportWScalingStateCreateInfoNV.pViewportWScalings );
13032  return seed;
13033  }
13034  };
13035 
13036 # if defined( VK_USE_PLATFORM_GGP )
13037  template <>
13038  struct hash<VULKAN_HPP_NAMESPACE::PresentFrameTokenGGP>
13039  {
13040  std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentFrameTokenGGP const & presentFrameTokenGGP ) const VULKAN_HPP_NOEXCEPT
13041  {
13042  std::size_t seed = 0;
13043  VULKAN_HPP_HASH_COMBINE( seed, presentFrameTokenGGP.sType );
13044  VULKAN_HPP_HASH_COMBINE( seed, presentFrameTokenGGP.pNext );
13045  VULKAN_HPP_HASH_COMBINE( seed, presentFrameTokenGGP.frameToken );
13046  return seed;
13047  }
13048  };
13049 # endif /*VK_USE_PLATFORM_GGP*/
13050 
13051  template <>
13052  struct hash<VULKAN_HPP_NAMESPACE::PresentIdKHR>
13053  {
13054  std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentIdKHR const & presentIdKHR ) const VULKAN_HPP_NOEXCEPT
13055  {
13056  std::size_t seed = 0;
13057  VULKAN_HPP_HASH_COMBINE( seed, presentIdKHR.sType );
13058  VULKAN_HPP_HASH_COMBINE( seed, presentIdKHR.pNext );
13059  VULKAN_HPP_HASH_COMBINE( seed, presentIdKHR.swapchainCount );
13060  VULKAN_HPP_HASH_COMBINE( seed, presentIdKHR.pPresentIds );
13061  return seed;
13062  }
13063  };
13064 
13065  template <>
13066  struct hash<VULKAN_HPP_NAMESPACE::PresentInfoKHR>
13067  {
13068  std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentInfoKHR const & presentInfoKHR ) const VULKAN_HPP_NOEXCEPT
13069  {
13070  std::size_t seed = 0;
13071  VULKAN_HPP_HASH_COMBINE( seed, presentInfoKHR.sType );
13072  VULKAN_HPP_HASH_COMBINE( seed, presentInfoKHR.pNext );
13073  VULKAN_HPP_HASH_COMBINE( seed, presentInfoKHR.waitSemaphoreCount );
13074  VULKAN_HPP_HASH_COMBINE( seed, presentInfoKHR.pWaitSemaphores );
13075  VULKAN_HPP_HASH_COMBINE( seed, presentInfoKHR.swapchainCount );
13076  VULKAN_HPP_HASH_COMBINE( seed, presentInfoKHR.pSwapchains );
13077  VULKAN_HPP_HASH_COMBINE( seed, presentInfoKHR.pImageIndices );
13078  VULKAN_HPP_HASH_COMBINE( seed, presentInfoKHR.pResults );
13079  return seed;
13080  }
13081  };
13082 
13083  template <>
13084  struct hash<VULKAN_HPP_NAMESPACE::RectLayerKHR>
13085  {
13086  std::size_t operator()( VULKAN_HPP_NAMESPACE::RectLayerKHR const & rectLayerKHR ) const VULKAN_HPP_NOEXCEPT
13087  {
13088  std::size_t seed = 0;
13089  VULKAN_HPP_HASH_COMBINE( seed, rectLayerKHR.offset );
13090  VULKAN_HPP_HASH_COMBINE( seed, rectLayerKHR.extent );
13091  VULKAN_HPP_HASH_COMBINE( seed, rectLayerKHR.layer );
13092  return seed;
13093  }
13094  };
13095 
13096  template <>
13097  struct hash<VULKAN_HPP_NAMESPACE::PresentRegionKHR>
13098  {
13099  std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentRegionKHR const & presentRegionKHR ) const VULKAN_HPP_NOEXCEPT
13100  {
13101  std::size_t seed = 0;
13102  VULKAN_HPP_HASH_COMBINE( seed, presentRegionKHR.rectangleCount );
13103  VULKAN_HPP_HASH_COMBINE( seed, presentRegionKHR.pRectangles );
13104  return seed;
13105  }
13106  };
13107 
13108  template <>
13109  struct hash<VULKAN_HPP_NAMESPACE::PresentRegionsKHR>
13110  {
13111  std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentRegionsKHR const & presentRegionsKHR ) const VULKAN_HPP_NOEXCEPT
13112  {
13113  std::size_t seed = 0;
13114  VULKAN_HPP_HASH_COMBINE( seed, presentRegionsKHR.sType );
13115  VULKAN_HPP_HASH_COMBINE( seed, presentRegionsKHR.pNext );
13116  VULKAN_HPP_HASH_COMBINE( seed, presentRegionsKHR.swapchainCount );
13117  VULKAN_HPP_HASH_COMBINE( seed, presentRegionsKHR.pRegions );
13118  return seed;
13119  }
13120  };
13121 
13122  template <>
13123  struct hash<VULKAN_HPP_NAMESPACE::PresentTimeGOOGLE>
13124  {
13125  std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentTimeGOOGLE const & presentTimeGOOGLE ) const VULKAN_HPP_NOEXCEPT
13126  {
13127  std::size_t seed = 0;
13128  VULKAN_HPP_HASH_COMBINE( seed, presentTimeGOOGLE.presentID );
13129  VULKAN_HPP_HASH_COMBINE( seed, presentTimeGOOGLE.desiredPresentTime );
13130  return seed;
13131  }
13132  };
13133 
13134  template <>
13135  struct hash<VULKAN_HPP_NAMESPACE::PresentTimesInfoGOOGLE>
13136  {
13137  std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentTimesInfoGOOGLE const & presentTimesInfoGOOGLE ) const VULKAN_HPP_NOEXCEPT
13138  {
13139  std::size_t seed = 0;
13140  VULKAN_HPP_HASH_COMBINE( seed, presentTimesInfoGOOGLE.sType );
13141  VULKAN_HPP_HASH_COMBINE( seed, presentTimesInfoGOOGLE.pNext );
13142  VULKAN_HPP_HASH_COMBINE( seed, presentTimesInfoGOOGLE.swapchainCount );
13143  VULKAN_HPP_HASH_COMBINE( seed, presentTimesInfoGOOGLE.pTimes );
13144  return seed;
13145  }
13146  };
13147 
13148  template <>
13149  struct hash<VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo>
13150  {
13151  std::size_t operator()( VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo const & privateDataSlotCreateInfo ) const VULKAN_HPP_NOEXCEPT
13152  {
13153  std::size_t seed = 0;
13154  VULKAN_HPP_HASH_COMBINE( seed, privateDataSlotCreateInfo.sType );
13155  VULKAN_HPP_HASH_COMBINE( seed, privateDataSlotCreateInfo.pNext );
13156  VULKAN_HPP_HASH_COMBINE( seed, privateDataSlotCreateInfo.flags );
13157  return seed;
13158  }
13159  };
13160 
13161  template <>
13162  struct hash<VULKAN_HPP_NAMESPACE::ProtectedSubmitInfo>
13163  {
13164  std::size_t operator()( VULKAN_HPP_NAMESPACE::ProtectedSubmitInfo const & protectedSubmitInfo ) const VULKAN_HPP_NOEXCEPT
13165  {
13166  std::size_t seed = 0;
13167  VULKAN_HPP_HASH_COMBINE( seed, protectedSubmitInfo.sType );
13168  VULKAN_HPP_HASH_COMBINE( seed, protectedSubmitInfo.pNext );
13169  VULKAN_HPP_HASH_COMBINE( seed, protectedSubmitInfo.protectedSubmit );
13170  return seed;
13171  }
13172  };
13173 
13174  template <>
13175  struct hash<VULKAN_HPP_NAMESPACE::PushConstantsInfoKHR>
13176  {
13177  std::size_t operator()( VULKAN_HPP_NAMESPACE::PushConstantsInfoKHR const & pushConstantsInfoKHR ) const VULKAN_HPP_NOEXCEPT
13178  {
13179  std::size_t seed = 0;
13180  VULKAN_HPP_HASH_COMBINE( seed, pushConstantsInfoKHR.sType );
13181  VULKAN_HPP_HASH_COMBINE( seed, pushConstantsInfoKHR.pNext );
13182  VULKAN_HPP_HASH_COMBINE( seed, pushConstantsInfoKHR.layout );
13183  VULKAN_HPP_HASH_COMBINE( seed, pushConstantsInfoKHR.stageFlags );
13184  VULKAN_HPP_HASH_COMBINE( seed, pushConstantsInfoKHR.offset );
13185  VULKAN_HPP_HASH_COMBINE( seed, pushConstantsInfoKHR.size );
13186  VULKAN_HPP_HASH_COMBINE( seed, pushConstantsInfoKHR.pValues );
13187  return seed;
13188  }
13189  };
13190 
13191  template <>
13192  struct hash<VULKAN_HPP_NAMESPACE::WriteDescriptorSet>
13193  {
13194  std::size_t operator()( VULKAN_HPP_NAMESPACE::WriteDescriptorSet const & writeDescriptorSet ) const VULKAN_HPP_NOEXCEPT
13195  {
13196  std::size_t seed = 0;
13197  VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.sType );
13198  VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.pNext );
13199  VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.dstSet );
13200  VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.dstBinding );
13201  VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.dstArrayElement );
13202  VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.descriptorCount );
13203  VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.descriptorType );
13204  VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.pImageInfo );
13205  VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.pBufferInfo );
13206  VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.pTexelBufferView );
13207  return seed;
13208  }
13209  };
13210 
13211  template <>
13212  struct hash<VULKAN_HPP_NAMESPACE::PushDescriptorSetInfoKHR>
13213  {
13214  std::size_t operator()( VULKAN_HPP_NAMESPACE::PushDescriptorSetInfoKHR const & pushDescriptorSetInfoKHR ) const VULKAN_HPP_NOEXCEPT
13215  {
13216  std::size_t seed = 0;
13217  VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetInfoKHR.sType );
13218  VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetInfoKHR.pNext );
13219  VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetInfoKHR.stageFlags );
13220  VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetInfoKHR.layout );
13221  VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetInfoKHR.set );
13222  VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetInfoKHR.descriptorWriteCount );
13223  VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetInfoKHR.pDescriptorWrites );
13224  return seed;
13225  }
13226  };
13227 
13228  template <>
13229  struct hash<VULKAN_HPP_NAMESPACE::PushDescriptorSetWithTemplateInfoKHR>
13230  {
13231  std::size_t operator()( VULKAN_HPP_NAMESPACE::PushDescriptorSetWithTemplateInfoKHR const & pushDescriptorSetWithTemplateInfoKHR ) const VULKAN_HPP_NOEXCEPT
13232  {
13233  std::size_t seed = 0;
13234  VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetWithTemplateInfoKHR.sType );
13235  VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetWithTemplateInfoKHR.pNext );
13236  VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetWithTemplateInfoKHR.descriptorUpdateTemplate );
13237  VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetWithTemplateInfoKHR.layout );
13238  VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetWithTemplateInfoKHR.set );
13239  VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetWithTemplateInfoKHR.pData );
13240  return seed;
13241  }
13242  };
13243 
13244  template <>
13245  struct hash<VULKAN_HPP_NAMESPACE::QueryLowLatencySupportNV>
13246  {
13247  std::size_t operator()( VULKAN_HPP_NAMESPACE::QueryLowLatencySupportNV const & queryLowLatencySupportNV ) const VULKAN_HPP_NOEXCEPT
13248  {
13249  std::size_t seed = 0;
13250  VULKAN_HPP_HASH_COMBINE( seed, queryLowLatencySupportNV.sType );
13251  VULKAN_HPP_HASH_COMBINE( seed, queryLowLatencySupportNV.pNext );
13252  VULKAN_HPP_HASH_COMBINE( seed, queryLowLatencySupportNV.pQueriedLowLatencyData );
13253  return seed;
13254  }
13255  };
13256 
13257  template <>
13258  struct hash<VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo>
13259  {
13260  std::size_t operator()( VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo const & queryPoolCreateInfo ) const VULKAN_HPP_NOEXCEPT
13261  {
13262  std::size_t seed = 0;
13263  VULKAN_HPP_HASH_COMBINE( seed, queryPoolCreateInfo.sType );
13264  VULKAN_HPP_HASH_COMBINE( seed, queryPoolCreateInfo.pNext );
13265  VULKAN_HPP_HASH_COMBINE( seed, queryPoolCreateInfo.flags );
13266  VULKAN_HPP_HASH_COMBINE( seed, queryPoolCreateInfo.queryType );
13267  VULKAN_HPP_HASH_COMBINE( seed, queryPoolCreateInfo.queryCount );
13268  VULKAN_HPP_HASH_COMBINE( seed, queryPoolCreateInfo.pipelineStatistics );
13269  return seed;
13270  }
13271  };
13272 
13273  template <>
13274  struct hash<VULKAN_HPP_NAMESPACE::QueryPoolPerformanceCreateInfoKHR>
13275  {
13276  std::size_t operator()( VULKAN_HPP_NAMESPACE::QueryPoolPerformanceCreateInfoKHR const & queryPoolPerformanceCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
13277  {
13278  std::size_t seed = 0;
13279  VULKAN_HPP_HASH_COMBINE( seed, queryPoolPerformanceCreateInfoKHR.sType );
13280  VULKAN_HPP_HASH_COMBINE( seed, queryPoolPerformanceCreateInfoKHR.pNext );
13281  VULKAN_HPP_HASH_COMBINE( seed, queryPoolPerformanceCreateInfoKHR.queueFamilyIndex );
13282  VULKAN_HPP_HASH_COMBINE( seed, queryPoolPerformanceCreateInfoKHR.counterIndexCount );
13283  VULKAN_HPP_HASH_COMBINE( seed, queryPoolPerformanceCreateInfoKHR.pCounterIndices );
13284  return seed;
13285  }
13286  };
13287 
13288  template <>
13289  struct hash<VULKAN_HPP_NAMESPACE::QueryPoolPerformanceQueryCreateInfoINTEL>
13290  {
13291  std::size_t
13292  operator()( VULKAN_HPP_NAMESPACE::QueryPoolPerformanceQueryCreateInfoINTEL const & queryPoolPerformanceQueryCreateInfoINTEL ) const VULKAN_HPP_NOEXCEPT
13293  {
13294  std::size_t seed = 0;
13295  VULKAN_HPP_HASH_COMBINE( seed, queryPoolPerformanceQueryCreateInfoINTEL.sType );
13296  VULKAN_HPP_HASH_COMBINE( seed, queryPoolPerformanceQueryCreateInfoINTEL.pNext );
13297  VULKAN_HPP_HASH_COMBINE( seed, queryPoolPerformanceQueryCreateInfoINTEL.performanceCountersSampling );
13298  return seed;
13299  }
13300  };
13301 
13302  template <>
13303  struct hash<VULKAN_HPP_NAMESPACE::QueryPoolVideoEncodeFeedbackCreateInfoKHR>
13304  {
13305  std::size_t
13306  operator()( VULKAN_HPP_NAMESPACE::QueryPoolVideoEncodeFeedbackCreateInfoKHR const & queryPoolVideoEncodeFeedbackCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
13307  {
13308  std::size_t seed = 0;
13309  VULKAN_HPP_HASH_COMBINE( seed, queryPoolVideoEncodeFeedbackCreateInfoKHR.sType );
13310  VULKAN_HPP_HASH_COMBINE( seed, queryPoolVideoEncodeFeedbackCreateInfoKHR.pNext );
13311  VULKAN_HPP_HASH_COMBINE( seed, queryPoolVideoEncodeFeedbackCreateInfoKHR.encodeFeedbackFlags );
13312  return seed;
13313  }
13314  };
13315 
13316  template <>
13317  struct hash<VULKAN_HPP_NAMESPACE::QueueFamilyCheckpointProperties2NV>
13318  {
13319  std::size_t operator()( VULKAN_HPP_NAMESPACE::QueueFamilyCheckpointProperties2NV const & queueFamilyCheckpointProperties2NV ) const VULKAN_HPP_NOEXCEPT
13320  {
13321  std::size_t seed = 0;
13322  VULKAN_HPP_HASH_COMBINE( seed, queueFamilyCheckpointProperties2NV.sType );
13323  VULKAN_HPP_HASH_COMBINE( seed, queueFamilyCheckpointProperties2NV.pNext );
13324  VULKAN_HPP_HASH_COMBINE( seed, queueFamilyCheckpointProperties2NV.checkpointExecutionStageMask );
13325  return seed;
13326  }
13327  };
13328 
13329  template <>
13330  struct hash<VULKAN_HPP_NAMESPACE::QueueFamilyCheckpointPropertiesNV>
13331  {
13332  std::size_t operator()( VULKAN_HPP_NAMESPACE::QueueFamilyCheckpointPropertiesNV const & queueFamilyCheckpointPropertiesNV ) const VULKAN_HPP_NOEXCEPT
13333  {
13334  std::size_t seed = 0;
13335  VULKAN_HPP_HASH_COMBINE( seed, queueFamilyCheckpointPropertiesNV.sType );
13336  VULKAN_HPP_HASH_COMBINE( seed, queueFamilyCheckpointPropertiesNV.pNext );
13337  VULKAN_HPP_HASH_COMBINE( seed, queueFamilyCheckpointPropertiesNV.checkpointExecutionStageMask );
13338  return seed;
13339  }
13340  };
13341 
13342  template <>
13343  struct hash<VULKAN_HPP_NAMESPACE::QueueFamilyGlobalPriorityPropertiesKHR>
13344  {
13345  std::size_t
13346  operator()( VULKAN_HPP_NAMESPACE::QueueFamilyGlobalPriorityPropertiesKHR const & queueFamilyGlobalPriorityPropertiesKHR ) const VULKAN_HPP_NOEXCEPT
13347  {
13348  std::size_t seed = 0;
13349  VULKAN_HPP_HASH_COMBINE( seed, queueFamilyGlobalPriorityPropertiesKHR.sType );
13350  VULKAN_HPP_HASH_COMBINE( seed, queueFamilyGlobalPriorityPropertiesKHR.pNext );
13351  VULKAN_HPP_HASH_COMBINE( seed, queueFamilyGlobalPriorityPropertiesKHR.priorityCount );
13352  for ( size_t i = 0; i < VK_MAX_GLOBAL_PRIORITY_SIZE_KHR; ++i )
13353  {
13354  VULKAN_HPP_HASH_COMBINE( seed, queueFamilyGlobalPriorityPropertiesKHR.priorities[i] );
13355  }
13356  return seed;
13357  }
13358  };
13359 
13360  template <>
13361  struct hash<VULKAN_HPP_NAMESPACE::QueueFamilyProperties>
13362  {
13363  std::size_t operator()( VULKAN_HPP_NAMESPACE::QueueFamilyProperties const & queueFamilyProperties ) const VULKAN_HPP_NOEXCEPT
13364  {
13365  std::size_t seed = 0;
13366  VULKAN_HPP_HASH_COMBINE( seed, queueFamilyProperties.queueFlags );
13367  VULKAN_HPP_HASH_COMBINE( seed, queueFamilyProperties.queueCount );
13368  VULKAN_HPP_HASH_COMBINE( seed, queueFamilyProperties.timestampValidBits );
13369  VULKAN_HPP_HASH_COMBINE( seed, queueFamilyProperties.minImageTransferGranularity );
13370  return seed;
13371  }
13372  };
13373 
13374  template <>
13375  struct hash<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>
13376  {
13377  std::size_t operator()( VULKAN_HPP_NAMESPACE::QueueFamilyProperties2 const & queueFamilyProperties2 ) const VULKAN_HPP_NOEXCEPT
13378  {
13379  std::size_t seed = 0;
13380  VULKAN_HPP_HASH_COMBINE( seed, queueFamilyProperties2.sType );
13381  VULKAN_HPP_HASH_COMBINE( seed, queueFamilyProperties2.pNext );
13382  VULKAN_HPP_HASH_COMBINE( seed, queueFamilyProperties2.queueFamilyProperties );
13383  return seed;
13384  }
13385  };
13386 
13387  template <>
13388  struct hash<VULKAN_HPP_NAMESPACE::QueueFamilyQueryResultStatusPropertiesKHR>
13389  {
13390  std::size_t
13391  operator()( VULKAN_HPP_NAMESPACE::QueueFamilyQueryResultStatusPropertiesKHR const & queueFamilyQueryResultStatusPropertiesKHR ) const VULKAN_HPP_NOEXCEPT
13392  {
13393  std::size_t seed = 0;
13394  VULKAN_HPP_HASH_COMBINE( seed, queueFamilyQueryResultStatusPropertiesKHR.sType );
13395  VULKAN_HPP_HASH_COMBINE( seed, queueFamilyQueryResultStatusPropertiesKHR.pNext );
13396  VULKAN_HPP_HASH_COMBINE( seed, queueFamilyQueryResultStatusPropertiesKHR.queryResultStatusSupport );
13397  return seed;
13398  }
13399  };
13400 
13401  template <>
13402  struct hash<VULKAN_HPP_NAMESPACE::QueueFamilyVideoPropertiesKHR>
13403  {
13404  std::size_t operator()( VULKAN_HPP_NAMESPACE::QueueFamilyVideoPropertiesKHR const & queueFamilyVideoPropertiesKHR ) const VULKAN_HPP_NOEXCEPT
13405  {
13406  std::size_t seed = 0;
13407  VULKAN_HPP_HASH_COMBINE( seed, queueFamilyVideoPropertiesKHR.sType );
13408  VULKAN_HPP_HASH_COMBINE( seed, queueFamilyVideoPropertiesKHR.pNext );
13409  VULKAN_HPP_HASH_COMBINE( seed, queueFamilyVideoPropertiesKHR.videoCodecOperations );
13410  return seed;
13411  }
13412  };
13413 
13414  template <>
13415  struct hash<VULKAN_HPP_NAMESPACE::RayTracingShaderGroupCreateInfoKHR>
13416  {
13417  std::size_t operator()( VULKAN_HPP_NAMESPACE::RayTracingShaderGroupCreateInfoKHR const & rayTracingShaderGroupCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
13418  {
13419  std::size_t seed = 0;
13420  VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoKHR.sType );
13421  VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoKHR.pNext );
13422  VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoKHR.type );
13423  VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoKHR.generalShader );
13424  VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoKHR.closestHitShader );
13425  VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoKHR.anyHitShader );
13426  VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoKHR.intersectionShader );
13427  VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoKHR.pShaderGroupCaptureReplayHandle );
13428  return seed;
13429  }
13430  };
13431 
13432  template <>
13433  struct hash<VULKAN_HPP_NAMESPACE::RayTracingPipelineInterfaceCreateInfoKHR>
13434  {
13435  std::size_t
13436  operator()( VULKAN_HPP_NAMESPACE::RayTracingPipelineInterfaceCreateInfoKHR const & rayTracingPipelineInterfaceCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
13437  {
13438  std::size_t seed = 0;
13439  VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineInterfaceCreateInfoKHR.sType );
13440  VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineInterfaceCreateInfoKHR.pNext );
13441  VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineInterfaceCreateInfoKHR.maxPipelineRayPayloadSize );
13442  VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineInterfaceCreateInfoKHR.maxPipelineRayHitAttributeSize );
13443  return seed;
13444  }
13445  };
13446 
13447  template <>
13448  struct hash<VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR>
13449  {
13450  std::size_t operator()( VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR const & rayTracingPipelineCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
13451  {
13452  std::size_t seed = 0;
13453  VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.sType );
13454  VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.pNext );
13455  VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.flags );
13456  VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.stageCount );
13457  VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.pStages );
13458  VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.groupCount );
13459  VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.pGroups );
13460  VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.maxPipelineRayRecursionDepth );
13461  VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.pLibraryInfo );
13462  VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.pLibraryInterface );
13463  VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.pDynamicState );
13464  VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.layout );
13465  VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.basePipelineHandle );
13466  VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.basePipelineIndex );
13467  return seed;
13468  }
13469  };
13470 
13471  template <>
13472  struct hash<VULKAN_HPP_NAMESPACE::RayTracingShaderGroupCreateInfoNV>
13473  {
13474  std::size_t operator()( VULKAN_HPP_NAMESPACE::RayTracingShaderGroupCreateInfoNV const & rayTracingShaderGroupCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
13475  {
13476  std::size_t seed = 0;
13477  VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoNV.sType );
13478  VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoNV.pNext );
13479  VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoNV.type );
13480  VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoNV.generalShader );
13481  VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoNV.closestHitShader );
13482  VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoNV.anyHitShader );
13483  VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoNV.intersectionShader );
13484  return seed;
13485  }
13486  };
13487 
13488  template <>
13489  struct hash<VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV>
13490  {
13491  std::size_t operator()( VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV const & rayTracingPipelineCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
13492  {
13493  std::size_t seed = 0;
13494  VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.sType );
13495  VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.pNext );
13496  VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.flags );
13497  VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.stageCount );
13498  VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.pStages );
13499  VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.groupCount );
13500  VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.pGroups );
13501  VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.maxRecursionDepth );
13502  VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.layout );
13503  VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.basePipelineHandle );
13504  VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.basePipelineIndex );
13505  return seed;
13506  }
13507  };
13508 
13509  template <>
13510  struct hash<VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE>
13511  {
13512  std::size_t operator()( VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE const & refreshCycleDurationGOOGLE ) const VULKAN_HPP_NOEXCEPT
13513  {
13514  std::size_t seed = 0;
13515  VULKAN_HPP_HASH_COMBINE( seed, refreshCycleDurationGOOGLE.refreshDuration );
13516  return seed;
13517  }
13518  };
13519 
13520  template <>
13521  struct hash<VULKAN_HPP_NAMESPACE::ReleaseSwapchainImagesInfoEXT>
13522  {
13523  std::size_t operator()( VULKAN_HPP_NAMESPACE::ReleaseSwapchainImagesInfoEXT const & releaseSwapchainImagesInfoEXT ) const VULKAN_HPP_NOEXCEPT
13524  {
13525  std::size_t seed = 0;
13526  VULKAN_HPP_HASH_COMBINE( seed, releaseSwapchainImagesInfoEXT.sType );
13527  VULKAN_HPP_HASH_COMBINE( seed, releaseSwapchainImagesInfoEXT.pNext );
13528  VULKAN_HPP_HASH_COMBINE( seed, releaseSwapchainImagesInfoEXT.swapchain );
13529  VULKAN_HPP_HASH_COMBINE( seed, releaseSwapchainImagesInfoEXT.imageIndexCount );
13530  VULKAN_HPP_HASH_COMBINE( seed, releaseSwapchainImagesInfoEXT.pImageIndices );
13531  return seed;
13532  }
13533  };
13534 
13535  template <>
13536  struct hash<VULKAN_HPP_NAMESPACE::RenderPassAttachmentBeginInfo>
13537  {
13538  std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassAttachmentBeginInfo const & renderPassAttachmentBeginInfo ) const VULKAN_HPP_NOEXCEPT
13539  {
13540  std::size_t seed = 0;
13541  VULKAN_HPP_HASH_COMBINE( seed, renderPassAttachmentBeginInfo.sType );
13542  VULKAN_HPP_HASH_COMBINE( seed, renderPassAttachmentBeginInfo.pNext );
13543  VULKAN_HPP_HASH_COMBINE( seed, renderPassAttachmentBeginInfo.attachmentCount );
13544  VULKAN_HPP_HASH_COMBINE( seed, renderPassAttachmentBeginInfo.pAttachments );
13545  return seed;
13546  }
13547  };
13548 
13549  template <>
13550  struct hash<VULKAN_HPP_NAMESPACE::RenderPassBeginInfo>
13551  {
13552  std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassBeginInfo const & renderPassBeginInfo ) const VULKAN_HPP_NOEXCEPT
13553  {
13554  std::size_t seed = 0;
13555  VULKAN_HPP_HASH_COMBINE( seed, renderPassBeginInfo.sType );
13556  VULKAN_HPP_HASH_COMBINE( seed, renderPassBeginInfo.pNext );
13557  VULKAN_HPP_HASH_COMBINE( seed, renderPassBeginInfo.renderPass );
13558  VULKAN_HPP_HASH_COMBINE( seed, renderPassBeginInfo.framebuffer );
13559  VULKAN_HPP_HASH_COMBINE( seed, renderPassBeginInfo.renderArea );
13560  VULKAN_HPP_HASH_COMBINE( seed, renderPassBeginInfo.clearValueCount );
13561  VULKAN_HPP_HASH_COMBINE( seed, renderPassBeginInfo.pClearValues );
13562  return seed;
13563  }
13564  };
13565 
13566  template <>
13567  struct hash<VULKAN_HPP_NAMESPACE::SubpassDescription>
13568  {
13569  std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassDescription const & subpassDescription ) const VULKAN_HPP_NOEXCEPT
13570  {
13571  std::size_t seed = 0;
13572  VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.flags );
13573  VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.pipelineBindPoint );
13574  VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.inputAttachmentCount );
13575  VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.pInputAttachments );
13576  VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.colorAttachmentCount );
13577  VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.pColorAttachments );
13578  VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.pResolveAttachments );
13579  VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.pDepthStencilAttachment );
13580  VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.preserveAttachmentCount );
13581  VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.pPreserveAttachments );
13582  return seed;
13583  }
13584  };
13585 
13586  template <>
13587  struct hash<VULKAN_HPP_NAMESPACE::SubpassDependency>
13588  {
13589  std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassDependency const & subpassDependency ) const VULKAN_HPP_NOEXCEPT
13590  {
13591  std::size_t seed = 0;
13592  VULKAN_HPP_HASH_COMBINE( seed, subpassDependency.srcSubpass );
13593  VULKAN_HPP_HASH_COMBINE( seed, subpassDependency.dstSubpass );
13594  VULKAN_HPP_HASH_COMBINE( seed, subpassDependency.srcStageMask );
13595  VULKAN_HPP_HASH_COMBINE( seed, subpassDependency.dstStageMask );
13596  VULKAN_HPP_HASH_COMBINE( seed, subpassDependency.srcAccessMask );
13597  VULKAN_HPP_HASH_COMBINE( seed, subpassDependency.dstAccessMask );
13598  VULKAN_HPP_HASH_COMBINE( seed, subpassDependency.dependencyFlags );
13599  return seed;
13600  }
13601  };
13602 
13603  template <>
13604  struct hash<VULKAN_HPP_NAMESPACE::RenderPassCreateInfo>
13605  {
13606  std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassCreateInfo const & renderPassCreateInfo ) const VULKAN_HPP_NOEXCEPT
13607  {
13608  std::size_t seed = 0;
13609  VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo.sType );
13610  VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo.pNext );
13611  VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo.flags );
13612  VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo.attachmentCount );
13613  VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo.pAttachments );
13614  VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo.subpassCount );
13615  VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo.pSubpasses );
13616  VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo.dependencyCount );
13617  VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo.pDependencies );
13618  return seed;
13619  }
13620  };
13621 
13622  template <>
13623  struct hash<VULKAN_HPP_NAMESPACE::SubpassDescription2>
13624  {
13625  std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassDescription2 const & subpassDescription2 ) const VULKAN_HPP_NOEXCEPT
13626  {
13627  std::size_t seed = 0;
13628  VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.sType );
13629  VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.pNext );
13630  VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.flags );
13631  VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.pipelineBindPoint );
13632  VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.viewMask );
13633  VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.inputAttachmentCount );
13634  VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.pInputAttachments );
13635  VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.colorAttachmentCount );
13636  VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.pColorAttachments );
13637  VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.pResolveAttachments );
13638  VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.pDepthStencilAttachment );
13639  VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.preserveAttachmentCount );
13640  VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.pPreserveAttachments );
13641  return seed;
13642  }
13643  };
13644 
13645  template <>
13646  struct hash<VULKAN_HPP_NAMESPACE::SubpassDependency2>
13647  {
13648  std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassDependency2 const & subpassDependency2 ) const VULKAN_HPP_NOEXCEPT
13649  {
13650  std::size_t seed = 0;
13651  VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.sType );
13652  VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.pNext );
13653  VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.srcSubpass );
13654  VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.dstSubpass );
13655  VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.srcStageMask );
13656  VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.dstStageMask );
13657  VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.srcAccessMask );
13658  VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.dstAccessMask );
13659  VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.dependencyFlags );
13660  VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.viewOffset );
13661  return seed;
13662  }
13663  };
13664 
13665  template <>
13666  struct hash<VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2>
13667  {
13668  std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 const & renderPassCreateInfo2 ) const VULKAN_HPP_NOEXCEPT
13669  {
13670  std::size_t seed = 0;
13671  VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.sType );
13672  VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.pNext );
13673  VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.flags );
13674  VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.attachmentCount );
13675  VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.pAttachments );
13676  VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.subpassCount );
13677  VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.pSubpasses );
13678  VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.dependencyCount );
13679  VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.pDependencies );
13680  VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.correlatedViewMaskCount );
13681  VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.pCorrelatedViewMasks );
13682  return seed;
13683  }
13684  };
13685 
13686  template <>
13687  struct hash<VULKAN_HPP_NAMESPACE::RenderPassCreationControlEXT>
13688  {
13689  std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassCreationControlEXT const & renderPassCreationControlEXT ) const VULKAN_HPP_NOEXCEPT
13690  {
13691  std::size_t seed = 0;
13692  VULKAN_HPP_HASH_COMBINE( seed, renderPassCreationControlEXT.sType );
13693  VULKAN_HPP_HASH_COMBINE( seed, renderPassCreationControlEXT.pNext );
13694  VULKAN_HPP_HASH_COMBINE( seed, renderPassCreationControlEXT.disallowMerging );
13695  return seed;
13696  }
13697  };
13698 
13699  template <>
13700  struct hash<VULKAN_HPP_NAMESPACE::RenderPassCreationFeedbackInfoEXT>
13701  {
13702  std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassCreationFeedbackInfoEXT const & renderPassCreationFeedbackInfoEXT ) const VULKAN_HPP_NOEXCEPT
13703  {
13704  std::size_t seed = 0;
13705  VULKAN_HPP_HASH_COMBINE( seed, renderPassCreationFeedbackInfoEXT.postMergeSubpassCount );
13706  return seed;
13707  }
13708  };
13709 
13710  template <>
13711  struct hash<VULKAN_HPP_NAMESPACE::RenderPassCreationFeedbackCreateInfoEXT>
13712  {
13713  std::size_t
13714  operator()( VULKAN_HPP_NAMESPACE::RenderPassCreationFeedbackCreateInfoEXT const & renderPassCreationFeedbackCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
13715  {
13716  std::size_t seed = 0;
13717  VULKAN_HPP_HASH_COMBINE( seed, renderPassCreationFeedbackCreateInfoEXT.sType );
13718  VULKAN_HPP_HASH_COMBINE( seed, renderPassCreationFeedbackCreateInfoEXT.pNext );
13719  VULKAN_HPP_HASH_COMBINE( seed, renderPassCreationFeedbackCreateInfoEXT.pRenderPassFeedback );
13720  return seed;
13721  }
13722  };
13723 
13724  template <>
13725  struct hash<VULKAN_HPP_NAMESPACE::RenderPassFragmentDensityMapCreateInfoEXT>
13726  {
13727  std::size_t
13728  operator()( VULKAN_HPP_NAMESPACE::RenderPassFragmentDensityMapCreateInfoEXT const & renderPassFragmentDensityMapCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
13729  {
13730  std::size_t seed = 0;
13731  VULKAN_HPP_HASH_COMBINE( seed, renderPassFragmentDensityMapCreateInfoEXT.sType );
13732  VULKAN_HPP_HASH_COMBINE( seed, renderPassFragmentDensityMapCreateInfoEXT.pNext );
13733  VULKAN_HPP_HASH_COMBINE( seed, renderPassFragmentDensityMapCreateInfoEXT.fragmentDensityMapAttachment );
13734  return seed;
13735  }
13736  };
13737 
13738  template <>
13739  struct hash<VULKAN_HPP_NAMESPACE::RenderPassInputAttachmentAspectCreateInfo>
13740  {
13741  std::size_t
13742  operator()( VULKAN_HPP_NAMESPACE::RenderPassInputAttachmentAspectCreateInfo const & renderPassInputAttachmentAspectCreateInfo ) const VULKAN_HPP_NOEXCEPT
13743  {
13744  std::size_t seed = 0;
13745  VULKAN_HPP_HASH_COMBINE( seed, renderPassInputAttachmentAspectCreateInfo.sType );
13746  VULKAN_HPP_HASH_COMBINE( seed, renderPassInputAttachmentAspectCreateInfo.pNext );
13747  VULKAN_HPP_HASH_COMBINE( seed, renderPassInputAttachmentAspectCreateInfo.aspectReferenceCount );
13748  VULKAN_HPP_HASH_COMBINE( seed, renderPassInputAttachmentAspectCreateInfo.pAspectReferences );
13749  return seed;
13750  }
13751  };
13752 
13753  template <>
13754  struct hash<VULKAN_HPP_NAMESPACE::RenderPassMultiviewCreateInfo>
13755  {
13756  std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassMultiviewCreateInfo const & renderPassMultiviewCreateInfo ) const VULKAN_HPP_NOEXCEPT
13757  {
13758  std::size_t seed = 0;
13759  VULKAN_HPP_HASH_COMBINE( seed, renderPassMultiviewCreateInfo.sType );
13760  VULKAN_HPP_HASH_COMBINE( seed, renderPassMultiviewCreateInfo.pNext );
13761  VULKAN_HPP_HASH_COMBINE( seed, renderPassMultiviewCreateInfo.subpassCount );
13762  VULKAN_HPP_HASH_COMBINE( seed, renderPassMultiviewCreateInfo.pViewMasks );
13763  VULKAN_HPP_HASH_COMBINE( seed, renderPassMultiviewCreateInfo.dependencyCount );
13764  VULKAN_HPP_HASH_COMBINE( seed, renderPassMultiviewCreateInfo.pViewOffsets );
13765  VULKAN_HPP_HASH_COMBINE( seed, renderPassMultiviewCreateInfo.correlationMaskCount );
13766  VULKAN_HPP_HASH_COMBINE( seed, renderPassMultiviewCreateInfo.pCorrelationMasks );
13767  return seed;
13768  }
13769  };
13770 
13771  template <>
13772  struct hash<VULKAN_HPP_NAMESPACE::SubpassSampleLocationsEXT>
13773  {
13774  std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassSampleLocationsEXT const & subpassSampleLocationsEXT ) const VULKAN_HPP_NOEXCEPT
13775  {
13776  std::size_t seed = 0;
13777  VULKAN_HPP_HASH_COMBINE( seed, subpassSampleLocationsEXT.subpassIndex );
13778  VULKAN_HPP_HASH_COMBINE( seed, subpassSampleLocationsEXT.sampleLocationsInfo );
13779  return seed;
13780  }
13781  };
13782 
13783  template <>
13784  struct hash<VULKAN_HPP_NAMESPACE::RenderPassSampleLocationsBeginInfoEXT>
13785  {
13786  std::size_t
13787  operator()( VULKAN_HPP_NAMESPACE::RenderPassSampleLocationsBeginInfoEXT const & renderPassSampleLocationsBeginInfoEXT ) const VULKAN_HPP_NOEXCEPT
13788  {
13789  std::size_t seed = 0;
13790  VULKAN_HPP_HASH_COMBINE( seed, renderPassSampleLocationsBeginInfoEXT.sType );
13791  VULKAN_HPP_HASH_COMBINE( seed, renderPassSampleLocationsBeginInfoEXT.pNext );
13792  VULKAN_HPP_HASH_COMBINE( seed, renderPassSampleLocationsBeginInfoEXT.attachmentInitialSampleLocationsCount );
13793  VULKAN_HPP_HASH_COMBINE( seed, renderPassSampleLocationsBeginInfoEXT.pAttachmentInitialSampleLocations );
13794  VULKAN_HPP_HASH_COMBINE( seed, renderPassSampleLocationsBeginInfoEXT.postSubpassSampleLocationsCount );
13795  VULKAN_HPP_HASH_COMBINE( seed, renderPassSampleLocationsBeginInfoEXT.pPostSubpassSampleLocations );
13796  return seed;
13797  }
13798  };
13799 
13800  template <>
13801  struct hash<VULKAN_HPP_NAMESPACE::RenderPassStripeInfoARM>
13802  {
13803  std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassStripeInfoARM const & renderPassStripeInfoARM ) const VULKAN_HPP_NOEXCEPT
13804  {
13805  std::size_t seed = 0;
13806  VULKAN_HPP_HASH_COMBINE( seed, renderPassStripeInfoARM.sType );
13807  VULKAN_HPP_HASH_COMBINE( seed, renderPassStripeInfoARM.pNext );
13808  VULKAN_HPP_HASH_COMBINE( seed, renderPassStripeInfoARM.stripeArea );
13809  return seed;
13810  }
13811  };
13812 
13813  template <>
13814  struct hash<VULKAN_HPP_NAMESPACE::RenderPassStripeBeginInfoARM>
13815  {
13816  std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassStripeBeginInfoARM const & renderPassStripeBeginInfoARM ) const VULKAN_HPP_NOEXCEPT
13817  {
13818  std::size_t seed = 0;
13819  VULKAN_HPP_HASH_COMBINE( seed, renderPassStripeBeginInfoARM.sType );
13820  VULKAN_HPP_HASH_COMBINE( seed, renderPassStripeBeginInfoARM.pNext );
13821  VULKAN_HPP_HASH_COMBINE( seed, renderPassStripeBeginInfoARM.stripeInfoCount );
13822  VULKAN_HPP_HASH_COMBINE( seed, renderPassStripeBeginInfoARM.pStripeInfos );
13823  return seed;
13824  }
13825  };
13826 
13827  template <>
13828  struct hash<VULKAN_HPP_NAMESPACE::SemaphoreSubmitInfo>
13829  {
13830  std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreSubmitInfo const & semaphoreSubmitInfo ) const VULKAN_HPP_NOEXCEPT
13831  {
13832  std::size_t seed = 0;
13833  VULKAN_HPP_HASH_COMBINE( seed, semaphoreSubmitInfo.sType );
13834  VULKAN_HPP_HASH_COMBINE( seed, semaphoreSubmitInfo.pNext );
13835  VULKAN_HPP_HASH_COMBINE( seed, semaphoreSubmitInfo.semaphore );
13836  VULKAN_HPP_HASH_COMBINE( seed, semaphoreSubmitInfo.value );
13837  VULKAN_HPP_HASH_COMBINE( seed, semaphoreSubmitInfo.stageMask );
13838  VULKAN_HPP_HASH_COMBINE( seed, semaphoreSubmitInfo.deviceIndex );
13839  return seed;
13840  }
13841  };
13842 
13843  template <>
13844  struct hash<VULKAN_HPP_NAMESPACE::RenderPassStripeSubmitInfoARM>
13845  {
13846  std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassStripeSubmitInfoARM const & renderPassStripeSubmitInfoARM ) const VULKAN_HPP_NOEXCEPT
13847  {
13848  std::size_t seed = 0;
13849  VULKAN_HPP_HASH_COMBINE( seed, renderPassStripeSubmitInfoARM.sType );
13850  VULKAN_HPP_HASH_COMBINE( seed, renderPassStripeSubmitInfoARM.pNext );
13851  VULKAN_HPP_HASH_COMBINE( seed, renderPassStripeSubmitInfoARM.stripeSemaphoreInfoCount );
13852  VULKAN_HPP_HASH_COMBINE( seed, renderPassStripeSubmitInfoARM.pStripeSemaphoreInfos );
13853  return seed;
13854  }
13855  };
13856 
13857  template <>
13858  struct hash<VULKAN_HPP_NAMESPACE::RenderPassSubpassFeedbackInfoEXT>
13859  {
13860  std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassSubpassFeedbackInfoEXT const & renderPassSubpassFeedbackInfoEXT ) const VULKAN_HPP_NOEXCEPT
13861  {
13862  std::size_t seed = 0;
13863  VULKAN_HPP_HASH_COMBINE( seed, renderPassSubpassFeedbackInfoEXT.subpassMergeStatus );
13864  for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i )
13865  {
13866  VULKAN_HPP_HASH_COMBINE( seed, renderPassSubpassFeedbackInfoEXT.description[i] );
13867  }
13868  VULKAN_HPP_HASH_COMBINE( seed, renderPassSubpassFeedbackInfoEXT.postMergeIndex );
13869  return seed;
13870  }
13871  };
13872 
13873  template <>
13874  struct hash<VULKAN_HPP_NAMESPACE::RenderPassSubpassFeedbackCreateInfoEXT>
13875  {
13876  std::size_t
13877  operator()( VULKAN_HPP_NAMESPACE::RenderPassSubpassFeedbackCreateInfoEXT const & renderPassSubpassFeedbackCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
13878  {
13879  std::size_t seed = 0;
13880  VULKAN_HPP_HASH_COMBINE( seed, renderPassSubpassFeedbackCreateInfoEXT.sType );
13881  VULKAN_HPP_HASH_COMBINE( seed, renderPassSubpassFeedbackCreateInfoEXT.pNext );
13882  VULKAN_HPP_HASH_COMBINE( seed, renderPassSubpassFeedbackCreateInfoEXT.pSubpassFeedback );
13883  return seed;
13884  }
13885  };
13886 
13887  template <>
13888  struct hash<VULKAN_HPP_NAMESPACE::RenderPassTransformBeginInfoQCOM>
13889  {
13890  std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassTransformBeginInfoQCOM const & renderPassTransformBeginInfoQCOM ) const VULKAN_HPP_NOEXCEPT
13891  {
13892  std::size_t seed = 0;
13893  VULKAN_HPP_HASH_COMBINE( seed, renderPassTransformBeginInfoQCOM.sType );
13894  VULKAN_HPP_HASH_COMBINE( seed, renderPassTransformBeginInfoQCOM.pNext );
13895  VULKAN_HPP_HASH_COMBINE( seed, renderPassTransformBeginInfoQCOM.transform );
13896  return seed;
13897  }
13898  };
13899 
13900  template <>
13901  struct hash<VULKAN_HPP_NAMESPACE::RenderingAreaInfoKHR>
13902  {
13903  std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderingAreaInfoKHR const & renderingAreaInfoKHR ) const VULKAN_HPP_NOEXCEPT
13904  {
13905  std::size_t seed = 0;
13906  VULKAN_HPP_HASH_COMBINE( seed, renderingAreaInfoKHR.sType );
13907  VULKAN_HPP_HASH_COMBINE( seed, renderingAreaInfoKHR.pNext );
13908  VULKAN_HPP_HASH_COMBINE( seed, renderingAreaInfoKHR.viewMask );
13909  VULKAN_HPP_HASH_COMBINE( seed, renderingAreaInfoKHR.colorAttachmentCount );
13910  VULKAN_HPP_HASH_COMBINE( seed, renderingAreaInfoKHR.pColorAttachmentFormats );
13911  VULKAN_HPP_HASH_COMBINE( seed, renderingAreaInfoKHR.depthAttachmentFormat );
13912  VULKAN_HPP_HASH_COMBINE( seed, renderingAreaInfoKHR.stencilAttachmentFormat );
13913  return seed;
13914  }
13915  };
13916 
13917  template <>
13918  struct hash<VULKAN_HPP_NAMESPACE::RenderingFragmentDensityMapAttachmentInfoEXT>
13919  {
13920  std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderingFragmentDensityMapAttachmentInfoEXT const & renderingFragmentDensityMapAttachmentInfoEXT ) const
13921  VULKAN_HPP_NOEXCEPT
13922  {
13923  std::size_t seed = 0;
13924  VULKAN_HPP_HASH_COMBINE( seed, renderingFragmentDensityMapAttachmentInfoEXT.sType );
13925  VULKAN_HPP_HASH_COMBINE( seed, renderingFragmentDensityMapAttachmentInfoEXT.pNext );
13926  VULKAN_HPP_HASH_COMBINE( seed, renderingFragmentDensityMapAttachmentInfoEXT.imageView );
13927  VULKAN_HPP_HASH_COMBINE( seed, renderingFragmentDensityMapAttachmentInfoEXT.imageLayout );
13928  return seed;
13929  }
13930  };
13931 
13932  template <>
13933  struct hash<VULKAN_HPP_NAMESPACE::RenderingFragmentShadingRateAttachmentInfoKHR>
13934  {
13935  std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderingFragmentShadingRateAttachmentInfoKHR const & renderingFragmentShadingRateAttachmentInfoKHR ) const
13936  VULKAN_HPP_NOEXCEPT
13937  {
13938  std::size_t seed = 0;
13939  VULKAN_HPP_HASH_COMBINE( seed, renderingFragmentShadingRateAttachmentInfoKHR.sType );
13940  VULKAN_HPP_HASH_COMBINE( seed, renderingFragmentShadingRateAttachmentInfoKHR.pNext );
13941  VULKAN_HPP_HASH_COMBINE( seed, renderingFragmentShadingRateAttachmentInfoKHR.imageView );
13942  VULKAN_HPP_HASH_COMBINE( seed, renderingFragmentShadingRateAttachmentInfoKHR.imageLayout );
13943  VULKAN_HPP_HASH_COMBINE( seed, renderingFragmentShadingRateAttachmentInfoKHR.shadingRateAttachmentTexelSize );
13944  return seed;
13945  }
13946  };
13947 
13948  template <>
13949  struct hash<VULKAN_HPP_NAMESPACE::RenderingInfo>
13950  {
13951  std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderingInfo const & renderingInfo ) const VULKAN_HPP_NOEXCEPT
13952  {
13953  std::size_t seed = 0;
13954  VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.sType );
13955  VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.pNext );
13956  VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.flags );
13957  VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.renderArea );
13958  VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.layerCount );
13959  VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.viewMask );
13960  VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.colorAttachmentCount );
13961  VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.pColorAttachments );
13962  VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.pDepthAttachment );
13963  VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.pStencilAttachment );
13964  return seed;
13965  }
13966  };
13967 
13968  template <>
13969  struct hash<VULKAN_HPP_NAMESPACE::ResolveImageInfo2>
13970  {
13971  std::size_t operator()( VULKAN_HPP_NAMESPACE::ResolveImageInfo2 const & resolveImageInfo2 ) const VULKAN_HPP_NOEXCEPT
13972  {
13973  std::size_t seed = 0;
13974  VULKAN_HPP_HASH_COMBINE( seed, resolveImageInfo2.sType );
13975  VULKAN_HPP_HASH_COMBINE( seed, resolveImageInfo2.pNext );
13976  VULKAN_HPP_HASH_COMBINE( seed, resolveImageInfo2.srcImage );
13977  VULKAN_HPP_HASH_COMBINE( seed, resolveImageInfo2.srcImageLayout );
13978  VULKAN_HPP_HASH_COMBINE( seed, resolveImageInfo2.dstImage );
13979  VULKAN_HPP_HASH_COMBINE( seed, resolveImageInfo2.dstImageLayout );
13980  VULKAN_HPP_HASH_COMBINE( seed, resolveImageInfo2.regionCount );
13981  VULKAN_HPP_HASH_COMBINE( seed, resolveImageInfo2.pRegions );
13982  return seed;
13983  }
13984  };
13985 
13986  template <>
13987  struct hash<VULKAN_HPP_NAMESPACE::SamplerBlockMatchWindowCreateInfoQCOM>
13988  {
13989  std::size_t
13990  operator()( VULKAN_HPP_NAMESPACE::SamplerBlockMatchWindowCreateInfoQCOM const & samplerBlockMatchWindowCreateInfoQCOM ) const VULKAN_HPP_NOEXCEPT
13991  {
13992  std::size_t seed = 0;
13993  VULKAN_HPP_HASH_COMBINE( seed, samplerBlockMatchWindowCreateInfoQCOM.sType );
13994  VULKAN_HPP_HASH_COMBINE( seed, samplerBlockMatchWindowCreateInfoQCOM.pNext );
13995  VULKAN_HPP_HASH_COMBINE( seed, samplerBlockMatchWindowCreateInfoQCOM.windowExtent );
13996  VULKAN_HPP_HASH_COMBINE( seed, samplerBlockMatchWindowCreateInfoQCOM.windowCompareMode );
13997  return seed;
13998  }
13999  };
14000 
14001  template <>
14002  struct hash<VULKAN_HPP_NAMESPACE::SamplerBorderColorComponentMappingCreateInfoEXT>
14003  {
14004  std::size_t operator()(
14005  VULKAN_HPP_NAMESPACE::SamplerBorderColorComponentMappingCreateInfoEXT const & samplerBorderColorComponentMappingCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
14006  {
14007  std::size_t seed = 0;
14008  VULKAN_HPP_HASH_COMBINE( seed, samplerBorderColorComponentMappingCreateInfoEXT.sType );
14009  VULKAN_HPP_HASH_COMBINE( seed, samplerBorderColorComponentMappingCreateInfoEXT.pNext );
14010  VULKAN_HPP_HASH_COMBINE( seed, samplerBorderColorComponentMappingCreateInfoEXT.components );
14011  VULKAN_HPP_HASH_COMBINE( seed, samplerBorderColorComponentMappingCreateInfoEXT.srgb );
14012  return seed;
14013  }
14014  };
14015 
14016  template <>
14017  struct hash<VULKAN_HPP_NAMESPACE::SamplerCaptureDescriptorDataInfoEXT>
14018  {
14019  std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerCaptureDescriptorDataInfoEXT const & samplerCaptureDescriptorDataInfoEXT ) const VULKAN_HPP_NOEXCEPT
14020  {
14021  std::size_t seed = 0;
14022  VULKAN_HPP_HASH_COMBINE( seed, samplerCaptureDescriptorDataInfoEXT.sType );
14023  VULKAN_HPP_HASH_COMBINE( seed, samplerCaptureDescriptorDataInfoEXT.pNext );
14024  VULKAN_HPP_HASH_COMBINE( seed, samplerCaptureDescriptorDataInfoEXT.sampler );
14025  return seed;
14026  }
14027  };
14028 
14029  template <>
14030  struct hash<VULKAN_HPP_NAMESPACE::SamplerCreateInfo>
14031  {
14032  std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerCreateInfo const & samplerCreateInfo ) const VULKAN_HPP_NOEXCEPT
14033  {
14034  std::size_t seed = 0;
14035  VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.sType );
14036  VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.pNext );
14037  VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.flags );
14038  VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.magFilter );
14039  VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.minFilter );
14040  VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.mipmapMode );
14041  VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.addressModeU );
14042  VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.addressModeV );
14043  VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.addressModeW );
14044  VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.mipLodBias );
14045  VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.anisotropyEnable );
14046  VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.maxAnisotropy );
14047  VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.compareEnable );
14048  VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.compareOp );
14049  VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.minLod );
14050  VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.maxLod );
14051  VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.borderColor );
14052  VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.unnormalizedCoordinates );
14053  return seed;
14054  }
14055  };
14056 
14057  template <>
14058  struct hash<VULKAN_HPP_NAMESPACE::SamplerCubicWeightsCreateInfoQCOM>
14059  {
14060  std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerCubicWeightsCreateInfoQCOM const & samplerCubicWeightsCreateInfoQCOM ) const VULKAN_HPP_NOEXCEPT
14061  {
14062  std::size_t seed = 0;
14063  VULKAN_HPP_HASH_COMBINE( seed, samplerCubicWeightsCreateInfoQCOM.sType );
14064  VULKAN_HPP_HASH_COMBINE( seed, samplerCubicWeightsCreateInfoQCOM.pNext );
14065  VULKAN_HPP_HASH_COMBINE( seed, samplerCubicWeightsCreateInfoQCOM.cubicWeights );
14066  return seed;
14067  }
14068  };
14069 
14070  template <>
14071  struct hash<VULKAN_HPP_NAMESPACE::SamplerReductionModeCreateInfo>
14072  {
14073  std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerReductionModeCreateInfo const & samplerReductionModeCreateInfo ) const VULKAN_HPP_NOEXCEPT
14074  {
14075  std::size_t seed = 0;
14076  VULKAN_HPP_HASH_COMBINE( seed, samplerReductionModeCreateInfo.sType );
14077  VULKAN_HPP_HASH_COMBINE( seed, samplerReductionModeCreateInfo.pNext );
14078  VULKAN_HPP_HASH_COMBINE( seed, samplerReductionModeCreateInfo.reductionMode );
14079  return seed;
14080  }
14081  };
14082 
14083  template <>
14084  struct hash<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo>
14085  {
14086  std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo const & samplerYcbcrConversionCreateInfo ) const VULKAN_HPP_NOEXCEPT
14087  {
14088  std::size_t seed = 0;
14089  VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.sType );
14090  VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.pNext );
14091  VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.format );
14092  VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.ycbcrModel );
14093  VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.ycbcrRange );
14094  VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.components );
14095  VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.xChromaOffset );
14096  VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.yChromaOffset );
14097  VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.chromaFilter );
14098  VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.forceExplicitReconstruction );
14099  return seed;
14100  }
14101  };
14102 
14103  template <>
14104  struct hash<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionImageFormatProperties>
14105  {
14106  std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionImageFormatProperties const & samplerYcbcrConversionImageFormatProperties ) const
14107  VULKAN_HPP_NOEXCEPT
14108  {
14109  std::size_t seed = 0;
14110  VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionImageFormatProperties.sType );
14111  VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionImageFormatProperties.pNext );
14112  VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionImageFormatProperties.combinedImageSamplerDescriptorCount );
14113  return seed;
14114  }
14115  };
14116 
14117  template <>
14118  struct hash<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionInfo>
14119  {
14120  std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionInfo const & samplerYcbcrConversionInfo ) const VULKAN_HPP_NOEXCEPT
14121  {
14122  std::size_t seed = 0;
14123  VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionInfo.sType );
14124  VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionInfo.pNext );
14125  VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionInfo.conversion );
14126  return seed;
14127  }
14128  };
14129 
14130  template <>
14131  struct hash<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM>
14132  {
14133  std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM const & samplerYcbcrConversionYcbcrDegammaCreateInfoQCOM )
14134  const VULKAN_HPP_NOEXCEPT
14135  {
14136  std::size_t seed = 0;
14137  VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionYcbcrDegammaCreateInfoQCOM.sType );
14138  VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionYcbcrDegammaCreateInfoQCOM.pNext );
14139  VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionYcbcrDegammaCreateInfoQCOM.enableYDegamma );
14140  VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionYcbcrDegammaCreateInfoQCOM.enableCbCrDegamma );
14141  return seed;
14142  }
14143  };
14144 
14145 # if defined( VK_USE_PLATFORM_SCREEN_QNX )
14146  template <>
14147  struct hash<VULKAN_HPP_NAMESPACE::ScreenBufferFormatPropertiesQNX>
14148  {
14149  std::size_t operator()( VULKAN_HPP_NAMESPACE::ScreenBufferFormatPropertiesQNX const & screenBufferFormatPropertiesQNX ) const VULKAN_HPP_NOEXCEPT
14150  {
14151  std::size_t seed = 0;
14152  VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.sType );
14153  VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.pNext );
14154  VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.format );
14155  VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.externalFormat );
14156  VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.screenUsage );
14157  VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.formatFeatures );
14158  VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.samplerYcbcrConversionComponents );
14159  VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.suggestedYcbcrModel );
14160  VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.suggestedYcbcrRange );
14161  VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.suggestedXChromaOffset );
14162  VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.suggestedYChromaOffset );
14163  return seed;
14164  }
14165  };
14166 # endif /*VK_USE_PLATFORM_SCREEN_QNX*/
14167 
14168 # if defined( VK_USE_PLATFORM_SCREEN_QNX )
14169  template <>
14170  struct hash<VULKAN_HPP_NAMESPACE::ScreenBufferPropertiesQNX>
14171  {
14172  std::size_t operator()( VULKAN_HPP_NAMESPACE::ScreenBufferPropertiesQNX const & screenBufferPropertiesQNX ) const VULKAN_HPP_NOEXCEPT
14173  {
14174  std::size_t seed = 0;
14175  VULKAN_HPP_HASH_COMBINE( seed, screenBufferPropertiesQNX.sType );
14176  VULKAN_HPP_HASH_COMBINE( seed, screenBufferPropertiesQNX.pNext );
14177  VULKAN_HPP_HASH_COMBINE( seed, screenBufferPropertiesQNX.allocationSize );
14178  VULKAN_HPP_HASH_COMBINE( seed, screenBufferPropertiesQNX.memoryTypeBits );
14179  return seed;
14180  }
14181  };
14182 # endif /*VK_USE_PLATFORM_SCREEN_QNX*/
14183 
14184 # if defined( VK_USE_PLATFORM_SCREEN_QNX )
14185  template <>
14186  struct hash<VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX>
14187  {
14188  std::size_t operator()( VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX const & screenSurfaceCreateInfoQNX ) const VULKAN_HPP_NOEXCEPT
14189  {
14190  std::size_t seed = 0;
14191  VULKAN_HPP_HASH_COMBINE( seed, screenSurfaceCreateInfoQNX.sType );
14192  VULKAN_HPP_HASH_COMBINE( seed, screenSurfaceCreateInfoQNX.pNext );
14193  VULKAN_HPP_HASH_COMBINE( seed, screenSurfaceCreateInfoQNX.flags );
14194  VULKAN_HPP_HASH_COMBINE( seed, screenSurfaceCreateInfoQNX.context );
14195  VULKAN_HPP_HASH_COMBINE( seed, screenSurfaceCreateInfoQNX.window );
14196  return seed;
14197  }
14198  };
14199 # endif /*VK_USE_PLATFORM_SCREEN_QNX*/
14200 
14201  template <>
14202  struct hash<VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo>
14203  {
14204  std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo const & semaphoreCreateInfo ) const VULKAN_HPP_NOEXCEPT
14205  {
14206  std::size_t seed = 0;
14207  VULKAN_HPP_HASH_COMBINE( seed, semaphoreCreateInfo.sType );
14208  VULKAN_HPP_HASH_COMBINE( seed, semaphoreCreateInfo.pNext );
14209  VULKAN_HPP_HASH_COMBINE( seed, semaphoreCreateInfo.flags );
14210  return seed;
14211  }
14212  };
14213 
14214  template <>
14215  struct hash<VULKAN_HPP_NAMESPACE::SemaphoreGetFdInfoKHR>
14216  {
14217  std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreGetFdInfoKHR const & semaphoreGetFdInfoKHR ) const VULKAN_HPP_NOEXCEPT
14218  {
14219  std::size_t seed = 0;
14220  VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetFdInfoKHR.sType );
14221  VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetFdInfoKHR.pNext );
14222  VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetFdInfoKHR.semaphore );
14223  VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetFdInfoKHR.handleType );
14224  return seed;
14225  }
14226  };
14227 
14228 # if defined( VK_USE_PLATFORM_WIN32_KHR )
14229  template <>
14230  struct hash<VULKAN_HPP_NAMESPACE::SemaphoreGetWin32HandleInfoKHR>
14231  {
14232  std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreGetWin32HandleInfoKHR const & semaphoreGetWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT
14233  {
14234  std::size_t seed = 0;
14235  VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetWin32HandleInfoKHR.sType );
14236  VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetWin32HandleInfoKHR.pNext );
14237  VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetWin32HandleInfoKHR.semaphore );
14238  VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetWin32HandleInfoKHR.handleType );
14239  return seed;
14240  }
14241  };
14242 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
14243 
14244 # if defined( VK_USE_PLATFORM_FUCHSIA )
14245  template <>
14246  struct hash<VULKAN_HPP_NAMESPACE::SemaphoreGetZirconHandleInfoFUCHSIA>
14247  {
14248  std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreGetZirconHandleInfoFUCHSIA const & semaphoreGetZirconHandleInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT
14249  {
14250  std::size_t seed = 0;
14251  VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetZirconHandleInfoFUCHSIA.sType );
14252  VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetZirconHandleInfoFUCHSIA.pNext );
14253  VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetZirconHandleInfoFUCHSIA.semaphore );
14254  VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetZirconHandleInfoFUCHSIA.handleType );
14255  return seed;
14256  }
14257  };
14258 # endif /*VK_USE_PLATFORM_FUCHSIA*/
14259 
14260  template <>
14261  struct hash<VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo>
14262  {
14263  std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo const & semaphoreSignalInfo ) const VULKAN_HPP_NOEXCEPT
14264  {
14265  std::size_t seed = 0;
14266  VULKAN_HPP_HASH_COMBINE( seed, semaphoreSignalInfo.sType );
14267  VULKAN_HPP_HASH_COMBINE( seed, semaphoreSignalInfo.pNext );
14268  VULKAN_HPP_HASH_COMBINE( seed, semaphoreSignalInfo.semaphore );
14269  VULKAN_HPP_HASH_COMBINE( seed, semaphoreSignalInfo.value );
14270  return seed;
14271  }
14272  };
14273 
14274  template <>
14275  struct hash<VULKAN_HPP_NAMESPACE::SemaphoreTypeCreateInfo>
14276  {
14277  std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreTypeCreateInfo const & semaphoreTypeCreateInfo ) const VULKAN_HPP_NOEXCEPT
14278  {
14279  std::size_t seed = 0;
14280  VULKAN_HPP_HASH_COMBINE( seed, semaphoreTypeCreateInfo.sType );
14281  VULKAN_HPP_HASH_COMBINE( seed, semaphoreTypeCreateInfo.pNext );
14282  VULKAN_HPP_HASH_COMBINE( seed, semaphoreTypeCreateInfo.semaphoreType );
14283  VULKAN_HPP_HASH_COMBINE( seed, semaphoreTypeCreateInfo.initialValue );
14284  return seed;
14285  }
14286  };
14287 
14288  template <>
14289  struct hash<VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo>
14290  {
14291  std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo const & semaphoreWaitInfo ) const VULKAN_HPP_NOEXCEPT
14292  {
14293  std::size_t seed = 0;
14294  VULKAN_HPP_HASH_COMBINE( seed, semaphoreWaitInfo.sType );
14295  VULKAN_HPP_HASH_COMBINE( seed, semaphoreWaitInfo.pNext );
14296  VULKAN_HPP_HASH_COMBINE( seed, semaphoreWaitInfo.flags );
14297  VULKAN_HPP_HASH_COMBINE( seed, semaphoreWaitInfo.semaphoreCount );
14298  VULKAN_HPP_HASH_COMBINE( seed, semaphoreWaitInfo.pSemaphores );
14299  VULKAN_HPP_HASH_COMBINE( seed, semaphoreWaitInfo.pValues );
14300  return seed;
14301  }
14302  };
14303 
14304  template <>
14305  struct hash<VULKAN_HPP_NAMESPACE::SetDescriptorBufferOffsetsInfoEXT>
14306  {
14307  std::size_t operator()( VULKAN_HPP_NAMESPACE::SetDescriptorBufferOffsetsInfoEXT const & setDescriptorBufferOffsetsInfoEXT ) const VULKAN_HPP_NOEXCEPT
14308  {
14309  std::size_t seed = 0;
14310  VULKAN_HPP_HASH_COMBINE( seed, setDescriptorBufferOffsetsInfoEXT.sType );
14311  VULKAN_HPP_HASH_COMBINE( seed, setDescriptorBufferOffsetsInfoEXT.pNext );
14312  VULKAN_HPP_HASH_COMBINE( seed, setDescriptorBufferOffsetsInfoEXT.stageFlags );
14313  VULKAN_HPP_HASH_COMBINE( seed, setDescriptorBufferOffsetsInfoEXT.layout );
14314  VULKAN_HPP_HASH_COMBINE( seed, setDescriptorBufferOffsetsInfoEXT.firstSet );
14315  VULKAN_HPP_HASH_COMBINE( seed, setDescriptorBufferOffsetsInfoEXT.setCount );
14316  VULKAN_HPP_HASH_COMBINE( seed, setDescriptorBufferOffsetsInfoEXT.pBufferIndices );
14317  VULKAN_HPP_HASH_COMBINE( seed, setDescriptorBufferOffsetsInfoEXT.pOffsets );
14318  return seed;
14319  }
14320  };
14321 
14322  template <>
14323  struct hash<VULKAN_HPP_NAMESPACE::SetLatencyMarkerInfoNV>
14324  {
14325  std::size_t operator()( VULKAN_HPP_NAMESPACE::SetLatencyMarkerInfoNV const & setLatencyMarkerInfoNV ) const VULKAN_HPP_NOEXCEPT
14326  {
14327  std::size_t seed = 0;
14328  VULKAN_HPP_HASH_COMBINE( seed, setLatencyMarkerInfoNV.sType );
14329  VULKAN_HPP_HASH_COMBINE( seed, setLatencyMarkerInfoNV.pNext );
14330  VULKAN_HPP_HASH_COMBINE( seed, setLatencyMarkerInfoNV.presentID );
14331  VULKAN_HPP_HASH_COMBINE( seed, setLatencyMarkerInfoNV.marker );
14332  return seed;
14333  }
14334  };
14335 
14336  template <>
14337  struct hash<VULKAN_HPP_NAMESPACE::SetStateFlagsIndirectCommandNV>
14338  {
14339  std::size_t operator()( VULKAN_HPP_NAMESPACE::SetStateFlagsIndirectCommandNV const & setStateFlagsIndirectCommandNV ) const VULKAN_HPP_NOEXCEPT
14340  {
14341  std::size_t seed = 0;
14342  VULKAN_HPP_HASH_COMBINE( seed, setStateFlagsIndirectCommandNV.data );
14343  return seed;
14344  }
14345  };
14346 
14347  template <>
14348  struct hash<VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT>
14349  {
14350  std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT const & shaderCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
14351  {
14352  std::size_t seed = 0;
14353  VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.sType );
14354  VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.pNext );
14355  VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.flags );
14356  VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.stage );
14357  VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.nextStage );
14358  VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.codeType );
14359  VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.codeSize );
14360  VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.pCode );
14361  for ( const char * p = shaderCreateInfoEXT.pName; *p != '\0'; ++p )
14362  {
14363  VULKAN_HPP_HASH_COMBINE( seed, *p );
14364  }
14365  VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.setLayoutCount );
14366  VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.pSetLayouts );
14367  VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.pushConstantRangeCount );
14368  VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.pPushConstantRanges );
14369  VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.pSpecializationInfo );
14370  return seed;
14371  }
14372  };
14373 
14374  template <>
14375  struct hash<VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo>
14376  {
14377  std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo const & shaderModuleCreateInfo ) const VULKAN_HPP_NOEXCEPT
14378  {
14379  std::size_t seed = 0;
14380  VULKAN_HPP_HASH_COMBINE( seed, shaderModuleCreateInfo.sType );
14381  VULKAN_HPP_HASH_COMBINE( seed, shaderModuleCreateInfo.pNext );
14382  VULKAN_HPP_HASH_COMBINE( seed, shaderModuleCreateInfo.flags );
14383  VULKAN_HPP_HASH_COMBINE( seed, shaderModuleCreateInfo.codeSize );
14384  VULKAN_HPP_HASH_COMBINE( seed, shaderModuleCreateInfo.pCode );
14385  return seed;
14386  }
14387  };
14388 
14389  template <>
14390  struct hash<VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT>
14391  {
14392  std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT const & shaderModuleIdentifierEXT ) const VULKAN_HPP_NOEXCEPT
14393  {
14394  std::size_t seed = 0;
14395  VULKAN_HPP_HASH_COMBINE( seed, shaderModuleIdentifierEXT.sType );
14396  VULKAN_HPP_HASH_COMBINE( seed, shaderModuleIdentifierEXT.pNext );
14397  VULKAN_HPP_HASH_COMBINE( seed, shaderModuleIdentifierEXT.identifierSize );
14398  for ( size_t i = 0; i < VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT; ++i )
14399  {
14400  VULKAN_HPP_HASH_COMBINE( seed, shaderModuleIdentifierEXT.identifier[i] );
14401  }
14402  return seed;
14403  }
14404  };
14405 
14406  template <>
14407  struct hash<VULKAN_HPP_NAMESPACE::ShaderModuleValidationCacheCreateInfoEXT>
14408  {
14409  std::size_t
14410  operator()( VULKAN_HPP_NAMESPACE::ShaderModuleValidationCacheCreateInfoEXT const & shaderModuleValidationCacheCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
14411  {
14412  std::size_t seed = 0;
14413  VULKAN_HPP_HASH_COMBINE( seed, shaderModuleValidationCacheCreateInfoEXT.sType );
14414  VULKAN_HPP_HASH_COMBINE( seed, shaderModuleValidationCacheCreateInfoEXT.pNext );
14415  VULKAN_HPP_HASH_COMBINE( seed, shaderModuleValidationCacheCreateInfoEXT.validationCache );
14416  return seed;
14417  }
14418  };
14419 
14420  template <>
14421  struct hash<VULKAN_HPP_NAMESPACE::ShaderResourceUsageAMD>
14422  {
14423  std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderResourceUsageAMD const & shaderResourceUsageAMD ) const VULKAN_HPP_NOEXCEPT
14424  {
14425  std::size_t seed = 0;
14426  VULKAN_HPP_HASH_COMBINE( seed, shaderResourceUsageAMD.numUsedVgprs );
14427  VULKAN_HPP_HASH_COMBINE( seed, shaderResourceUsageAMD.numUsedSgprs );
14428  VULKAN_HPP_HASH_COMBINE( seed, shaderResourceUsageAMD.ldsSizePerLocalWorkGroup );
14429  VULKAN_HPP_HASH_COMBINE( seed, shaderResourceUsageAMD.ldsUsageSizeInBytes );
14430  VULKAN_HPP_HASH_COMBINE( seed, shaderResourceUsageAMD.scratchMemUsageInBytes );
14431  return seed;
14432  }
14433  };
14434 
14435  template <>
14436  struct hash<VULKAN_HPP_NAMESPACE::ShaderStatisticsInfoAMD>
14437  {
14438  std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderStatisticsInfoAMD const & shaderStatisticsInfoAMD ) const VULKAN_HPP_NOEXCEPT
14439  {
14440  std::size_t seed = 0;
14441  VULKAN_HPP_HASH_COMBINE( seed, shaderStatisticsInfoAMD.shaderStageMask );
14442  VULKAN_HPP_HASH_COMBINE( seed, shaderStatisticsInfoAMD.resourceUsage );
14443  VULKAN_HPP_HASH_COMBINE( seed, shaderStatisticsInfoAMD.numPhysicalVgprs );
14444  VULKAN_HPP_HASH_COMBINE( seed, shaderStatisticsInfoAMD.numPhysicalSgprs );
14445  VULKAN_HPP_HASH_COMBINE( seed, shaderStatisticsInfoAMD.numAvailableVgprs );
14446  VULKAN_HPP_HASH_COMBINE( seed, shaderStatisticsInfoAMD.numAvailableSgprs );
14447  for ( size_t i = 0; i < 3; ++i )
14448  {
14449  VULKAN_HPP_HASH_COMBINE( seed, shaderStatisticsInfoAMD.computeWorkGroupSize[i] );
14450  }
14451  return seed;
14452  }
14453  };
14454 
14455  template <>
14456  struct hash<VULKAN_HPP_NAMESPACE::SharedPresentSurfaceCapabilitiesKHR>
14457  {
14458  std::size_t operator()( VULKAN_HPP_NAMESPACE::SharedPresentSurfaceCapabilitiesKHR const & sharedPresentSurfaceCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT
14459  {
14460  std::size_t seed = 0;
14461  VULKAN_HPP_HASH_COMBINE( seed, sharedPresentSurfaceCapabilitiesKHR.sType );
14462  VULKAN_HPP_HASH_COMBINE( seed, sharedPresentSurfaceCapabilitiesKHR.pNext );
14463  VULKAN_HPP_HASH_COMBINE( seed, sharedPresentSurfaceCapabilitiesKHR.sharedPresentSupportedUsageFlags );
14464  return seed;
14465  }
14466  };
14467 
14468  template <>
14469  struct hash<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties>
14470  {
14471  std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageFormatProperties const & sparseImageFormatProperties ) const VULKAN_HPP_NOEXCEPT
14472  {
14473  std::size_t seed = 0;
14474  VULKAN_HPP_HASH_COMBINE( seed, sparseImageFormatProperties.aspectMask );
14475  VULKAN_HPP_HASH_COMBINE( seed, sparseImageFormatProperties.imageGranularity );
14476  VULKAN_HPP_HASH_COMBINE( seed, sparseImageFormatProperties.flags );
14477  return seed;
14478  }
14479  };
14480 
14481  template <>
14482  struct hash<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>
14483  {
14484  std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2 const & sparseImageFormatProperties2 ) const VULKAN_HPP_NOEXCEPT
14485  {
14486  std::size_t seed = 0;
14487  VULKAN_HPP_HASH_COMBINE( seed, sparseImageFormatProperties2.sType );
14488  VULKAN_HPP_HASH_COMBINE( seed, sparseImageFormatProperties2.pNext );
14489  VULKAN_HPP_HASH_COMBINE( seed, sparseImageFormatProperties2.properties );
14490  return seed;
14491  }
14492  };
14493 
14494  template <>
14495  struct hash<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements>
14496  {
14497  std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements const & sparseImageMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
14498  {
14499  std::size_t seed = 0;
14500  VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryRequirements.formatProperties );
14501  VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryRequirements.imageMipTailFirstLod );
14502  VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryRequirements.imageMipTailSize );
14503  VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryRequirements.imageMipTailOffset );
14504  VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryRequirements.imageMipTailStride );
14505  return seed;
14506  }
14507  };
14508 
14509  template <>
14510  struct hash<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>
14511  {
14512  std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 const & sparseImageMemoryRequirements2 ) const VULKAN_HPP_NOEXCEPT
14513  {
14514  std::size_t seed = 0;
14515  VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryRequirements2.sType );
14516  VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryRequirements2.pNext );
14517  VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryRequirements2.memoryRequirements );
14518  return seed;
14519  }
14520  };
14521 
14522 # if defined( VK_USE_PLATFORM_GGP )
14523  template <>
14524  struct hash<VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP>
14525  {
14526  std::size_t operator()( VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP const & streamDescriptorSurfaceCreateInfoGGP ) const VULKAN_HPP_NOEXCEPT
14527  {
14528  std::size_t seed = 0;
14529  VULKAN_HPP_HASH_COMBINE( seed, streamDescriptorSurfaceCreateInfoGGP.sType );
14530  VULKAN_HPP_HASH_COMBINE( seed, streamDescriptorSurfaceCreateInfoGGP.pNext );
14531  VULKAN_HPP_HASH_COMBINE( seed, streamDescriptorSurfaceCreateInfoGGP.flags );
14532  VULKAN_HPP_HASH_COMBINE( seed, streamDescriptorSurfaceCreateInfoGGP.streamDescriptor );
14533  return seed;
14534  }
14535  };
14536 # endif /*VK_USE_PLATFORM_GGP*/
14537 
14538  template <>
14539  struct hash<VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR>
14540  {
14541  std::size_t operator()( VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR const & stridedDeviceAddressRegionKHR ) const VULKAN_HPP_NOEXCEPT
14542  {
14543  std::size_t seed = 0;
14544  VULKAN_HPP_HASH_COMBINE( seed, stridedDeviceAddressRegionKHR.deviceAddress );
14545  VULKAN_HPP_HASH_COMBINE( seed, stridedDeviceAddressRegionKHR.stride );
14546  VULKAN_HPP_HASH_COMBINE( seed, stridedDeviceAddressRegionKHR.size );
14547  return seed;
14548  }
14549  };
14550 
14551  template <>
14552  struct hash<VULKAN_HPP_NAMESPACE::SubmitInfo>
14553  {
14554  std::size_t operator()( VULKAN_HPP_NAMESPACE::SubmitInfo const & submitInfo ) const VULKAN_HPP_NOEXCEPT
14555  {
14556  std::size_t seed = 0;
14557  VULKAN_HPP_HASH_COMBINE( seed, submitInfo.sType );
14558  VULKAN_HPP_HASH_COMBINE( seed, submitInfo.pNext );
14559  VULKAN_HPP_HASH_COMBINE( seed, submitInfo.waitSemaphoreCount );
14560  VULKAN_HPP_HASH_COMBINE( seed, submitInfo.pWaitSemaphores );
14561  VULKAN_HPP_HASH_COMBINE( seed, submitInfo.pWaitDstStageMask );
14562  VULKAN_HPP_HASH_COMBINE( seed, submitInfo.commandBufferCount );
14563  VULKAN_HPP_HASH_COMBINE( seed, submitInfo.pCommandBuffers );
14564  VULKAN_HPP_HASH_COMBINE( seed, submitInfo.signalSemaphoreCount );
14565  VULKAN_HPP_HASH_COMBINE( seed, submitInfo.pSignalSemaphores );
14566  return seed;
14567  }
14568  };
14569 
14570  template <>
14571  struct hash<VULKAN_HPP_NAMESPACE::SubmitInfo2>
14572  {
14573  std::size_t operator()( VULKAN_HPP_NAMESPACE::SubmitInfo2 const & submitInfo2 ) const VULKAN_HPP_NOEXCEPT
14574  {
14575  std::size_t seed = 0;
14576  VULKAN_HPP_HASH_COMBINE( seed, submitInfo2.sType );
14577  VULKAN_HPP_HASH_COMBINE( seed, submitInfo2.pNext );
14578  VULKAN_HPP_HASH_COMBINE( seed, submitInfo2.flags );
14579  VULKAN_HPP_HASH_COMBINE( seed, submitInfo2.waitSemaphoreInfoCount );
14580  VULKAN_HPP_HASH_COMBINE( seed, submitInfo2.pWaitSemaphoreInfos );
14581  VULKAN_HPP_HASH_COMBINE( seed, submitInfo2.commandBufferInfoCount );
14582  VULKAN_HPP_HASH_COMBINE( seed, submitInfo2.pCommandBufferInfos );
14583  VULKAN_HPP_HASH_COMBINE( seed, submitInfo2.signalSemaphoreInfoCount );
14584  VULKAN_HPP_HASH_COMBINE( seed, submitInfo2.pSignalSemaphoreInfos );
14585  return seed;
14586  }
14587  };
14588 
14589  template <>
14590  struct hash<VULKAN_HPP_NAMESPACE::SubpassBeginInfo>
14591  {
14592  std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassBeginInfo const & subpassBeginInfo ) const VULKAN_HPP_NOEXCEPT
14593  {
14594  std::size_t seed = 0;
14595  VULKAN_HPP_HASH_COMBINE( seed, subpassBeginInfo.sType );
14596  VULKAN_HPP_HASH_COMBINE( seed, subpassBeginInfo.pNext );
14597  VULKAN_HPP_HASH_COMBINE( seed, subpassBeginInfo.contents );
14598  return seed;
14599  }
14600  };
14601 
14602  template <>
14603  struct hash<VULKAN_HPP_NAMESPACE::SubpassDescriptionDepthStencilResolve>
14604  {
14605  std::size_t
14606  operator()( VULKAN_HPP_NAMESPACE::SubpassDescriptionDepthStencilResolve const & subpassDescriptionDepthStencilResolve ) const VULKAN_HPP_NOEXCEPT
14607  {
14608  std::size_t seed = 0;
14609  VULKAN_HPP_HASH_COMBINE( seed, subpassDescriptionDepthStencilResolve.sType );
14610  VULKAN_HPP_HASH_COMBINE( seed, subpassDescriptionDepthStencilResolve.pNext );
14611  VULKAN_HPP_HASH_COMBINE( seed, subpassDescriptionDepthStencilResolve.depthResolveMode );
14612  VULKAN_HPP_HASH_COMBINE( seed, subpassDescriptionDepthStencilResolve.stencilResolveMode );
14613  VULKAN_HPP_HASH_COMBINE( seed, subpassDescriptionDepthStencilResolve.pDepthStencilResolveAttachment );
14614  return seed;
14615  }
14616  };
14617 
14618  template <>
14619  struct hash<VULKAN_HPP_NAMESPACE::SubpassEndInfo>
14620  {
14621  std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassEndInfo const & subpassEndInfo ) const VULKAN_HPP_NOEXCEPT
14622  {
14623  std::size_t seed = 0;
14624  VULKAN_HPP_HASH_COMBINE( seed, subpassEndInfo.sType );
14625  VULKAN_HPP_HASH_COMBINE( seed, subpassEndInfo.pNext );
14626  return seed;
14627  }
14628  };
14629 
14630  template <>
14631  struct hash<VULKAN_HPP_NAMESPACE::SubpassFragmentDensityMapOffsetEndInfoQCOM>
14632  {
14633  std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassFragmentDensityMapOffsetEndInfoQCOM const & subpassFragmentDensityMapOffsetEndInfoQCOM ) const
14634  VULKAN_HPP_NOEXCEPT
14635  {
14636  std::size_t seed = 0;
14637  VULKAN_HPP_HASH_COMBINE( seed, subpassFragmentDensityMapOffsetEndInfoQCOM.sType );
14638  VULKAN_HPP_HASH_COMBINE( seed, subpassFragmentDensityMapOffsetEndInfoQCOM.pNext );
14639  VULKAN_HPP_HASH_COMBINE( seed, subpassFragmentDensityMapOffsetEndInfoQCOM.fragmentDensityOffsetCount );
14640  VULKAN_HPP_HASH_COMBINE( seed, subpassFragmentDensityMapOffsetEndInfoQCOM.pFragmentDensityOffsets );
14641  return seed;
14642  }
14643  };
14644 
14645  template <>
14646  struct hash<VULKAN_HPP_NAMESPACE::SubpassResolvePerformanceQueryEXT>
14647  {
14648  std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassResolvePerformanceQueryEXT const & subpassResolvePerformanceQueryEXT ) const VULKAN_HPP_NOEXCEPT
14649  {
14650  std::size_t seed = 0;
14651  VULKAN_HPP_HASH_COMBINE( seed, subpassResolvePerformanceQueryEXT.sType );
14652  VULKAN_HPP_HASH_COMBINE( seed, subpassResolvePerformanceQueryEXT.pNext );
14653  VULKAN_HPP_HASH_COMBINE( seed, subpassResolvePerformanceQueryEXT.optimal );
14654  return seed;
14655  }
14656  };
14657 
14658  template <>
14659  struct hash<VULKAN_HPP_NAMESPACE::SubpassShadingPipelineCreateInfoHUAWEI>
14660  {
14661  std::size_t
14662  operator()( VULKAN_HPP_NAMESPACE::SubpassShadingPipelineCreateInfoHUAWEI const & subpassShadingPipelineCreateInfoHUAWEI ) const VULKAN_HPP_NOEXCEPT
14663  {
14664  std::size_t seed = 0;
14665  VULKAN_HPP_HASH_COMBINE( seed, subpassShadingPipelineCreateInfoHUAWEI.sType );
14666  VULKAN_HPP_HASH_COMBINE( seed, subpassShadingPipelineCreateInfoHUAWEI.pNext );
14667  VULKAN_HPP_HASH_COMBINE( seed, subpassShadingPipelineCreateInfoHUAWEI.renderPass );
14668  VULKAN_HPP_HASH_COMBINE( seed, subpassShadingPipelineCreateInfoHUAWEI.subpass );
14669  return seed;
14670  }
14671  };
14672 
14673  template <>
14674  struct hash<VULKAN_HPP_NAMESPACE::SubresourceHostMemcpySizeEXT>
14675  {
14676  std::size_t operator()( VULKAN_HPP_NAMESPACE::SubresourceHostMemcpySizeEXT const & subresourceHostMemcpySizeEXT ) const VULKAN_HPP_NOEXCEPT
14677  {
14678  std::size_t seed = 0;
14679  VULKAN_HPP_HASH_COMBINE( seed, subresourceHostMemcpySizeEXT.sType );
14680  VULKAN_HPP_HASH_COMBINE( seed, subresourceHostMemcpySizeEXT.pNext );
14681  VULKAN_HPP_HASH_COMBINE( seed, subresourceHostMemcpySizeEXT.size );
14682  return seed;
14683  }
14684  };
14685 
14686  template <>
14687  struct hash<VULKAN_HPP_NAMESPACE::SubresourceLayout2KHR>
14688  {
14689  std::size_t operator()( VULKAN_HPP_NAMESPACE::SubresourceLayout2KHR const & subresourceLayout2KHR ) const VULKAN_HPP_NOEXCEPT
14690  {
14691  std::size_t seed = 0;
14692  VULKAN_HPP_HASH_COMBINE( seed, subresourceLayout2KHR.sType );
14693  VULKAN_HPP_HASH_COMBINE( seed, subresourceLayout2KHR.pNext );
14694  VULKAN_HPP_HASH_COMBINE( seed, subresourceLayout2KHR.subresourceLayout );
14695  return seed;
14696  }
14697  };
14698 
14699  template <>
14700  struct hash<VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT>
14701  {
14702  std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT const & surfaceCapabilities2EXT ) const VULKAN_HPP_NOEXCEPT
14703  {
14704  std::size_t seed = 0;
14705  VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.sType );
14706  VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.pNext );
14707  VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.minImageCount );
14708  VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.maxImageCount );
14709  VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.currentExtent );
14710  VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.minImageExtent );
14711  VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.maxImageExtent );
14712  VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.maxImageArrayLayers );
14713  VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.supportedTransforms );
14714  VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.currentTransform );
14715  VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.supportedCompositeAlpha );
14716  VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.supportedUsageFlags );
14717  VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.supportedSurfaceCounters );
14718  return seed;
14719  }
14720  };
14721 
14722  template <>
14723  struct hash<VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR>
14724  {
14725  std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR const & surfaceCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT
14726  {
14727  std::size_t seed = 0;
14728  VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.minImageCount );
14729  VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.maxImageCount );
14730  VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.currentExtent );
14731  VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.minImageExtent );
14732  VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.maxImageExtent );
14733  VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.maxImageArrayLayers );
14734  VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.supportedTransforms );
14735  VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.currentTransform );
14736  VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.supportedCompositeAlpha );
14737  VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.supportedUsageFlags );
14738  return seed;
14739  }
14740  };
14741 
14742  template <>
14743  struct hash<VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR>
14744  {
14745  std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR const & surfaceCapabilities2KHR ) const VULKAN_HPP_NOEXCEPT
14746  {
14747  std::size_t seed = 0;
14748  VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2KHR.sType );
14749  VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2KHR.pNext );
14750  VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2KHR.surfaceCapabilities );
14751  return seed;
14752  }
14753  };
14754 
14755 # if defined( VK_USE_PLATFORM_WIN32_KHR )
14756  template <>
14757  struct hash<VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesFullScreenExclusiveEXT>
14758  {
14759  std::size_t
14760  operator()( VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesFullScreenExclusiveEXT const & surfaceCapabilitiesFullScreenExclusiveEXT ) const VULKAN_HPP_NOEXCEPT
14761  {
14762  std::size_t seed = 0;
14763  VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesFullScreenExclusiveEXT.sType );
14764  VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesFullScreenExclusiveEXT.pNext );
14765  VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesFullScreenExclusiveEXT.fullScreenExclusiveSupported );
14766  return seed;
14767  }
14768  };
14769 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
14770 
14771  template <>
14772  struct hash<VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesPresentBarrierNV>
14773  {
14774  std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesPresentBarrierNV const & surfaceCapabilitiesPresentBarrierNV ) const VULKAN_HPP_NOEXCEPT
14775  {
14776  std::size_t seed = 0;
14777  VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesPresentBarrierNV.sType );
14778  VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesPresentBarrierNV.pNext );
14779  VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesPresentBarrierNV.presentBarrierSupported );
14780  return seed;
14781  }
14782  };
14783 
14784  template <>
14785  struct hash<VULKAN_HPP_NAMESPACE::SurfaceFormatKHR>
14786  {
14787  std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceFormatKHR const & surfaceFormatKHR ) const VULKAN_HPP_NOEXCEPT
14788  {
14789  std::size_t seed = 0;
14790  VULKAN_HPP_HASH_COMBINE( seed, surfaceFormatKHR.format );
14791  VULKAN_HPP_HASH_COMBINE( seed, surfaceFormatKHR.colorSpace );
14792  return seed;
14793  }
14794  };
14795 
14796  template <>
14797  struct hash<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR>
14798  {
14799  std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR const & surfaceFormat2KHR ) const VULKAN_HPP_NOEXCEPT
14800  {
14801  std::size_t seed = 0;
14802  VULKAN_HPP_HASH_COMBINE( seed, surfaceFormat2KHR.sType );
14803  VULKAN_HPP_HASH_COMBINE( seed, surfaceFormat2KHR.pNext );
14804  VULKAN_HPP_HASH_COMBINE( seed, surfaceFormat2KHR.surfaceFormat );
14805  return seed;
14806  }
14807  };
14808 
14809 # if defined( VK_USE_PLATFORM_WIN32_KHR )
14810  template <>
14811  struct hash<VULKAN_HPP_NAMESPACE::SurfaceFullScreenExclusiveInfoEXT>
14812  {
14813  std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceFullScreenExclusiveInfoEXT const & surfaceFullScreenExclusiveInfoEXT ) const VULKAN_HPP_NOEXCEPT
14814  {
14815  std::size_t seed = 0;
14816  VULKAN_HPP_HASH_COMBINE( seed, surfaceFullScreenExclusiveInfoEXT.sType );
14817  VULKAN_HPP_HASH_COMBINE( seed, surfaceFullScreenExclusiveInfoEXT.pNext );
14818  VULKAN_HPP_HASH_COMBINE( seed, surfaceFullScreenExclusiveInfoEXT.fullScreenExclusive );
14819  return seed;
14820  }
14821  };
14822 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
14823 
14824 # if defined( VK_USE_PLATFORM_WIN32_KHR )
14825  template <>
14826  struct hash<VULKAN_HPP_NAMESPACE::SurfaceFullScreenExclusiveWin32InfoEXT>
14827  {
14828  std::size_t
14829  operator()( VULKAN_HPP_NAMESPACE::SurfaceFullScreenExclusiveWin32InfoEXT const & surfaceFullScreenExclusiveWin32InfoEXT ) const VULKAN_HPP_NOEXCEPT
14830  {
14831  std::size_t seed = 0;
14832  VULKAN_HPP_HASH_COMBINE( seed, surfaceFullScreenExclusiveWin32InfoEXT.sType );
14833  VULKAN_HPP_HASH_COMBINE( seed, surfaceFullScreenExclusiveWin32InfoEXT.pNext );
14834  VULKAN_HPP_HASH_COMBINE( seed, surfaceFullScreenExclusiveWin32InfoEXT.hmonitor );
14835  return seed;
14836  }
14837  };
14838 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
14839 
14840  template <>
14841  struct hash<VULKAN_HPP_NAMESPACE::SurfacePresentModeCompatibilityEXT>
14842  {
14843  std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfacePresentModeCompatibilityEXT const & surfacePresentModeCompatibilityEXT ) const VULKAN_HPP_NOEXCEPT
14844  {
14845  std::size_t seed = 0;
14846  VULKAN_HPP_HASH_COMBINE( seed, surfacePresentModeCompatibilityEXT.sType );
14847  VULKAN_HPP_HASH_COMBINE( seed, surfacePresentModeCompatibilityEXT.pNext );
14848  VULKAN_HPP_HASH_COMBINE( seed, surfacePresentModeCompatibilityEXT.presentModeCount );
14849  VULKAN_HPP_HASH_COMBINE( seed, surfacePresentModeCompatibilityEXT.pPresentModes );
14850  return seed;
14851  }
14852  };
14853 
14854  template <>
14855  struct hash<VULKAN_HPP_NAMESPACE::SurfacePresentModeEXT>
14856  {
14857  std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfacePresentModeEXT const & surfacePresentModeEXT ) const VULKAN_HPP_NOEXCEPT
14858  {
14859  std::size_t seed = 0;
14860  VULKAN_HPP_HASH_COMBINE( seed, surfacePresentModeEXT.sType );
14861  VULKAN_HPP_HASH_COMBINE( seed, surfacePresentModeEXT.pNext );
14862  VULKAN_HPP_HASH_COMBINE( seed, surfacePresentModeEXT.presentMode );
14863  return seed;
14864  }
14865  };
14866 
14867  template <>
14868  struct hash<VULKAN_HPP_NAMESPACE::SurfacePresentScalingCapabilitiesEXT>
14869  {
14870  std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfacePresentScalingCapabilitiesEXT const & surfacePresentScalingCapabilitiesEXT ) const VULKAN_HPP_NOEXCEPT
14871  {
14872  std::size_t seed = 0;
14873  VULKAN_HPP_HASH_COMBINE( seed, surfacePresentScalingCapabilitiesEXT.sType );
14874  VULKAN_HPP_HASH_COMBINE( seed, surfacePresentScalingCapabilitiesEXT.pNext );
14875  VULKAN_HPP_HASH_COMBINE( seed, surfacePresentScalingCapabilitiesEXT.supportedPresentScaling );
14876  VULKAN_HPP_HASH_COMBINE( seed, surfacePresentScalingCapabilitiesEXT.supportedPresentGravityX );
14877  VULKAN_HPP_HASH_COMBINE( seed, surfacePresentScalingCapabilitiesEXT.supportedPresentGravityY );
14878  VULKAN_HPP_HASH_COMBINE( seed, surfacePresentScalingCapabilitiesEXT.minScaledImageExtent );
14879  VULKAN_HPP_HASH_COMBINE( seed, surfacePresentScalingCapabilitiesEXT.maxScaledImageExtent );
14880  return seed;
14881  }
14882  };
14883 
14884  template <>
14885  struct hash<VULKAN_HPP_NAMESPACE::SurfaceProtectedCapabilitiesKHR>
14886  {
14887  std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceProtectedCapabilitiesKHR const & surfaceProtectedCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT
14888  {
14889  std::size_t seed = 0;
14890  VULKAN_HPP_HASH_COMBINE( seed, surfaceProtectedCapabilitiesKHR.sType );
14891  VULKAN_HPP_HASH_COMBINE( seed, surfaceProtectedCapabilitiesKHR.pNext );
14892  VULKAN_HPP_HASH_COMBINE( seed, surfaceProtectedCapabilitiesKHR.supportsProtected );
14893  return seed;
14894  }
14895  };
14896 
14897  template <>
14898  struct hash<VULKAN_HPP_NAMESPACE::SwapchainCounterCreateInfoEXT>
14899  {
14900  std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainCounterCreateInfoEXT const & swapchainCounterCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
14901  {
14902  std::size_t seed = 0;
14903  VULKAN_HPP_HASH_COMBINE( seed, swapchainCounterCreateInfoEXT.sType );
14904  VULKAN_HPP_HASH_COMBINE( seed, swapchainCounterCreateInfoEXT.pNext );
14905  VULKAN_HPP_HASH_COMBINE( seed, swapchainCounterCreateInfoEXT.surfaceCounters );
14906  return seed;
14907  }
14908  };
14909 
14910  template <>
14911  struct hash<VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR>
14912  {
14913  std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR const & swapchainCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
14914  {
14915  std::size_t seed = 0;
14916  VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.sType );
14917  VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.pNext );
14918  VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.flags );
14919  VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.surface );
14920  VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.minImageCount );
14921  VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.imageFormat );
14922  VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.imageColorSpace );
14923  VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.imageExtent );
14924  VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.imageArrayLayers );
14925  VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.imageUsage );
14926  VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.imageSharingMode );
14927  VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.queueFamilyIndexCount );
14928  VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.pQueueFamilyIndices );
14929  VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.preTransform );
14930  VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.compositeAlpha );
14931  VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.presentMode );
14932  VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.clipped );
14933  VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.oldSwapchain );
14934  return seed;
14935  }
14936  };
14937 
14938  template <>
14939  struct hash<VULKAN_HPP_NAMESPACE::SwapchainDisplayNativeHdrCreateInfoAMD>
14940  {
14941  std::size_t
14942  operator()( VULKAN_HPP_NAMESPACE::SwapchainDisplayNativeHdrCreateInfoAMD const & swapchainDisplayNativeHdrCreateInfoAMD ) const VULKAN_HPP_NOEXCEPT
14943  {
14944  std::size_t seed = 0;
14945  VULKAN_HPP_HASH_COMBINE( seed, swapchainDisplayNativeHdrCreateInfoAMD.sType );
14946  VULKAN_HPP_HASH_COMBINE( seed, swapchainDisplayNativeHdrCreateInfoAMD.pNext );
14947  VULKAN_HPP_HASH_COMBINE( seed, swapchainDisplayNativeHdrCreateInfoAMD.localDimmingEnable );
14948  return seed;
14949  }
14950  };
14951 
14952  template <>
14953  struct hash<VULKAN_HPP_NAMESPACE::SwapchainLatencyCreateInfoNV>
14954  {
14955  std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainLatencyCreateInfoNV const & swapchainLatencyCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
14956  {
14957  std::size_t seed = 0;
14958  VULKAN_HPP_HASH_COMBINE( seed, swapchainLatencyCreateInfoNV.sType );
14959  VULKAN_HPP_HASH_COMBINE( seed, swapchainLatencyCreateInfoNV.pNext );
14960  VULKAN_HPP_HASH_COMBINE( seed, swapchainLatencyCreateInfoNV.latencyModeEnable );
14961  return seed;
14962  }
14963  };
14964 
14965  template <>
14966  struct hash<VULKAN_HPP_NAMESPACE::SwapchainPresentBarrierCreateInfoNV>
14967  {
14968  std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainPresentBarrierCreateInfoNV const & swapchainPresentBarrierCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
14969  {
14970  std::size_t seed = 0;
14971  VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentBarrierCreateInfoNV.sType );
14972  VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentBarrierCreateInfoNV.pNext );
14973  VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentBarrierCreateInfoNV.presentBarrierEnable );
14974  return seed;
14975  }
14976  };
14977 
14978  template <>
14979  struct hash<VULKAN_HPP_NAMESPACE::SwapchainPresentFenceInfoEXT>
14980  {
14981  std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainPresentFenceInfoEXT const & swapchainPresentFenceInfoEXT ) const VULKAN_HPP_NOEXCEPT
14982  {
14983  std::size_t seed = 0;
14984  VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentFenceInfoEXT.sType );
14985  VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentFenceInfoEXT.pNext );
14986  VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentFenceInfoEXT.swapchainCount );
14987  VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentFenceInfoEXT.pFences );
14988  return seed;
14989  }
14990  };
14991 
14992  template <>
14993  struct hash<VULKAN_HPP_NAMESPACE::SwapchainPresentModeInfoEXT>
14994  {
14995  std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainPresentModeInfoEXT const & swapchainPresentModeInfoEXT ) const VULKAN_HPP_NOEXCEPT
14996  {
14997  std::size_t seed = 0;
14998  VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentModeInfoEXT.sType );
14999  VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentModeInfoEXT.pNext );
15000  VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentModeInfoEXT.swapchainCount );
15001  VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentModeInfoEXT.pPresentModes );
15002  return seed;
15003  }
15004  };
15005 
15006  template <>
15007  struct hash<VULKAN_HPP_NAMESPACE::SwapchainPresentModesCreateInfoEXT>
15008  {
15009  std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainPresentModesCreateInfoEXT const & swapchainPresentModesCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
15010  {
15011  std::size_t seed = 0;
15012  VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentModesCreateInfoEXT.sType );
15013  VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentModesCreateInfoEXT.pNext );
15014  VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentModesCreateInfoEXT.presentModeCount );
15015  VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentModesCreateInfoEXT.pPresentModes );
15016  return seed;
15017  }
15018  };
15019 
15020  template <>
15021  struct hash<VULKAN_HPP_NAMESPACE::SwapchainPresentScalingCreateInfoEXT>
15022  {
15023  std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainPresentScalingCreateInfoEXT const & swapchainPresentScalingCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
15024  {
15025  std::size_t seed = 0;
15026  VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentScalingCreateInfoEXT.sType );
15027  VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentScalingCreateInfoEXT.pNext );
15028  VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentScalingCreateInfoEXT.scalingBehavior );
15029  VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentScalingCreateInfoEXT.presentGravityX );
15030  VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentScalingCreateInfoEXT.presentGravityY );
15031  return seed;
15032  }
15033  };
15034 
15035  template <>
15036  struct hash<VULKAN_HPP_NAMESPACE::TextureLODGatherFormatPropertiesAMD>
15037  {
15038  std::size_t operator()( VULKAN_HPP_NAMESPACE::TextureLODGatherFormatPropertiesAMD const & textureLODGatherFormatPropertiesAMD ) const VULKAN_HPP_NOEXCEPT
15039  {
15040  std::size_t seed = 0;
15041  VULKAN_HPP_HASH_COMBINE( seed, textureLODGatherFormatPropertiesAMD.sType );
15042  VULKAN_HPP_HASH_COMBINE( seed, textureLODGatherFormatPropertiesAMD.pNext );
15043  VULKAN_HPP_HASH_COMBINE( seed, textureLODGatherFormatPropertiesAMD.supportsTextureGatherLODBiasAMD );
15044  return seed;
15045  }
15046  };
15047 
15048  template <>
15049  struct hash<VULKAN_HPP_NAMESPACE::TilePropertiesQCOM>
15050  {
15051  std::size_t operator()( VULKAN_HPP_NAMESPACE::TilePropertiesQCOM const & tilePropertiesQCOM ) const VULKAN_HPP_NOEXCEPT
15052  {
15053  std::size_t seed = 0;
15054  VULKAN_HPP_HASH_COMBINE( seed, tilePropertiesQCOM.sType );
15055  VULKAN_HPP_HASH_COMBINE( seed, tilePropertiesQCOM.pNext );
15056  VULKAN_HPP_HASH_COMBINE( seed, tilePropertiesQCOM.tileSize );
15057  VULKAN_HPP_HASH_COMBINE( seed, tilePropertiesQCOM.apronSize );
15058  VULKAN_HPP_HASH_COMBINE( seed, tilePropertiesQCOM.origin );
15059  return seed;
15060  }
15061  };
15062 
15063  template <>
15064  struct hash<VULKAN_HPP_NAMESPACE::TimelineSemaphoreSubmitInfo>
15065  {
15066  std::size_t operator()( VULKAN_HPP_NAMESPACE::TimelineSemaphoreSubmitInfo const & timelineSemaphoreSubmitInfo ) const VULKAN_HPP_NOEXCEPT
15067  {
15068  std::size_t seed = 0;
15069  VULKAN_HPP_HASH_COMBINE( seed, timelineSemaphoreSubmitInfo.sType );
15070  VULKAN_HPP_HASH_COMBINE( seed, timelineSemaphoreSubmitInfo.pNext );
15071  VULKAN_HPP_HASH_COMBINE( seed, timelineSemaphoreSubmitInfo.waitSemaphoreValueCount );
15072  VULKAN_HPP_HASH_COMBINE( seed, timelineSemaphoreSubmitInfo.pWaitSemaphoreValues );
15073  VULKAN_HPP_HASH_COMBINE( seed, timelineSemaphoreSubmitInfo.signalSemaphoreValueCount );
15074  VULKAN_HPP_HASH_COMBINE( seed, timelineSemaphoreSubmitInfo.pSignalSemaphoreValues );
15075  return seed;
15076  }
15077  };
15078 
15079  template <>
15080  struct hash<VULKAN_HPP_NAMESPACE::TraceRaysIndirectCommand2KHR>
15081  {
15082  std::size_t operator()( VULKAN_HPP_NAMESPACE::TraceRaysIndirectCommand2KHR const & traceRaysIndirectCommand2KHR ) const VULKAN_HPP_NOEXCEPT
15083  {
15084  std::size_t seed = 0;
15085  VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.raygenShaderRecordAddress );
15086  VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.raygenShaderRecordSize );
15087  VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.missShaderBindingTableAddress );
15088  VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.missShaderBindingTableSize );
15089  VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.missShaderBindingTableStride );
15090  VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.hitShaderBindingTableAddress );
15091  VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.hitShaderBindingTableSize );
15092  VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.hitShaderBindingTableStride );
15093  VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.callableShaderBindingTableAddress );
15094  VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.callableShaderBindingTableSize );
15095  VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.callableShaderBindingTableStride );
15096  VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.width );
15097  VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.height );
15098  VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.depth );
15099  return seed;
15100  }
15101  };
15102 
15103  template <>
15104  struct hash<VULKAN_HPP_NAMESPACE::TraceRaysIndirectCommandKHR>
15105  {
15106  std::size_t operator()( VULKAN_HPP_NAMESPACE::TraceRaysIndirectCommandKHR const & traceRaysIndirectCommandKHR ) const VULKAN_HPP_NOEXCEPT
15107  {
15108  std::size_t seed = 0;
15109  VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommandKHR.width );
15110  VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommandKHR.height );
15111  VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommandKHR.depth );
15112  return seed;
15113  }
15114  };
15115 
15116  template <>
15117  struct hash<VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT>
15118  {
15119  std::size_t operator()( VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT const & validationCacheCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
15120  {
15121  std::size_t seed = 0;
15122  VULKAN_HPP_HASH_COMBINE( seed, validationCacheCreateInfoEXT.sType );
15123  VULKAN_HPP_HASH_COMBINE( seed, validationCacheCreateInfoEXT.pNext );
15124  VULKAN_HPP_HASH_COMBINE( seed, validationCacheCreateInfoEXT.flags );
15125  VULKAN_HPP_HASH_COMBINE( seed, validationCacheCreateInfoEXT.initialDataSize );
15126  VULKAN_HPP_HASH_COMBINE( seed, validationCacheCreateInfoEXT.pInitialData );
15127  return seed;
15128  }
15129  };
15130 
15131  template <>
15132  struct hash<VULKAN_HPP_NAMESPACE::ValidationFeaturesEXT>
15133  {
15134  std::size_t operator()( VULKAN_HPP_NAMESPACE::ValidationFeaturesEXT const & validationFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
15135  {
15136  std::size_t seed = 0;
15137  VULKAN_HPP_HASH_COMBINE( seed, validationFeaturesEXT.sType );
15138  VULKAN_HPP_HASH_COMBINE( seed, validationFeaturesEXT.pNext );
15139  VULKAN_HPP_HASH_COMBINE( seed, validationFeaturesEXT.enabledValidationFeatureCount );
15140  VULKAN_HPP_HASH_COMBINE( seed, validationFeaturesEXT.pEnabledValidationFeatures );
15141  VULKAN_HPP_HASH_COMBINE( seed, validationFeaturesEXT.disabledValidationFeatureCount );
15142  VULKAN_HPP_HASH_COMBINE( seed, validationFeaturesEXT.pDisabledValidationFeatures );
15143  return seed;
15144  }
15145  };
15146 
15147  template <>
15148  struct hash<VULKAN_HPP_NAMESPACE::ValidationFlagsEXT>
15149  {
15150  std::size_t operator()( VULKAN_HPP_NAMESPACE::ValidationFlagsEXT const & validationFlagsEXT ) const VULKAN_HPP_NOEXCEPT
15151  {
15152  std::size_t seed = 0;
15153  VULKAN_HPP_HASH_COMBINE( seed, validationFlagsEXT.sType );
15154  VULKAN_HPP_HASH_COMBINE( seed, validationFlagsEXT.pNext );
15155  VULKAN_HPP_HASH_COMBINE( seed, validationFlagsEXT.disabledValidationCheckCount );
15156  VULKAN_HPP_HASH_COMBINE( seed, validationFlagsEXT.pDisabledValidationChecks );
15157  return seed;
15158  }
15159  };
15160 
15161  template <>
15162  struct hash<VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT>
15163  {
15164  std::size_t operator()( VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT const & vertexInputAttributeDescription2EXT ) const VULKAN_HPP_NOEXCEPT
15165  {
15166  std::size_t seed = 0;
15167  VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription2EXT.sType );
15168  VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription2EXT.pNext );
15169  VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription2EXT.location );
15170  VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription2EXT.binding );
15171  VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription2EXT.format );
15172  VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription2EXT.offset );
15173  return seed;
15174  }
15175  };
15176 
15177  template <>
15178  struct hash<VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT>
15179  {
15180  std::size_t operator()( VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT const & vertexInputBindingDescription2EXT ) const VULKAN_HPP_NOEXCEPT
15181  {
15182  std::size_t seed = 0;
15183  VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDescription2EXT.sType );
15184  VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDescription2EXT.pNext );
15185  VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDescription2EXT.binding );
15186  VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDescription2EXT.stride );
15187  VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDescription2EXT.inputRate );
15188  VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDescription2EXT.divisor );
15189  return seed;
15190  }
15191  };
15192 
15193 # if defined( VK_USE_PLATFORM_VI_NN )
15194  template <>
15195  struct hash<VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN>
15196  {
15197  std::size_t operator()( VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN const & viSurfaceCreateInfoNN ) const VULKAN_HPP_NOEXCEPT
15198  {
15199  std::size_t seed = 0;
15200  VULKAN_HPP_HASH_COMBINE( seed, viSurfaceCreateInfoNN.sType );
15201  VULKAN_HPP_HASH_COMBINE( seed, viSurfaceCreateInfoNN.pNext );
15202  VULKAN_HPP_HASH_COMBINE( seed, viSurfaceCreateInfoNN.flags );
15203  VULKAN_HPP_HASH_COMBINE( seed, viSurfaceCreateInfoNN.window );
15204  return seed;
15205  }
15206  };
15207 # endif /*VK_USE_PLATFORM_VI_NN*/
15208 
15209  template <>
15210  struct hash<VULKAN_HPP_NAMESPACE::VideoPictureResourceInfoKHR>
15211  {
15212  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoPictureResourceInfoKHR const & videoPictureResourceInfoKHR ) const VULKAN_HPP_NOEXCEPT
15213  {
15214  std::size_t seed = 0;
15215  VULKAN_HPP_HASH_COMBINE( seed, videoPictureResourceInfoKHR.sType );
15216  VULKAN_HPP_HASH_COMBINE( seed, videoPictureResourceInfoKHR.pNext );
15217  VULKAN_HPP_HASH_COMBINE( seed, videoPictureResourceInfoKHR.codedOffset );
15218  VULKAN_HPP_HASH_COMBINE( seed, videoPictureResourceInfoKHR.codedExtent );
15219  VULKAN_HPP_HASH_COMBINE( seed, videoPictureResourceInfoKHR.baseArrayLayer );
15220  VULKAN_HPP_HASH_COMBINE( seed, videoPictureResourceInfoKHR.imageViewBinding );
15221  return seed;
15222  }
15223  };
15224 
15225  template <>
15226  struct hash<VULKAN_HPP_NAMESPACE::VideoReferenceSlotInfoKHR>
15227  {
15228  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoReferenceSlotInfoKHR const & videoReferenceSlotInfoKHR ) const VULKAN_HPP_NOEXCEPT
15229  {
15230  std::size_t seed = 0;
15231  VULKAN_HPP_HASH_COMBINE( seed, videoReferenceSlotInfoKHR.sType );
15232  VULKAN_HPP_HASH_COMBINE( seed, videoReferenceSlotInfoKHR.pNext );
15233  VULKAN_HPP_HASH_COMBINE( seed, videoReferenceSlotInfoKHR.slotIndex );
15234  VULKAN_HPP_HASH_COMBINE( seed, videoReferenceSlotInfoKHR.pPictureResource );
15235  return seed;
15236  }
15237  };
15238 
15239  template <>
15240  struct hash<VULKAN_HPP_NAMESPACE::VideoBeginCodingInfoKHR>
15241  {
15242  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoBeginCodingInfoKHR const & videoBeginCodingInfoKHR ) const VULKAN_HPP_NOEXCEPT
15243  {
15244  std::size_t seed = 0;
15245  VULKAN_HPP_HASH_COMBINE( seed, videoBeginCodingInfoKHR.sType );
15246  VULKAN_HPP_HASH_COMBINE( seed, videoBeginCodingInfoKHR.pNext );
15247  VULKAN_HPP_HASH_COMBINE( seed, videoBeginCodingInfoKHR.flags );
15248  VULKAN_HPP_HASH_COMBINE( seed, videoBeginCodingInfoKHR.videoSession );
15249  VULKAN_HPP_HASH_COMBINE( seed, videoBeginCodingInfoKHR.videoSessionParameters );
15250  VULKAN_HPP_HASH_COMBINE( seed, videoBeginCodingInfoKHR.referenceSlotCount );
15251  VULKAN_HPP_HASH_COMBINE( seed, videoBeginCodingInfoKHR.pReferenceSlots );
15252  return seed;
15253  }
15254  };
15255 
15256  template <>
15257  struct hash<VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR>
15258  {
15259  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR const & videoCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT
15260  {
15261  std::size_t seed = 0;
15262  VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.sType );
15263  VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.pNext );
15264  VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.flags );
15265  VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.minBitstreamBufferOffsetAlignment );
15266  VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.minBitstreamBufferSizeAlignment );
15267  VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.pictureAccessGranularity );
15268  VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.minCodedExtent );
15269  VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.maxCodedExtent );
15270  VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.maxDpbSlots );
15271  VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.maxActiveReferencePictures );
15272  VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.stdHeaderVersion );
15273  return seed;
15274  }
15275  };
15276 
15277  template <>
15278  struct hash<VULKAN_HPP_NAMESPACE::VideoCodingControlInfoKHR>
15279  {
15280  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoCodingControlInfoKHR const & videoCodingControlInfoKHR ) const VULKAN_HPP_NOEXCEPT
15281  {
15282  std::size_t seed = 0;
15283  VULKAN_HPP_HASH_COMBINE( seed, videoCodingControlInfoKHR.sType );
15284  VULKAN_HPP_HASH_COMBINE( seed, videoCodingControlInfoKHR.pNext );
15285  VULKAN_HPP_HASH_COMBINE( seed, videoCodingControlInfoKHR.flags );
15286  return seed;
15287  }
15288  };
15289 
15290  template <>
15291  struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeCapabilitiesKHR>
15292  {
15293  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeCapabilitiesKHR const & videoDecodeCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT
15294  {
15295  std::size_t seed = 0;
15296  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeCapabilitiesKHR.sType );
15297  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeCapabilitiesKHR.pNext );
15298  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeCapabilitiesKHR.flags );
15299  return seed;
15300  }
15301  };
15302 
15303  template <>
15304  struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH264CapabilitiesKHR>
15305  {
15306  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264CapabilitiesKHR const & videoDecodeH264CapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT
15307  {
15308  std::size_t seed = 0;
15309  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264CapabilitiesKHR.sType );
15310  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264CapabilitiesKHR.pNext );
15311  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264CapabilitiesKHR.maxLevelIdc );
15312  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264CapabilitiesKHR.fieldOffsetGranularity );
15313  return seed;
15314  }
15315  };
15316 
15317  template <>
15318  struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH264DpbSlotInfoKHR>
15319  {
15320  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264DpbSlotInfoKHR const & videoDecodeH264DpbSlotInfoKHR ) const VULKAN_HPP_NOEXCEPT
15321  {
15322  std::size_t seed = 0;
15323  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264DpbSlotInfoKHR.sType );
15324  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264DpbSlotInfoKHR.pNext );
15325  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264DpbSlotInfoKHR.pStdReferenceInfo );
15326  return seed;
15327  }
15328  };
15329 
15330  template <>
15331  struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH264PictureInfoKHR>
15332  {
15333  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264PictureInfoKHR const & videoDecodeH264PictureInfoKHR ) const VULKAN_HPP_NOEXCEPT
15334  {
15335  std::size_t seed = 0;
15336  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264PictureInfoKHR.sType );
15337  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264PictureInfoKHR.pNext );
15338  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264PictureInfoKHR.pStdPictureInfo );
15339  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264PictureInfoKHR.sliceCount );
15340  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264PictureInfoKHR.pSliceOffsets );
15341  return seed;
15342  }
15343  };
15344 
15345  template <>
15346  struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH264ProfileInfoKHR>
15347  {
15348  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264ProfileInfoKHR const & videoDecodeH264ProfileInfoKHR ) const VULKAN_HPP_NOEXCEPT
15349  {
15350  std::size_t seed = 0;
15351  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264ProfileInfoKHR.sType );
15352  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264ProfileInfoKHR.pNext );
15353  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264ProfileInfoKHR.stdProfileIdc );
15354  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264ProfileInfoKHR.pictureLayout );
15355  return seed;
15356  }
15357  };
15358 
15359  template <>
15360  struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH264SessionParametersAddInfoKHR>
15361  {
15362  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264SessionParametersAddInfoKHR const & videoDecodeH264SessionParametersAddInfoKHR ) const
15363  VULKAN_HPP_NOEXCEPT
15364  {
15365  std::size_t seed = 0;
15366  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersAddInfoKHR.sType );
15367  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersAddInfoKHR.pNext );
15368  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersAddInfoKHR.stdSPSCount );
15369  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersAddInfoKHR.pStdSPSs );
15370  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersAddInfoKHR.stdPPSCount );
15371  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersAddInfoKHR.pStdPPSs );
15372  return seed;
15373  }
15374  };
15375 
15376  template <>
15377  struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH264SessionParametersCreateInfoKHR>
15378  {
15379  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264SessionParametersCreateInfoKHR const & videoDecodeH264SessionParametersCreateInfoKHR ) const
15380  VULKAN_HPP_NOEXCEPT
15381  {
15382  std::size_t seed = 0;
15383  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersCreateInfoKHR.sType );
15384  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersCreateInfoKHR.pNext );
15385  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersCreateInfoKHR.maxStdSPSCount );
15386  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersCreateInfoKHR.maxStdPPSCount );
15387  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersCreateInfoKHR.pParametersAddInfo );
15388  return seed;
15389  }
15390  };
15391 
15392  template <>
15393  struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH265CapabilitiesKHR>
15394  {
15395  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265CapabilitiesKHR const & videoDecodeH265CapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT
15396  {
15397  std::size_t seed = 0;
15398  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265CapabilitiesKHR.sType );
15399  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265CapabilitiesKHR.pNext );
15400  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265CapabilitiesKHR.maxLevelIdc );
15401  return seed;
15402  }
15403  };
15404 
15405  template <>
15406  struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH265DpbSlotInfoKHR>
15407  {
15408  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265DpbSlotInfoKHR const & videoDecodeH265DpbSlotInfoKHR ) const VULKAN_HPP_NOEXCEPT
15409  {
15410  std::size_t seed = 0;
15411  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265DpbSlotInfoKHR.sType );
15412  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265DpbSlotInfoKHR.pNext );
15413  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265DpbSlotInfoKHR.pStdReferenceInfo );
15414  return seed;
15415  }
15416  };
15417 
15418  template <>
15419  struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH265PictureInfoKHR>
15420  {
15421  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265PictureInfoKHR const & videoDecodeH265PictureInfoKHR ) const VULKAN_HPP_NOEXCEPT
15422  {
15423  std::size_t seed = 0;
15424  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265PictureInfoKHR.sType );
15425  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265PictureInfoKHR.pNext );
15426  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265PictureInfoKHR.pStdPictureInfo );
15427  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265PictureInfoKHR.sliceSegmentCount );
15428  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265PictureInfoKHR.pSliceSegmentOffsets );
15429  return seed;
15430  }
15431  };
15432 
15433  template <>
15434  struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH265ProfileInfoKHR>
15435  {
15436  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265ProfileInfoKHR const & videoDecodeH265ProfileInfoKHR ) const VULKAN_HPP_NOEXCEPT
15437  {
15438  std::size_t seed = 0;
15439  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265ProfileInfoKHR.sType );
15440  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265ProfileInfoKHR.pNext );
15441  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265ProfileInfoKHR.stdProfileIdc );
15442  return seed;
15443  }
15444  };
15445 
15446  template <>
15447  struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH265SessionParametersAddInfoKHR>
15448  {
15449  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265SessionParametersAddInfoKHR const & videoDecodeH265SessionParametersAddInfoKHR ) const
15450  VULKAN_HPP_NOEXCEPT
15451  {
15452  std::size_t seed = 0;
15453  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersAddInfoKHR.sType );
15454  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersAddInfoKHR.pNext );
15455  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersAddInfoKHR.stdVPSCount );
15456  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersAddInfoKHR.pStdVPSs );
15457  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersAddInfoKHR.stdSPSCount );
15458  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersAddInfoKHR.pStdSPSs );
15459  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersAddInfoKHR.stdPPSCount );
15460  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersAddInfoKHR.pStdPPSs );
15461  return seed;
15462  }
15463  };
15464 
15465  template <>
15466  struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH265SessionParametersCreateInfoKHR>
15467  {
15468  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265SessionParametersCreateInfoKHR const & videoDecodeH265SessionParametersCreateInfoKHR ) const
15469  VULKAN_HPP_NOEXCEPT
15470  {
15471  std::size_t seed = 0;
15472  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersCreateInfoKHR.sType );
15473  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersCreateInfoKHR.pNext );
15474  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersCreateInfoKHR.maxStdVPSCount );
15475  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersCreateInfoKHR.maxStdSPSCount );
15476  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersCreateInfoKHR.maxStdPPSCount );
15477  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersCreateInfoKHR.pParametersAddInfo );
15478  return seed;
15479  }
15480  };
15481 
15482  template <>
15483  struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR>
15484  {
15485  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR const & videoDecodeInfoKHR ) const VULKAN_HPP_NOEXCEPT
15486  {
15487  std::size_t seed = 0;
15488  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.sType );
15489  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.pNext );
15490  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.flags );
15491  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.srcBuffer );
15492  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.srcBufferOffset );
15493  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.srcBufferRange );
15494  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.dstPictureResource );
15495  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.pSetupReferenceSlot );
15496  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.referenceSlotCount );
15497  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.pReferenceSlots );
15498  return seed;
15499  }
15500  };
15501 
15502  template <>
15503  struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeUsageInfoKHR>
15504  {
15505  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeUsageInfoKHR const & videoDecodeUsageInfoKHR ) const VULKAN_HPP_NOEXCEPT
15506  {
15507  std::size_t seed = 0;
15508  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeUsageInfoKHR.sType );
15509  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeUsageInfoKHR.pNext );
15510  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeUsageInfoKHR.videoUsageHints );
15511  return seed;
15512  }
15513  };
15514 
15515  template <>
15516  struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeCapabilitiesKHR>
15517  {
15518  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeCapabilitiesKHR const & videoEncodeCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT
15519  {
15520  std::size_t seed = 0;
15521  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.sType );
15522  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.pNext );
15523  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.flags );
15524  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.rateControlModes );
15525  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.maxRateControlLayers );
15526  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.maxBitrate );
15527  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.maxQualityLevels );
15528  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.encodeInputPictureGranularity );
15529  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.supportedEncodeFeedbackFlags );
15530  return seed;
15531  }
15532  };
15533 
15534  template <>
15535  struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilitiesKHR>
15536  {
15537  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilitiesKHR const & videoEncodeH264CapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT
15538  {
15539  std::size_t seed = 0;
15540  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.sType );
15541  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.pNext );
15542  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.flags );
15543  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.maxLevelIdc );
15544  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.maxSliceCount );
15545  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.maxPPictureL0ReferenceCount );
15546  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.maxBPictureL0ReferenceCount );
15547  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.maxL1ReferenceCount );
15548  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.maxTemporalLayerCount );
15549  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.expectDyadicTemporalLayerPattern );
15550  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.minQp );
15551  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.maxQp );
15552  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.prefersGopRemainingFrames );
15553  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.requiresGopRemainingFrames );
15554  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.stdSyntaxFlags );
15555  return seed;
15556  }
15557  };
15558 
15559  template <>
15560  struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoKHR>
15561  {
15562  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoKHR const & videoEncodeH264DpbSlotInfoKHR ) const VULKAN_HPP_NOEXCEPT
15563  {
15564  std::size_t seed = 0;
15565  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264DpbSlotInfoKHR.sType );
15566  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264DpbSlotInfoKHR.pNext );
15567  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264DpbSlotInfoKHR.pStdReferenceInfo );
15568  return seed;
15569  }
15570  };
15571 
15572  template <>
15573  struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264FrameSizeKHR>
15574  {
15575  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264FrameSizeKHR const & videoEncodeH264FrameSizeKHR ) const VULKAN_HPP_NOEXCEPT
15576  {
15577  std::size_t seed = 0;
15578  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264FrameSizeKHR.frameISize );
15579  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264FrameSizeKHR.framePSize );
15580  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264FrameSizeKHR.frameBSize );
15581  return seed;
15582  }
15583  };
15584 
15585  template <>
15586  struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264GopRemainingFrameInfoKHR>
15587  {
15588  std::size_t
15589  operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264GopRemainingFrameInfoKHR const & videoEncodeH264GopRemainingFrameInfoKHR ) const VULKAN_HPP_NOEXCEPT
15590  {
15591  std::size_t seed = 0;
15592  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264GopRemainingFrameInfoKHR.sType );
15593  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264GopRemainingFrameInfoKHR.pNext );
15594  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264GopRemainingFrameInfoKHR.useGopRemainingFrames );
15595  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264GopRemainingFrameInfoKHR.gopRemainingI );
15596  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264GopRemainingFrameInfoKHR.gopRemainingP );
15597  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264GopRemainingFrameInfoKHR.gopRemainingB );
15598  return seed;
15599  }
15600  };
15601 
15602  template <>
15603  struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264NaluSliceInfoKHR>
15604  {
15605  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264NaluSliceInfoKHR const & videoEncodeH264NaluSliceInfoKHR ) const VULKAN_HPP_NOEXCEPT
15606  {
15607  std::size_t seed = 0;
15608  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264NaluSliceInfoKHR.sType );
15609  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264NaluSliceInfoKHR.pNext );
15610  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264NaluSliceInfoKHR.constantQp );
15611  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264NaluSliceInfoKHR.pStdSliceHeader );
15612  return seed;
15613  }
15614  };
15615 
15616  template <>
15617  struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264PictureInfoKHR>
15618  {
15619  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264PictureInfoKHR const & videoEncodeH264PictureInfoKHR ) const VULKAN_HPP_NOEXCEPT
15620  {
15621  std::size_t seed = 0;
15622  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264PictureInfoKHR.sType );
15623  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264PictureInfoKHR.pNext );
15624  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264PictureInfoKHR.naluSliceEntryCount );
15625  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264PictureInfoKHR.pNaluSliceEntries );
15626  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264PictureInfoKHR.pStdPictureInfo );
15627  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264PictureInfoKHR.generatePrefixNalu );
15628  return seed;
15629  }
15630  };
15631 
15632  template <>
15633  struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264ProfileInfoKHR>
15634  {
15635  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264ProfileInfoKHR const & videoEncodeH264ProfileInfoKHR ) const VULKAN_HPP_NOEXCEPT
15636  {
15637  std::size_t seed = 0;
15638  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264ProfileInfoKHR.sType );
15639  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264ProfileInfoKHR.pNext );
15640  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264ProfileInfoKHR.stdProfileIdc );
15641  return seed;
15642  }
15643  };
15644 
15645  template <>
15646  struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264QpKHR>
15647  {
15648  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264QpKHR const & videoEncodeH264QpKHR ) const VULKAN_HPP_NOEXCEPT
15649  {
15650  std::size_t seed = 0;
15651  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QpKHR.qpI );
15652  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QpKHR.qpP );
15653  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QpKHR.qpB );
15654  return seed;
15655  }
15656  };
15657 
15658  template <>
15659  struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264QualityLevelPropertiesKHR>
15660  {
15661  std::size_t
15662  operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264QualityLevelPropertiesKHR const & videoEncodeH264QualityLevelPropertiesKHR ) const VULKAN_HPP_NOEXCEPT
15663  {
15664  std::size_t seed = 0;
15665  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesKHR.sType );
15666  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesKHR.pNext );
15667  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesKHR.preferredRateControlFlags );
15668  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesKHR.preferredGopFrameCount );
15669  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesKHR.preferredIdrPeriod );
15670  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesKHR.preferredConsecutiveBFrameCount );
15671  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesKHR.preferredTemporalLayerCount );
15672  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesKHR.preferredConstantQp );
15673  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesKHR.preferredMaxL0ReferenceCount );
15674  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesKHR.preferredMaxL1ReferenceCount );
15675  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesKHR.preferredStdEntropyCodingModeFlag );
15676  return seed;
15677  }
15678  };
15679 
15680  template <>
15681  struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlInfoKHR>
15682  {
15683  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlInfoKHR const & videoEncodeH264RateControlInfoKHR ) const VULKAN_HPP_NOEXCEPT
15684  {
15685  std::size_t seed = 0;
15686  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlInfoKHR.sType );
15687  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlInfoKHR.pNext );
15688  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlInfoKHR.flags );
15689  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlInfoKHR.gopFrameCount );
15690  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlInfoKHR.idrPeriod );
15691  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlInfoKHR.consecutiveBFrameCount );
15692  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlInfoKHR.temporalLayerCount );
15693  return seed;
15694  }
15695  };
15696 
15697  template <>
15698  struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlLayerInfoKHR>
15699  {
15700  std::size_t
15701  operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlLayerInfoKHR const & videoEncodeH264RateControlLayerInfoKHR ) const VULKAN_HPP_NOEXCEPT
15702  {
15703  std::size_t seed = 0;
15704  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoKHR.sType );
15705  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoKHR.pNext );
15706  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoKHR.useMinQp );
15707  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoKHR.minQp );
15708  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoKHR.useMaxQp );
15709  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoKHR.maxQp );
15710  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoKHR.useMaxFrameSize );
15711  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoKHR.maxFrameSize );
15712  return seed;
15713  }
15714  };
15715 
15716  template <>
15717  struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionCreateInfoKHR>
15718  {
15719  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionCreateInfoKHR const & videoEncodeH264SessionCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
15720  {
15721  std::size_t seed = 0;
15722  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionCreateInfoKHR.sType );
15723  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionCreateInfoKHR.pNext );
15724  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionCreateInfoKHR.useMaxLevelIdc );
15725  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionCreateInfoKHR.maxLevelIdc );
15726  return seed;
15727  }
15728  };
15729 
15730  template <>
15731  struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersAddInfoKHR>
15732  {
15733  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersAddInfoKHR const & videoEncodeH264SessionParametersAddInfoKHR ) const
15734  VULKAN_HPP_NOEXCEPT
15735  {
15736  std::size_t seed = 0;
15737  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersAddInfoKHR.sType );
15738  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersAddInfoKHR.pNext );
15739  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersAddInfoKHR.stdSPSCount );
15740  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersAddInfoKHR.pStdSPSs );
15741  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersAddInfoKHR.stdPPSCount );
15742  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersAddInfoKHR.pStdPPSs );
15743  return seed;
15744  }
15745  };
15746 
15747  template <>
15748  struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersCreateInfoKHR>
15749  {
15750  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersCreateInfoKHR const & videoEncodeH264SessionParametersCreateInfoKHR ) const
15751  VULKAN_HPP_NOEXCEPT
15752  {
15753  std::size_t seed = 0;
15754  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersCreateInfoKHR.sType );
15755  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersCreateInfoKHR.pNext );
15756  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersCreateInfoKHR.maxStdSPSCount );
15757  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersCreateInfoKHR.maxStdPPSCount );
15758  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersCreateInfoKHR.pParametersAddInfo );
15759  return seed;
15760  }
15761  };
15762 
15763  template <>
15764  struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersFeedbackInfoKHR>
15765  {
15766  std::size_t operator()(
15767  VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersFeedbackInfoKHR const & videoEncodeH264SessionParametersFeedbackInfoKHR ) const VULKAN_HPP_NOEXCEPT
15768  {
15769  std::size_t seed = 0;
15770  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersFeedbackInfoKHR.sType );
15771  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersFeedbackInfoKHR.pNext );
15772  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersFeedbackInfoKHR.hasStdSPSOverrides );
15773  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersFeedbackInfoKHR.hasStdPPSOverrides );
15774  return seed;
15775  }
15776  };
15777 
15778  template <>
15779  struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersGetInfoKHR>
15780  {
15781  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersGetInfoKHR const & videoEncodeH264SessionParametersGetInfoKHR ) const
15782  VULKAN_HPP_NOEXCEPT
15783  {
15784  std::size_t seed = 0;
15785  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersGetInfoKHR.sType );
15786  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersGetInfoKHR.pNext );
15787  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersGetInfoKHR.writeStdSPS );
15788  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersGetInfoKHR.writeStdPPS );
15789  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersGetInfoKHR.stdSPSId );
15790  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersGetInfoKHR.stdPPSId );
15791  return seed;
15792  }
15793  };
15794 
15795  template <>
15796  struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265CapabilitiesKHR>
15797  {
15798  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265CapabilitiesKHR const & videoEncodeH265CapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT
15799  {
15800  std::size_t seed = 0;
15801  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.sType );
15802  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.pNext );
15803  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.flags );
15804  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.maxLevelIdc );
15805  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.maxSliceSegmentCount );
15806  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.maxTiles );
15807  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.ctbSizes );
15808  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.transformBlockSizes );
15809  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.maxPPictureL0ReferenceCount );
15810  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.maxBPictureL0ReferenceCount );
15811  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.maxL1ReferenceCount );
15812  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.maxSubLayerCount );
15813  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.expectDyadicTemporalSubLayerPattern );
15814  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.minQp );
15815  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.maxQp );
15816  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.prefersGopRemainingFrames );
15817  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.requiresGopRemainingFrames );
15818  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.stdSyntaxFlags );
15819  return seed;
15820  }
15821  };
15822 
15823  template <>
15824  struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265DpbSlotInfoKHR>
15825  {
15826  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265DpbSlotInfoKHR const & videoEncodeH265DpbSlotInfoKHR ) const VULKAN_HPP_NOEXCEPT
15827  {
15828  std::size_t seed = 0;
15829  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265DpbSlotInfoKHR.sType );
15830  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265DpbSlotInfoKHR.pNext );
15831  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265DpbSlotInfoKHR.pStdReferenceInfo );
15832  return seed;
15833  }
15834  };
15835 
15836  template <>
15837  struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265FrameSizeKHR>
15838  {
15839  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265FrameSizeKHR const & videoEncodeH265FrameSizeKHR ) const VULKAN_HPP_NOEXCEPT
15840  {
15841  std::size_t seed = 0;
15842  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265FrameSizeKHR.frameISize );
15843  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265FrameSizeKHR.framePSize );
15844  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265FrameSizeKHR.frameBSize );
15845  return seed;
15846  }
15847  };
15848 
15849  template <>
15850  struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265GopRemainingFrameInfoKHR>
15851  {
15852  std::size_t
15853  operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265GopRemainingFrameInfoKHR const & videoEncodeH265GopRemainingFrameInfoKHR ) const VULKAN_HPP_NOEXCEPT
15854  {
15855  std::size_t seed = 0;
15856  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265GopRemainingFrameInfoKHR.sType );
15857  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265GopRemainingFrameInfoKHR.pNext );
15858  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265GopRemainingFrameInfoKHR.useGopRemainingFrames );
15859  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265GopRemainingFrameInfoKHR.gopRemainingI );
15860  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265GopRemainingFrameInfoKHR.gopRemainingP );
15861  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265GopRemainingFrameInfoKHR.gopRemainingB );
15862  return seed;
15863  }
15864  };
15865 
15866  template <>
15867  struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceSegmentInfoKHR>
15868  {
15869  std::size_t
15870  operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceSegmentInfoKHR const & videoEncodeH265NaluSliceSegmentInfoKHR ) const VULKAN_HPP_NOEXCEPT
15871  {
15872  std::size_t seed = 0;
15873  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265NaluSliceSegmentInfoKHR.sType );
15874  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265NaluSliceSegmentInfoKHR.pNext );
15875  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265NaluSliceSegmentInfoKHR.constantQp );
15876  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265NaluSliceSegmentInfoKHR.pStdSliceSegmentHeader );
15877  return seed;
15878  }
15879  };
15880 
15881  template <>
15882  struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265PictureInfoKHR>
15883  {
15884  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265PictureInfoKHR const & videoEncodeH265PictureInfoKHR ) const VULKAN_HPP_NOEXCEPT
15885  {
15886  std::size_t seed = 0;
15887  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265PictureInfoKHR.sType );
15888  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265PictureInfoKHR.pNext );
15889  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265PictureInfoKHR.naluSliceSegmentEntryCount );
15890  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265PictureInfoKHR.pNaluSliceSegmentEntries );
15891  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265PictureInfoKHR.pStdPictureInfo );
15892  return seed;
15893  }
15894  };
15895 
15896  template <>
15897  struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265ProfileInfoKHR>
15898  {
15899  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265ProfileInfoKHR const & videoEncodeH265ProfileInfoKHR ) const VULKAN_HPP_NOEXCEPT
15900  {
15901  std::size_t seed = 0;
15902  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265ProfileInfoKHR.sType );
15903  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265ProfileInfoKHR.pNext );
15904  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265ProfileInfoKHR.stdProfileIdc );
15905  return seed;
15906  }
15907  };
15908 
15909  template <>
15910  struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265QpKHR>
15911  {
15912  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265QpKHR const & videoEncodeH265QpKHR ) const VULKAN_HPP_NOEXCEPT
15913  {
15914  std::size_t seed = 0;
15915  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QpKHR.qpI );
15916  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QpKHR.qpP );
15917  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QpKHR.qpB );
15918  return seed;
15919  }
15920  };
15921 
15922  template <>
15923  struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265QualityLevelPropertiesKHR>
15924  {
15925  std::size_t
15926  operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265QualityLevelPropertiesKHR const & videoEncodeH265QualityLevelPropertiesKHR ) const VULKAN_HPP_NOEXCEPT
15927  {
15928  std::size_t seed = 0;
15929  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesKHR.sType );
15930  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesKHR.pNext );
15931  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesKHR.preferredRateControlFlags );
15932  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesKHR.preferredGopFrameCount );
15933  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesKHR.preferredIdrPeriod );
15934  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesKHR.preferredConsecutiveBFrameCount );
15935  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesKHR.preferredSubLayerCount );
15936  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesKHR.preferredConstantQp );
15937  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesKHR.preferredMaxL0ReferenceCount );
15938  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesKHR.preferredMaxL1ReferenceCount );
15939  return seed;
15940  }
15941  };
15942 
15943  template <>
15944  struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlInfoKHR>
15945  {
15946  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlInfoKHR const & videoEncodeH265RateControlInfoKHR ) const VULKAN_HPP_NOEXCEPT
15947  {
15948  std::size_t seed = 0;
15949  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlInfoKHR.sType );
15950  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlInfoKHR.pNext );
15951  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlInfoKHR.flags );
15952  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlInfoKHR.gopFrameCount );
15953  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlInfoKHR.idrPeriod );
15954  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlInfoKHR.consecutiveBFrameCount );
15955  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlInfoKHR.subLayerCount );
15956  return seed;
15957  }
15958  };
15959 
15960  template <>
15961  struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlLayerInfoKHR>
15962  {
15963  std::size_t
15964  operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlLayerInfoKHR const & videoEncodeH265RateControlLayerInfoKHR ) const VULKAN_HPP_NOEXCEPT
15965  {
15966  std::size_t seed = 0;
15967  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoKHR.sType );
15968  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoKHR.pNext );
15969  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoKHR.useMinQp );
15970  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoKHR.minQp );
15971  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoKHR.useMaxQp );
15972  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoKHR.maxQp );
15973  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoKHR.useMaxFrameSize );
15974  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoKHR.maxFrameSize );
15975  return seed;
15976  }
15977  };
15978 
15979  template <>
15980  struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionCreateInfoKHR>
15981  {
15982  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionCreateInfoKHR const & videoEncodeH265SessionCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
15983  {
15984  std::size_t seed = 0;
15985  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionCreateInfoKHR.sType );
15986  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionCreateInfoKHR.pNext );
15987  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionCreateInfoKHR.useMaxLevelIdc );
15988  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionCreateInfoKHR.maxLevelIdc );
15989  return seed;
15990  }
15991  };
15992 
15993  template <>
15994  struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersAddInfoKHR>
15995  {
15996  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersAddInfoKHR const & videoEncodeH265SessionParametersAddInfoKHR ) const
15997  VULKAN_HPP_NOEXCEPT
15998  {
15999  std::size_t seed = 0;
16000  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersAddInfoKHR.sType );
16001  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersAddInfoKHR.pNext );
16002  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersAddInfoKHR.stdVPSCount );
16003  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersAddInfoKHR.pStdVPSs );
16004  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersAddInfoKHR.stdSPSCount );
16005  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersAddInfoKHR.pStdSPSs );
16006  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersAddInfoKHR.stdPPSCount );
16007  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersAddInfoKHR.pStdPPSs );
16008  return seed;
16009  }
16010  };
16011 
16012  template <>
16013  struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersCreateInfoKHR>
16014  {
16015  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersCreateInfoKHR const & videoEncodeH265SessionParametersCreateInfoKHR ) const
16016  VULKAN_HPP_NOEXCEPT
16017  {
16018  std::size_t seed = 0;
16019  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersCreateInfoKHR.sType );
16020  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersCreateInfoKHR.pNext );
16021  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersCreateInfoKHR.maxStdVPSCount );
16022  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersCreateInfoKHR.maxStdSPSCount );
16023  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersCreateInfoKHR.maxStdPPSCount );
16024  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersCreateInfoKHR.pParametersAddInfo );
16025  return seed;
16026  }
16027  };
16028 
16029  template <>
16030  struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersFeedbackInfoKHR>
16031  {
16032  std::size_t operator()(
16033  VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersFeedbackInfoKHR const & videoEncodeH265SessionParametersFeedbackInfoKHR ) const VULKAN_HPP_NOEXCEPT
16034  {
16035  std::size_t seed = 0;
16036  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersFeedbackInfoKHR.sType );
16037  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersFeedbackInfoKHR.pNext );
16038  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersFeedbackInfoKHR.hasStdVPSOverrides );
16039  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersFeedbackInfoKHR.hasStdSPSOverrides );
16040  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersFeedbackInfoKHR.hasStdPPSOverrides );
16041  return seed;
16042  }
16043  };
16044 
16045  template <>
16046  struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersGetInfoKHR>
16047  {
16048  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersGetInfoKHR const & videoEncodeH265SessionParametersGetInfoKHR ) const
16049  VULKAN_HPP_NOEXCEPT
16050  {
16051  std::size_t seed = 0;
16052  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersGetInfoKHR.sType );
16053  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersGetInfoKHR.pNext );
16054  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersGetInfoKHR.writeStdVPS );
16055  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersGetInfoKHR.writeStdSPS );
16056  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersGetInfoKHR.writeStdPPS );
16057  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersGetInfoKHR.stdVPSId );
16058  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersGetInfoKHR.stdSPSId );
16059  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersGetInfoKHR.stdPPSId );
16060  return seed;
16061  }
16062  };
16063 
16064  template <>
16065  struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeInfoKHR>
16066  {
16067  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeInfoKHR const & videoEncodeInfoKHR ) const VULKAN_HPP_NOEXCEPT
16068  {
16069  std::size_t seed = 0;
16070  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.sType );
16071  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.pNext );
16072  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.flags );
16073  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.dstBuffer );
16074  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.dstBufferOffset );
16075  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.dstBufferRange );
16076  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.srcPictureResource );
16077  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.pSetupReferenceSlot );
16078  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.referenceSlotCount );
16079  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.pReferenceSlots );
16080  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.precedingExternallyEncodedBytes );
16081  return seed;
16082  }
16083  };
16084 
16085  template <>
16086  struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelInfoKHR>
16087  {
16088  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelInfoKHR const & videoEncodeQualityLevelInfoKHR ) const VULKAN_HPP_NOEXCEPT
16089  {
16090  std::size_t seed = 0;
16091  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQualityLevelInfoKHR.sType );
16092  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQualityLevelInfoKHR.pNext );
16093  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQualityLevelInfoKHR.qualityLevel );
16094  return seed;
16095  }
16096  };
16097 
16098  template <>
16099  struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelPropertiesKHR>
16100  {
16101  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelPropertiesKHR const & videoEncodeQualityLevelPropertiesKHR ) const VULKAN_HPP_NOEXCEPT
16102  {
16103  std::size_t seed = 0;
16104  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQualityLevelPropertiesKHR.sType );
16105  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQualityLevelPropertiesKHR.pNext );
16106  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQualityLevelPropertiesKHR.preferredRateControlMode );
16107  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQualityLevelPropertiesKHR.preferredRateControlLayerCount );
16108  return seed;
16109  }
16110  };
16111 
16112  template <>
16113  struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeRateControlLayerInfoKHR>
16114  {
16115  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeRateControlLayerInfoKHR const & videoEncodeRateControlLayerInfoKHR ) const VULKAN_HPP_NOEXCEPT
16116  {
16117  std::size_t seed = 0;
16118  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlLayerInfoKHR.sType );
16119  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlLayerInfoKHR.pNext );
16120  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlLayerInfoKHR.averageBitrate );
16121  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlLayerInfoKHR.maxBitrate );
16122  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlLayerInfoKHR.frameRateNumerator );
16123  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlLayerInfoKHR.frameRateDenominator );
16124  return seed;
16125  }
16126  };
16127 
16128  template <>
16129  struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeRateControlInfoKHR>
16130  {
16131  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeRateControlInfoKHR const & videoEncodeRateControlInfoKHR ) const VULKAN_HPP_NOEXCEPT
16132  {
16133  std::size_t seed = 0;
16134  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlInfoKHR.sType );
16135  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlInfoKHR.pNext );
16136  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlInfoKHR.flags );
16137  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlInfoKHR.rateControlMode );
16138  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlInfoKHR.layerCount );
16139  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlInfoKHR.pLayers );
16140  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlInfoKHR.virtualBufferSizeInMs );
16141  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlInfoKHR.initialVirtualBufferSizeInMs );
16142  return seed;
16143  }
16144  };
16145 
16146  template <>
16147  struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersFeedbackInfoKHR>
16148  {
16149  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersFeedbackInfoKHR const & videoEncodeSessionParametersFeedbackInfoKHR ) const
16150  VULKAN_HPP_NOEXCEPT
16151  {
16152  std::size_t seed = 0;
16153  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionParametersFeedbackInfoKHR.sType );
16154  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionParametersFeedbackInfoKHR.pNext );
16155  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionParametersFeedbackInfoKHR.hasOverrides );
16156  return seed;
16157  }
16158  };
16159 
16160  template <>
16161  struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR>
16162  {
16163  std::size_t
16164  operator()( VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR const & videoEncodeSessionParametersGetInfoKHR ) const VULKAN_HPP_NOEXCEPT
16165  {
16166  std::size_t seed = 0;
16167  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionParametersGetInfoKHR.sType );
16168  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionParametersGetInfoKHR.pNext );
16169  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionParametersGetInfoKHR.videoSessionParameters );
16170  return seed;
16171  }
16172  };
16173 
16174  template <>
16175  struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeUsageInfoKHR>
16176  {
16177  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeUsageInfoKHR const & videoEncodeUsageInfoKHR ) const VULKAN_HPP_NOEXCEPT
16178  {
16179  std::size_t seed = 0;
16180  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeUsageInfoKHR.sType );
16181  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeUsageInfoKHR.pNext );
16182  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeUsageInfoKHR.videoUsageHints );
16183  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeUsageInfoKHR.videoContentHints );
16184  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeUsageInfoKHR.tuningMode );
16185  return seed;
16186  }
16187  };
16188 
16189  template <>
16190  struct hash<VULKAN_HPP_NAMESPACE::VideoEndCodingInfoKHR>
16191  {
16192  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEndCodingInfoKHR const & videoEndCodingInfoKHR ) const VULKAN_HPP_NOEXCEPT
16193  {
16194  std::size_t seed = 0;
16195  VULKAN_HPP_HASH_COMBINE( seed, videoEndCodingInfoKHR.sType );
16196  VULKAN_HPP_HASH_COMBINE( seed, videoEndCodingInfoKHR.pNext );
16197  VULKAN_HPP_HASH_COMBINE( seed, videoEndCodingInfoKHR.flags );
16198  return seed;
16199  }
16200  };
16201 
16202  template <>
16203  struct hash<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR>
16204  {
16205  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR const & videoFormatPropertiesKHR ) const VULKAN_HPP_NOEXCEPT
16206  {
16207  std::size_t seed = 0;
16208  VULKAN_HPP_HASH_COMBINE( seed, videoFormatPropertiesKHR.sType );
16209  VULKAN_HPP_HASH_COMBINE( seed, videoFormatPropertiesKHR.pNext );
16210  VULKAN_HPP_HASH_COMBINE( seed, videoFormatPropertiesKHR.format );
16211  VULKAN_HPP_HASH_COMBINE( seed, videoFormatPropertiesKHR.componentMapping );
16212  VULKAN_HPP_HASH_COMBINE( seed, videoFormatPropertiesKHR.imageCreateFlags );
16213  VULKAN_HPP_HASH_COMBINE( seed, videoFormatPropertiesKHR.imageType );
16214  VULKAN_HPP_HASH_COMBINE( seed, videoFormatPropertiesKHR.imageTiling );
16215  VULKAN_HPP_HASH_COMBINE( seed, videoFormatPropertiesKHR.imageUsageFlags );
16216  return seed;
16217  }
16218  };
16219 
16220  template <>
16221  struct hash<VULKAN_HPP_NAMESPACE::VideoInlineQueryInfoKHR>
16222  {
16223  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoInlineQueryInfoKHR const & videoInlineQueryInfoKHR ) const VULKAN_HPP_NOEXCEPT
16224  {
16225  std::size_t seed = 0;
16226  VULKAN_HPP_HASH_COMBINE( seed, videoInlineQueryInfoKHR.sType );
16227  VULKAN_HPP_HASH_COMBINE( seed, videoInlineQueryInfoKHR.pNext );
16228  VULKAN_HPP_HASH_COMBINE( seed, videoInlineQueryInfoKHR.queryPool );
16229  VULKAN_HPP_HASH_COMBINE( seed, videoInlineQueryInfoKHR.firstQuery );
16230  VULKAN_HPP_HASH_COMBINE( seed, videoInlineQueryInfoKHR.queryCount );
16231  return seed;
16232  }
16233  };
16234 
16235  template <>
16236  struct hash<VULKAN_HPP_NAMESPACE::VideoProfileListInfoKHR>
16237  {
16238  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoProfileListInfoKHR const & videoProfileListInfoKHR ) const VULKAN_HPP_NOEXCEPT
16239  {
16240  std::size_t seed = 0;
16241  VULKAN_HPP_HASH_COMBINE( seed, videoProfileListInfoKHR.sType );
16242  VULKAN_HPP_HASH_COMBINE( seed, videoProfileListInfoKHR.pNext );
16243  VULKAN_HPP_HASH_COMBINE( seed, videoProfileListInfoKHR.profileCount );
16244  VULKAN_HPP_HASH_COMBINE( seed, videoProfileListInfoKHR.pProfiles );
16245  return seed;
16246  }
16247  };
16248 
16249  template <>
16250  struct hash<VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR>
16251  {
16252  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR const & videoSessionCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
16253  {
16254  std::size_t seed = 0;
16255  VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.sType );
16256  VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.pNext );
16257  VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.queueFamilyIndex );
16258  VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.flags );
16259  VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.pVideoProfile );
16260  VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.pictureFormat );
16261  VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.maxCodedExtent );
16262  VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.referencePictureFormat );
16263  VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.maxDpbSlots );
16264  VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.maxActiveReferencePictures );
16265  VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.pStdHeaderVersion );
16266  return seed;
16267  }
16268  };
16269 
16270  template <>
16271  struct hash<VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR>
16272  {
16273  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR const & videoSessionMemoryRequirementsKHR ) const VULKAN_HPP_NOEXCEPT
16274  {
16275  std::size_t seed = 0;
16276  VULKAN_HPP_HASH_COMBINE( seed, videoSessionMemoryRequirementsKHR.sType );
16277  VULKAN_HPP_HASH_COMBINE( seed, videoSessionMemoryRequirementsKHR.pNext );
16278  VULKAN_HPP_HASH_COMBINE( seed, videoSessionMemoryRequirementsKHR.memoryBindIndex );
16279  VULKAN_HPP_HASH_COMBINE( seed, videoSessionMemoryRequirementsKHR.memoryRequirements );
16280  return seed;
16281  }
16282  };
16283 
16284  template <>
16285  struct hash<VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR>
16286  {
16287  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR const & videoSessionParametersCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
16288  {
16289  std::size_t seed = 0;
16290  VULKAN_HPP_HASH_COMBINE( seed, videoSessionParametersCreateInfoKHR.sType );
16291  VULKAN_HPP_HASH_COMBINE( seed, videoSessionParametersCreateInfoKHR.pNext );
16292  VULKAN_HPP_HASH_COMBINE( seed, videoSessionParametersCreateInfoKHR.flags );
16293  VULKAN_HPP_HASH_COMBINE( seed, videoSessionParametersCreateInfoKHR.videoSessionParametersTemplate );
16294  VULKAN_HPP_HASH_COMBINE( seed, videoSessionParametersCreateInfoKHR.videoSession );
16295  return seed;
16296  }
16297  };
16298 
16299  template <>
16300  struct hash<VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR>
16301  {
16302  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR const & videoSessionParametersUpdateInfoKHR ) const VULKAN_HPP_NOEXCEPT
16303  {
16304  std::size_t seed = 0;
16305  VULKAN_HPP_HASH_COMBINE( seed, videoSessionParametersUpdateInfoKHR.sType );
16306  VULKAN_HPP_HASH_COMBINE( seed, videoSessionParametersUpdateInfoKHR.pNext );
16307  VULKAN_HPP_HASH_COMBINE( seed, videoSessionParametersUpdateInfoKHR.updateSequenceCount );
16308  return seed;
16309  }
16310  };
16311 
16312 # if defined( VK_USE_PLATFORM_WAYLAND_KHR )
16313  template <>
16314  struct hash<VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR>
16315  {
16316  std::size_t operator()( VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR const & waylandSurfaceCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
16317  {
16318  std::size_t seed = 0;
16319  VULKAN_HPP_HASH_COMBINE( seed, waylandSurfaceCreateInfoKHR.sType );
16320  VULKAN_HPP_HASH_COMBINE( seed, waylandSurfaceCreateInfoKHR.pNext );
16321  VULKAN_HPP_HASH_COMBINE( seed, waylandSurfaceCreateInfoKHR.flags );
16322  VULKAN_HPP_HASH_COMBINE( seed, waylandSurfaceCreateInfoKHR.display );
16323  VULKAN_HPP_HASH_COMBINE( seed, waylandSurfaceCreateInfoKHR.surface );
16324  return seed;
16325  }
16326  };
16327 # endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
16328 
16329 # if defined( VK_USE_PLATFORM_WIN32_KHR )
16330  template <>
16331  struct hash<VULKAN_HPP_NAMESPACE::Win32KeyedMutexAcquireReleaseInfoKHR>
16332  {
16333  std::size_t operator()( VULKAN_HPP_NAMESPACE::Win32KeyedMutexAcquireReleaseInfoKHR const & win32KeyedMutexAcquireReleaseInfoKHR ) const VULKAN_HPP_NOEXCEPT
16334  {
16335  std::size_t seed = 0;
16336  VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoKHR.sType );
16337  VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoKHR.pNext );
16338  VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoKHR.acquireCount );
16339  VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoKHR.pAcquireSyncs );
16340  VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoKHR.pAcquireKeys );
16341  VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoKHR.pAcquireTimeouts );
16342  VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoKHR.releaseCount );
16343  VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoKHR.pReleaseSyncs );
16344  VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoKHR.pReleaseKeys );
16345  return seed;
16346  }
16347  };
16348 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
16349 
16350 # if defined( VK_USE_PLATFORM_WIN32_KHR )
16351  template <>
16352  struct hash<VULKAN_HPP_NAMESPACE::Win32KeyedMutexAcquireReleaseInfoNV>
16353  {
16354  std::size_t operator()( VULKAN_HPP_NAMESPACE::Win32KeyedMutexAcquireReleaseInfoNV const & win32KeyedMutexAcquireReleaseInfoNV ) const VULKAN_HPP_NOEXCEPT
16355  {
16356  std::size_t seed = 0;
16357  VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoNV.sType );
16358  VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoNV.pNext );
16359  VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoNV.acquireCount );
16360  VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoNV.pAcquireSyncs );
16361  VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoNV.pAcquireKeys );
16362  VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoNV.pAcquireTimeoutMilliseconds );
16363  VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoNV.releaseCount );
16364  VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoNV.pReleaseSyncs );
16365  VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoNV.pReleaseKeys );
16366  return seed;
16367  }
16368  };
16369 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
16370 
16371 # if defined( VK_USE_PLATFORM_WIN32_KHR )
16372  template <>
16373  struct hash<VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR>
16374  {
16375  std::size_t operator()( VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR const & win32SurfaceCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
16376  {
16377  std::size_t seed = 0;
16378  VULKAN_HPP_HASH_COMBINE( seed, win32SurfaceCreateInfoKHR.sType );
16379  VULKAN_HPP_HASH_COMBINE( seed, win32SurfaceCreateInfoKHR.pNext );
16380  VULKAN_HPP_HASH_COMBINE( seed, win32SurfaceCreateInfoKHR.flags );
16381  VULKAN_HPP_HASH_COMBINE( seed, win32SurfaceCreateInfoKHR.hinstance );
16382  VULKAN_HPP_HASH_COMBINE( seed, win32SurfaceCreateInfoKHR.hwnd );
16383  return seed;
16384  }
16385  };
16386 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
16387 
16388  template <>
16389  struct hash<VULKAN_HPP_NAMESPACE::WriteDescriptorSetAccelerationStructureKHR>
16390  {
16391  std::size_t operator()( VULKAN_HPP_NAMESPACE::WriteDescriptorSetAccelerationStructureKHR const & writeDescriptorSetAccelerationStructureKHR ) const
16392  VULKAN_HPP_NOEXCEPT
16393  {
16394  std::size_t seed = 0;
16395  VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetAccelerationStructureKHR.sType );
16396  VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetAccelerationStructureKHR.pNext );
16397  VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetAccelerationStructureKHR.accelerationStructureCount );
16398  VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetAccelerationStructureKHR.pAccelerationStructures );
16399  return seed;
16400  }
16401  };
16402 
16403  template <>
16404  struct hash<VULKAN_HPP_NAMESPACE::WriteDescriptorSetAccelerationStructureNV>
16405  {
16406  std::size_t
16407  operator()( VULKAN_HPP_NAMESPACE::WriteDescriptorSetAccelerationStructureNV const & writeDescriptorSetAccelerationStructureNV ) const VULKAN_HPP_NOEXCEPT
16408  {
16409  std::size_t seed = 0;
16410  VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetAccelerationStructureNV.sType );
16411  VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetAccelerationStructureNV.pNext );
16412  VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetAccelerationStructureNV.accelerationStructureCount );
16413  VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetAccelerationStructureNV.pAccelerationStructures );
16414  return seed;
16415  }
16416  };
16417 
16418  template <>
16419  struct hash<VULKAN_HPP_NAMESPACE::WriteDescriptorSetInlineUniformBlock>
16420  {
16421  std::size_t operator()( VULKAN_HPP_NAMESPACE::WriteDescriptorSetInlineUniformBlock const & writeDescriptorSetInlineUniformBlock ) const VULKAN_HPP_NOEXCEPT
16422  {
16423  std::size_t seed = 0;
16424  VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetInlineUniformBlock.sType );
16425  VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetInlineUniformBlock.pNext );
16426  VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetInlineUniformBlock.dataSize );
16427  VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetInlineUniformBlock.pData );
16428  return seed;
16429  }
16430  };
16431 
16432 # if defined( VK_USE_PLATFORM_XCB_KHR )
16433  template <>
16434  struct hash<VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR>
16435  {
16436  std::size_t operator()( VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR const & xcbSurfaceCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
16437  {
16438  std::size_t seed = 0;
16439  VULKAN_HPP_HASH_COMBINE( seed, xcbSurfaceCreateInfoKHR.sType );
16440  VULKAN_HPP_HASH_COMBINE( seed, xcbSurfaceCreateInfoKHR.pNext );
16441  VULKAN_HPP_HASH_COMBINE( seed, xcbSurfaceCreateInfoKHR.flags );
16442  VULKAN_HPP_HASH_COMBINE( seed, xcbSurfaceCreateInfoKHR.connection );
16443  VULKAN_HPP_HASH_COMBINE( seed, xcbSurfaceCreateInfoKHR.window );
16444  return seed;
16445  }
16446  };
16447 # endif /*VK_USE_PLATFORM_XCB_KHR*/
16448 
16449 # if defined( VK_USE_PLATFORM_XLIB_KHR )
16450  template <>
16451  struct hash<VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR>
16452  {
16453  std::size_t operator()( VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR const & xlibSurfaceCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
16454  {
16455  std::size_t seed = 0;
16456  VULKAN_HPP_HASH_COMBINE( seed, xlibSurfaceCreateInfoKHR.sType );
16457  VULKAN_HPP_HASH_COMBINE( seed, xlibSurfaceCreateInfoKHR.pNext );
16458  VULKAN_HPP_HASH_COMBINE( seed, xlibSurfaceCreateInfoKHR.flags );
16459  VULKAN_HPP_HASH_COMBINE( seed, xlibSurfaceCreateInfoKHR.dpy );
16460  VULKAN_HPP_HASH_COMBINE( seed, xlibSurfaceCreateInfoKHR.window );
16461  return seed;
16462  }
16463  };
16464 # endif /*VK_USE_PLATFORM_XLIB_KHR*/
16465 
16466 #endif // 14 <= VULKAN_HPP_CPP_VERSION
16467 
16468 } // namespace std
16469 #endif
std
Definition: vulkan.hpp:854
std::hash< vk::AccelerationStructureKHR >::operator()
std::size_t operator()(vk::AccelerationStructureKHR const &accelerationStructureKHR) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:399
std::hash< vk::AccelerationStructureNV >::operator()
std::size_t operator()(vk::AccelerationStructureNV const &accelerationStructureNV) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:421
std::hash< vk::BufferView >::operator()
std::size_t operator()(vk::BufferView const &bufferView) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:127
std::hash< vk::Buffer >::operator()
std::size_t operator()(vk::Buffer const &buffer) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:118
std::hash< vk::CommandBuffer >::operator()
std::size_t operator()(vk::CommandBuffer const &commandBuffer) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:253
std::hash< vk::CommandPool >::operator()
std::size_t operator()(vk::CommandPool const &commandPool) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:244
std::hash< vk::CuFunctionNVX >::operator()
std::size_t operator()(vk::CuFunctionNVX const &cuFunctionNVX) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:377
std::hash< vk::CuModuleNVX >::operator()
std::size_t operator()(vk::CuModuleNVX const &cuModuleNVX) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:368
std::hash< vk::CudaFunctionNV >::operator()
std::size_t operator()(vk::CudaFunctionNV const &cudaFunctionNV) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:475
std::hash< vk::CudaModuleNV >::operator()
std::size_t operator()(vk::CudaModuleNV const &cudaModuleNV) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:466
std::hash< vk::DebugReportCallbackEXT >::operator()
std::size_t operator()(vk::DebugReportCallbackEXT const &debugReportCallbackEXT) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:337
std::hash< vk::DebugUtilsMessengerEXT >::operator()
std::size_t operator()(vk::DebugUtilsMessengerEXT const &debugUtilsMessengerEXT) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:388
std::hash< vk::DeferredOperationKHR >::operator()
std::size_t operator()(vk::DeferredOperationKHR const &deferredOperationKHR) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:443
std::hash< vk::DescriptorPool >::operator()
std::size_t operator()(vk::DescriptorPool const &descriptorPool) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:199
std::hash< vk::DescriptorSetLayout >::operator()
std::size_t operator()(vk::DescriptorSetLayout const &descriptorSetLayout) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:217
std::hash< vk::DescriptorSet >::operator()
std::size_t operator()(vk::DescriptorSet const &descriptorSet) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:208
std::hash< vk::DescriptorUpdateTemplate >::operator()
std::size_t operator()(vk::DescriptorUpdateTemplate const &descriptorUpdateTemplate) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:273
std::hash< vk::DeviceMemory >::operator()
std::size_t operator()(vk::DeviceMemory const &deviceMemory) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:73
std::hash< vk::Device >::operator()
std::size_t operator()(vk::Device const &device) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:55
std::hash< vk::DisplayKHR >::operator()
std::size_t operator()(vk::DisplayKHR const &displayKHR) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:317
std::hash< vk::DisplayModeKHR >::operator()
std::size_t operator()(vk::DisplayModeKHR const &displayModeKHR) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:326
std::hash< vk::Event >::operator()
std::size_t operator()(vk::Event const &event) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:100
std::hash< vk::Fence >::operator()
std::size_t operator()(vk::Fence const &fence) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:82
std::hash< vk::Flags< BitType > >::operator()
std::size_t operator()(vk::Flags< BitType > const &flags) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:22
std::hash< vk::Framebuffer >::operator()
std::size_t operator()(vk::Framebuffer const &framebuffer) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:226
std::hash< vk::ImageView >::operator()
std::size_t operator()(vk::ImageView const &imageView) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:145
std::hash< vk::Image >::operator()
std::size_t operator()(vk::Image const &image) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:136
std::hash< vk::IndirectCommandsLayoutNV >::operator()
std::size_t operator()(vk::IndirectCommandsLayoutNV const &indirectCommandsLayoutNV) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:454
std::hash< vk::Instance >::operator()
std::size_t operator()(vk::Instance const &instance) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:37
std::hash< vk::MicromapEXT >::operator()
std::size_t operator()(vk::MicromapEXT const &micromapEXT) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:500
std::hash< vk::OpticalFlowSessionNV >::operator()
std::size_t operator()(vk::OpticalFlowSessionNV const &opticalFlowSessionNV) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:511
std::hash< vk::PerformanceConfigurationINTEL >::operator()
std::size_t operator()(vk::PerformanceConfigurationINTEL const &performanceConfigurationINTEL) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:432
std::hash< vk::PhysicalDevice >::operator()
std::size_t operator()(vk::PhysicalDevice const &physicalDevice) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:46
std::hash< vk::PipelineCache >::operator()
std::size_t operator()(vk::PipelineCache const &pipelineCache) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:163
std::hash< vk::PipelineLayout >::operator()
std::size_t operator()(vk::PipelineLayout const &pipelineLayout) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:181
std::hash< vk::Pipeline >::operator()
std::size_t operator()(vk::Pipeline const &pipeline) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:172
std::hash< vk::PrivateDataSlot >::operator()
std::size_t operator()(vk::PrivateDataSlot const &privateDataSlot) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:284
std::hash< vk::QueryPool >::operator()
std::size_t operator()(vk::QueryPool const &queryPool) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:109
std::hash< vk::Queue >::operator()
std::size_t operator()(vk::Queue const &queue) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:64
std::hash< vk::RenderPass >::operator()
std::size_t operator()(vk::RenderPass const &renderPass) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:235
std::hash< vk::SamplerYcbcrConversion >::operator()
std::size_t operator()(vk::SamplerYcbcrConversion const &samplerYcbcrConversion) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:264
std::hash< vk::Sampler >::operator()
std::size_t operator()(vk::Sampler const &sampler) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:190
std::hash< vk::Semaphore >::operator()
std::size_t operator()(vk::Semaphore const &semaphore) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:91
std::hash< vk::ShaderEXT >::operator()
std::size_t operator()(vk::ShaderEXT const &shaderEXT) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:522
std::hash< vk::ShaderModule >::operator()
std::size_t operator()(vk::ShaderModule const &shaderModule) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:154
std::hash< vk::SurfaceKHR >::operator()
std::size_t operator()(vk::SurfaceKHR const &surfaceKHR) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:295
std::hash< vk::SwapchainKHR >::operator()
std::size_t operator()(vk::SwapchainKHR const &swapchainKHR) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:306
std::hash< vk::ValidationCacheEXT >::operator()
std::size_t operator()(vk::ValidationCacheEXT const &validationCacheEXT) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:410
std::hash< vk::VideoSessionKHR >::operator()
std::size_t operator()(vk::VideoSessionKHR const &videoSessionKHR) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:348
std::hash< vk::VideoSessionParametersKHR >::operator()
std::size_t operator()(vk::VideoSessionParametersKHR const &videoSessionParametersKHR) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:357
VK_LUID_SIZE
#define VK_LUID_SIZE
Definition: vulkan_core.h:4859
VkVideoSessionParametersKHR
uint64_t VkVideoSessionParametersKHR
Definition: vulkan_core.h:7946
VkImage
uint64_t VkImage
Definition: vulkan_core.h:100
VK_MAX_DRIVER_INFO_SIZE
#define VK_MAX_DRIVER_INFO_SIZE
Definition: vulkan_core.h:5724
VK_MAX_MEMORY_HEAPS
#define VK_MAX_MEMORY_HEAPS
Definition: vulkan_core.h:138
VkSurfaceKHR
uint64_t VkSurfaceKHR
Definition: vulkan_core.h:7513
VkShaderModule
uint64_t VkShaderModule
Definition: vulkan_core.h:113
VkQueryPool
uint64_t VkQueryPool
Definition: vulkan_core.h:110
VK_MAX_EXTENSION_NAME_SIZE
#define VK_MAX_EXTENSION_NAME_SIZE
Definition: vulkan_core.h:136
VkMicromapEXT
uint64_t VkMicromapEXT
Definition: vulkan_core.h:16913
VK_MAX_MEMORY_TYPES
#define VK_MAX_MEMORY_TYPES
Definition: vulkan_core.h:133
VkIndirectCommandsLayoutNV
uint64_t VkIndirectCommandsLayoutNV
Definition: vulkan_core.h:15109
VkSampler
uint64_t VkSampler
Definition: vulkan_core.h:119
VkRenderPass
uint64_t VkRenderPass
Definition: vulkan_core.h:117
VkCommandPool
uint64_t VkCommandPool
Definition: vulkan_core.h:123
VkPipelineCache
uint64_t VkPipelineCache
Definition: vulkan_core.h:114
VkEvent
uint64_t VkEvent
Definition: vulkan_core.h:109
VkBuffer
uint64_t VkBuffer
Definition: vulkan_core.h:99
VkCuModuleNVX
uint64_t VkCuModuleNVX
Definition: vulkan_core.h:11781
VkPhysicalDevice
struct VkPhysicalDevice_T * VkPhysicalDevice
Definition: vulkan_core.h:102
VkFramebuffer
uint64_t VkFramebuffer
Definition: vulkan_core.h:122
VK_MAX_DESCRIPTION_SIZE
#define VK_MAX_DESCRIPTION_SIZE
Definition: vulkan_core.h:137
VK_MAX_PHYSICAL_DEVICE_NAME_SIZE
#define VK_MAX_PHYSICAL_DEVICE_NAME_SIZE
Definition: vulkan_core.h:134
VkBufferView
uint64_t VkBufferView
Definition: vulkan_core.h:111
VkCudaModuleNV
uint64_t VkCudaModuleNV
Definition: vulkan_core.h:15632
VkQueue
struct VkQueue_T * VkQueue
Definition: vulkan_core.h:104
VkDisplayKHR
uint64_t VkDisplayKHR
Definition: vulkan_core.h:7789
VkDisplayModeKHR
uint64_t VkDisplayModeKHR
Definition: vulkan_core.h:7790
VkInstance
struct VkInstance_T * VkInstance
Definition: vulkan_core.h:101
VkDevice
struct VkDevice_T * VkDevice
Definition: vulkan_core.h:103
VkDeferredOperationKHR
uint64_t VkDeferredOperationKHR
Definition: vulkan_core.h:10293
VK_MAX_DRIVER_NAME_SIZE
#define VK_MAX_DRIVER_NAME_SIZE
Definition: vulkan_core.h:5723
VkOpticalFlowSessionNV
uint64_t VkOpticalFlowSessionNV
Definition: vulkan_core.h:18087
VkFence
uint64_t VkFence
Definition: vulkan_core.h:107
VkDescriptorSet
uint64_t VkDescriptorSet
Definition: vulkan_core.h:120
VK_UUID_SIZE
#define VK_UUID_SIZE
Definition: vulkan_core.h:135
VkDescriptorPool
uint64_t VkDescriptorPool
Definition: vulkan_core.h:121
VkAccelerationStructureNV
uint64_t VkAccelerationStructureNV
Definition: vulkan_core.h:13282
VkSwapchainKHR
uint64_t VkSwapchainKHR
Definition: vulkan_core.h:7628
VkPipelineLayout
uint64_t VkPipelineLayout
Definition: vulkan_core.h:115
VkShaderEXT
uint64_t VkShaderEXT
Definition: vulkan_core.h:18276
VkDescriptorUpdateTemplate
uint64_t VkDescriptorUpdateTemplate
Definition: vulkan_core.h:4857
VkDescriptorSetLayout
uint64_t VkDescriptorSetLayout
Definition: vulkan_core.h:118
VkAccelerationStructureKHR
uint64_t VkAccelerationStructureKHR
Definition: vulkan_core.h:15736
VK_MAX_GLOBAL_PRIORITY_SIZE_KHR
#define VK_MAX_GLOBAL_PRIORITY_SIZE_KHR
Definition: vulkan_core.h:9980
VkCudaFunctionNV
uint64_t VkCudaFunctionNV
Definition: vulkan_core.h:15633
VkSamplerYcbcrConversion
uint64_t VkSamplerYcbcrConversion
Definition: vulkan_core.h:4856
VK_MAX_DEVICE_GROUP_SIZE
#define VK_MAX_DEVICE_GROUP_SIZE
Definition: vulkan_core.h:4858
VkPipeline
uint64_t VkPipeline
Definition: vulkan_core.h:116
VkDebugUtilsMessengerEXT
uint64_t VkDebugUtilsMessengerEXT
Definition: vulkan_core.h:12652
VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT
#define VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT
Definition: vulkan_core.h:18034
VkCommandBuffer
struct VkCommandBuffer_T * VkCommandBuffer
Definition: vulkan_core.h:106
VkDebugReportCallbackEXT
uint64_t VkDebugReportCallbackEXT
Definition: vulkan_core.h:11447
VkSemaphore
uint64_t VkSemaphore
Definition: vulkan_core.h:105
VkCuFunctionNVX
uint64_t VkCuFunctionNVX
Definition: vulkan_core.h:11782
VkPrivateDataSlot
uint64_t VkPrivateDataSlot
Definition: vulkan_core.h:6482
VkPerformanceConfigurationINTEL
uint64_t VkPerformanceConfigurationINTEL
Definition: vulkan_core.h:14063
VkImageView
uint64_t VkImageView
Definition: vulkan_core.h:112
VkDeviceMemory
uint64_t VkDeviceMemory
Definition: vulkan_core.h:108
VkValidationCacheEXT
uint64_t VkValidationCacheEXT
Definition: vulkan_core.h:13099
VkVideoSessionKHR
uint64_t VkVideoSessionKHR
Definition: vulkan_core.h:7945
VULKAN_HPP_NOEXCEPT
#define VULKAN_HPP_NOEXCEPT
Definition: vulkan_hpp_macros.hpp:171