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
13namespace 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
16470