HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
vulkan_hash.hpp
Go to the documentation of this file.
1 // Copyright 2015-2022 The Khronos Group Inc.
2 //
3 // SPDX-License-Identifier: Apache-2.0 OR MIT
4 //
5 
6 // This header is generated from the Khronos Vulkan XML API Registry.
7 
8 #ifndef VULKAN_HASH_HPP
9 #define VULKAN_HASH_HPP
10 
11 #include <vulkan/vulkan.hpp>
12 
13 namespace std
14 {
15  //=======================================
16  //=== HASH structures for Flags types ===
17  //=======================================
18 
19  template <typename BitType>
20  struct hash<VULKAN_HPP_NAMESPACE::Flags<BitType>>
21  {
22  std::size_t operator()( VULKAN_HPP_NAMESPACE::Flags<BitType> const & flags ) const VULKAN_HPP_NOEXCEPT
23  {
24  return std::hash<typename std::underlying_type<BitType>::type>{}( static_cast<typename std::underlying_type<BitType>::type>( flags ) );
25  }
26  };
27 
28  //===================================
29  //=== HASH structures for handles ===
30  //===================================
31 
32  //=== VK_VERSION_1_0 ===
33 
34  template <>
35  struct hash<VULKAN_HPP_NAMESPACE::Instance>
36  {
37  std::size_t operator()( VULKAN_HPP_NAMESPACE::Instance const & instance ) const VULKAN_HPP_NOEXCEPT
38  {
39  return std::hash<VkInstance>{}( static_cast<VkInstance>( instance ) );
40  }
41  };
42 
43  template <>
44  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevice>
45  {
46  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevice const & physicalDevice ) const VULKAN_HPP_NOEXCEPT
47  {
48  return std::hash<VkPhysicalDevice>{}( static_cast<VkPhysicalDevice>( physicalDevice ) );
49  }
50  };
51 
52  template <>
53  struct hash<VULKAN_HPP_NAMESPACE::Device>
54  {
55  std::size_t operator()( VULKAN_HPP_NAMESPACE::Device const & device ) const VULKAN_HPP_NOEXCEPT
56  {
57  return std::hash<VkDevice>{}( static_cast<VkDevice>( device ) );
58  }
59  };
60 
61  template <>
62  struct hash<VULKAN_HPP_NAMESPACE::Queue>
63  {
64  std::size_t operator()( VULKAN_HPP_NAMESPACE::Queue const & queue ) const VULKAN_HPP_NOEXCEPT
65  {
66  return std::hash<VkQueue>{}( static_cast<VkQueue>( queue ) );
67  }
68  };
69 
70  template <>
71  struct hash<VULKAN_HPP_NAMESPACE::DeviceMemory>
72  {
73  std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceMemory const & deviceMemory ) const VULKAN_HPP_NOEXCEPT
74  {
75  return std::hash<VkDeviceMemory>{}( static_cast<VkDeviceMemory>( deviceMemory ) );
76  }
77  };
78 
79  template <>
80  struct hash<VULKAN_HPP_NAMESPACE::Fence>
81  {
82  std::size_t operator()( VULKAN_HPP_NAMESPACE::Fence const & fence ) const VULKAN_HPP_NOEXCEPT
83  {
84  return std::hash<VkFence>{}( static_cast<VkFence>( fence ) );
85  }
86  };
87 
88  template <>
89  struct hash<VULKAN_HPP_NAMESPACE::Semaphore>
90  {
91  std::size_t operator()( VULKAN_HPP_NAMESPACE::Semaphore const & semaphore ) const VULKAN_HPP_NOEXCEPT
92  {
93  return std::hash<VkSemaphore>{}( static_cast<VkSemaphore>( semaphore ) );
94  }
95  };
96 
97  template <>
98  struct hash<VULKAN_HPP_NAMESPACE::Event>
99  {
100  std::size_t operator()( VULKAN_HPP_NAMESPACE::Event const & event ) const VULKAN_HPP_NOEXCEPT
101  {
102  return std::hash<VkEvent>{}( static_cast<VkEvent>( event ) );
103  }
104  };
105 
106  template <>
107  struct hash<VULKAN_HPP_NAMESPACE::QueryPool>
108  {
109  std::size_t operator()( VULKAN_HPP_NAMESPACE::QueryPool const & queryPool ) const VULKAN_HPP_NOEXCEPT
110  {
111  return std::hash<VkQueryPool>{}( static_cast<VkQueryPool>( queryPool ) );
112  }
113  };
114 
115  template <>
116  struct hash<VULKAN_HPP_NAMESPACE::Buffer>
117  {
118  std::size_t operator()( VULKAN_HPP_NAMESPACE::Buffer const & buffer ) const VULKAN_HPP_NOEXCEPT
119  {
120  return std::hash<VkBuffer>{}( static_cast<VkBuffer>( buffer ) );
121  }
122  };
123 
124  template <>
125  struct hash<VULKAN_HPP_NAMESPACE::BufferView>
126  {
127  std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferView const & bufferView ) const VULKAN_HPP_NOEXCEPT
128  {
129  return std::hash<VkBufferView>{}( static_cast<VkBufferView>( bufferView ) );
130  }
131  };
132 
133  template <>
134  struct hash<VULKAN_HPP_NAMESPACE::Image>
135  {
136  std::size_t operator()( VULKAN_HPP_NAMESPACE::Image const & image ) const VULKAN_HPP_NOEXCEPT
137  {
138  return std::hash<VkImage>{}( static_cast<VkImage>( image ) );
139  }
140  };
141 
142  template <>
143  struct hash<VULKAN_HPP_NAMESPACE::ImageView>
144  {
145  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageView const & imageView ) const VULKAN_HPP_NOEXCEPT
146  {
147  return std::hash<VkImageView>{}( static_cast<VkImageView>( imageView ) );
148  }
149  };
150 
151  template <>
152  struct hash<VULKAN_HPP_NAMESPACE::ShaderModule>
153  {
154  std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderModule const & shaderModule ) const VULKAN_HPP_NOEXCEPT
155  {
156  return std::hash<VkShaderModule>{}( static_cast<VkShaderModule>( shaderModule ) );
157  }
158  };
159 
160  template <>
161  struct hash<VULKAN_HPP_NAMESPACE::PipelineCache>
162  {
163  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCache const & pipelineCache ) const VULKAN_HPP_NOEXCEPT
164  {
165  return std::hash<VkPipelineCache>{}( static_cast<VkPipelineCache>( pipelineCache ) );
166  }
167  };
168 
169  template <>
170  struct hash<VULKAN_HPP_NAMESPACE::Pipeline>
171  {
172  std::size_t operator()( VULKAN_HPP_NAMESPACE::Pipeline const & pipeline ) const VULKAN_HPP_NOEXCEPT
173  {
174  return std::hash<VkPipeline>{}( static_cast<VkPipeline>( pipeline ) );
175  }
176  };
177 
178  template <>
179  struct hash<VULKAN_HPP_NAMESPACE::PipelineLayout>
180  {
181  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineLayout const & pipelineLayout ) const VULKAN_HPP_NOEXCEPT
182  {
183  return std::hash<VkPipelineLayout>{}( static_cast<VkPipelineLayout>( pipelineLayout ) );
184  }
185  };
186 
187  template <>
188  struct hash<VULKAN_HPP_NAMESPACE::Sampler>
189  {
190  std::size_t operator()( VULKAN_HPP_NAMESPACE::Sampler const & sampler ) const VULKAN_HPP_NOEXCEPT
191  {
192  return std::hash<VkSampler>{}( static_cast<VkSampler>( sampler ) );
193  }
194  };
195 
196  template <>
197  struct hash<VULKAN_HPP_NAMESPACE::DescriptorPool>
198  {
199  std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorPool const & descriptorPool ) const VULKAN_HPP_NOEXCEPT
200  {
201  return std::hash<VkDescriptorPool>{}( static_cast<VkDescriptorPool>( descriptorPool ) );
202  }
203  };
204 
205  template <>
206  struct hash<VULKAN_HPP_NAMESPACE::DescriptorSet>
207  {
208  std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSet const & descriptorSet ) const VULKAN_HPP_NOEXCEPT
209  {
210  return std::hash<VkDescriptorSet>{}( static_cast<VkDescriptorSet>( descriptorSet ) );
211  }
212  };
213 
214  template <>
215  struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetLayout>
216  {
217  std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetLayout const & descriptorSetLayout ) const VULKAN_HPP_NOEXCEPT
218  {
219  return std::hash<VkDescriptorSetLayout>{}( static_cast<VkDescriptorSetLayout>( descriptorSetLayout ) );
220  }
221  };
222 
223  template <>
224  struct hash<VULKAN_HPP_NAMESPACE::Framebuffer>
225  {
226  std::size_t operator()( VULKAN_HPP_NAMESPACE::Framebuffer const & framebuffer ) const VULKAN_HPP_NOEXCEPT
227  {
228  return std::hash<VkFramebuffer>{}( static_cast<VkFramebuffer>( framebuffer ) );
229  }
230  };
231 
232  template <>
233  struct hash<VULKAN_HPP_NAMESPACE::RenderPass>
234  {
235  std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPass const & renderPass ) const VULKAN_HPP_NOEXCEPT
236  {
237  return std::hash<VkRenderPass>{}( static_cast<VkRenderPass>( renderPass ) );
238  }
239  };
240 
241  template <>
242  struct hash<VULKAN_HPP_NAMESPACE::CommandPool>
243  {
244  std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandPool const & commandPool ) const VULKAN_HPP_NOEXCEPT
245  {
246  return std::hash<VkCommandPool>{}( static_cast<VkCommandPool>( commandPool ) );
247  }
248  };
249 
250  template <>
251  struct hash<VULKAN_HPP_NAMESPACE::CommandBuffer>
252  {
253  std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBuffer const & commandBuffer ) const VULKAN_HPP_NOEXCEPT
254  {
255  return std::hash<VkCommandBuffer>{}( static_cast<VkCommandBuffer>( commandBuffer ) );
256  }
257  };
258 
259  //=== VK_VERSION_1_1 ===
260 
261  template <>
262  struct hash<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion>
263  {
264  std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion const & samplerYcbcrConversion ) const VULKAN_HPP_NOEXCEPT
265  {
266  return std::hash<VkSamplerYcbcrConversion>{}( static_cast<VkSamplerYcbcrConversion>( samplerYcbcrConversion ) );
267  }
268  };
269 
270  template <>
271  struct hash<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate>
272  {
273  std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate const & descriptorUpdateTemplate ) const VULKAN_HPP_NOEXCEPT
274  {
275  return std::hash<VkDescriptorUpdateTemplate>{}( static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ) );
276  }
277  };
278 
279  //=== VK_VERSION_1_3 ===
280 
281  template <>
282  struct hash<VULKAN_HPP_NAMESPACE::PrivateDataSlot>
283  {
284  std::size_t operator()( VULKAN_HPP_NAMESPACE::PrivateDataSlot const & privateDataSlot ) const VULKAN_HPP_NOEXCEPT
285  {
286  return std::hash<VkPrivateDataSlot>{}( static_cast<VkPrivateDataSlot>( privateDataSlot ) );
287  }
288  };
289 
290  //=== VK_KHR_surface ===
291 
292  template <>
293  struct hash<VULKAN_HPP_NAMESPACE::SurfaceKHR>
294  {
295  std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceKHR const & surfaceKHR ) const VULKAN_HPP_NOEXCEPT
296  {
297  return std::hash<VkSurfaceKHR>{}( static_cast<VkSurfaceKHR>( surfaceKHR ) );
298  }
299  };
300 
301  //=== VK_KHR_swapchain ===
302 
303  template <>
304  struct hash<VULKAN_HPP_NAMESPACE::SwapchainKHR>
305  {
306  std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainKHR const & swapchainKHR ) const VULKAN_HPP_NOEXCEPT
307  {
308  return std::hash<VkSwapchainKHR>{}( static_cast<VkSwapchainKHR>( swapchainKHR ) );
309  }
310  };
311 
312  //=== VK_KHR_display ===
313 
314  template <>
315  struct hash<VULKAN_HPP_NAMESPACE::DisplayKHR>
316  {
317  std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayKHR const & displayKHR ) const VULKAN_HPP_NOEXCEPT
318  {
319  return std::hash<VkDisplayKHR>{}( static_cast<VkDisplayKHR>( displayKHR ) );
320  }
321  };
322 
323  template <>
324  struct hash<VULKAN_HPP_NAMESPACE::DisplayModeKHR>
325  {
326  std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayModeKHR const & displayModeKHR ) const VULKAN_HPP_NOEXCEPT
327  {
328  return std::hash<VkDisplayModeKHR>{}( static_cast<VkDisplayModeKHR>( displayModeKHR ) );
329  }
330  };
331 
332  //=== VK_EXT_debug_report ===
333 
334  template <>
335  struct hash<VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT>
336  {
337  std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT const & debugReportCallbackEXT ) const VULKAN_HPP_NOEXCEPT
338  {
339  return std::hash<VkDebugReportCallbackEXT>{}( static_cast<VkDebugReportCallbackEXT>( debugReportCallbackEXT ) );
340  }
341  };
342 
343 #if defined( VK_ENABLE_BETA_EXTENSIONS )
344  //=== VK_KHR_video_queue ===
345 
346  template <>
347  struct hash<VULKAN_HPP_NAMESPACE::VideoSessionKHR>
348  {
349  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoSessionKHR const & videoSessionKHR ) const VULKAN_HPP_NOEXCEPT
350  {
351  return std::hash<VkVideoSessionKHR>{}( static_cast<VkVideoSessionKHR>( videoSessionKHR ) );
352  }
353  };
354 
355  template <>
356  struct hash<VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR>
357  {
358  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR const & videoSessionParametersKHR ) const VULKAN_HPP_NOEXCEPT
359  {
360  return std::hash<VkVideoSessionParametersKHR>{}( static_cast<VkVideoSessionParametersKHR>( videoSessionParametersKHR ) );
361  }
362  };
363 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
364 
365  //=== VK_NVX_binary_import ===
366 
367  template <>
368  struct hash<VULKAN_HPP_NAMESPACE::CuModuleNVX>
369  {
370  std::size_t operator()( VULKAN_HPP_NAMESPACE::CuModuleNVX const & cuModuleNVX ) const VULKAN_HPP_NOEXCEPT
371  {
372  return std::hash<VkCuModuleNVX>{}( static_cast<VkCuModuleNVX>( cuModuleNVX ) );
373  }
374  };
375 
376  template <>
377  struct hash<VULKAN_HPP_NAMESPACE::CuFunctionNVX>
378  {
379  std::size_t operator()( VULKAN_HPP_NAMESPACE::CuFunctionNVX const & cuFunctionNVX ) const VULKAN_HPP_NOEXCEPT
380  {
381  return std::hash<VkCuFunctionNVX>{}( static_cast<VkCuFunctionNVX>( cuFunctionNVX ) );
382  }
383  };
384 
385  //=== VK_EXT_debug_utils ===
386 
387  template <>
388  struct hash<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT>
389  {
390  std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT const & debugUtilsMessengerEXT ) const VULKAN_HPP_NOEXCEPT
391  {
392  return std::hash<VkDebugUtilsMessengerEXT>{}( static_cast<VkDebugUtilsMessengerEXT>( debugUtilsMessengerEXT ) );
393  }
394  };
395 
396  //=== VK_KHR_acceleration_structure ===
397 
398  template <>
399  struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureKHR>
400  {
401  std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR const & accelerationStructureKHR ) const VULKAN_HPP_NOEXCEPT
402  {
403  return std::hash<VkAccelerationStructureKHR>{}( static_cast<VkAccelerationStructureKHR>( accelerationStructureKHR ) );
404  }
405  };
406 
407  //=== VK_EXT_validation_cache ===
408 
409  template <>
410  struct hash<VULKAN_HPP_NAMESPACE::ValidationCacheEXT>
411  {
412  std::size_t operator()( VULKAN_HPP_NAMESPACE::ValidationCacheEXT const & validationCacheEXT ) const VULKAN_HPP_NOEXCEPT
413  {
414  return std::hash<VkValidationCacheEXT>{}( static_cast<VkValidationCacheEXT>( validationCacheEXT ) );
415  }
416  };
417 
418  //=== VK_NV_ray_tracing ===
419 
420  template <>
421  struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureNV>
422  {
423  std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureNV const & accelerationStructureNV ) const VULKAN_HPP_NOEXCEPT
424  {
425  return std::hash<VkAccelerationStructureNV>{}( static_cast<VkAccelerationStructureNV>( accelerationStructureNV ) );
426  }
427  };
428 
429  //=== VK_INTEL_performance_query ===
430 
431  template <>
432  struct hash<VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL>
433  {
434  std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL const & performanceConfigurationINTEL ) const VULKAN_HPP_NOEXCEPT
435  {
436  return std::hash<VkPerformanceConfigurationINTEL>{}( static_cast<VkPerformanceConfigurationINTEL>( performanceConfigurationINTEL ) );
437  }
438  };
439 
440  //=== VK_KHR_deferred_host_operations ===
441 
442  template <>
443  struct hash<VULKAN_HPP_NAMESPACE::DeferredOperationKHR>
444  {
445  std::size_t operator()( VULKAN_HPP_NAMESPACE::DeferredOperationKHR const & deferredOperationKHR ) const VULKAN_HPP_NOEXCEPT
446  {
447  return std::hash<VkDeferredOperationKHR>{}( static_cast<VkDeferredOperationKHR>( deferredOperationKHR ) );
448  }
449  };
450 
451  //=== VK_NV_device_generated_commands ===
452 
453  template <>
454  struct hash<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV>
455  {
456  std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV const & indirectCommandsLayoutNV ) const VULKAN_HPP_NOEXCEPT
457  {
458  return std::hash<VkIndirectCommandsLayoutNV>{}( static_cast<VkIndirectCommandsLayoutNV>( indirectCommandsLayoutNV ) );
459  }
460  };
461 
462 #if defined( VK_USE_PLATFORM_FUCHSIA )
463  //=== VK_FUCHSIA_buffer_collection ===
464 
465  template <>
466  struct hash<VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA>
467  {
468  std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA const & bufferCollectionFUCHSIA ) const VULKAN_HPP_NOEXCEPT
469  {
470  return std::hash<VkBufferCollectionFUCHSIA>{}( static_cast<VkBufferCollectionFUCHSIA>( bufferCollectionFUCHSIA ) );
471  }
472  };
473 #endif /*VK_USE_PLATFORM_FUCHSIA*/
474 
475  //=== VK_EXT_opacity_micromap ===
476 
477  template <>
478  struct hash<VULKAN_HPP_NAMESPACE::MicromapEXT>
479  {
480  std::size_t operator()( VULKAN_HPP_NAMESPACE::MicromapEXT const & micromapEXT ) const VULKAN_HPP_NOEXCEPT
481  {
482  return std::hash<VkMicromapEXT>{}( static_cast<VkMicromapEXT>( micromapEXT ) );
483  }
484  };
485 
486  //=== VK_NV_optical_flow ===
487 
488  template <>
489  struct hash<VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV>
490  {
491  std::size_t operator()( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV const & opticalFlowSessionNV ) const VULKAN_HPP_NOEXCEPT
492  {
493  return std::hash<VkOpticalFlowSessionNV>{}( static_cast<VkOpticalFlowSessionNV>( opticalFlowSessionNV ) );
494  }
495  };
496 
497 #if 14 <= VULKAN_HPP_CPP_VERSION
498  //======================================
499  //=== HASH structures for structures ===
500  //======================================
501 
502 # if !defined( VULKAN_HPP_HASH_COMBINE )
503 # define VULKAN_HPP_HASH_COMBINE( seed, value ) \
504  seed ^= std::hash<std::decay<decltype( value )>::type>{}( value ) + 0x9e3779b9 + ( seed << 6 ) + ( seed >> 2 )
505 # endif
506 
507  template <>
508  struct hash<VULKAN_HPP_NAMESPACE::AabbPositionsKHR>
509  {
510  std::size_t operator()( VULKAN_HPP_NAMESPACE::AabbPositionsKHR const & aabbPositionsKHR ) const VULKAN_HPP_NOEXCEPT
511  {
512  std::size_t seed = 0;
513  VULKAN_HPP_HASH_COMBINE( seed, aabbPositionsKHR.minX );
514  VULKAN_HPP_HASH_COMBINE( seed, aabbPositionsKHR.minY );
515  VULKAN_HPP_HASH_COMBINE( seed, aabbPositionsKHR.minZ );
516  VULKAN_HPP_HASH_COMBINE( seed, aabbPositionsKHR.maxX );
517  VULKAN_HPP_HASH_COMBINE( seed, aabbPositionsKHR.maxY );
518  VULKAN_HPP_HASH_COMBINE( seed, aabbPositionsKHR.maxZ );
519  return seed;
520  }
521  };
522 
523  template <>
524  struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR>
525  {
526  std::size_t
527  operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR const & accelerationStructureBuildRangeInfoKHR ) const VULKAN_HPP_NOEXCEPT
528  {
529  std::size_t seed = 0;
530  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildRangeInfoKHR.primitiveCount );
531  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildRangeInfoKHR.primitiveOffset );
532  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildRangeInfoKHR.firstVertex );
533  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildRangeInfoKHR.transformOffset );
534  return seed;
535  }
536  };
537 
538  template <>
539  struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR>
540  {
541  std::size_t
542  operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR const & accelerationStructureBuildSizesInfoKHR ) const VULKAN_HPP_NOEXCEPT
543  {
544  std::size_t seed = 0;
545  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildSizesInfoKHR.sType );
546  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildSizesInfoKHR.pNext );
547  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildSizesInfoKHR.accelerationStructureSize );
548  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildSizesInfoKHR.updateScratchSize );
549  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildSizesInfoKHR.buildScratchSize );
550  return seed;
551  }
552  };
553 
554  template <>
555  struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureCaptureDescriptorDataInfoEXT>
556  {
557  std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureCaptureDescriptorDataInfoEXT const & accelerationStructureCaptureDescriptorDataInfoEXT )
558  const VULKAN_HPP_NOEXCEPT
559  {
560  std::size_t seed = 0;
561  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCaptureDescriptorDataInfoEXT.sType );
562  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCaptureDescriptorDataInfoEXT.pNext );
563  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCaptureDescriptorDataInfoEXT.accelerationStructure );
564  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCaptureDescriptorDataInfoEXT.accelerationStructureNV );
565  return seed;
566  }
567  };
568 
569  template <>
570  struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR>
571  {
572  std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR const & accelerationStructureCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
573  {
574  std::size_t seed = 0;
575  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoKHR.sType );
576  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoKHR.pNext );
577  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoKHR.createFlags );
578  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoKHR.buffer );
579  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoKHR.offset );
580  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoKHR.size );
581  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoKHR.type );
582  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoKHR.deviceAddress );
583  return seed;
584  }
585  };
586 
587  template <>
588  struct hash<VULKAN_HPP_NAMESPACE::GeometryTrianglesNV>
589  {
590  std::size_t operator()( VULKAN_HPP_NAMESPACE::GeometryTrianglesNV const & geometryTrianglesNV ) const VULKAN_HPP_NOEXCEPT
591  {
592  std::size_t seed = 0;
593  VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.sType );
594  VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.pNext );
595  VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.vertexData );
596  VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.vertexOffset );
597  VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.vertexCount );
598  VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.vertexStride );
599  VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.vertexFormat );
600  VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.indexData );
601  VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.indexOffset );
602  VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.indexCount );
603  VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.indexType );
604  VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.transformData );
605  VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.transformOffset );
606  return seed;
607  }
608  };
609 
610  template <>
611  struct hash<VULKAN_HPP_NAMESPACE::GeometryAABBNV>
612  {
613  std::size_t operator()( VULKAN_HPP_NAMESPACE::GeometryAABBNV const & geometryAABBNV ) const VULKAN_HPP_NOEXCEPT
614  {
615  std::size_t seed = 0;
616  VULKAN_HPP_HASH_COMBINE( seed, geometryAABBNV.sType );
617  VULKAN_HPP_HASH_COMBINE( seed, geometryAABBNV.pNext );
618  VULKAN_HPP_HASH_COMBINE( seed, geometryAABBNV.aabbData );
619  VULKAN_HPP_HASH_COMBINE( seed, geometryAABBNV.numAABBs );
620  VULKAN_HPP_HASH_COMBINE( seed, geometryAABBNV.stride );
621  VULKAN_HPP_HASH_COMBINE( seed, geometryAABBNV.offset );
622  return seed;
623  }
624  };
625 
626  template <>
627  struct hash<VULKAN_HPP_NAMESPACE::GeometryDataNV>
628  {
629  std::size_t operator()( VULKAN_HPP_NAMESPACE::GeometryDataNV const & geometryDataNV ) const VULKAN_HPP_NOEXCEPT
630  {
631  std::size_t seed = 0;
632  VULKAN_HPP_HASH_COMBINE( seed, geometryDataNV.triangles );
633  VULKAN_HPP_HASH_COMBINE( seed, geometryDataNV.aabbs );
634  return seed;
635  }
636  };
637 
638  template <>
639  struct hash<VULKAN_HPP_NAMESPACE::GeometryNV>
640  {
641  std::size_t operator()( VULKAN_HPP_NAMESPACE::GeometryNV const & geometryNV ) const VULKAN_HPP_NOEXCEPT
642  {
643  std::size_t seed = 0;
644  VULKAN_HPP_HASH_COMBINE( seed, geometryNV.sType );
645  VULKAN_HPP_HASH_COMBINE( seed, geometryNV.pNext );
646  VULKAN_HPP_HASH_COMBINE( seed, geometryNV.geometryType );
647  VULKAN_HPP_HASH_COMBINE( seed, geometryNV.geometry );
648  VULKAN_HPP_HASH_COMBINE( seed, geometryNV.flags );
649  return seed;
650  }
651  };
652 
653  template <>
654  struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV>
655  {
656  std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV const & accelerationStructureInfoNV ) const VULKAN_HPP_NOEXCEPT
657  {
658  std::size_t seed = 0;
659  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInfoNV.sType );
660  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInfoNV.pNext );
661  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInfoNV.type );
662  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInfoNV.flags );
663  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInfoNV.instanceCount );
664  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInfoNV.geometryCount );
665  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInfoNV.pGeometries );
666  return seed;
667  }
668  };
669 
670  template <>
671  struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV>
672  {
673  std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV const & accelerationStructureCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
674  {
675  std::size_t seed = 0;
676  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoNV.sType );
677  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoNV.pNext );
678  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoNV.compactedSize );
679  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoNV.info );
680  return seed;
681  }
682  };
683 
684  template <>
685  struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR>
686  {
687  std::size_t
688  operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR const & accelerationStructureDeviceAddressInfoKHR ) const VULKAN_HPP_NOEXCEPT
689  {
690  std::size_t seed = 0;
691  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureDeviceAddressInfoKHR.sType );
692  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureDeviceAddressInfoKHR.pNext );
693  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureDeviceAddressInfoKHR.accelerationStructure );
694  return seed;
695  }
696  };
697 
698  template <>
699  struct hash<VULKAN_HPP_NAMESPACE::TransformMatrixKHR>
700  {
701  std::size_t operator()( VULKAN_HPP_NAMESPACE::TransformMatrixKHR const & transformMatrixKHR ) const VULKAN_HPP_NOEXCEPT
702  {
703  std::size_t seed = 0;
704  for ( size_t i = 0; i < 3; ++i )
705  {
706  for ( size_t j = 0; j < 4; ++j )
707  {
708  VULKAN_HPP_HASH_COMBINE( seed, transformMatrixKHR.matrix[i][j] );
709  }
710  }
711  return seed;
712  }
713  };
714 
715  template <>
716  struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureInstanceKHR>
717  {
718  std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureInstanceKHR const & accelerationStructureInstanceKHR ) const VULKAN_HPP_NOEXCEPT
719  {
720  std::size_t seed = 0;
721  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInstanceKHR.transform );
722  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInstanceKHR.instanceCustomIndex );
723  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInstanceKHR.mask );
724  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInstanceKHR.instanceShaderBindingTableRecordOffset );
725  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInstanceKHR.flags );
726  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInstanceKHR.accelerationStructureReference );
727  return seed;
728  }
729  };
730 
731  template <>
732  struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureMatrixMotionInstanceNV>
733  {
734  std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureMatrixMotionInstanceNV const & accelerationStructureMatrixMotionInstanceNV ) const
735  VULKAN_HPP_NOEXCEPT
736  {
737  std::size_t seed = 0;
738  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMatrixMotionInstanceNV.transformT0 );
739  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMatrixMotionInstanceNV.transformT1 );
740  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMatrixMotionInstanceNV.instanceCustomIndex );
741  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMatrixMotionInstanceNV.mask );
742  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMatrixMotionInstanceNV.instanceShaderBindingTableRecordOffset );
743  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMatrixMotionInstanceNV.flags );
744  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMatrixMotionInstanceNV.accelerationStructureReference );
745  return seed;
746  }
747  };
748 
749  template <>
750  struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV>
751  {
752  std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV const & accelerationStructureMemoryRequirementsInfoNV ) const
753  VULKAN_HPP_NOEXCEPT
754  {
755  std::size_t seed = 0;
756  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMemoryRequirementsInfoNV.sType );
757  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMemoryRequirementsInfoNV.pNext );
758  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMemoryRequirementsInfoNV.type );
759  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMemoryRequirementsInfoNV.accelerationStructure );
760  return seed;
761  }
762  };
763 
764  template <>
765  struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInfoNV>
766  {
767  std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInfoNV const & accelerationStructureMotionInfoNV ) const VULKAN_HPP_NOEXCEPT
768  {
769  std::size_t seed = 0;
770  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMotionInfoNV.sType );
771  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMotionInfoNV.pNext );
772  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMotionInfoNV.maxInstances );
773  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMotionInfoNV.flags );
774  return seed;
775  }
776  };
777 
778  template <>
779  struct hash<VULKAN_HPP_NAMESPACE::SRTDataNV>
780  {
781  std::size_t operator()( VULKAN_HPP_NAMESPACE::SRTDataNV const & sRTDataNV ) const VULKAN_HPP_NOEXCEPT
782  {
783  std::size_t seed = 0;
784  VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.sx );
785  VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.a );
786  VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.b );
787  VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.pvx );
788  VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.sy );
789  VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.c );
790  VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.pvy );
791  VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.sz );
792  VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.pvz );
793  VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.qx );
794  VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.qy );
795  VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.qz );
796  VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.qw );
797  VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.tx );
798  VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.ty );
799  VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.tz );
800  return seed;
801  }
802  };
803 
804  template <>
805  struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureSRTMotionInstanceNV>
806  {
807  std::size_t
808  operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureSRTMotionInstanceNV const & accelerationStructureSRTMotionInstanceNV ) const VULKAN_HPP_NOEXCEPT
809  {
810  std::size_t seed = 0;
811  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureSRTMotionInstanceNV.transformT0 );
812  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureSRTMotionInstanceNV.transformT1 );
813  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureSRTMotionInstanceNV.instanceCustomIndex );
814  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureSRTMotionInstanceNV.mask );
815  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureSRTMotionInstanceNV.instanceShaderBindingTableRecordOffset );
816  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureSRTMotionInstanceNV.flags );
817  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureSRTMotionInstanceNV.accelerationStructureReference );
818  return seed;
819  }
820  };
821 
822  template <>
823  struct hash<VULKAN_HPP_NAMESPACE::MicromapUsageEXT>
824  {
825  std::size_t operator()( VULKAN_HPP_NAMESPACE::MicromapUsageEXT const & micromapUsageEXT ) const VULKAN_HPP_NOEXCEPT
826  {
827  std::size_t seed = 0;
828  VULKAN_HPP_HASH_COMBINE( seed, micromapUsageEXT.count );
829  VULKAN_HPP_HASH_COMBINE( seed, micromapUsageEXT.subdivisionLevel );
830  VULKAN_HPP_HASH_COMBINE( seed, micromapUsageEXT.format );
831  return seed;
832  }
833  };
834 
835  template <>
836  struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureVersionInfoKHR>
837  {
838  std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureVersionInfoKHR const & accelerationStructureVersionInfoKHR ) const VULKAN_HPP_NOEXCEPT
839  {
840  std::size_t seed = 0;
841  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureVersionInfoKHR.sType );
842  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureVersionInfoKHR.pNext );
843  VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureVersionInfoKHR.pVersionData );
844  return seed;
845  }
846  };
847 
848  template <>
849  struct hash<VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR>
850  {
851  std::size_t operator()( VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR const & acquireNextImageInfoKHR ) const VULKAN_HPP_NOEXCEPT
852  {
853  std::size_t seed = 0;
854  VULKAN_HPP_HASH_COMBINE( seed, acquireNextImageInfoKHR.sType );
855  VULKAN_HPP_HASH_COMBINE( seed, acquireNextImageInfoKHR.pNext );
856  VULKAN_HPP_HASH_COMBINE( seed, acquireNextImageInfoKHR.swapchain );
857  VULKAN_HPP_HASH_COMBINE( seed, acquireNextImageInfoKHR.timeout );
858  VULKAN_HPP_HASH_COMBINE( seed, acquireNextImageInfoKHR.semaphore );
859  VULKAN_HPP_HASH_COMBINE( seed, acquireNextImageInfoKHR.fence );
860  VULKAN_HPP_HASH_COMBINE( seed, acquireNextImageInfoKHR.deviceMask );
861  return seed;
862  }
863  };
864 
865  template <>
866  struct hash<VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR>
867  {
868  std::size_t operator()( VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR const & acquireProfilingLockInfoKHR ) const VULKAN_HPP_NOEXCEPT
869  {
870  std::size_t seed = 0;
871  VULKAN_HPP_HASH_COMBINE( seed, acquireProfilingLockInfoKHR.sType );
872  VULKAN_HPP_HASH_COMBINE( seed, acquireProfilingLockInfoKHR.pNext );
873  VULKAN_HPP_HASH_COMBINE( seed, acquireProfilingLockInfoKHR.flags );
874  VULKAN_HPP_HASH_COMBINE( seed, acquireProfilingLockInfoKHR.timeout );
875  return seed;
876  }
877  };
878 
879  template <>
880  struct hash<VULKAN_HPP_NAMESPACE::AllocationCallbacks>
881  {
882  std::size_t operator()( VULKAN_HPP_NAMESPACE::AllocationCallbacks const & allocationCallbacks ) const VULKAN_HPP_NOEXCEPT
883  {
884  std::size_t seed = 0;
885  VULKAN_HPP_HASH_COMBINE( seed, allocationCallbacks.pUserData );
886  VULKAN_HPP_HASH_COMBINE( seed, allocationCallbacks.pfnAllocation );
887  VULKAN_HPP_HASH_COMBINE( seed, allocationCallbacks.pfnReallocation );
888  VULKAN_HPP_HASH_COMBINE( seed, allocationCallbacks.pfnFree );
889  VULKAN_HPP_HASH_COMBINE( seed, allocationCallbacks.pfnInternalAllocation );
890  VULKAN_HPP_HASH_COMBINE( seed, allocationCallbacks.pfnInternalFree );
891  return seed;
892  }
893  };
894 
895  template <>
896  struct hash<VULKAN_HPP_NAMESPACE::AmigoProfilingSubmitInfoSEC>
897  {
898  std::size_t operator()( VULKAN_HPP_NAMESPACE::AmigoProfilingSubmitInfoSEC const & amigoProfilingSubmitInfoSEC ) const VULKAN_HPP_NOEXCEPT
899  {
900  std::size_t seed = 0;
901  VULKAN_HPP_HASH_COMBINE( seed, amigoProfilingSubmitInfoSEC.sType );
902  VULKAN_HPP_HASH_COMBINE( seed, amigoProfilingSubmitInfoSEC.pNext );
903  VULKAN_HPP_HASH_COMBINE( seed, amigoProfilingSubmitInfoSEC.firstDrawTimestamp );
904  VULKAN_HPP_HASH_COMBINE( seed, amigoProfilingSubmitInfoSEC.swapBufferTimestamp );
905  return seed;
906  }
907  };
908 
909  template <>
910  struct hash<VULKAN_HPP_NAMESPACE::ComponentMapping>
911  {
912  std::size_t operator()( VULKAN_HPP_NAMESPACE::ComponentMapping const & componentMapping ) const VULKAN_HPP_NOEXCEPT
913  {
914  std::size_t seed = 0;
915  VULKAN_HPP_HASH_COMBINE( seed, componentMapping.r );
916  VULKAN_HPP_HASH_COMBINE( seed, componentMapping.g );
917  VULKAN_HPP_HASH_COMBINE( seed, componentMapping.b );
918  VULKAN_HPP_HASH_COMBINE( seed, componentMapping.a );
919  return seed;
920  }
921  };
922 
923 # if defined( VK_USE_PLATFORM_ANDROID_KHR )
924  template <>
925  struct hash<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatProperties2ANDROID>
926  {
927  std::size_t operator()( VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatProperties2ANDROID const & androidHardwareBufferFormatProperties2ANDROID ) const
928  VULKAN_HPP_NOEXCEPT
929  {
930  std::size_t seed = 0;
931  VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.sType );
932  VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.pNext );
933  VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.format );
934  VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.externalFormat );
935  VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.formatFeatures );
936  VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.samplerYcbcrConversionComponents );
937  VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.suggestedYcbcrModel );
938  VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.suggestedYcbcrRange );
939  VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.suggestedXChromaOffset );
940  VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.suggestedYChromaOffset );
941  return seed;
942  }
943  };
944 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/
945 
946 # if defined( VK_USE_PLATFORM_ANDROID_KHR )
947  template <>
948  struct hash<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatPropertiesANDROID>
949  {
950  std::size_t operator()( VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatPropertiesANDROID const & androidHardwareBufferFormatPropertiesANDROID ) const
951  VULKAN_HPP_NOEXCEPT
952  {
953  std::size_t seed = 0;
954  VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.sType );
955  VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.pNext );
956  VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.format );
957  VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.externalFormat );
958  VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.formatFeatures );
959  VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.samplerYcbcrConversionComponents );
960  VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.suggestedYcbcrModel );
961  VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.suggestedYcbcrRange );
962  VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.suggestedXChromaOffset );
963  VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.suggestedYChromaOffset );
964  return seed;
965  }
966  };
967 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/
968 
969 # if defined( VK_USE_PLATFORM_ANDROID_KHR )
970  template <>
971  struct hash<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID>
972  {
973  std::size_t
974  operator()( VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID const & androidHardwareBufferPropertiesANDROID ) const VULKAN_HPP_NOEXCEPT
975  {
976  std::size_t seed = 0;
977  VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferPropertiesANDROID.sType );
978  VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferPropertiesANDROID.pNext );
979  VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferPropertiesANDROID.allocationSize );
980  VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferPropertiesANDROID.memoryTypeBits );
981  return seed;
982  }
983  };
984 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/
985 
986 # if defined( VK_USE_PLATFORM_ANDROID_KHR )
987  template <>
988  struct hash<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferUsageANDROID>
989  {
990  std::size_t operator()( VULKAN_HPP_NAMESPACE::AndroidHardwareBufferUsageANDROID const & androidHardwareBufferUsageANDROID ) const VULKAN_HPP_NOEXCEPT
991  {
992  std::size_t seed = 0;
993  VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferUsageANDROID.sType );
994  VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferUsageANDROID.pNext );
995  VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferUsageANDROID.androidHardwareBufferUsage );
996  return seed;
997  }
998  };
999 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/
1000 
1001 # if defined( VK_USE_PLATFORM_ANDROID_KHR )
1002  template <>
1003  struct hash<VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR>
1004  {
1005  std::size_t operator()( VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR const & androidSurfaceCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
1006  {
1007  std::size_t seed = 0;
1008  VULKAN_HPP_HASH_COMBINE( seed, androidSurfaceCreateInfoKHR.sType );
1009  VULKAN_HPP_HASH_COMBINE( seed, androidSurfaceCreateInfoKHR.pNext );
1010  VULKAN_HPP_HASH_COMBINE( seed, androidSurfaceCreateInfoKHR.flags );
1011  VULKAN_HPP_HASH_COMBINE( seed, androidSurfaceCreateInfoKHR.window );
1012  return seed;
1013  }
1014  };
1015 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/
1016 
1017  template <>
1018  struct hash<VULKAN_HPP_NAMESPACE::ApplicationInfo>
1019  {
1020  std::size_t operator()( VULKAN_HPP_NAMESPACE::ApplicationInfo const & applicationInfo ) const VULKAN_HPP_NOEXCEPT
1021  {
1022  std::size_t seed = 0;
1023  VULKAN_HPP_HASH_COMBINE( seed, applicationInfo.sType );
1024  VULKAN_HPP_HASH_COMBINE( seed, applicationInfo.pNext );
1025  for ( const char * p = applicationInfo.pApplicationName; *p != '\0'; ++p )
1026  {
1027  VULKAN_HPP_HASH_COMBINE( seed, *p );
1028  }
1029  VULKAN_HPP_HASH_COMBINE( seed, applicationInfo.applicationVersion );
1030  for ( const char * p = applicationInfo.pEngineName; *p != '\0'; ++p )
1031  {
1032  VULKAN_HPP_HASH_COMBINE( seed, *p );
1033  }
1034  VULKAN_HPP_HASH_COMBINE( seed, applicationInfo.engineVersion );
1035  VULKAN_HPP_HASH_COMBINE( seed, applicationInfo.apiVersion );
1036  return seed;
1037  }
1038  };
1039 
1040  template <>
1041  struct hash<VULKAN_HPP_NAMESPACE::AttachmentDescription>
1042  {
1043  std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentDescription const & attachmentDescription ) const VULKAN_HPP_NOEXCEPT
1044  {
1045  std::size_t seed = 0;
1046  VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.flags );
1047  VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.format );
1048  VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.samples );
1049  VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.loadOp );
1050  VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.storeOp );
1051  VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.stencilLoadOp );
1052  VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.stencilStoreOp );
1053  VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.initialLayout );
1054  VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.finalLayout );
1055  return seed;
1056  }
1057  };
1058 
1059  template <>
1060  struct hash<VULKAN_HPP_NAMESPACE::AttachmentDescription2>
1061  {
1062  std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentDescription2 const & attachmentDescription2 ) const VULKAN_HPP_NOEXCEPT
1063  {
1064  std::size_t seed = 0;
1065  VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.sType );
1066  VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.pNext );
1067  VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.flags );
1068  VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.format );
1069  VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.samples );
1070  VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.loadOp );
1071  VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.storeOp );
1072  VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.stencilLoadOp );
1073  VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.stencilStoreOp );
1074  VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.initialLayout );
1075  VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.finalLayout );
1076  return seed;
1077  }
1078  };
1079 
1080  template <>
1081  struct hash<VULKAN_HPP_NAMESPACE::AttachmentDescriptionStencilLayout>
1082  {
1083  std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentDescriptionStencilLayout const & attachmentDescriptionStencilLayout ) const VULKAN_HPP_NOEXCEPT
1084  {
1085  std::size_t seed = 0;
1086  VULKAN_HPP_HASH_COMBINE( seed, attachmentDescriptionStencilLayout.sType );
1087  VULKAN_HPP_HASH_COMBINE( seed, attachmentDescriptionStencilLayout.pNext );
1088  VULKAN_HPP_HASH_COMBINE( seed, attachmentDescriptionStencilLayout.stencilInitialLayout );
1089  VULKAN_HPP_HASH_COMBINE( seed, attachmentDescriptionStencilLayout.stencilFinalLayout );
1090  return seed;
1091  }
1092  };
1093 
1094  template <>
1095  struct hash<VULKAN_HPP_NAMESPACE::AttachmentReference>
1096  {
1097  std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentReference const & attachmentReference ) const VULKAN_HPP_NOEXCEPT
1098  {
1099  std::size_t seed = 0;
1100  VULKAN_HPP_HASH_COMBINE( seed, attachmentReference.attachment );
1101  VULKAN_HPP_HASH_COMBINE( seed, attachmentReference.layout );
1102  return seed;
1103  }
1104  };
1105 
1106  template <>
1107  struct hash<VULKAN_HPP_NAMESPACE::AttachmentReference2>
1108  {
1109  std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentReference2 const & attachmentReference2 ) const VULKAN_HPP_NOEXCEPT
1110  {
1111  std::size_t seed = 0;
1112  VULKAN_HPP_HASH_COMBINE( seed, attachmentReference2.sType );
1113  VULKAN_HPP_HASH_COMBINE( seed, attachmentReference2.pNext );
1114  VULKAN_HPP_HASH_COMBINE( seed, attachmentReference2.attachment );
1115  VULKAN_HPP_HASH_COMBINE( seed, attachmentReference2.layout );
1116  VULKAN_HPP_HASH_COMBINE( seed, attachmentReference2.aspectMask );
1117  return seed;
1118  }
1119  };
1120 
1121  template <>
1122  struct hash<VULKAN_HPP_NAMESPACE::AttachmentReferenceStencilLayout>
1123  {
1124  std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentReferenceStencilLayout const & attachmentReferenceStencilLayout ) const VULKAN_HPP_NOEXCEPT
1125  {
1126  std::size_t seed = 0;
1127  VULKAN_HPP_HASH_COMBINE( seed, attachmentReferenceStencilLayout.sType );
1128  VULKAN_HPP_HASH_COMBINE( seed, attachmentReferenceStencilLayout.pNext );
1129  VULKAN_HPP_HASH_COMBINE( seed, attachmentReferenceStencilLayout.stencilLayout );
1130  return seed;
1131  }
1132  };
1133 
1134  template <>
1135  struct hash<VULKAN_HPP_NAMESPACE::AttachmentSampleCountInfoAMD>
1136  {
1137  std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentSampleCountInfoAMD const & attachmentSampleCountInfoAMD ) const VULKAN_HPP_NOEXCEPT
1138  {
1139  std::size_t seed = 0;
1140  VULKAN_HPP_HASH_COMBINE( seed, attachmentSampleCountInfoAMD.sType );
1141  VULKAN_HPP_HASH_COMBINE( seed, attachmentSampleCountInfoAMD.pNext );
1142  VULKAN_HPP_HASH_COMBINE( seed, attachmentSampleCountInfoAMD.colorAttachmentCount );
1143  VULKAN_HPP_HASH_COMBINE( seed, attachmentSampleCountInfoAMD.pColorAttachmentSamples );
1144  VULKAN_HPP_HASH_COMBINE( seed, attachmentSampleCountInfoAMD.depthStencilAttachmentSamples );
1145  return seed;
1146  }
1147  };
1148 
1149  template <>
1150  struct hash<VULKAN_HPP_NAMESPACE::Extent2D>
1151  {
1152  std::size_t operator()( VULKAN_HPP_NAMESPACE::Extent2D const & extent2D ) const VULKAN_HPP_NOEXCEPT
1153  {
1154  std::size_t seed = 0;
1155  VULKAN_HPP_HASH_COMBINE( seed, extent2D.width );
1156  VULKAN_HPP_HASH_COMBINE( seed, extent2D.height );
1157  return seed;
1158  }
1159  };
1160 
1161  template <>
1162  struct hash<VULKAN_HPP_NAMESPACE::SampleLocationEXT>
1163  {
1164  std::size_t operator()( VULKAN_HPP_NAMESPACE::SampleLocationEXT const & sampleLocationEXT ) const VULKAN_HPP_NOEXCEPT
1165  {
1166  std::size_t seed = 0;
1167  VULKAN_HPP_HASH_COMBINE( seed, sampleLocationEXT.x );
1168  VULKAN_HPP_HASH_COMBINE( seed, sampleLocationEXT.y );
1169  return seed;
1170  }
1171  };
1172 
1173  template <>
1174  struct hash<VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT>
1175  {
1176  std::size_t operator()( VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT const & sampleLocationsInfoEXT ) const VULKAN_HPP_NOEXCEPT
1177  {
1178  std::size_t seed = 0;
1179  VULKAN_HPP_HASH_COMBINE( seed, sampleLocationsInfoEXT.sType );
1180  VULKAN_HPP_HASH_COMBINE( seed, sampleLocationsInfoEXT.pNext );
1181  VULKAN_HPP_HASH_COMBINE( seed, sampleLocationsInfoEXT.sampleLocationsPerPixel );
1182  VULKAN_HPP_HASH_COMBINE( seed, sampleLocationsInfoEXT.sampleLocationGridSize );
1183  VULKAN_HPP_HASH_COMBINE( seed, sampleLocationsInfoEXT.sampleLocationsCount );
1184  VULKAN_HPP_HASH_COMBINE( seed, sampleLocationsInfoEXT.pSampleLocations );
1185  return seed;
1186  }
1187  };
1188 
1189  template <>
1190  struct hash<VULKAN_HPP_NAMESPACE::AttachmentSampleLocationsEXT>
1191  {
1192  std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentSampleLocationsEXT const & attachmentSampleLocationsEXT ) const VULKAN_HPP_NOEXCEPT
1193  {
1194  std::size_t seed = 0;
1195  VULKAN_HPP_HASH_COMBINE( seed, attachmentSampleLocationsEXT.attachmentIndex );
1196  VULKAN_HPP_HASH_COMBINE( seed, attachmentSampleLocationsEXT.sampleLocationsInfo );
1197  return seed;
1198  }
1199  };
1200 
1201  template <>
1202  struct hash<VULKAN_HPP_NAMESPACE::BaseInStructure>
1203  {
1204  std::size_t operator()( VULKAN_HPP_NAMESPACE::BaseInStructure const & baseInStructure ) const VULKAN_HPP_NOEXCEPT
1205  {
1206  std::size_t seed = 0;
1207  VULKAN_HPP_HASH_COMBINE( seed, baseInStructure.sType );
1208  VULKAN_HPP_HASH_COMBINE( seed, baseInStructure.pNext );
1209  return seed;
1210  }
1211  };
1212 
1213  template <>
1214  struct hash<VULKAN_HPP_NAMESPACE::BaseOutStructure>
1215  {
1216  std::size_t operator()( VULKAN_HPP_NAMESPACE::BaseOutStructure const & baseOutStructure ) const VULKAN_HPP_NOEXCEPT
1217  {
1218  std::size_t seed = 0;
1219  VULKAN_HPP_HASH_COMBINE( seed, baseOutStructure.sType );
1220  VULKAN_HPP_HASH_COMBINE( seed, baseOutStructure.pNext );
1221  return seed;
1222  }
1223  };
1224 
1225  template <>
1226  struct hash<VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV>
1227  {
1228  std::size_t
1229  operator()( VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV const & bindAccelerationStructureMemoryInfoNV ) const VULKAN_HPP_NOEXCEPT
1230  {
1231  std::size_t seed = 0;
1232  VULKAN_HPP_HASH_COMBINE( seed, bindAccelerationStructureMemoryInfoNV.sType );
1233  VULKAN_HPP_HASH_COMBINE( seed, bindAccelerationStructureMemoryInfoNV.pNext );
1234  VULKAN_HPP_HASH_COMBINE( seed, bindAccelerationStructureMemoryInfoNV.accelerationStructure );
1235  VULKAN_HPP_HASH_COMBINE( seed, bindAccelerationStructureMemoryInfoNV.memory );
1236  VULKAN_HPP_HASH_COMBINE( seed, bindAccelerationStructureMemoryInfoNV.memoryOffset );
1237  VULKAN_HPP_HASH_COMBINE( seed, bindAccelerationStructureMemoryInfoNV.deviceIndexCount );
1238  VULKAN_HPP_HASH_COMBINE( seed, bindAccelerationStructureMemoryInfoNV.pDeviceIndices );
1239  return seed;
1240  }
1241  };
1242 
1243  template <>
1244  struct hash<VULKAN_HPP_NAMESPACE::BindBufferMemoryDeviceGroupInfo>
1245  {
1246  std::size_t operator()( VULKAN_HPP_NAMESPACE::BindBufferMemoryDeviceGroupInfo const & bindBufferMemoryDeviceGroupInfo ) const VULKAN_HPP_NOEXCEPT
1247  {
1248  std::size_t seed = 0;
1249  VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryDeviceGroupInfo.sType );
1250  VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryDeviceGroupInfo.pNext );
1251  VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryDeviceGroupInfo.deviceIndexCount );
1252  VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryDeviceGroupInfo.pDeviceIndices );
1253  return seed;
1254  }
1255  };
1256 
1257  template <>
1258  struct hash<VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo>
1259  {
1260  std::size_t operator()( VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo const & bindBufferMemoryInfo ) const VULKAN_HPP_NOEXCEPT
1261  {
1262  std::size_t seed = 0;
1263  VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryInfo.sType );
1264  VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryInfo.pNext );
1265  VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryInfo.buffer );
1266  VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryInfo.memory );
1267  VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryInfo.memoryOffset );
1268  return seed;
1269  }
1270  };
1271 
1272  template <>
1273  struct hash<VULKAN_HPP_NAMESPACE::Offset2D>
1274  {
1275  std::size_t operator()( VULKAN_HPP_NAMESPACE::Offset2D const & offset2D ) const VULKAN_HPP_NOEXCEPT
1276  {
1277  std::size_t seed = 0;
1278  VULKAN_HPP_HASH_COMBINE( seed, offset2D.x );
1279  VULKAN_HPP_HASH_COMBINE( seed, offset2D.y );
1280  return seed;
1281  }
1282  };
1283 
1284  template <>
1285  struct hash<VULKAN_HPP_NAMESPACE::Rect2D>
1286  {
1287  std::size_t operator()( VULKAN_HPP_NAMESPACE::Rect2D const & rect2D ) const VULKAN_HPP_NOEXCEPT
1288  {
1289  std::size_t seed = 0;
1290  VULKAN_HPP_HASH_COMBINE( seed, rect2D.offset );
1291  VULKAN_HPP_HASH_COMBINE( seed, rect2D.extent );
1292  return seed;
1293  }
1294  };
1295 
1296  template <>
1297  struct hash<VULKAN_HPP_NAMESPACE::BindImageMemoryDeviceGroupInfo>
1298  {
1299  std::size_t operator()( VULKAN_HPP_NAMESPACE::BindImageMemoryDeviceGroupInfo const & bindImageMemoryDeviceGroupInfo ) const VULKAN_HPP_NOEXCEPT
1300  {
1301  std::size_t seed = 0;
1302  VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryDeviceGroupInfo.sType );
1303  VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryDeviceGroupInfo.pNext );
1304  VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryDeviceGroupInfo.deviceIndexCount );
1305  VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryDeviceGroupInfo.pDeviceIndices );
1306  VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryDeviceGroupInfo.splitInstanceBindRegionCount );
1307  VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryDeviceGroupInfo.pSplitInstanceBindRegions );
1308  return seed;
1309  }
1310  };
1311 
1312  template <>
1313  struct hash<VULKAN_HPP_NAMESPACE::BindImageMemoryInfo>
1314  {
1315  std::size_t operator()( VULKAN_HPP_NAMESPACE::BindImageMemoryInfo const & bindImageMemoryInfo ) const VULKAN_HPP_NOEXCEPT
1316  {
1317  std::size_t seed = 0;
1318  VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryInfo.sType );
1319  VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryInfo.pNext );
1320  VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryInfo.image );
1321  VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryInfo.memory );
1322  VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryInfo.memoryOffset );
1323  return seed;
1324  }
1325  };
1326 
1327  template <>
1328  struct hash<VULKAN_HPP_NAMESPACE::BindImageMemorySwapchainInfoKHR>
1329  {
1330  std::size_t operator()( VULKAN_HPP_NAMESPACE::BindImageMemorySwapchainInfoKHR const & bindImageMemorySwapchainInfoKHR ) const VULKAN_HPP_NOEXCEPT
1331  {
1332  std::size_t seed = 0;
1333  VULKAN_HPP_HASH_COMBINE( seed, bindImageMemorySwapchainInfoKHR.sType );
1334  VULKAN_HPP_HASH_COMBINE( seed, bindImageMemorySwapchainInfoKHR.pNext );
1335  VULKAN_HPP_HASH_COMBINE( seed, bindImageMemorySwapchainInfoKHR.swapchain );
1336  VULKAN_HPP_HASH_COMBINE( seed, bindImageMemorySwapchainInfoKHR.imageIndex );
1337  return seed;
1338  }
1339  };
1340 
1341  template <>
1342  struct hash<VULKAN_HPP_NAMESPACE::BindImagePlaneMemoryInfo>
1343  {
1344  std::size_t operator()( VULKAN_HPP_NAMESPACE::BindImagePlaneMemoryInfo const & bindImagePlaneMemoryInfo ) const VULKAN_HPP_NOEXCEPT
1345  {
1346  std::size_t seed = 0;
1347  VULKAN_HPP_HASH_COMBINE( seed, bindImagePlaneMemoryInfo.sType );
1348  VULKAN_HPP_HASH_COMBINE( seed, bindImagePlaneMemoryInfo.pNext );
1349  VULKAN_HPP_HASH_COMBINE( seed, bindImagePlaneMemoryInfo.planeAspect );
1350  return seed;
1351  }
1352  };
1353 
1354  template <>
1355  struct hash<VULKAN_HPP_NAMESPACE::BindIndexBufferIndirectCommandNV>
1356  {
1357  std::size_t operator()( VULKAN_HPP_NAMESPACE::BindIndexBufferIndirectCommandNV const & bindIndexBufferIndirectCommandNV ) const VULKAN_HPP_NOEXCEPT
1358  {
1359  std::size_t seed = 0;
1360  VULKAN_HPP_HASH_COMBINE( seed, bindIndexBufferIndirectCommandNV.bufferAddress );
1361  VULKAN_HPP_HASH_COMBINE( seed, bindIndexBufferIndirectCommandNV.size );
1362  VULKAN_HPP_HASH_COMBINE( seed, bindIndexBufferIndirectCommandNV.indexType );
1363  return seed;
1364  }
1365  };
1366 
1367  template <>
1368  struct hash<VULKAN_HPP_NAMESPACE::BindShaderGroupIndirectCommandNV>
1369  {
1370  std::size_t operator()( VULKAN_HPP_NAMESPACE::BindShaderGroupIndirectCommandNV const & bindShaderGroupIndirectCommandNV ) const VULKAN_HPP_NOEXCEPT
1371  {
1372  std::size_t seed = 0;
1373  VULKAN_HPP_HASH_COMBINE( seed, bindShaderGroupIndirectCommandNV.groupIndex );
1374  return seed;
1375  }
1376  };
1377 
1378  template <>
1379  struct hash<VULKAN_HPP_NAMESPACE::SparseMemoryBind>
1380  {
1381  std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseMemoryBind const & sparseMemoryBind ) const VULKAN_HPP_NOEXCEPT
1382  {
1383  std::size_t seed = 0;
1384  VULKAN_HPP_HASH_COMBINE( seed, sparseMemoryBind.resourceOffset );
1385  VULKAN_HPP_HASH_COMBINE( seed, sparseMemoryBind.size );
1386  VULKAN_HPP_HASH_COMBINE( seed, sparseMemoryBind.memory );
1387  VULKAN_HPP_HASH_COMBINE( seed, sparseMemoryBind.memoryOffset );
1388  VULKAN_HPP_HASH_COMBINE( seed, sparseMemoryBind.flags );
1389  return seed;
1390  }
1391  };
1392 
1393  template <>
1394  struct hash<VULKAN_HPP_NAMESPACE::SparseBufferMemoryBindInfo>
1395  {
1396  std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseBufferMemoryBindInfo const & sparseBufferMemoryBindInfo ) const VULKAN_HPP_NOEXCEPT
1397  {
1398  std::size_t seed = 0;
1399  VULKAN_HPP_HASH_COMBINE( seed, sparseBufferMemoryBindInfo.buffer );
1400  VULKAN_HPP_HASH_COMBINE( seed, sparseBufferMemoryBindInfo.bindCount );
1401  VULKAN_HPP_HASH_COMBINE( seed, sparseBufferMemoryBindInfo.pBinds );
1402  return seed;
1403  }
1404  };
1405 
1406  template <>
1407  struct hash<VULKAN_HPP_NAMESPACE::SparseImageOpaqueMemoryBindInfo>
1408  {
1409  std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageOpaqueMemoryBindInfo const & sparseImageOpaqueMemoryBindInfo ) const VULKAN_HPP_NOEXCEPT
1410  {
1411  std::size_t seed = 0;
1412  VULKAN_HPP_HASH_COMBINE( seed, sparseImageOpaqueMemoryBindInfo.image );
1413  VULKAN_HPP_HASH_COMBINE( seed, sparseImageOpaqueMemoryBindInfo.bindCount );
1414  VULKAN_HPP_HASH_COMBINE( seed, sparseImageOpaqueMemoryBindInfo.pBinds );
1415  return seed;
1416  }
1417  };
1418 
1419  template <>
1420  struct hash<VULKAN_HPP_NAMESPACE::ImageSubresource>
1421  {
1422  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageSubresource const & imageSubresource ) const VULKAN_HPP_NOEXCEPT
1423  {
1424  std::size_t seed = 0;
1425  VULKAN_HPP_HASH_COMBINE( seed, imageSubresource.aspectMask );
1426  VULKAN_HPP_HASH_COMBINE( seed, imageSubresource.mipLevel );
1427  VULKAN_HPP_HASH_COMBINE( seed, imageSubresource.arrayLayer );
1428  return seed;
1429  }
1430  };
1431 
1432  template <>
1433  struct hash<VULKAN_HPP_NAMESPACE::Offset3D>
1434  {
1435  std::size_t operator()( VULKAN_HPP_NAMESPACE::Offset3D const & offset3D ) const VULKAN_HPP_NOEXCEPT
1436  {
1437  std::size_t seed = 0;
1438  VULKAN_HPP_HASH_COMBINE( seed, offset3D.x );
1439  VULKAN_HPP_HASH_COMBINE( seed, offset3D.y );
1440  VULKAN_HPP_HASH_COMBINE( seed, offset3D.z );
1441  return seed;
1442  }
1443  };
1444 
1445  template <>
1446  struct hash<VULKAN_HPP_NAMESPACE::Extent3D>
1447  {
1448  std::size_t operator()( VULKAN_HPP_NAMESPACE::Extent3D const & extent3D ) const VULKAN_HPP_NOEXCEPT
1449  {
1450  std::size_t seed = 0;
1451  VULKAN_HPP_HASH_COMBINE( seed, extent3D.width );
1452  VULKAN_HPP_HASH_COMBINE( seed, extent3D.height );
1453  VULKAN_HPP_HASH_COMBINE( seed, extent3D.depth );
1454  return seed;
1455  }
1456  };
1457 
1458  template <>
1459  struct hash<VULKAN_HPP_NAMESPACE::SparseImageMemoryBind>
1460  {
1461  std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageMemoryBind const & sparseImageMemoryBind ) const VULKAN_HPP_NOEXCEPT
1462  {
1463  std::size_t seed = 0;
1464  VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBind.subresource );
1465  VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBind.offset );
1466  VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBind.extent );
1467  VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBind.memory );
1468  VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBind.memoryOffset );
1469  VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBind.flags );
1470  return seed;
1471  }
1472  };
1473 
1474  template <>
1475  struct hash<VULKAN_HPP_NAMESPACE::SparseImageMemoryBindInfo>
1476  {
1477  std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageMemoryBindInfo const & sparseImageMemoryBindInfo ) const VULKAN_HPP_NOEXCEPT
1478  {
1479  std::size_t seed = 0;
1480  VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBindInfo.image );
1481  VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBindInfo.bindCount );
1482  VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBindInfo.pBinds );
1483  return seed;
1484  }
1485  };
1486 
1487  template <>
1488  struct hash<VULKAN_HPP_NAMESPACE::BindSparseInfo>
1489  {
1490  std::size_t operator()( VULKAN_HPP_NAMESPACE::BindSparseInfo const & bindSparseInfo ) const VULKAN_HPP_NOEXCEPT
1491  {
1492  std::size_t seed = 0;
1493  VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.sType );
1494  VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.pNext );
1495  VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.waitSemaphoreCount );
1496  VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.pWaitSemaphores );
1497  VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.bufferBindCount );
1498  VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.pBufferBinds );
1499  VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.imageOpaqueBindCount );
1500  VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.pImageOpaqueBinds );
1501  VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.imageBindCount );
1502  VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.pImageBinds );
1503  VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.signalSemaphoreCount );
1504  VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.pSignalSemaphores );
1505  return seed;
1506  }
1507  };
1508 
1509  template <>
1510  struct hash<VULKAN_HPP_NAMESPACE::BindVertexBufferIndirectCommandNV>
1511  {
1512  std::size_t operator()( VULKAN_HPP_NAMESPACE::BindVertexBufferIndirectCommandNV const & bindVertexBufferIndirectCommandNV ) const VULKAN_HPP_NOEXCEPT
1513  {
1514  std::size_t seed = 0;
1515  VULKAN_HPP_HASH_COMBINE( seed, bindVertexBufferIndirectCommandNV.bufferAddress );
1516  VULKAN_HPP_HASH_COMBINE( seed, bindVertexBufferIndirectCommandNV.size );
1517  VULKAN_HPP_HASH_COMBINE( seed, bindVertexBufferIndirectCommandNV.stride );
1518  return seed;
1519  }
1520  };
1521 
1522 # if defined( VK_ENABLE_BETA_EXTENSIONS )
1523  template <>
1524  struct hash<VULKAN_HPP_NAMESPACE::BindVideoSessionMemoryInfoKHR>
1525  {
1526  std::size_t operator()( VULKAN_HPP_NAMESPACE::BindVideoSessionMemoryInfoKHR const & bindVideoSessionMemoryInfoKHR ) const VULKAN_HPP_NOEXCEPT
1527  {
1528  std::size_t seed = 0;
1529  VULKAN_HPP_HASH_COMBINE( seed, bindVideoSessionMemoryInfoKHR.sType );
1530  VULKAN_HPP_HASH_COMBINE( seed, bindVideoSessionMemoryInfoKHR.pNext );
1531  VULKAN_HPP_HASH_COMBINE( seed, bindVideoSessionMemoryInfoKHR.memoryBindIndex );
1532  VULKAN_HPP_HASH_COMBINE( seed, bindVideoSessionMemoryInfoKHR.memory );
1533  VULKAN_HPP_HASH_COMBINE( seed, bindVideoSessionMemoryInfoKHR.memoryOffset );
1534  VULKAN_HPP_HASH_COMBINE( seed, bindVideoSessionMemoryInfoKHR.memorySize );
1535  return seed;
1536  }
1537  };
1538 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
1539 
1540  template <>
1541  struct hash<VULKAN_HPP_NAMESPACE::ImageSubresourceLayers>
1542  {
1543  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const & imageSubresourceLayers ) const VULKAN_HPP_NOEXCEPT
1544  {
1545  std::size_t seed = 0;
1546  VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceLayers.aspectMask );
1547  VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceLayers.mipLevel );
1548  VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceLayers.baseArrayLayer );
1549  VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceLayers.layerCount );
1550  return seed;
1551  }
1552  };
1553 
1554  template <>
1555  struct hash<VULKAN_HPP_NAMESPACE::ImageBlit2>
1556  {
1557  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageBlit2 const & imageBlit2 ) const VULKAN_HPP_NOEXCEPT
1558  {
1559  std::size_t seed = 0;
1560  VULKAN_HPP_HASH_COMBINE( seed, imageBlit2.sType );
1561  VULKAN_HPP_HASH_COMBINE( seed, imageBlit2.pNext );
1562  VULKAN_HPP_HASH_COMBINE( seed, imageBlit2.srcSubresource );
1563  for ( size_t i = 0; i < 2; ++i )
1564  {
1565  VULKAN_HPP_HASH_COMBINE( seed, imageBlit2.srcOffsets[i] );
1566  }
1567  VULKAN_HPP_HASH_COMBINE( seed, imageBlit2.dstSubresource );
1568  for ( size_t i = 0; i < 2; ++i )
1569  {
1570  VULKAN_HPP_HASH_COMBINE( seed, imageBlit2.dstOffsets[i] );
1571  }
1572  return seed;
1573  }
1574  };
1575 
1576  template <>
1577  struct hash<VULKAN_HPP_NAMESPACE::BlitImageInfo2>
1578  {
1579  std::size_t operator()( VULKAN_HPP_NAMESPACE::BlitImageInfo2 const & blitImageInfo2 ) const VULKAN_HPP_NOEXCEPT
1580  {
1581  std::size_t seed = 0;
1582  VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.sType );
1583  VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.pNext );
1584  VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.srcImage );
1585  VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.srcImageLayout );
1586  VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.dstImage );
1587  VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.dstImageLayout );
1588  VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.regionCount );
1589  VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.pRegions );
1590  VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.filter );
1591  return seed;
1592  }
1593  };
1594 
1595  template <>
1596  struct hash<VULKAN_HPP_NAMESPACE::BufferCaptureDescriptorDataInfoEXT>
1597  {
1598  std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCaptureDescriptorDataInfoEXT const & bufferCaptureDescriptorDataInfoEXT ) const VULKAN_HPP_NOEXCEPT
1599  {
1600  std::size_t seed = 0;
1601  VULKAN_HPP_HASH_COMBINE( seed, bufferCaptureDescriptorDataInfoEXT.sType );
1602  VULKAN_HPP_HASH_COMBINE( seed, bufferCaptureDescriptorDataInfoEXT.pNext );
1603  VULKAN_HPP_HASH_COMBINE( seed, bufferCaptureDescriptorDataInfoEXT.buffer );
1604  return seed;
1605  }
1606  };
1607 
1608 # if defined( VK_USE_PLATFORM_FUCHSIA )
1609  template <>
1610  struct hash<VULKAN_HPP_NAMESPACE::BufferCollectionBufferCreateInfoFUCHSIA>
1611  {
1612  std::size_t
1613  operator()( VULKAN_HPP_NAMESPACE::BufferCollectionBufferCreateInfoFUCHSIA const & bufferCollectionBufferCreateInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT
1614  {
1615  std::size_t seed = 0;
1616  VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionBufferCreateInfoFUCHSIA.sType );
1617  VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionBufferCreateInfoFUCHSIA.pNext );
1618  VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionBufferCreateInfoFUCHSIA.collection );
1619  VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionBufferCreateInfoFUCHSIA.index );
1620  return seed;
1621  }
1622  };
1623 # endif /*VK_USE_PLATFORM_FUCHSIA*/
1624 
1625 # if defined( VK_USE_PLATFORM_FUCHSIA )
1626  template <>
1627  struct hash<VULKAN_HPP_NAMESPACE::BufferCollectionConstraintsInfoFUCHSIA>
1628  {
1629  std::size_t
1630  operator()( VULKAN_HPP_NAMESPACE::BufferCollectionConstraintsInfoFUCHSIA const & bufferCollectionConstraintsInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT
1631  {
1632  std::size_t seed = 0;
1633  VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionConstraintsInfoFUCHSIA.sType );
1634  VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionConstraintsInfoFUCHSIA.pNext );
1635  VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionConstraintsInfoFUCHSIA.minBufferCount );
1636  VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionConstraintsInfoFUCHSIA.maxBufferCount );
1637  VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionConstraintsInfoFUCHSIA.minBufferCountForCamping );
1638  VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionConstraintsInfoFUCHSIA.minBufferCountForDedicatedSlack );
1639  VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionConstraintsInfoFUCHSIA.minBufferCountForSharedSlack );
1640  return seed;
1641  }
1642  };
1643 # endif /*VK_USE_PLATFORM_FUCHSIA*/
1644 
1645 # if defined( VK_USE_PLATFORM_FUCHSIA )
1646  template <>
1647  struct hash<VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA>
1648  {
1649  std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA const & bufferCollectionCreateInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT
1650  {
1651  std::size_t seed = 0;
1652  VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionCreateInfoFUCHSIA.sType );
1653  VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionCreateInfoFUCHSIA.pNext );
1654  VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionCreateInfoFUCHSIA.collectionToken );
1655  return seed;
1656  }
1657  };
1658 # endif /*VK_USE_PLATFORM_FUCHSIA*/
1659 
1660 # if defined( VK_USE_PLATFORM_FUCHSIA )
1661  template <>
1662  struct hash<VULKAN_HPP_NAMESPACE::BufferCollectionImageCreateInfoFUCHSIA>
1663  {
1664  std::size_t
1665  operator()( VULKAN_HPP_NAMESPACE::BufferCollectionImageCreateInfoFUCHSIA const & bufferCollectionImageCreateInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT
1666  {
1667  std::size_t seed = 0;
1668  VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionImageCreateInfoFUCHSIA.sType );
1669  VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionImageCreateInfoFUCHSIA.pNext );
1670  VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionImageCreateInfoFUCHSIA.collection );
1671  VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionImageCreateInfoFUCHSIA.index );
1672  return seed;
1673  }
1674  };
1675 # endif /*VK_USE_PLATFORM_FUCHSIA*/
1676 
1677 # if defined( VK_USE_PLATFORM_FUCHSIA )
1678  template <>
1679  struct hash<VULKAN_HPP_NAMESPACE::SysmemColorSpaceFUCHSIA>
1680  {
1681  std::size_t operator()( VULKAN_HPP_NAMESPACE::SysmemColorSpaceFUCHSIA const & sysmemColorSpaceFUCHSIA ) const VULKAN_HPP_NOEXCEPT
1682  {
1683  std::size_t seed = 0;
1684  VULKAN_HPP_HASH_COMBINE( seed, sysmemColorSpaceFUCHSIA.sType );
1685  VULKAN_HPP_HASH_COMBINE( seed, sysmemColorSpaceFUCHSIA.pNext );
1686  VULKAN_HPP_HASH_COMBINE( seed, sysmemColorSpaceFUCHSIA.colorSpace );
1687  return seed;
1688  }
1689  };
1690 # endif /*VK_USE_PLATFORM_FUCHSIA*/
1691 
1692 # if defined( VK_USE_PLATFORM_FUCHSIA )
1693  template <>
1694  struct hash<VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA>
1695  {
1696  std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA const & bufferCollectionPropertiesFUCHSIA ) const VULKAN_HPP_NOEXCEPT
1697  {
1698  std::size_t seed = 0;
1699  VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.sType );
1700  VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.pNext );
1701  VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.memoryTypeBits );
1702  VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.bufferCount );
1703  VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.createInfoIndex );
1704  VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.sysmemPixelFormat );
1705  VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.formatFeatures );
1706  VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.sysmemColorSpaceIndex );
1707  VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.samplerYcbcrConversionComponents );
1708  VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.suggestedYcbcrModel );
1709  VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.suggestedYcbcrRange );
1710  VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.suggestedXChromaOffset );
1711  VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.suggestedYChromaOffset );
1712  return seed;
1713  }
1714  };
1715 # endif /*VK_USE_PLATFORM_FUCHSIA*/
1716 
1717  template <>
1718  struct hash<VULKAN_HPP_NAMESPACE::BufferCreateInfo>
1719  {
1720  std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCreateInfo const & bufferCreateInfo ) const VULKAN_HPP_NOEXCEPT
1721  {
1722  std::size_t seed = 0;
1723  VULKAN_HPP_HASH_COMBINE( seed, bufferCreateInfo.sType );
1724  VULKAN_HPP_HASH_COMBINE( seed, bufferCreateInfo.pNext );
1725  VULKAN_HPP_HASH_COMBINE( seed, bufferCreateInfo.flags );
1726  VULKAN_HPP_HASH_COMBINE( seed, bufferCreateInfo.size );
1727  VULKAN_HPP_HASH_COMBINE( seed, bufferCreateInfo.usage );
1728  VULKAN_HPP_HASH_COMBINE( seed, bufferCreateInfo.sharingMode );
1729  VULKAN_HPP_HASH_COMBINE( seed, bufferCreateInfo.queueFamilyIndexCount );
1730  VULKAN_HPP_HASH_COMBINE( seed, bufferCreateInfo.pQueueFamilyIndices );
1731  return seed;
1732  }
1733  };
1734 
1735 # if defined( VK_USE_PLATFORM_FUCHSIA )
1736  template <>
1737  struct hash<VULKAN_HPP_NAMESPACE::BufferConstraintsInfoFUCHSIA>
1738  {
1739  std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferConstraintsInfoFUCHSIA const & bufferConstraintsInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT
1740  {
1741  std::size_t seed = 0;
1742  VULKAN_HPP_HASH_COMBINE( seed, bufferConstraintsInfoFUCHSIA.sType );
1743  VULKAN_HPP_HASH_COMBINE( seed, bufferConstraintsInfoFUCHSIA.pNext );
1744  VULKAN_HPP_HASH_COMBINE( seed, bufferConstraintsInfoFUCHSIA.createInfo );
1745  VULKAN_HPP_HASH_COMBINE( seed, bufferConstraintsInfoFUCHSIA.requiredFormatFeatures );
1746  VULKAN_HPP_HASH_COMBINE( seed, bufferConstraintsInfoFUCHSIA.bufferCollectionConstraints );
1747  return seed;
1748  }
1749  };
1750 # endif /*VK_USE_PLATFORM_FUCHSIA*/
1751 
1752  template <>
1753  struct hash<VULKAN_HPP_NAMESPACE::BufferCopy>
1754  {
1755  std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCopy const & bufferCopy ) const VULKAN_HPP_NOEXCEPT
1756  {
1757  std::size_t seed = 0;
1758  VULKAN_HPP_HASH_COMBINE( seed, bufferCopy.srcOffset );
1759  VULKAN_HPP_HASH_COMBINE( seed, bufferCopy.dstOffset );
1760  VULKAN_HPP_HASH_COMBINE( seed, bufferCopy.size );
1761  return seed;
1762  }
1763  };
1764 
1765  template <>
1766  struct hash<VULKAN_HPP_NAMESPACE::BufferCopy2>
1767  {
1768  std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCopy2 const & bufferCopy2 ) const VULKAN_HPP_NOEXCEPT
1769  {
1770  std::size_t seed = 0;
1771  VULKAN_HPP_HASH_COMBINE( seed, bufferCopy2.sType );
1772  VULKAN_HPP_HASH_COMBINE( seed, bufferCopy2.pNext );
1773  VULKAN_HPP_HASH_COMBINE( seed, bufferCopy2.srcOffset );
1774  VULKAN_HPP_HASH_COMBINE( seed, bufferCopy2.dstOffset );
1775  VULKAN_HPP_HASH_COMBINE( seed, bufferCopy2.size );
1776  return seed;
1777  }
1778  };
1779 
1780  template <>
1781  struct hash<VULKAN_HPP_NAMESPACE::BufferDeviceAddressCreateInfoEXT>
1782  {
1783  std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferDeviceAddressCreateInfoEXT const & bufferDeviceAddressCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
1784  {
1785  std::size_t seed = 0;
1786  VULKAN_HPP_HASH_COMBINE( seed, bufferDeviceAddressCreateInfoEXT.sType );
1787  VULKAN_HPP_HASH_COMBINE( seed, bufferDeviceAddressCreateInfoEXT.pNext );
1788  VULKAN_HPP_HASH_COMBINE( seed, bufferDeviceAddressCreateInfoEXT.deviceAddress );
1789  return seed;
1790  }
1791  };
1792 
1793  template <>
1794  struct hash<VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo>
1795  {
1796  std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo const & bufferDeviceAddressInfo ) const VULKAN_HPP_NOEXCEPT
1797  {
1798  std::size_t seed = 0;
1799  VULKAN_HPP_HASH_COMBINE( seed, bufferDeviceAddressInfo.sType );
1800  VULKAN_HPP_HASH_COMBINE( seed, bufferDeviceAddressInfo.pNext );
1801  VULKAN_HPP_HASH_COMBINE( seed, bufferDeviceAddressInfo.buffer );
1802  return seed;
1803  }
1804  };
1805 
1806  template <>
1807  struct hash<VULKAN_HPP_NAMESPACE::BufferImageCopy>
1808  {
1809  std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferImageCopy const & bufferImageCopy ) const VULKAN_HPP_NOEXCEPT
1810  {
1811  std::size_t seed = 0;
1812  VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy.bufferOffset );
1813  VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy.bufferRowLength );
1814  VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy.bufferImageHeight );
1815  VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy.imageSubresource );
1816  VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy.imageOffset );
1817  VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy.imageExtent );
1818  return seed;
1819  }
1820  };
1821 
1822  template <>
1823  struct hash<VULKAN_HPP_NAMESPACE::BufferImageCopy2>
1824  {
1825  std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferImageCopy2 const & bufferImageCopy2 ) const VULKAN_HPP_NOEXCEPT
1826  {
1827  std::size_t seed = 0;
1828  VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy2.sType );
1829  VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy2.pNext );
1830  VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy2.bufferOffset );
1831  VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy2.bufferRowLength );
1832  VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy2.bufferImageHeight );
1833  VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy2.imageSubresource );
1834  VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy2.imageOffset );
1835  VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy2.imageExtent );
1836  return seed;
1837  }
1838  };
1839 
1840  template <>
1841  struct hash<VULKAN_HPP_NAMESPACE::BufferMemoryBarrier>
1842  {
1843  std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferMemoryBarrier const & bufferMemoryBarrier ) const VULKAN_HPP_NOEXCEPT
1844  {
1845  std::size_t seed = 0;
1846  VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.sType );
1847  VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.pNext );
1848  VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.srcAccessMask );
1849  VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.dstAccessMask );
1850  VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.srcQueueFamilyIndex );
1851  VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.dstQueueFamilyIndex );
1852  VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.buffer );
1853  VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.offset );
1854  VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.size );
1855  return seed;
1856  }
1857  };
1858 
1859  template <>
1860  struct hash<VULKAN_HPP_NAMESPACE::BufferMemoryBarrier2>
1861  {
1862  std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferMemoryBarrier2 const & bufferMemoryBarrier2 ) const VULKAN_HPP_NOEXCEPT
1863  {
1864  std::size_t seed = 0;
1865  VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.sType );
1866  VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.pNext );
1867  VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.srcStageMask );
1868  VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.srcAccessMask );
1869  VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.dstStageMask );
1870  VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.dstAccessMask );
1871  VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.srcQueueFamilyIndex );
1872  VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.dstQueueFamilyIndex );
1873  VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.buffer );
1874  VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.offset );
1875  VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.size );
1876  return seed;
1877  }
1878  };
1879 
1880  template <>
1881  struct hash<VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2>
1882  {
1883  std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 const & bufferMemoryRequirementsInfo2 ) const VULKAN_HPP_NOEXCEPT
1884  {
1885  std::size_t seed = 0;
1886  VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryRequirementsInfo2.sType );
1887  VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryRequirementsInfo2.pNext );
1888  VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryRequirementsInfo2.buffer );
1889  return seed;
1890  }
1891  };
1892 
1893  template <>
1894  struct hash<VULKAN_HPP_NAMESPACE::BufferOpaqueCaptureAddressCreateInfo>
1895  {
1896  std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferOpaqueCaptureAddressCreateInfo const & bufferOpaqueCaptureAddressCreateInfo ) const VULKAN_HPP_NOEXCEPT
1897  {
1898  std::size_t seed = 0;
1899  VULKAN_HPP_HASH_COMBINE( seed, bufferOpaqueCaptureAddressCreateInfo.sType );
1900  VULKAN_HPP_HASH_COMBINE( seed, bufferOpaqueCaptureAddressCreateInfo.pNext );
1901  VULKAN_HPP_HASH_COMBINE( seed, bufferOpaqueCaptureAddressCreateInfo.opaqueCaptureAddress );
1902  return seed;
1903  }
1904  };
1905 
1906  template <>
1907  struct hash<VULKAN_HPP_NAMESPACE::BufferViewCreateInfo>
1908  {
1909  std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferViewCreateInfo const & bufferViewCreateInfo ) const VULKAN_HPP_NOEXCEPT
1910  {
1911  std::size_t seed = 0;
1912  VULKAN_HPP_HASH_COMBINE( seed, bufferViewCreateInfo.sType );
1913  VULKAN_HPP_HASH_COMBINE( seed, bufferViewCreateInfo.pNext );
1914  VULKAN_HPP_HASH_COMBINE( seed, bufferViewCreateInfo.flags );
1915  VULKAN_HPP_HASH_COMBINE( seed, bufferViewCreateInfo.buffer );
1916  VULKAN_HPP_HASH_COMBINE( seed, bufferViewCreateInfo.format );
1917  VULKAN_HPP_HASH_COMBINE( seed, bufferViewCreateInfo.offset );
1918  VULKAN_HPP_HASH_COMBINE( seed, bufferViewCreateInfo.range );
1919  return seed;
1920  }
1921  };
1922 
1923  template <>
1924  struct hash<VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT>
1925  {
1926  std::size_t operator()( VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT const & calibratedTimestampInfoEXT ) const VULKAN_HPP_NOEXCEPT
1927  {
1928  std::size_t seed = 0;
1929  VULKAN_HPP_HASH_COMBINE( seed, calibratedTimestampInfoEXT.sType );
1930  VULKAN_HPP_HASH_COMBINE( seed, calibratedTimestampInfoEXT.pNext );
1931  VULKAN_HPP_HASH_COMBINE( seed, calibratedTimestampInfoEXT.timeDomain );
1932  return seed;
1933  }
1934  };
1935 
1936  template <>
1937  struct hash<VULKAN_HPP_NAMESPACE::CheckpointData2NV>
1938  {
1939  std::size_t operator()( VULKAN_HPP_NAMESPACE::CheckpointData2NV const & checkpointData2NV ) const VULKAN_HPP_NOEXCEPT
1940  {
1941  std::size_t seed = 0;
1942  VULKAN_HPP_HASH_COMBINE( seed, checkpointData2NV.sType );
1943  VULKAN_HPP_HASH_COMBINE( seed, checkpointData2NV.pNext );
1944  VULKAN_HPP_HASH_COMBINE( seed, checkpointData2NV.stage );
1945  VULKAN_HPP_HASH_COMBINE( seed, checkpointData2NV.pCheckpointMarker );
1946  return seed;
1947  }
1948  };
1949 
1950  template <>
1951  struct hash<VULKAN_HPP_NAMESPACE::CheckpointDataNV>
1952  {
1953  std::size_t operator()( VULKAN_HPP_NAMESPACE::CheckpointDataNV const & checkpointDataNV ) const VULKAN_HPP_NOEXCEPT
1954  {
1955  std::size_t seed = 0;
1956  VULKAN_HPP_HASH_COMBINE( seed, checkpointDataNV.sType );
1957  VULKAN_HPP_HASH_COMBINE( seed, checkpointDataNV.pNext );
1958  VULKAN_HPP_HASH_COMBINE( seed, checkpointDataNV.stage );
1959  VULKAN_HPP_HASH_COMBINE( seed, checkpointDataNV.pCheckpointMarker );
1960  return seed;
1961  }
1962  };
1963 
1964  template <>
1965  struct hash<VULKAN_HPP_NAMESPACE::ClearDepthStencilValue>
1966  {
1967  std::size_t operator()( VULKAN_HPP_NAMESPACE::ClearDepthStencilValue const & clearDepthStencilValue ) const VULKAN_HPP_NOEXCEPT
1968  {
1969  std::size_t seed = 0;
1970  VULKAN_HPP_HASH_COMBINE( seed, clearDepthStencilValue.depth );
1971  VULKAN_HPP_HASH_COMBINE( seed, clearDepthStencilValue.stencil );
1972  return seed;
1973  }
1974  };
1975 
1976  template <>
1977  struct hash<VULKAN_HPP_NAMESPACE::ClearRect>
1978  {
1979  std::size_t operator()( VULKAN_HPP_NAMESPACE::ClearRect const & clearRect ) const VULKAN_HPP_NOEXCEPT
1980  {
1981  std::size_t seed = 0;
1982  VULKAN_HPP_HASH_COMBINE( seed, clearRect.rect );
1983  VULKAN_HPP_HASH_COMBINE( seed, clearRect.baseArrayLayer );
1984  VULKAN_HPP_HASH_COMBINE( seed, clearRect.layerCount );
1985  return seed;
1986  }
1987  };
1988 
1989  template <>
1990  struct hash<VULKAN_HPP_NAMESPACE::CoarseSampleLocationNV>
1991  {
1992  std::size_t operator()( VULKAN_HPP_NAMESPACE::CoarseSampleLocationNV const & coarseSampleLocationNV ) const VULKAN_HPP_NOEXCEPT
1993  {
1994  std::size_t seed = 0;
1995  VULKAN_HPP_HASH_COMBINE( seed, coarseSampleLocationNV.pixelX );
1996  VULKAN_HPP_HASH_COMBINE( seed, coarseSampleLocationNV.pixelY );
1997  VULKAN_HPP_HASH_COMBINE( seed, coarseSampleLocationNV.sample );
1998  return seed;
1999  }
2000  };
2001 
2002  template <>
2003  struct hash<VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV>
2004  {
2005  std::size_t operator()( VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV const & coarseSampleOrderCustomNV ) const VULKAN_HPP_NOEXCEPT
2006  {
2007  std::size_t seed = 0;
2008  VULKAN_HPP_HASH_COMBINE( seed, coarseSampleOrderCustomNV.shadingRate );
2009  VULKAN_HPP_HASH_COMBINE( seed, coarseSampleOrderCustomNV.sampleCount );
2010  VULKAN_HPP_HASH_COMBINE( seed, coarseSampleOrderCustomNV.sampleLocationCount );
2011  VULKAN_HPP_HASH_COMBINE( seed, coarseSampleOrderCustomNV.pSampleLocations );
2012  return seed;
2013  }
2014  };
2015 
2016  template <>
2017  struct hash<VULKAN_HPP_NAMESPACE::ColorBlendAdvancedEXT>
2018  {
2019  std::size_t operator()( VULKAN_HPP_NAMESPACE::ColorBlendAdvancedEXT const & colorBlendAdvancedEXT ) const VULKAN_HPP_NOEXCEPT
2020  {
2021  std::size_t seed = 0;
2022  VULKAN_HPP_HASH_COMBINE( seed, colorBlendAdvancedEXT.advancedBlendOp );
2023  VULKAN_HPP_HASH_COMBINE( seed, colorBlendAdvancedEXT.srcPremultiplied );
2024  VULKAN_HPP_HASH_COMBINE( seed, colorBlendAdvancedEXT.dstPremultiplied );
2025  VULKAN_HPP_HASH_COMBINE( seed, colorBlendAdvancedEXT.blendOverlap );
2026  VULKAN_HPP_HASH_COMBINE( seed, colorBlendAdvancedEXT.clampResults );
2027  return seed;
2028  }
2029  };
2030 
2031  template <>
2032  struct hash<VULKAN_HPP_NAMESPACE::ColorBlendEquationEXT>
2033  {
2034  std::size_t operator()( VULKAN_HPP_NAMESPACE::ColorBlendEquationEXT const & colorBlendEquationEXT ) const VULKAN_HPP_NOEXCEPT
2035  {
2036  std::size_t seed = 0;
2037  VULKAN_HPP_HASH_COMBINE( seed, colorBlendEquationEXT.srcColorBlendFactor );
2038  VULKAN_HPP_HASH_COMBINE( seed, colorBlendEquationEXT.dstColorBlendFactor );
2039  VULKAN_HPP_HASH_COMBINE( seed, colorBlendEquationEXT.colorBlendOp );
2040  VULKAN_HPP_HASH_COMBINE( seed, colorBlendEquationEXT.srcAlphaBlendFactor );
2041  VULKAN_HPP_HASH_COMBINE( seed, colorBlendEquationEXT.dstAlphaBlendFactor );
2042  VULKAN_HPP_HASH_COMBINE( seed, colorBlendEquationEXT.alphaBlendOp );
2043  return seed;
2044  }
2045  };
2046 
2047  template <>
2048  struct hash<VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo>
2049  {
2050  std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo const & commandBufferAllocateInfo ) const VULKAN_HPP_NOEXCEPT
2051  {
2052  std::size_t seed = 0;
2053  VULKAN_HPP_HASH_COMBINE( seed, commandBufferAllocateInfo.sType );
2054  VULKAN_HPP_HASH_COMBINE( seed, commandBufferAllocateInfo.pNext );
2055  VULKAN_HPP_HASH_COMBINE( seed, commandBufferAllocateInfo.commandPool );
2056  VULKAN_HPP_HASH_COMBINE( seed, commandBufferAllocateInfo.level );
2057  VULKAN_HPP_HASH_COMBINE( seed, commandBufferAllocateInfo.commandBufferCount );
2058  return seed;
2059  }
2060  };
2061 
2062  template <>
2063  struct hash<VULKAN_HPP_NAMESPACE::CommandBufferInheritanceInfo>
2064  {
2065  std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceInfo const & commandBufferInheritanceInfo ) const VULKAN_HPP_NOEXCEPT
2066  {
2067  std::size_t seed = 0;
2068  VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceInfo.sType );
2069  VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceInfo.pNext );
2070  VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceInfo.renderPass );
2071  VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceInfo.subpass );
2072  VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceInfo.framebuffer );
2073  VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceInfo.occlusionQueryEnable );
2074  VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceInfo.queryFlags );
2075  VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceInfo.pipelineStatistics );
2076  return seed;
2077  }
2078  };
2079 
2080  template <>
2081  struct hash<VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo>
2082  {
2083  std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo const & commandBufferBeginInfo ) const VULKAN_HPP_NOEXCEPT
2084  {
2085  std::size_t seed = 0;
2086  VULKAN_HPP_HASH_COMBINE( seed, commandBufferBeginInfo.sType );
2087  VULKAN_HPP_HASH_COMBINE( seed, commandBufferBeginInfo.pNext );
2088  VULKAN_HPP_HASH_COMBINE( seed, commandBufferBeginInfo.flags );
2089  VULKAN_HPP_HASH_COMBINE( seed, commandBufferBeginInfo.pInheritanceInfo );
2090  return seed;
2091  }
2092  };
2093 
2094  template <>
2095  struct hash<VULKAN_HPP_NAMESPACE::CommandBufferInheritanceConditionalRenderingInfoEXT>
2096  {
2097  std::size_t
2098  operator()( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceConditionalRenderingInfoEXT const & commandBufferInheritanceConditionalRenderingInfoEXT ) const
2099  VULKAN_HPP_NOEXCEPT
2100  {
2101  std::size_t seed = 0;
2102  VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceConditionalRenderingInfoEXT.sType );
2103  VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceConditionalRenderingInfoEXT.pNext );
2104  VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceConditionalRenderingInfoEXT.conditionalRenderingEnable );
2105  return seed;
2106  }
2107  };
2108 
2109  template <>
2110  struct hash<VULKAN_HPP_NAMESPACE::CommandBufferInheritanceRenderPassTransformInfoQCOM>
2111  {
2112  std::size_t
2113  operator()( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceRenderPassTransformInfoQCOM const & commandBufferInheritanceRenderPassTransformInfoQCOM ) const
2114  VULKAN_HPP_NOEXCEPT
2115  {
2116  std::size_t seed = 0;
2117  VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderPassTransformInfoQCOM.sType );
2118  VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderPassTransformInfoQCOM.pNext );
2119  VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderPassTransformInfoQCOM.transform );
2120  VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderPassTransformInfoQCOM.renderArea );
2121  return seed;
2122  }
2123  };
2124 
2125  template <>
2126  struct hash<VULKAN_HPP_NAMESPACE::CommandBufferInheritanceRenderingInfo>
2127  {
2128  std::size_t
2129  operator()( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceRenderingInfo const & commandBufferInheritanceRenderingInfo ) const VULKAN_HPP_NOEXCEPT
2130  {
2131  std::size_t seed = 0;
2132  VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.sType );
2133  VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.pNext );
2134  VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.flags );
2135  VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.viewMask );
2136  VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.colorAttachmentCount );
2137  VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.pColorAttachmentFormats );
2138  VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.depthAttachmentFormat );
2139  VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.stencilAttachmentFormat );
2140  VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.rasterizationSamples );
2141  return seed;
2142  }
2143  };
2144 
2145  template <>
2146  struct hash<VULKAN_HPP_NAMESPACE::Viewport>
2147  {
2148  std::size_t operator()( VULKAN_HPP_NAMESPACE::Viewport const & viewport ) const VULKAN_HPP_NOEXCEPT
2149  {
2150  std::size_t seed = 0;
2151  VULKAN_HPP_HASH_COMBINE( seed, viewport.x );
2152  VULKAN_HPP_HASH_COMBINE( seed, viewport.y );
2153  VULKAN_HPP_HASH_COMBINE( seed, viewport.width );
2154  VULKAN_HPP_HASH_COMBINE( seed, viewport.height );
2155  VULKAN_HPP_HASH_COMBINE( seed, viewport.minDepth );
2156  VULKAN_HPP_HASH_COMBINE( seed, viewport.maxDepth );
2157  return seed;
2158  }
2159  };
2160 
2161  template <>
2162  struct hash<VULKAN_HPP_NAMESPACE::CommandBufferInheritanceViewportScissorInfoNV>
2163  {
2164  std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceViewportScissorInfoNV const & commandBufferInheritanceViewportScissorInfoNV ) const
2165  VULKAN_HPP_NOEXCEPT
2166  {
2167  std::size_t seed = 0;
2168  VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceViewportScissorInfoNV.sType );
2169  VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceViewportScissorInfoNV.pNext );
2170  VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceViewportScissorInfoNV.viewportScissor2D );
2171  VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceViewportScissorInfoNV.viewportDepthCount );
2172  VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceViewportScissorInfoNV.pViewportDepths );
2173  return seed;
2174  }
2175  };
2176 
2177  template <>
2178  struct hash<VULKAN_HPP_NAMESPACE::CommandBufferSubmitInfo>
2179  {
2180  std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBufferSubmitInfo const & commandBufferSubmitInfo ) const VULKAN_HPP_NOEXCEPT
2181  {
2182  std::size_t seed = 0;
2183  VULKAN_HPP_HASH_COMBINE( seed, commandBufferSubmitInfo.sType );
2184  VULKAN_HPP_HASH_COMBINE( seed, commandBufferSubmitInfo.pNext );
2185  VULKAN_HPP_HASH_COMBINE( seed, commandBufferSubmitInfo.commandBuffer );
2186  VULKAN_HPP_HASH_COMBINE( seed, commandBufferSubmitInfo.deviceMask );
2187  return seed;
2188  }
2189  };
2190 
2191  template <>
2192  struct hash<VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo>
2193  {
2194  std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo const & commandPoolCreateInfo ) const VULKAN_HPP_NOEXCEPT
2195  {
2196  std::size_t seed = 0;
2197  VULKAN_HPP_HASH_COMBINE( seed, commandPoolCreateInfo.sType );
2198  VULKAN_HPP_HASH_COMBINE( seed, commandPoolCreateInfo.pNext );
2199  VULKAN_HPP_HASH_COMBINE( seed, commandPoolCreateInfo.flags );
2200  VULKAN_HPP_HASH_COMBINE( seed, commandPoolCreateInfo.queueFamilyIndex );
2201  return seed;
2202  }
2203  };
2204 
2205  template <>
2206  struct hash<VULKAN_HPP_NAMESPACE::SpecializationMapEntry>
2207  {
2208  std::size_t operator()( VULKAN_HPP_NAMESPACE::SpecializationMapEntry const & specializationMapEntry ) const VULKAN_HPP_NOEXCEPT
2209  {
2210  std::size_t seed = 0;
2211  VULKAN_HPP_HASH_COMBINE( seed, specializationMapEntry.constantID );
2212  VULKAN_HPP_HASH_COMBINE( seed, specializationMapEntry.offset );
2213  VULKAN_HPP_HASH_COMBINE( seed, specializationMapEntry.size );
2214  return seed;
2215  }
2216  };
2217 
2218  template <>
2219  struct hash<VULKAN_HPP_NAMESPACE::SpecializationInfo>
2220  {
2221  std::size_t operator()( VULKAN_HPP_NAMESPACE::SpecializationInfo const & specializationInfo ) const VULKAN_HPP_NOEXCEPT
2222  {
2223  std::size_t seed = 0;
2224  VULKAN_HPP_HASH_COMBINE( seed, specializationInfo.mapEntryCount );
2225  VULKAN_HPP_HASH_COMBINE( seed, specializationInfo.pMapEntries );
2226  VULKAN_HPP_HASH_COMBINE( seed, specializationInfo.dataSize );
2227  VULKAN_HPP_HASH_COMBINE( seed, specializationInfo.pData );
2228  return seed;
2229  }
2230  };
2231 
2232  template <>
2233  struct hash<VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo>
2234  {
2235  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo const & pipelineShaderStageCreateInfo ) const VULKAN_HPP_NOEXCEPT
2236  {
2237  std::size_t seed = 0;
2238  VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageCreateInfo.sType );
2239  VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageCreateInfo.pNext );
2240  VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageCreateInfo.flags );
2241  VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageCreateInfo.stage );
2242  VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageCreateInfo.module );
2243  for ( const char * p = pipelineShaderStageCreateInfo.pName; *p != '\0'; ++p )
2244  {
2245  VULKAN_HPP_HASH_COMBINE( seed, *p );
2246  }
2247  VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageCreateInfo.pSpecializationInfo );
2248  return seed;
2249  }
2250  };
2251 
2252  template <>
2253  struct hash<VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo>
2254  {
2255  std::size_t operator()( VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo const & computePipelineCreateInfo ) const VULKAN_HPP_NOEXCEPT
2256  {
2257  std::size_t seed = 0;
2258  VULKAN_HPP_HASH_COMBINE( seed, computePipelineCreateInfo.sType );
2259  VULKAN_HPP_HASH_COMBINE( seed, computePipelineCreateInfo.pNext );
2260  VULKAN_HPP_HASH_COMBINE( seed, computePipelineCreateInfo.flags );
2261  VULKAN_HPP_HASH_COMBINE( seed, computePipelineCreateInfo.stage );
2262  VULKAN_HPP_HASH_COMBINE( seed, computePipelineCreateInfo.layout );
2263  VULKAN_HPP_HASH_COMBINE( seed, computePipelineCreateInfo.basePipelineHandle );
2264  VULKAN_HPP_HASH_COMBINE( seed, computePipelineCreateInfo.basePipelineIndex );
2265  return seed;
2266  }
2267  };
2268 
2269  template <>
2270  struct hash<VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfoEXT>
2271  {
2272  std::size_t operator()( VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfoEXT const & conditionalRenderingBeginInfoEXT ) const VULKAN_HPP_NOEXCEPT
2273  {
2274  std::size_t seed = 0;
2275  VULKAN_HPP_HASH_COMBINE( seed, conditionalRenderingBeginInfoEXT.sType );
2276  VULKAN_HPP_HASH_COMBINE( seed, conditionalRenderingBeginInfoEXT.pNext );
2277  VULKAN_HPP_HASH_COMBINE( seed, conditionalRenderingBeginInfoEXT.buffer );
2278  VULKAN_HPP_HASH_COMBINE( seed, conditionalRenderingBeginInfoEXT.offset );
2279  VULKAN_HPP_HASH_COMBINE( seed, conditionalRenderingBeginInfoEXT.flags );
2280  return seed;
2281  }
2282  };
2283 
2284  template <>
2285  struct hash<VULKAN_HPP_NAMESPACE::ConformanceVersion>
2286  {
2287  std::size_t operator()( VULKAN_HPP_NAMESPACE::ConformanceVersion const & conformanceVersion ) const VULKAN_HPP_NOEXCEPT
2288  {
2289  std::size_t seed = 0;
2290  VULKAN_HPP_HASH_COMBINE( seed, conformanceVersion.major );
2291  VULKAN_HPP_HASH_COMBINE( seed, conformanceVersion.minor );
2292  VULKAN_HPP_HASH_COMBINE( seed, conformanceVersion.subminor );
2293  VULKAN_HPP_HASH_COMBINE( seed, conformanceVersion.patch );
2294  return seed;
2295  }
2296  };
2297 
2298  template <>
2299  struct hash<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV>
2300  {
2301  std::size_t operator()( VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV const & cooperativeMatrixPropertiesNV ) const VULKAN_HPP_NOEXCEPT
2302  {
2303  std::size_t seed = 0;
2304  VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.sType );
2305  VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.pNext );
2306  VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.MSize );
2307  VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.NSize );
2308  VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.KSize );
2309  VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.AType );
2310  VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.BType );
2311  VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.CType );
2312  VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.DType );
2313  VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.scope );
2314  return seed;
2315  }
2316  };
2317 
2318  template <>
2319  struct hash<VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR>
2320  {
2321  std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR const & copyAccelerationStructureInfoKHR ) const VULKAN_HPP_NOEXCEPT
2322  {
2323  std::size_t seed = 0;
2324  VULKAN_HPP_HASH_COMBINE( seed, copyAccelerationStructureInfoKHR.sType );
2325  VULKAN_HPP_HASH_COMBINE( seed, copyAccelerationStructureInfoKHR.pNext );
2326  VULKAN_HPP_HASH_COMBINE( seed, copyAccelerationStructureInfoKHR.src );
2327  VULKAN_HPP_HASH_COMBINE( seed, copyAccelerationStructureInfoKHR.dst );
2328  VULKAN_HPP_HASH_COMBINE( seed, copyAccelerationStructureInfoKHR.mode );
2329  return seed;
2330  }
2331  };
2332 
2333  template <>
2334  struct hash<VULKAN_HPP_NAMESPACE::CopyBufferInfo2>
2335  {
2336  std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyBufferInfo2 const & copyBufferInfo2 ) const VULKAN_HPP_NOEXCEPT
2337  {
2338  std::size_t seed = 0;
2339  VULKAN_HPP_HASH_COMBINE( seed, copyBufferInfo2.sType );
2340  VULKAN_HPP_HASH_COMBINE( seed, copyBufferInfo2.pNext );
2341  VULKAN_HPP_HASH_COMBINE( seed, copyBufferInfo2.srcBuffer );
2342  VULKAN_HPP_HASH_COMBINE( seed, copyBufferInfo2.dstBuffer );
2343  VULKAN_HPP_HASH_COMBINE( seed, copyBufferInfo2.regionCount );
2344  VULKAN_HPP_HASH_COMBINE( seed, copyBufferInfo2.pRegions );
2345  return seed;
2346  }
2347  };
2348 
2349  template <>
2350  struct hash<VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2>
2351  {
2352  std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 const & copyBufferToImageInfo2 ) const VULKAN_HPP_NOEXCEPT
2353  {
2354  std::size_t seed = 0;
2355  VULKAN_HPP_HASH_COMBINE( seed, copyBufferToImageInfo2.sType );
2356  VULKAN_HPP_HASH_COMBINE( seed, copyBufferToImageInfo2.pNext );
2357  VULKAN_HPP_HASH_COMBINE( seed, copyBufferToImageInfo2.srcBuffer );
2358  VULKAN_HPP_HASH_COMBINE( seed, copyBufferToImageInfo2.dstImage );
2359  VULKAN_HPP_HASH_COMBINE( seed, copyBufferToImageInfo2.dstImageLayout );
2360  VULKAN_HPP_HASH_COMBINE( seed, copyBufferToImageInfo2.regionCount );
2361  VULKAN_HPP_HASH_COMBINE( seed, copyBufferToImageInfo2.pRegions );
2362  return seed;
2363  }
2364  };
2365 
2366  template <>
2367  struct hash<VULKAN_HPP_NAMESPACE::CopyCommandTransformInfoQCOM>
2368  {
2369  std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyCommandTransformInfoQCOM const & copyCommandTransformInfoQCOM ) const VULKAN_HPP_NOEXCEPT
2370  {
2371  std::size_t seed = 0;
2372  VULKAN_HPP_HASH_COMBINE( seed, copyCommandTransformInfoQCOM.sType );
2373  VULKAN_HPP_HASH_COMBINE( seed, copyCommandTransformInfoQCOM.pNext );
2374  VULKAN_HPP_HASH_COMBINE( seed, copyCommandTransformInfoQCOM.transform );
2375  return seed;
2376  }
2377  };
2378 
2379  template <>
2380  struct hash<VULKAN_HPP_NAMESPACE::CopyDescriptorSet>
2381  {
2382  std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyDescriptorSet const & copyDescriptorSet ) const VULKAN_HPP_NOEXCEPT
2383  {
2384  std::size_t seed = 0;
2385  VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.sType );
2386  VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.pNext );
2387  VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.srcSet );
2388  VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.srcBinding );
2389  VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.srcArrayElement );
2390  VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.dstSet );
2391  VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.dstBinding );
2392  VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.dstArrayElement );
2393  VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.descriptorCount );
2394  return seed;
2395  }
2396  };
2397 
2398  template <>
2399  struct hash<VULKAN_HPP_NAMESPACE::ImageCopy2>
2400  {
2401  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageCopy2 const & imageCopy2 ) const VULKAN_HPP_NOEXCEPT
2402  {
2403  std::size_t seed = 0;
2404  VULKAN_HPP_HASH_COMBINE( seed, imageCopy2.sType );
2405  VULKAN_HPP_HASH_COMBINE( seed, imageCopy2.pNext );
2406  VULKAN_HPP_HASH_COMBINE( seed, imageCopy2.srcSubresource );
2407  VULKAN_HPP_HASH_COMBINE( seed, imageCopy2.srcOffset );
2408  VULKAN_HPP_HASH_COMBINE( seed, imageCopy2.dstSubresource );
2409  VULKAN_HPP_HASH_COMBINE( seed, imageCopy2.dstOffset );
2410  VULKAN_HPP_HASH_COMBINE( seed, imageCopy2.extent );
2411  return seed;
2412  }
2413  };
2414 
2415  template <>
2416  struct hash<VULKAN_HPP_NAMESPACE::CopyImageInfo2>
2417  {
2418  std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyImageInfo2 const & copyImageInfo2 ) const VULKAN_HPP_NOEXCEPT
2419  {
2420  std::size_t seed = 0;
2421  VULKAN_HPP_HASH_COMBINE( seed, copyImageInfo2.sType );
2422  VULKAN_HPP_HASH_COMBINE( seed, copyImageInfo2.pNext );
2423  VULKAN_HPP_HASH_COMBINE( seed, copyImageInfo2.srcImage );
2424  VULKAN_HPP_HASH_COMBINE( seed, copyImageInfo2.srcImageLayout );
2425  VULKAN_HPP_HASH_COMBINE( seed, copyImageInfo2.dstImage );
2426  VULKAN_HPP_HASH_COMBINE( seed, copyImageInfo2.dstImageLayout );
2427  VULKAN_HPP_HASH_COMBINE( seed, copyImageInfo2.regionCount );
2428  VULKAN_HPP_HASH_COMBINE( seed, copyImageInfo2.pRegions );
2429  return seed;
2430  }
2431  };
2432 
2433  template <>
2434  struct hash<VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2>
2435  {
2436  std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 const & copyImageToBufferInfo2 ) const VULKAN_HPP_NOEXCEPT
2437  {
2438  std::size_t seed = 0;
2439  VULKAN_HPP_HASH_COMBINE( seed, copyImageToBufferInfo2.sType );
2440  VULKAN_HPP_HASH_COMBINE( seed, copyImageToBufferInfo2.pNext );
2441  VULKAN_HPP_HASH_COMBINE( seed, copyImageToBufferInfo2.srcImage );
2442  VULKAN_HPP_HASH_COMBINE( seed, copyImageToBufferInfo2.srcImageLayout );
2443  VULKAN_HPP_HASH_COMBINE( seed, copyImageToBufferInfo2.dstBuffer );
2444  VULKAN_HPP_HASH_COMBINE( seed, copyImageToBufferInfo2.regionCount );
2445  VULKAN_HPP_HASH_COMBINE( seed, copyImageToBufferInfo2.pRegions );
2446  return seed;
2447  }
2448  };
2449 
2450  template <>
2451  struct hash<VULKAN_HPP_NAMESPACE::CopyMemoryIndirectCommandNV>
2452  {
2453  std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyMemoryIndirectCommandNV const & copyMemoryIndirectCommandNV ) const VULKAN_HPP_NOEXCEPT
2454  {
2455  std::size_t seed = 0;
2456  VULKAN_HPP_HASH_COMBINE( seed, copyMemoryIndirectCommandNV.srcAddress );
2457  VULKAN_HPP_HASH_COMBINE( seed, copyMemoryIndirectCommandNV.dstAddress );
2458  VULKAN_HPP_HASH_COMBINE( seed, copyMemoryIndirectCommandNV.size );
2459  return seed;
2460  }
2461  };
2462 
2463  template <>
2464  struct hash<VULKAN_HPP_NAMESPACE::CopyMemoryToImageIndirectCommandNV>
2465  {
2466  std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyMemoryToImageIndirectCommandNV const & copyMemoryToImageIndirectCommandNV ) const VULKAN_HPP_NOEXCEPT
2467  {
2468  std::size_t seed = 0;
2469  VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectCommandNV.srcAddress );
2470  VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectCommandNV.bufferRowLength );
2471  VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectCommandNV.bufferImageHeight );
2472  VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectCommandNV.imageSubresource );
2473  VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectCommandNV.imageOffset );
2474  VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectCommandNV.imageExtent );
2475  return seed;
2476  }
2477  };
2478 
2479  template <>
2480  struct hash<VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT>
2481  {
2482  std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT const & copyMicromapInfoEXT ) const VULKAN_HPP_NOEXCEPT
2483  {
2484  std::size_t seed = 0;
2485  VULKAN_HPP_HASH_COMBINE( seed, copyMicromapInfoEXT.sType );
2486  VULKAN_HPP_HASH_COMBINE( seed, copyMicromapInfoEXT.pNext );
2487  VULKAN_HPP_HASH_COMBINE( seed, copyMicromapInfoEXT.src );
2488  VULKAN_HPP_HASH_COMBINE( seed, copyMicromapInfoEXT.dst );
2489  VULKAN_HPP_HASH_COMBINE( seed, copyMicromapInfoEXT.mode );
2490  return seed;
2491  }
2492  };
2493 
2494  template <>
2495  struct hash<VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX>
2496  {
2497  std::size_t operator()( VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX const & cuFunctionCreateInfoNVX ) const VULKAN_HPP_NOEXCEPT
2498  {
2499  std::size_t seed = 0;
2500  VULKAN_HPP_HASH_COMBINE( seed, cuFunctionCreateInfoNVX.sType );
2501  VULKAN_HPP_HASH_COMBINE( seed, cuFunctionCreateInfoNVX.pNext );
2502  VULKAN_HPP_HASH_COMBINE( seed, cuFunctionCreateInfoNVX.module );
2503  for ( const char * p = cuFunctionCreateInfoNVX.pName; *p != '\0'; ++p )
2504  {
2505  VULKAN_HPP_HASH_COMBINE( seed, *p );
2506  }
2507  return seed;
2508  }
2509  };
2510 
2511  template <>
2512  struct hash<VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX>
2513  {
2514  std::size_t operator()( VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX const & cuLaunchInfoNVX ) const VULKAN_HPP_NOEXCEPT
2515  {
2516  std::size_t seed = 0;
2517  VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.sType );
2518  VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.pNext );
2519  VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.function );
2520  VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.gridDimX );
2521  VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.gridDimY );
2522  VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.gridDimZ );
2523  VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.blockDimX );
2524  VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.blockDimY );
2525  VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.blockDimZ );
2526  VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.sharedMemBytes );
2527  VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.paramCount );
2528  VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.pParams );
2529  VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.extraCount );
2530  VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.pExtras );
2531  return seed;
2532  }
2533  };
2534 
2535  template <>
2536  struct hash<VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX>
2537  {
2538  std::size_t operator()( VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX const & cuModuleCreateInfoNVX ) const VULKAN_HPP_NOEXCEPT
2539  {
2540  std::size_t seed = 0;
2541  VULKAN_HPP_HASH_COMBINE( seed, cuModuleCreateInfoNVX.sType );
2542  VULKAN_HPP_HASH_COMBINE( seed, cuModuleCreateInfoNVX.pNext );
2543  VULKAN_HPP_HASH_COMBINE( seed, cuModuleCreateInfoNVX.dataSize );
2544  VULKAN_HPP_HASH_COMBINE( seed, cuModuleCreateInfoNVX.pData );
2545  return seed;
2546  }
2547  };
2548 
2549 # if defined( VK_USE_PLATFORM_WIN32_KHR )
2550  template <>
2551  struct hash<VULKAN_HPP_NAMESPACE::D3D12FenceSubmitInfoKHR>
2552  {
2553  std::size_t operator()( VULKAN_HPP_NAMESPACE::D3D12FenceSubmitInfoKHR const & d3D12FenceSubmitInfoKHR ) const VULKAN_HPP_NOEXCEPT
2554  {
2555  std::size_t seed = 0;
2556  VULKAN_HPP_HASH_COMBINE( seed, d3D12FenceSubmitInfoKHR.sType );
2557  VULKAN_HPP_HASH_COMBINE( seed, d3D12FenceSubmitInfoKHR.pNext );
2558  VULKAN_HPP_HASH_COMBINE( seed, d3D12FenceSubmitInfoKHR.waitSemaphoreValuesCount );
2559  VULKAN_HPP_HASH_COMBINE( seed, d3D12FenceSubmitInfoKHR.pWaitSemaphoreValues );
2560  VULKAN_HPP_HASH_COMBINE( seed, d3D12FenceSubmitInfoKHR.signalSemaphoreValuesCount );
2561  VULKAN_HPP_HASH_COMBINE( seed, d3D12FenceSubmitInfoKHR.pSignalSemaphoreValues );
2562  return seed;
2563  }
2564  };
2565 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
2566 
2567  template <>
2568  struct hash<VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT>
2569  {
2570  std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT const & debugMarkerMarkerInfoEXT ) const VULKAN_HPP_NOEXCEPT
2571  {
2572  std::size_t seed = 0;
2573  VULKAN_HPP_HASH_COMBINE( seed, debugMarkerMarkerInfoEXT.sType );
2574  VULKAN_HPP_HASH_COMBINE( seed, debugMarkerMarkerInfoEXT.pNext );
2575  for ( const char * p = debugMarkerMarkerInfoEXT.pMarkerName; *p != '\0'; ++p )
2576  {
2577  VULKAN_HPP_HASH_COMBINE( seed, *p );
2578  }
2579  for ( size_t i = 0; i < 4; ++i )
2580  {
2581  VULKAN_HPP_HASH_COMBINE( seed, debugMarkerMarkerInfoEXT.color[i] );
2582  }
2583  return seed;
2584  }
2585  };
2586 
2587  template <>
2588  struct hash<VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT>
2589  {
2590  std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT const & debugMarkerObjectNameInfoEXT ) const VULKAN_HPP_NOEXCEPT
2591  {
2592  std::size_t seed = 0;
2593  VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectNameInfoEXT.sType );
2594  VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectNameInfoEXT.pNext );
2595  VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectNameInfoEXT.objectType );
2596  VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectNameInfoEXT.object );
2597  for ( const char * p = debugMarkerObjectNameInfoEXT.pObjectName; *p != '\0'; ++p )
2598  {
2599  VULKAN_HPP_HASH_COMBINE( seed, *p );
2600  }
2601  return seed;
2602  }
2603  };
2604 
2605  template <>
2606  struct hash<VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT>
2607  {
2608  std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT const & debugMarkerObjectTagInfoEXT ) const VULKAN_HPP_NOEXCEPT
2609  {
2610  std::size_t seed = 0;
2611  VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectTagInfoEXT.sType );
2612  VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectTagInfoEXT.pNext );
2613  VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectTagInfoEXT.objectType );
2614  VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectTagInfoEXT.object );
2615  VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectTagInfoEXT.tagName );
2616  VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectTagInfoEXT.tagSize );
2617  VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectTagInfoEXT.pTag );
2618  return seed;
2619  }
2620  };
2621 
2622  template <>
2623  struct hash<VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT>
2624  {
2625  std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT const & debugReportCallbackCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
2626  {
2627  std::size_t seed = 0;
2628  VULKAN_HPP_HASH_COMBINE( seed, debugReportCallbackCreateInfoEXT.sType );
2629  VULKAN_HPP_HASH_COMBINE( seed, debugReportCallbackCreateInfoEXT.pNext );
2630  VULKAN_HPP_HASH_COMBINE( seed, debugReportCallbackCreateInfoEXT.flags );
2631  VULKAN_HPP_HASH_COMBINE( seed, debugReportCallbackCreateInfoEXT.pfnCallback );
2632  VULKAN_HPP_HASH_COMBINE( seed, debugReportCallbackCreateInfoEXT.pUserData );
2633  return seed;
2634  }
2635  };
2636 
2637  template <>
2638  struct hash<VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT>
2639  {
2640  std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT const & debugUtilsLabelEXT ) const VULKAN_HPP_NOEXCEPT
2641  {
2642  std::size_t seed = 0;
2643  VULKAN_HPP_HASH_COMBINE( seed, debugUtilsLabelEXT.sType );
2644  VULKAN_HPP_HASH_COMBINE( seed, debugUtilsLabelEXT.pNext );
2645  for ( const char * p = debugUtilsLabelEXT.pLabelName; *p != '\0'; ++p )
2646  {
2647  VULKAN_HPP_HASH_COMBINE( seed, *p );
2648  }
2649  for ( size_t i = 0; i < 4; ++i )
2650  {
2651  VULKAN_HPP_HASH_COMBINE( seed, debugUtilsLabelEXT.color[i] );
2652  }
2653  return seed;
2654  }
2655  };
2656 
2657  template <>
2658  struct hash<VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT>
2659  {
2660  std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT const & debugUtilsObjectNameInfoEXT ) const VULKAN_HPP_NOEXCEPT
2661  {
2662  std::size_t seed = 0;
2663  VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectNameInfoEXT.sType );
2664  VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectNameInfoEXT.pNext );
2665  VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectNameInfoEXT.objectType );
2666  VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectNameInfoEXT.objectHandle );
2667  for ( const char * p = debugUtilsObjectNameInfoEXT.pObjectName; *p != '\0'; ++p )
2668  {
2669  VULKAN_HPP_HASH_COMBINE( seed, *p );
2670  }
2671  return seed;
2672  }
2673  };
2674 
2675  template <>
2676  struct hash<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataEXT>
2677  {
2678  std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataEXT const & debugUtilsMessengerCallbackDataEXT ) const VULKAN_HPP_NOEXCEPT
2679  {
2680  std::size_t seed = 0;
2681  VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.sType );
2682  VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.pNext );
2683  VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.flags );
2684  for ( const char * p = debugUtilsMessengerCallbackDataEXT.pMessageIdName; *p != '\0'; ++p )
2685  {
2686  VULKAN_HPP_HASH_COMBINE( seed, *p );
2687  }
2688  VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.messageIdNumber );
2689  for ( const char * p = debugUtilsMessengerCallbackDataEXT.pMessage; *p != '\0'; ++p )
2690  {
2691  VULKAN_HPP_HASH_COMBINE( seed, *p );
2692  }
2693  VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.queueLabelCount );
2694  VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.pQueueLabels );
2695  VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.cmdBufLabelCount );
2696  VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.pCmdBufLabels );
2697  VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.objectCount );
2698  VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.pObjects );
2699  return seed;
2700  }
2701  };
2702 
2703  template <>
2704  struct hash<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT>
2705  {
2706  std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT const & debugUtilsMessengerCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
2707  {
2708  std::size_t seed = 0;
2709  VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCreateInfoEXT.sType );
2710  VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCreateInfoEXT.pNext );
2711  VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCreateInfoEXT.flags );
2712  VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCreateInfoEXT.messageSeverity );
2713  VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCreateInfoEXT.messageType );
2714  VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCreateInfoEXT.pfnUserCallback );
2715  VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCreateInfoEXT.pUserData );
2716  return seed;
2717  }
2718  };
2719 
2720  template <>
2721  struct hash<VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT>
2722  {
2723  std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT const & debugUtilsObjectTagInfoEXT ) const VULKAN_HPP_NOEXCEPT
2724  {
2725  std::size_t seed = 0;
2726  VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectTagInfoEXT.sType );
2727  VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectTagInfoEXT.pNext );
2728  VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectTagInfoEXT.objectType );
2729  VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectTagInfoEXT.objectHandle );
2730  VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectTagInfoEXT.tagName );
2731  VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectTagInfoEXT.tagSize );
2732  VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectTagInfoEXT.pTag );
2733  return seed;
2734  }
2735  };
2736 
2737  template <>
2738  struct hash<VULKAN_HPP_NAMESPACE::DecompressMemoryRegionNV>
2739  {
2740  std::size_t operator()( VULKAN_HPP_NAMESPACE::DecompressMemoryRegionNV const & decompressMemoryRegionNV ) const VULKAN_HPP_NOEXCEPT
2741  {
2742  std::size_t seed = 0;
2743  VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryRegionNV.srcAddress );
2744  VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryRegionNV.dstAddress );
2745  VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryRegionNV.compressedSize );
2746  VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryRegionNV.decompressedSize );
2747  VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryRegionNV.decompressionMethod );
2748  return seed;
2749  }
2750  };
2751 
2752  template <>
2753  struct hash<VULKAN_HPP_NAMESPACE::DedicatedAllocationBufferCreateInfoNV>
2754  {
2755  std::size_t
2756  operator()( VULKAN_HPP_NAMESPACE::DedicatedAllocationBufferCreateInfoNV const & dedicatedAllocationBufferCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
2757  {
2758  std::size_t seed = 0;
2759  VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationBufferCreateInfoNV.sType );
2760  VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationBufferCreateInfoNV.pNext );
2761  VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationBufferCreateInfoNV.dedicatedAllocation );
2762  return seed;
2763  }
2764  };
2765 
2766  template <>
2767  struct hash<VULKAN_HPP_NAMESPACE::DedicatedAllocationImageCreateInfoNV>
2768  {
2769  std::size_t operator()( VULKAN_HPP_NAMESPACE::DedicatedAllocationImageCreateInfoNV const & dedicatedAllocationImageCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
2770  {
2771  std::size_t seed = 0;
2772  VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationImageCreateInfoNV.sType );
2773  VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationImageCreateInfoNV.pNext );
2774  VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationImageCreateInfoNV.dedicatedAllocation );
2775  return seed;
2776  }
2777  };
2778 
2779  template <>
2780  struct hash<VULKAN_HPP_NAMESPACE::DedicatedAllocationMemoryAllocateInfoNV>
2781  {
2782  std::size_t
2783  operator()( VULKAN_HPP_NAMESPACE::DedicatedAllocationMemoryAllocateInfoNV const & dedicatedAllocationMemoryAllocateInfoNV ) const VULKAN_HPP_NOEXCEPT
2784  {
2785  std::size_t seed = 0;
2786  VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationMemoryAllocateInfoNV.sType );
2787  VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationMemoryAllocateInfoNV.pNext );
2788  VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationMemoryAllocateInfoNV.image );
2789  VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationMemoryAllocateInfoNV.buffer );
2790  return seed;
2791  }
2792  };
2793 
2794  template <>
2795  struct hash<VULKAN_HPP_NAMESPACE::MemoryBarrier2>
2796  {
2797  std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryBarrier2 const & memoryBarrier2 ) const VULKAN_HPP_NOEXCEPT
2798  {
2799  std::size_t seed = 0;
2800  VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier2.sType );
2801  VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier2.pNext );
2802  VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier2.srcStageMask );
2803  VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier2.srcAccessMask );
2804  VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier2.dstStageMask );
2805  VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier2.dstAccessMask );
2806  return seed;
2807  }
2808  };
2809 
2810  template <>
2811  struct hash<VULKAN_HPP_NAMESPACE::ImageSubresourceRange>
2812  {
2813  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageSubresourceRange const & imageSubresourceRange ) const VULKAN_HPP_NOEXCEPT
2814  {
2815  std::size_t seed = 0;
2816  VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceRange.aspectMask );
2817  VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceRange.baseMipLevel );
2818  VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceRange.levelCount );
2819  VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceRange.baseArrayLayer );
2820  VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceRange.layerCount );
2821  return seed;
2822  }
2823  };
2824 
2825  template <>
2826  struct hash<VULKAN_HPP_NAMESPACE::ImageMemoryBarrier2>
2827  {
2828  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageMemoryBarrier2 const & imageMemoryBarrier2 ) const VULKAN_HPP_NOEXCEPT
2829  {
2830  std::size_t seed = 0;
2831  VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.sType );
2832  VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.pNext );
2833  VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.srcStageMask );
2834  VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.srcAccessMask );
2835  VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.dstStageMask );
2836  VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.dstAccessMask );
2837  VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.oldLayout );
2838  VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.newLayout );
2839  VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.srcQueueFamilyIndex );
2840  VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.dstQueueFamilyIndex );
2841  VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.image );
2842  VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.subresourceRange );
2843  return seed;
2844  }
2845  };
2846 
2847  template <>
2848  struct hash<VULKAN_HPP_NAMESPACE::DependencyInfo>
2849  {
2850  std::size_t operator()( VULKAN_HPP_NAMESPACE::DependencyInfo const & dependencyInfo ) const VULKAN_HPP_NOEXCEPT
2851  {
2852  std::size_t seed = 0;
2853  VULKAN_HPP_HASH_COMBINE( seed, dependencyInfo.sType );
2854  VULKAN_HPP_HASH_COMBINE( seed, dependencyInfo.pNext );
2855  VULKAN_HPP_HASH_COMBINE( seed, dependencyInfo.dependencyFlags );
2856  VULKAN_HPP_HASH_COMBINE( seed, dependencyInfo.memoryBarrierCount );
2857  VULKAN_HPP_HASH_COMBINE( seed, dependencyInfo.pMemoryBarriers );
2858  VULKAN_HPP_HASH_COMBINE( seed, dependencyInfo.bufferMemoryBarrierCount );
2859  VULKAN_HPP_HASH_COMBINE( seed, dependencyInfo.pBufferMemoryBarriers );
2860  VULKAN_HPP_HASH_COMBINE( seed, dependencyInfo.imageMemoryBarrierCount );
2861  VULKAN_HPP_HASH_COMBINE( seed, dependencyInfo.pImageMemoryBarriers );
2862  return seed;
2863  }
2864  };
2865 
2866  template <>
2867  struct hash<VULKAN_HPP_NAMESPACE::DescriptorAddressInfoEXT>
2868  {
2869  std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorAddressInfoEXT const & descriptorAddressInfoEXT ) const VULKAN_HPP_NOEXCEPT
2870  {
2871  std::size_t seed = 0;
2872  VULKAN_HPP_HASH_COMBINE( seed, descriptorAddressInfoEXT.sType );
2873  VULKAN_HPP_HASH_COMBINE( seed, descriptorAddressInfoEXT.pNext );
2874  VULKAN_HPP_HASH_COMBINE( seed, descriptorAddressInfoEXT.address );
2875  VULKAN_HPP_HASH_COMBINE( seed, descriptorAddressInfoEXT.range );
2876  VULKAN_HPP_HASH_COMBINE( seed, descriptorAddressInfoEXT.format );
2877  return seed;
2878  }
2879  };
2880 
2881  template <>
2882  struct hash<VULKAN_HPP_NAMESPACE::DescriptorBufferBindingInfoEXT>
2883  {
2884  std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorBufferBindingInfoEXT const & descriptorBufferBindingInfoEXT ) const VULKAN_HPP_NOEXCEPT
2885  {
2886  std::size_t seed = 0;
2887  VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferBindingInfoEXT.sType );
2888  VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferBindingInfoEXT.pNext );
2889  VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferBindingInfoEXT.address );
2890  VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferBindingInfoEXT.usage );
2891  return seed;
2892  }
2893  };
2894 
2895  template <>
2896  struct hash<VULKAN_HPP_NAMESPACE::DescriptorBufferBindingPushDescriptorBufferHandleEXT>
2897  {
2898  std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorBufferBindingPushDescriptorBufferHandleEXT const &
2899  descriptorBufferBindingPushDescriptorBufferHandleEXT ) const VULKAN_HPP_NOEXCEPT
2900  {
2901  std::size_t seed = 0;
2902  VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferBindingPushDescriptorBufferHandleEXT.sType );
2903  VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferBindingPushDescriptorBufferHandleEXT.pNext );
2904  VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferBindingPushDescriptorBufferHandleEXT.buffer );
2905  return seed;
2906  }
2907  };
2908 
2909  template <>
2910  struct hash<VULKAN_HPP_NAMESPACE::DescriptorBufferInfo>
2911  {
2912  std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorBufferInfo const & descriptorBufferInfo ) const VULKAN_HPP_NOEXCEPT
2913  {
2914  std::size_t seed = 0;
2915  VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferInfo.buffer );
2916  VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferInfo.offset );
2917  VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferInfo.range );
2918  return seed;
2919  }
2920  };
2921 
2922  template <>
2923  struct hash<VULKAN_HPP_NAMESPACE::DescriptorImageInfo>
2924  {
2925  std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorImageInfo const & descriptorImageInfo ) const VULKAN_HPP_NOEXCEPT
2926  {
2927  std::size_t seed = 0;
2928  VULKAN_HPP_HASH_COMBINE( seed, descriptorImageInfo.sampler );
2929  VULKAN_HPP_HASH_COMBINE( seed, descriptorImageInfo.imageView );
2930  VULKAN_HPP_HASH_COMBINE( seed, descriptorImageInfo.imageLayout );
2931  return seed;
2932  }
2933  };
2934 
2935  template <>
2936  struct hash<VULKAN_HPP_NAMESPACE::DescriptorPoolSize>
2937  {
2938  std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorPoolSize const & descriptorPoolSize ) const VULKAN_HPP_NOEXCEPT
2939  {
2940  std::size_t seed = 0;
2941  VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolSize.type );
2942  VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolSize.descriptorCount );
2943  return seed;
2944  }
2945  };
2946 
2947  template <>
2948  struct hash<VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo>
2949  {
2950  std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo const & descriptorPoolCreateInfo ) const VULKAN_HPP_NOEXCEPT
2951  {
2952  std::size_t seed = 0;
2953  VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolCreateInfo.sType );
2954  VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolCreateInfo.pNext );
2955  VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolCreateInfo.flags );
2956  VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolCreateInfo.maxSets );
2957  VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolCreateInfo.poolSizeCount );
2958  VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolCreateInfo.pPoolSizes );
2959  return seed;
2960  }
2961  };
2962 
2963  template <>
2964  struct hash<VULKAN_HPP_NAMESPACE::DescriptorPoolInlineUniformBlockCreateInfo>
2965  {
2966  std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorPoolInlineUniformBlockCreateInfo const & descriptorPoolInlineUniformBlockCreateInfo ) const
2967  VULKAN_HPP_NOEXCEPT
2968  {
2969  std::size_t seed = 0;
2970  VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolInlineUniformBlockCreateInfo.sType );
2971  VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolInlineUniformBlockCreateInfo.pNext );
2972  VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolInlineUniformBlockCreateInfo.maxInlineUniformBlockBindings );
2973  return seed;
2974  }
2975  };
2976 
2977  template <>
2978  struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo>
2979  {
2980  std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo const & descriptorSetAllocateInfo ) const VULKAN_HPP_NOEXCEPT
2981  {
2982  std::size_t seed = 0;
2983  VULKAN_HPP_HASH_COMBINE( seed, descriptorSetAllocateInfo.sType );
2984  VULKAN_HPP_HASH_COMBINE( seed, descriptorSetAllocateInfo.pNext );
2985  VULKAN_HPP_HASH_COMBINE( seed, descriptorSetAllocateInfo.descriptorPool );
2986  VULKAN_HPP_HASH_COMBINE( seed, descriptorSetAllocateInfo.descriptorSetCount );
2987  VULKAN_HPP_HASH_COMBINE( seed, descriptorSetAllocateInfo.pSetLayouts );
2988  return seed;
2989  }
2990  };
2991 
2992  template <>
2993  struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetBindingReferenceVALVE>
2994  {
2995  std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetBindingReferenceVALVE const & descriptorSetBindingReferenceVALVE ) const VULKAN_HPP_NOEXCEPT
2996  {
2997  std::size_t seed = 0;
2998  VULKAN_HPP_HASH_COMBINE( seed, descriptorSetBindingReferenceVALVE.sType );
2999  VULKAN_HPP_HASH_COMBINE( seed, descriptorSetBindingReferenceVALVE.pNext );
3000  VULKAN_HPP_HASH_COMBINE( seed, descriptorSetBindingReferenceVALVE.descriptorSetLayout );
3001  VULKAN_HPP_HASH_COMBINE( seed, descriptorSetBindingReferenceVALVE.binding );
3002  return seed;
3003  }
3004  };
3005 
3006  template <>
3007  struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBinding>
3008  {
3009  std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBinding const & descriptorSetLayoutBinding ) const VULKAN_HPP_NOEXCEPT
3010  {
3011  std::size_t seed = 0;
3012  VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutBinding.binding );
3013  VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutBinding.descriptorType );
3014  VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutBinding.descriptorCount );
3015  VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutBinding.stageFlags );
3016  VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutBinding.pImmutableSamplers );
3017  return seed;
3018  }
3019  };
3020 
3021  template <>
3022  struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBindingFlagsCreateInfo>
3023  {
3024  std::size_t
3025  operator()( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBindingFlagsCreateInfo const & descriptorSetLayoutBindingFlagsCreateInfo ) const VULKAN_HPP_NOEXCEPT
3026  {
3027  std::size_t seed = 0;
3028  VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutBindingFlagsCreateInfo.sType );
3029  VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutBindingFlagsCreateInfo.pNext );
3030  VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutBindingFlagsCreateInfo.bindingCount );
3031  VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutBindingFlagsCreateInfo.pBindingFlags );
3032  return seed;
3033  }
3034  };
3035 
3036  template <>
3037  struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo>
3038  {
3039  std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo const & descriptorSetLayoutCreateInfo ) const VULKAN_HPP_NOEXCEPT
3040  {
3041  std::size_t seed = 0;
3042  VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutCreateInfo.sType );
3043  VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutCreateInfo.pNext );
3044  VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutCreateInfo.flags );
3045  VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutCreateInfo.bindingCount );
3046  VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutCreateInfo.pBindings );
3047  return seed;
3048  }
3049  };
3050 
3051  template <>
3052  struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutHostMappingInfoVALVE>
3053  {
3054  std::size_t
3055  operator()( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutHostMappingInfoVALVE const & descriptorSetLayoutHostMappingInfoVALVE ) const VULKAN_HPP_NOEXCEPT
3056  {
3057  std::size_t seed = 0;
3058  VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutHostMappingInfoVALVE.sType );
3059  VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutHostMappingInfoVALVE.pNext );
3060  VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutHostMappingInfoVALVE.descriptorOffset );
3061  VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutHostMappingInfoVALVE.descriptorSize );
3062  return seed;
3063  }
3064  };
3065 
3066  template <>
3067  struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport>
3068  {
3069  std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport const & descriptorSetLayoutSupport ) const VULKAN_HPP_NOEXCEPT
3070  {
3071  std::size_t seed = 0;
3072  VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutSupport.sType );
3073  VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutSupport.pNext );
3074  VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutSupport.supported );
3075  return seed;
3076  }
3077  };
3078 
3079  template <>
3080  struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetVariableDescriptorCountAllocateInfo>
3081  {
3082  std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetVariableDescriptorCountAllocateInfo const & descriptorSetVariableDescriptorCountAllocateInfo )
3083  const VULKAN_HPP_NOEXCEPT
3084  {
3085  std::size_t seed = 0;
3086  VULKAN_HPP_HASH_COMBINE( seed, descriptorSetVariableDescriptorCountAllocateInfo.sType );
3087  VULKAN_HPP_HASH_COMBINE( seed, descriptorSetVariableDescriptorCountAllocateInfo.pNext );
3088  VULKAN_HPP_HASH_COMBINE( seed, descriptorSetVariableDescriptorCountAllocateInfo.descriptorSetCount );
3089  VULKAN_HPP_HASH_COMBINE( seed, descriptorSetVariableDescriptorCountAllocateInfo.pDescriptorCounts );
3090  return seed;
3091  }
3092  };
3093 
3094  template <>
3095  struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetVariableDescriptorCountLayoutSupport>
3096  {
3097  std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetVariableDescriptorCountLayoutSupport const & descriptorSetVariableDescriptorCountLayoutSupport )
3098  const VULKAN_HPP_NOEXCEPT
3099  {
3100  std::size_t seed = 0;
3101  VULKAN_HPP_HASH_COMBINE( seed, descriptorSetVariableDescriptorCountLayoutSupport.sType );
3102  VULKAN_HPP_HASH_COMBINE( seed, descriptorSetVariableDescriptorCountLayoutSupport.pNext );
3103  VULKAN_HPP_HASH_COMBINE( seed, descriptorSetVariableDescriptorCountLayoutSupport.maxVariableDescriptorCount );
3104  return seed;
3105  }
3106  };
3107 
3108  template <>
3109  struct hash<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateEntry>
3110  {
3111  std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateEntry const & descriptorUpdateTemplateEntry ) const VULKAN_HPP_NOEXCEPT
3112  {
3113  std::size_t seed = 0;
3114  VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateEntry.dstBinding );
3115  VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateEntry.dstArrayElement );
3116  VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateEntry.descriptorCount );
3117  VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateEntry.descriptorType );
3118  VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateEntry.offset );
3119  VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateEntry.stride );
3120  return seed;
3121  }
3122  };
3123 
3124  template <>
3125  struct hash<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo>
3126  {
3127  std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo const & descriptorUpdateTemplateCreateInfo ) const VULKAN_HPP_NOEXCEPT
3128  {
3129  std::size_t seed = 0;
3130  VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.sType );
3131  VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.pNext );
3132  VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.flags );
3133  VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.descriptorUpdateEntryCount );
3134  VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.pDescriptorUpdateEntries );
3135  VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.templateType );
3136  VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.descriptorSetLayout );
3137  VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.pipelineBindPoint );
3138  VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.pipelineLayout );
3139  VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.set );
3140  return seed;
3141  }
3142  };
3143 
3144  template <>
3145  struct hash<VULKAN_HPP_NAMESPACE::DeviceAddressBindingCallbackDataEXT>
3146  {
3147  std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceAddressBindingCallbackDataEXT const & deviceAddressBindingCallbackDataEXT ) const VULKAN_HPP_NOEXCEPT
3148  {
3149  std::size_t seed = 0;
3150  VULKAN_HPP_HASH_COMBINE( seed, deviceAddressBindingCallbackDataEXT.sType );
3151  VULKAN_HPP_HASH_COMBINE( seed, deviceAddressBindingCallbackDataEXT.pNext );
3152  VULKAN_HPP_HASH_COMBINE( seed, deviceAddressBindingCallbackDataEXT.flags );
3153  VULKAN_HPP_HASH_COMBINE( seed, deviceAddressBindingCallbackDataEXT.baseAddress );
3154  VULKAN_HPP_HASH_COMBINE( seed, deviceAddressBindingCallbackDataEXT.size );
3155  VULKAN_HPP_HASH_COMBINE( seed, deviceAddressBindingCallbackDataEXT.bindingType );
3156  return seed;
3157  }
3158  };
3159 
3160  template <>
3161  struct hash<VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements>
3162  {
3163  std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements const & deviceBufferMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
3164  {
3165  std::size_t seed = 0;
3166  VULKAN_HPP_HASH_COMBINE( seed, deviceBufferMemoryRequirements.sType );
3167  VULKAN_HPP_HASH_COMBINE( seed, deviceBufferMemoryRequirements.pNext );
3168  VULKAN_HPP_HASH_COMBINE( seed, deviceBufferMemoryRequirements.pCreateInfo );
3169  return seed;
3170  }
3171  };
3172 
3173  template <>
3174  struct hash<VULKAN_HPP_NAMESPACE::DeviceQueueCreateInfo>
3175  {
3176  std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceQueueCreateInfo const & deviceQueueCreateInfo ) const VULKAN_HPP_NOEXCEPT
3177  {
3178  std::size_t seed = 0;
3179  VULKAN_HPP_HASH_COMBINE( seed, deviceQueueCreateInfo.sType );
3180  VULKAN_HPP_HASH_COMBINE( seed, deviceQueueCreateInfo.pNext );
3181  VULKAN_HPP_HASH_COMBINE( seed, deviceQueueCreateInfo.flags );
3182  VULKAN_HPP_HASH_COMBINE( seed, deviceQueueCreateInfo.queueFamilyIndex );
3183  VULKAN_HPP_HASH_COMBINE( seed, deviceQueueCreateInfo.queueCount );
3184  VULKAN_HPP_HASH_COMBINE( seed, deviceQueueCreateInfo.pQueuePriorities );
3185  return seed;
3186  }
3187  };
3188 
3189  template <>
3190  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures>
3191  {
3192  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures const & physicalDeviceFeatures ) const VULKAN_HPP_NOEXCEPT
3193  {
3194  std::size_t seed = 0;
3195  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.robustBufferAccess );
3196  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.fullDrawIndexUint32 );
3197  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.imageCubeArray );
3198  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.independentBlend );
3199  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.geometryShader );
3200  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.tessellationShader );
3201  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sampleRateShading );
3202  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.dualSrcBlend );
3203  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.logicOp );
3204  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.multiDrawIndirect );
3205  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.drawIndirectFirstInstance );
3206  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.depthClamp );
3207  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.depthBiasClamp );
3208  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.fillModeNonSolid );
3209  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.depthBounds );
3210  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.wideLines );
3211  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.largePoints );
3212  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.alphaToOne );
3213  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.multiViewport );
3214  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.samplerAnisotropy );
3215  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.textureCompressionETC2 );
3216  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.textureCompressionASTC_LDR );
3217  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.textureCompressionBC );
3218  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.occlusionQueryPrecise );
3219  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.pipelineStatisticsQuery );
3220  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.vertexPipelineStoresAndAtomics );
3221  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.fragmentStoresAndAtomics );
3222  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderTessellationAndGeometryPointSize );
3223  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderImageGatherExtended );
3224  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderStorageImageExtendedFormats );
3225  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderStorageImageMultisample );
3226  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderStorageImageReadWithoutFormat );
3227  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderStorageImageWriteWithoutFormat );
3228  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderUniformBufferArrayDynamicIndexing );
3229  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderSampledImageArrayDynamicIndexing );
3230  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderStorageBufferArrayDynamicIndexing );
3231  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderStorageImageArrayDynamicIndexing );
3232  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderClipDistance );
3233  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderCullDistance );
3234  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderFloat64 );
3235  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderInt64 );
3236  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderInt16 );
3237  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderResourceResidency );
3238  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderResourceMinLod );
3239  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sparseBinding );
3240  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sparseResidencyBuffer );
3241  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sparseResidencyImage2D );
3242  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sparseResidencyImage3D );
3243  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sparseResidency2Samples );
3244  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sparseResidency4Samples );
3245  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sparseResidency8Samples );
3246  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sparseResidency16Samples );
3247  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sparseResidencyAliased );
3248  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.variableMultisampleRate );
3249  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.inheritedQueries );
3250  return seed;
3251  }
3252  };
3253 
3254  template <>
3255  struct hash<VULKAN_HPP_NAMESPACE::DeviceCreateInfo>
3256  {
3257  std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceCreateInfo const & deviceCreateInfo ) const VULKAN_HPP_NOEXCEPT
3258  {
3259  std::size_t seed = 0;
3260  VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.sType );
3261  VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.pNext );
3262  VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.flags );
3263  VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.queueCreateInfoCount );
3264  VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.pQueueCreateInfos );
3265  VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.enabledLayerCount );
3266  for ( size_t i = 0; i < deviceCreateInfo.enabledLayerCount; ++i )
3267  {
3268  for ( const char * p = deviceCreateInfo.ppEnabledLayerNames[i]; *p != '\0'; ++p )
3269  {
3270  VULKAN_HPP_HASH_COMBINE( seed, *p );
3271  }
3272  }
3273  VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.enabledExtensionCount );
3274  for ( size_t i = 0; i < deviceCreateInfo.enabledExtensionCount; ++i )
3275  {
3276  for ( const char * p = deviceCreateInfo.ppEnabledExtensionNames[i]; *p != '\0'; ++p )
3277  {
3278  VULKAN_HPP_HASH_COMBINE( seed, *p );
3279  }
3280  }
3281  VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.pEnabledFeatures );
3282  return seed;
3283  }
3284  };
3285 
3286  template <>
3287  struct hash<VULKAN_HPP_NAMESPACE::DeviceDeviceMemoryReportCreateInfoEXT>
3288  {
3289  std::size_t
3290  operator()( VULKAN_HPP_NAMESPACE::DeviceDeviceMemoryReportCreateInfoEXT const & deviceDeviceMemoryReportCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
3291  {
3292  std::size_t seed = 0;
3293  VULKAN_HPP_HASH_COMBINE( seed, deviceDeviceMemoryReportCreateInfoEXT.sType );
3294  VULKAN_HPP_HASH_COMBINE( seed, deviceDeviceMemoryReportCreateInfoEXT.pNext );
3295  VULKAN_HPP_HASH_COMBINE( seed, deviceDeviceMemoryReportCreateInfoEXT.flags );
3296  VULKAN_HPP_HASH_COMBINE( seed, deviceDeviceMemoryReportCreateInfoEXT.pfnUserCallback );
3297  VULKAN_HPP_HASH_COMBINE( seed, deviceDeviceMemoryReportCreateInfoEXT.pUserData );
3298  return seed;
3299  }
3300  };
3301 
3302  template <>
3303  struct hash<VULKAN_HPP_NAMESPACE::DeviceDiagnosticsConfigCreateInfoNV>
3304  {
3305  std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceDiagnosticsConfigCreateInfoNV const & deviceDiagnosticsConfigCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
3306  {
3307  std::size_t seed = 0;
3308  VULKAN_HPP_HASH_COMBINE( seed, deviceDiagnosticsConfigCreateInfoNV.sType );
3309  VULKAN_HPP_HASH_COMBINE( seed, deviceDiagnosticsConfigCreateInfoNV.pNext );
3310  VULKAN_HPP_HASH_COMBINE( seed, deviceDiagnosticsConfigCreateInfoNV.flags );
3311  return seed;
3312  }
3313  };
3314 
3315  template <>
3316  struct hash<VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT>
3317  {
3318  std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT const & deviceEventInfoEXT ) const VULKAN_HPP_NOEXCEPT
3319  {
3320  std::size_t seed = 0;
3321  VULKAN_HPP_HASH_COMBINE( seed, deviceEventInfoEXT.sType );
3322  VULKAN_HPP_HASH_COMBINE( seed, deviceEventInfoEXT.pNext );
3323  VULKAN_HPP_HASH_COMBINE( seed, deviceEventInfoEXT.deviceEvent );
3324  return seed;
3325  }
3326  };
3327 
3328  template <>
3329  struct hash<VULKAN_HPP_NAMESPACE::DeviceFaultAddressInfoEXT>
3330  {
3331  std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceFaultAddressInfoEXT const & deviceFaultAddressInfoEXT ) const VULKAN_HPP_NOEXCEPT
3332  {
3333  std::size_t seed = 0;
3334  VULKAN_HPP_HASH_COMBINE( seed, deviceFaultAddressInfoEXT.addressType );
3335  VULKAN_HPP_HASH_COMBINE( seed, deviceFaultAddressInfoEXT.reportedAddress );
3336  VULKAN_HPP_HASH_COMBINE( seed, deviceFaultAddressInfoEXT.addressPrecision );
3337  return seed;
3338  }
3339  };
3340 
3341  template <>
3342  struct hash<VULKAN_HPP_NAMESPACE::DeviceFaultCountsEXT>
3343  {
3344  std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceFaultCountsEXT const & deviceFaultCountsEXT ) const VULKAN_HPP_NOEXCEPT
3345  {
3346  std::size_t seed = 0;
3347  VULKAN_HPP_HASH_COMBINE( seed, deviceFaultCountsEXT.sType );
3348  VULKAN_HPP_HASH_COMBINE( seed, deviceFaultCountsEXT.pNext );
3349  VULKAN_HPP_HASH_COMBINE( seed, deviceFaultCountsEXT.addressInfoCount );
3350  VULKAN_HPP_HASH_COMBINE( seed, deviceFaultCountsEXT.vendorInfoCount );
3351  VULKAN_HPP_HASH_COMBINE( seed, deviceFaultCountsEXT.vendorBinarySize );
3352  return seed;
3353  }
3354  };
3355 
3356  template <>
3357  struct hash<VULKAN_HPP_NAMESPACE::DeviceFaultVendorInfoEXT>
3358  {
3359  std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceFaultVendorInfoEXT const & deviceFaultVendorInfoEXT ) const VULKAN_HPP_NOEXCEPT
3360  {
3361  std::size_t seed = 0;
3362  for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i )
3363  {
3364  VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorInfoEXT.description[i] );
3365  }
3366  VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorInfoEXT.vendorFaultCode );
3367  VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorInfoEXT.vendorFaultData );
3368  return seed;
3369  }
3370  };
3371 
3372  template <>
3373  struct hash<VULKAN_HPP_NAMESPACE::DeviceFaultInfoEXT>
3374  {
3375  std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceFaultInfoEXT const & deviceFaultInfoEXT ) const VULKAN_HPP_NOEXCEPT
3376  {
3377  std::size_t seed = 0;
3378  VULKAN_HPP_HASH_COMBINE( seed, deviceFaultInfoEXT.sType );
3379  VULKAN_HPP_HASH_COMBINE( seed, deviceFaultInfoEXT.pNext );
3380  for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i )
3381  {
3382  VULKAN_HPP_HASH_COMBINE( seed, deviceFaultInfoEXT.description[i] );
3383  }
3384  VULKAN_HPP_HASH_COMBINE( seed, deviceFaultInfoEXT.pAddressInfos );
3385  VULKAN_HPP_HASH_COMBINE( seed, deviceFaultInfoEXT.pVendorInfos );
3386  VULKAN_HPP_HASH_COMBINE( seed, deviceFaultInfoEXT.pVendorBinaryData );
3387  return seed;
3388  }
3389  };
3390 
3391  template <>
3392  struct hash<VULKAN_HPP_NAMESPACE::DeviceFaultVendorBinaryHeaderVersionOneEXT>
3393  {
3394  std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceFaultVendorBinaryHeaderVersionOneEXT const & deviceFaultVendorBinaryHeaderVersionOneEXT ) const
3395  VULKAN_HPP_NOEXCEPT
3396  {
3397  std::size_t seed = 0;
3398  VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.headerSize );
3399  VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.headerVersion );
3400  VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.vendorID );
3401  VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.deviceID );
3402  VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.driverVersion );
3403  for ( size_t i = 0; i < VK_UUID_SIZE; ++i )
3404  {
3405  VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.pipelineCacheUUID[i] );
3406  }
3407  VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.applicationNameOffset );
3408  VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.applicationVersion );
3409  VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.engineNameOffset );
3410  return seed;
3411  }
3412  };
3413 
3414  template <>
3415  struct hash<VULKAN_HPP_NAMESPACE::DeviceGroupBindSparseInfo>
3416  {
3417  std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupBindSparseInfo const & deviceGroupBindSparseInfo ) const VULKAN_HPP_NOEXCEPT
3418  {
3419  std::size_t seed = 0;
3420  VULKAN_HPP_HASH_COMBINE( seed, deviceGroupBindSparseInfo.sType );
3421  VULKAN_HPP_HASH_COMBINE( seed, deviceGroupBindSparseInfo.pNext );
3422  VULKAN_HPP_HASH_COMBINE( seed, deviceGroupBindSparseInfo.resourceDeviceIndex );
3423  VULKAN_HPP_HASH_COMBINE( seed, deviceGroupBindSparseInfo.memoryDeviceIndex );
3424  return seed;
3425  }
3426  };
3427 
3428  template <>
3429  struct hash<VULKAN_HPP_NAMESPACE::DeviceGroupCommandBufferBeginInfo>
3430  {
3431  std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupCommandBufferBeginInfo const & deviceGroupCommandBufferBeginInfo ) const VULKAN_HPP_NOEXCEPT
3432  {
3433  std::size_t seed = 0;
3434  VULKAN_HPP_HASH_COMBINE( seed, deviceGroupCommandBufferBeginInfo.sType );
3435  VULKAN_HPP_HASH_COMBINE( seed, deviceGroupCommandBufferBeginInfo.pNext );
3436  VULKAN_HPP_HASH_COMBINE( seed, deviceGroupCommandBufferBeginInfo.deviceMask );
3437  return seed;
3438  }
3439  };
3440 
3441  template <>
3442  struct hash<VULKAN_HPP_NAMESPACE::DeviceGroupDeviceCreateInfo>
3443  {
3444  std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupDeviceCreateInfo const & deviceGroupDeviceCreateInfo ) const VULKAN_HPP_NOEXCEPT
3445  {
3446  std::size_t seed = 0;
3447  VULKAN_HPP_HASH_COMBINE( seed, deviceGroupDeviceCreateInfo.sType );
3448  VULKAN_HPP_HASH_COMBINE( seed, deviceGroupDeviceCreateInfo.pNext );
3449  VULKAN_HPP_HASH_COMBINE( seed, deviceGroupDeviceCreateInfo.physicalDeviceCount );
3450  VULKAN_HPP_HASH_COMBINE( seed, deviceGroupDeviceCreateInfo.pPhysicalDevices );
3451  return seed;
3452  }
3453  };
3454 
3455  template <>
3456  struct hash<VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR>
3457  {
3458  std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR const & deviceGroupPresentCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT
3459  {
3460  std::size_t seed = 0;
3461  VULKAN_HPP_HASH_COMBINE( seed, deviceGroupPresentCapabilitiesKHR.sType );
3462  VULKAN_HPP_HASH_COMBINE( seed, deviceGroupPresentCapabilitiesKHR.pNext );
3463  for ( size_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; ++i )
3464  {
3465  VULKAN_HPP_HASH_COMBINE( seed, deviceGroupPresentCapabilitiesKHR.presentMask[i] );
3466  }
3467  VULKAN_HPP_HASH_COMBINE( seed, deviceGroupPresentCapabilitiesKHR.modes );
3468  return seed;
3469  }
3470  };
3471 
3472  template <>
3473  struct hash<VULKAN_HPP_NAMESPACE::DeviceGroupPresentInfoKHR>
3474  {
3475  std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupPresentInfoKHR const & deviceGroupPresentInfoKHR ) const VULKAN_HPP_NOEXCEPT
3476  {
3477  std::size_t seed = 0;
3478  VULKAN_HPP_HASH_COMBINE( seed, deviceGroupPresentInfoKHR.sType );
3479  VULKAN_HPP_HASH_COMBINE( seed, deviceGroupPresentInfoKHR.pNext );
3480  VULKAN_HPP_HASH_COMBINE( seed, deviceGroupPresentInfoKHR.swapchainCount );
3481  VULKAN_HPP_HASH_COMBINE( seed, deviceGroupPresentInfoKHR.pDeviceMasks );
3482  VULKAN_HPP_HASH_COMBINE( seed, deviceGroupPresentInfoKHR.mode );
3483  return seed;
3484  }
3485  };
3486 
3487  template <>
3488  struct hash<VULKAN_HPP_NAMESPACE::DeviceGroupRenderPassBeginInfo>
3489  {
3490  std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupRenderPassBeginInfo const & deviceGroupRenderPassBeginInfo ) const VULKAN_HPP_NOEXCEPT
3491  {
3492  std::size_t seed = 0;
3493  VULKAN_HPP_HASH_COMBINE( seed, deviceGroupRenderPassBeginInfo.sType );
3494  VULKAN_HPP_HASH_COMBINE( seed, deviceGroupRenderPassBeginInfo.pNext );
3495  VULKAN_HPP_HASH_COMBINE( seed, deviceGroupRenderPassBeginInfo.deviceMask );
3496  VULKAN_HPP_HASH_COMBINE( seed, deviceGroupRenderPassBeginInfo.deviceRenderAreaCount );
3497  VULKAN_HPP_HASH_COMBINE( seed, deviceGroupRenderPassBeginInfo.pDeviceRenderAreas );
3498  return seed;
3499  }
3500  };
3501 
3502  template <>
3503  struct hash<VULKAN_HPP_NAMESPACE::DeviceGroupSubmitInfo>
3504  {
3505  std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupSubmitInfo const & deviceGroupSubmitInfo ) const VULKAN_HPP_NOEXCEPT
3506  {
3507  std::size_t seed = 0;
3508  VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSubmitInfo.sType );
3509  VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSubmitInfo.pNext );
3510  VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSubmitInfo.waitSemaphoreCount );
3511  VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSubmitInfo.pWaitSemaphoreDeviceIndices );
3512  VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSubmitInfo.commandBufferCount );
3513  VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSubmitInfo.pCommandBufferDeviceMasks );
3514  VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSubmitInfo.signalSemaphoreCount );
3515  VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSubmitInfo.pSignalSemaphoreDeviceIndices );
3516  return seed;
3517  }
3518  };
3519 
3520  template <>
3521  struct hash<VULKAN_HPP_NAMESPACE::DeviceGroupSwapchainCreateInfoKHR>
3522  {
3523  std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupSwapchainCreateInfoKHR const & deviceGroupSwapchainCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
3524  {
3525  std::size_t seed = 0;
3526  VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSwapchainCreateInfoKHR.sType );
3527  VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSwapchainCreateInfoKHR.pNext );
3528  VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSwapchainCreateInfoKHR.modes );
3529  return seed;
3530  }
3531  };
3532 
3533  template <>
3534  struct hash<VULKAN_HPP_NAMESPACE::ImageCreateInfo>
3535  {
3536  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageCreateInfo const & imageCreateInfo ) const VULKAN_HPP_NOEXCEPT
3537  {
3538  std::size_t seed = 0;
3539  VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.sType );
3540  VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.pNext );
3541  VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.flags );
3542  VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.imageType );
3543  VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.format );
3544  VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.extent );
3545  VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.mipLevels );
3546  VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.arrayLayers );
3547  VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.samples );
3548  VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.tiling );
3549  VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.usage );
3550  VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.sharingMode );
3551  VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.queueFamilyIndexCount );
3552  VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.pQueueFamilyIndices );
3553  VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.initialLayout );
3554  return seed;
3555  }
3556  };
3557 
3558  template <>
3559  struct hash<VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements>
3560  {
3561  std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements const & deviceImageMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
3562  {
3563  std::size_t seed = 0;
3564  VULKAN_HPP_HASH_COMBINE( seed, deviceImageMemoryRequirements.sType );
3565  VULKAN_HPP_HASH_COMBINE( seed, deviceImageMemoryRequirements.pNext );
3566  VULKAN_HPP_HASH_COMBINE( seed, deviceImageMemoryRequirements.pCreateInfo );
3567  VULKAN_HPP_HASH_COMBINE( seed, deviceImageMemoryRequirements.planeAspect );
3568  return seed;
3569  }
3570  };
3571 
3572  template <>
3573  struct hash<VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo>
3574  {
3575  std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo const & deviceMemoryOpaqueCaptureAddressInfo ) const VULKAN_HPP_NOEXCEPT
3576  {
3577  std::size_t seed = 0;
3578  VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryOpaqueCaptureAddressInfo.sType );
3579  VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryOpaqueCaptureAddressInfo.pNext );
3580  VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryOpaqueCaptureAddressInfo.memory );
3581  return seed;
3582  }
3583  };
3584 
3585  template <>
3586  struct hash<VULKAN_HPP_NAMESPACE::DeviceMemoryOverallocationCreateInfoAMD>
3587  {
3588  std::size_t
3589  operator()( VULKAN_HPP_NAMESPACE::DeviceMemoryOverallocationCreateInfoAMD const & deviceMemoryOverallocationCreateInfoAMD ) const VULKAN_HPP_NOEXCEPT
3590  {
3591  std::size_t seed = 0;
3592  VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryOverallocationCreateInfoAMD.sType );
3593  VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryOverallocationCreateInfoAMD.pNext );
3594  VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryOverallocationCreateInfoAMD.overallocationBehavior );
3595  return seed;
3596  }
3597  };
3598 
3599  template <>
3600  struct hash<VULKAN_HPP_NAMESPACE::DeviceMemoryReportCallbackDataEXT>
3601  {
3602  std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceMemoryReportCallbackDataEXT const & deviceMemoryReportCallbackDataEXT ) const VULKAN_HPP_NOEXCEPT
3603  {
3604  std::size_t seed = 0;
3605  VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryReportCallbackDataEXT.sType );
3606  VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryReportCallbackDataEXT.pNext );
3607  VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryReportCallbackDataEXT.flags );
3608  VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryReportCallbackDataEXT.type );
3609  VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryReportCallbackDataEXT.memoryObjectId );
3610  VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryReportCallbackDataEXT.size );
3611  VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryReportCallbackDataEXT.objectType );
3612  VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryReportCallbackDataEXT.objectHandle );
3613  VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryReportCallbackDataEXT.heapIndex );
3614  return seed;
3615  }
3616  };
3617 
3618  template <>
3619  struct hash<VULKAN_HPP_NAMESPACE::DevicePrivateDataCreateInfo>
3620  {
3621  std::size_t operator()( VULKAN_HPP_NAMESPACE::DevicePrivateDataCreateInfo const & devicePrivateDataCreateInfo ) const VULKAN_HPP_NOEXCEPT
3622  {
3623  std::size_t seed = 0;
3624  VULKAN_HPP_HASH_COMBINE( seed, devicePrivateDataCreateInfo.sType );
3625  VULKAN_HPP_HASH_COMBINE( seed, devicePrivateDataCreateInfo.pNext );
3626  VULKAN_HPP_HASH_COMBINE( seed, devicePrivateDataCreateInfo.privateDataSlotRequestCount );
3627  return seed;
3628  }
3629  };
3630 
3631  template <>
3632  struct hash<VULKAN_HPP_NAMESPACE::DeviceQueueGlobalPriorityCreateInfoKHR>
3633  {
3634  std::size_t
3635  operator()( VULKAN_HPP_NAMESPACE::DeviceQueueGlobalPriorityCreateInfoKHR const & deviceQueueGlobalPriorityCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
3636  {
3637  std::size_t seed = 0;
3638  VULKAN_HPP_HASH_COMBINE( seed, deviceQueueGlobalPriorityCreateInfoKHR.sType );
3639  VULKAN_HPP_HASH_COMBINE( seed, deviceQueueGlobalPriorityCreateInfoKHR.pNext );
3640  VULKAN_HPP_HASH_COMBINE( seed, deviceQueueGlobalPriorityCreateInfoKHR.globalPriority );
3641  return seed;
3642  }
3643  };
3644 
3645  template <>
3646  struct hash<VULKAN_HPP_NAMESPACE::DeviceQueueInfo2>
3647  {
3648  std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceQueueInfo2 const & deviceQueueInfo2 ) const VULKAN_HPP_NOEXCEPT
3649  {
3650  std::size_t seed = 0;
3651  VULKAN_HPP_HASH_COMBINE( seed, deviceQueueInfo2.sType );
3652  VULKAN_HPP_HASH_COMBINE( seed, deviceQueueInfo2.pNext );
3653  VULKAN_HPP_HASH_COMBINE( seed, deviceQueueInfo2.flags );
3654  VULKAN_HPP_HASH_COMBINE( seed, deviceQueueInfo2.queueFamilyIndex );
3655  VULKAN_HPP_HASH_COMBINE( seed, deviceQueueInfo2.queueIndex );
3656  return seed;
3657  }
3658  };
3659 
3660  template <>
3661  struct hash<VULKAN_HPP_NAMESPACE::DirectDriverLoadingInfoLUNARG>
3662  {
3663  std::size_t operator()( VULKAN_HPP_NAMESPACE::DirectDriverLoadingInfoLUNARG const & directDriverLoadingInfoLUNARG ) const VULKAN_HPP_NOEXCEPT
3664  {
3665  std::size_t seed = 0;
3666  VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingInfoLUNARG.sType );
3667  VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingInfoLUNARG.pNext );
3668  VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingInfoLUNARG.flags );
3669  VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingInfoLUNARG.pfnGetInstanceProcAddr );
3670  return seed;
3671  }
3672  };
3673 
3674  template <>
3675  struct hash<VULKAN_HPP_NAMESPACE::DirectDriverLoadingListLUNARG>
3676  {
3677  std::size_t operator()( VULKAN_HPP_NAMESPACE::DirectDriverLoadingListLUNARG const & directDriverLoadingListLUNARG ) const VULKAN_HPP_NOEXCEPT
3678  {
3679  std::size_t seed = 0;
3680  VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingListLUNARG.sType );
3681  VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingListLUNARG.pNext );
3682  VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingListLUNARG.mode );
3683  VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingListLUNARG.driverCount );
3684  VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingListLUNARG.pDrivers );
3685  return seed;
3686  }
3687  };
3688 
3689 # if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
3690  template <>
3691  struct hash<VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT>
3692  {
3693  std::size_t operator()( VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT const & directFBSurfaceCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
3694  {
3695  std::size_t seed = 0;
3696  VULKAN_HPP_HASH_COMBINE( seed, directFBSurfaceCreateInfoEXT.sType );
3697  VULKAN_HPP_HASH_COMBINE( seed, directFBSurfaceCreateInfoEXT.pNext );
3698  VULKAN_HPP_HASH_COMBINE( seed, directFBSurfaceCreateInfoEXT.flags );
3699  VULKAN_HPP_HASH_COMBINE( seed, directFBSurfaceCreateInfoEXT.dfb );
3700  VULKAN_HPP_HASH_COMBINE( seed, directFBSurfaceCreateInfoEXT.surface );
3701  return seed;
3702  }
3703  };
3704 # endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
3705 
3706  template <>
3707  struct hash<VULKAN_HPP_NAMESPACE::DispatchIndirectCommand>
3708  {
3709  std::size_t operator()( VULKAN_HPP_NAMESPACE::DispatchIndirectCommand const & dispatchIndirectCommand ) const VULKAN_HPP_NOEXCEPT
3710  {
3711  std::size_t seed = 0;
3712  VULKAN_HPP_HASH_COMBINE( seed, dispatchIndirectCommand.x );
3713  VULKAN_HPP_HASH_COMBINE( seed, dispatchIndirectCommand.y );
3714  VULKAN_HPP_HASH_COMBINE( seed, dispatchIndirectCommand.z );
3715  return seed;
3716  }
3717  };
3718 
3719  template <>
3720  struct hash<VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT>
3721  {
3722  std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT const & displayEventInfoEXT ) const VULKAN_HPP_NOEXCEPT
3723  {
3724  std::size_t seed = 0;
3725  VULKAN_HPP_HASH_COMBINE( seed, displayEventInfoEXT.sType );
3726  VULKAN_HPP_HASH_COMBINE( seed, displayEventInfoEXT.pNext );
3727  VULKAN_HPP_HASH_COMBINE( seed, displayEventInfoEXT.displayEvent );
3728  return seed;
3729  }
3730  };
3731 
3732  template <>
3733  struct hash<VULKAN_HPP_NAMESPACE::DisplayModeParametersKHR>
3734  {
3735  std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayModeParametersKHR const & displayModeParametersKHR ) const VULKAN_HPP_NOEXCEPT
3736  {
3737  std::size_t seed = 0;
3738  VULKAN_HPP_HASH_COMBINE( seed, displayModeParametersKHR.visibleRegion );
3739  VULKAN_HPP_HASH_COMBINE( seed, displayModeParametersKHR.refreshRate );
3740  return seed;
3741  }
3742  };
3743 
3744  template <>
3745  struct hash<VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR>
3746  {
3747  std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR const & displayModeCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
3748  {
3749  std::size_t seed = 0;
3750  VULKAN_HPP_HASH_COMBINE( seed, displayModeCreateInfoKHR.sType );
3751  VULKAN_HPP_HASH_COMBINE( seed, displayModeCreateInfoKHR.pNext );
3752  VULKAN_HPP_HASH_COMBINE( seed, displayModeCreateInfoKHR.flags );
3753  VULKAN_HPP_HASH_COMBINE( seed, displayModeCreateInfoKHR.parameters );
3754  return seed;
3755  }
3756  };
3757 
3758  template <>
3759  struct hash<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR>
3760  {
3761  std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR const & displayModePropertiesKHR ) const VULKAN_HPP_NOEXCEPT
3762  {
3763  std::size_t seed = 0;
3764  VULKAN_HPP_HASH_COMBINE( seed, displayModePropertiesKHR.displayMode );
3765  VULKAN_HPP_HASH_COMBINE( seed, displayModePropertiesKHR.parameters );
3766  return seed;
3767  }
3768  };
3769 
3770  template <>
3771  struct hash<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR>
3772  {
3773  std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR const & displayModeProperties2KHR ) const VULKAN_HPP_NOEXCEPT
3774  {
3775  std::size_t seed = 0;
3776  VULKAN_HPP_HASH_COMBINE( seed, displayModeProperties2KHR.sType );
3777  VULKAN_HPP_HASH_COMBINE( seed, displayModeProperties2KHR.pNext );
3778  VULKAN_HPP_HASH_COMBINE( seed, displayModeProperties2KHR.displayModeProperties );
3779  return seed;
3780  }
3781  };
3782 
3783  template <>
3784  struct hash<VULKAN_HPP_NAMESPACE::DisplayNativeHdrSurfaceCapabilitiesAMD>
3785  {
3786  std::size_t
3787  operator()( VULKAN_HPP_NAMESPACE::DisplayNativeHdrSurfaceCapabilitiesAMD const & displayNativeHdrSurfaceCapabilitiesAMD ) const VULKAN_HPP_NOEXCEPT
3788  {
3789  std::size_t seed = 0;
3790  VULKAN_HPP_HASH_COMBINE( seed, displayNativeHdrSurfaceCapabilitiesAMD.sType );
3791  VULKAN_HPP_HASH_COMBINE( seed, displayNativeHdrSurfaceCapabilitiesAMD.pNext );
3792  VULKAN_HPP_HASH_COMBINE( seed, displayNativeHdrSurfaceCapabilitiesAMD.localDimmingSupport );
3793  return seed;
3794  }
3795  };
3796 
3797  template <>
3798  struct hash<VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR>
3799  {
3800  std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR const & displayPlaneCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT
3801  {
3802  std::size_t seed = 0;
3803  VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilitiesKHR.supportedAlpha );
3804  VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilitiesKHR.minSrcPosition );
3805  VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilitiesKHR.maxSrcPosition );
3806  VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilitiesKHR.minSrcExtent );
3807  VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilitiesKHR.maxSrcExtent );
3808  VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilitiesKHR.minDstPosition );
3809  VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilitiesKHR.maxDstPosition );
3810  VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilitiesKHR.minDstExtent );
3811  VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilitiesKHR.maxDstExtent );
3812  return seed;
3813  }
3814  };
3815 
3816  template <>
3817  struct hash<VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR>
3818  {
3819  std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR const & displayPlaneCapabilities2KHR ) const VULKAN_HPP_NOEXCEPT
3820  {
3821  std::size_t seed = 0;
3822  VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilities2KHR.sType );
3823  VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilities2KHR.pNext );
3824  VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilities2KHR.capabilities );
3825  return seed;
3826  }
3827  };
3828 
3829  template <>
3830  struct hash<VULKAN_HPP_NAMESPACE::DisplayPlaneInfo2KHR>
3831  {
3832  std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPlaneInfo2KHR const & displayPlaneInfo2KHR ) const VULKAN_HPP_NOEXCEPT
3833  {
3834  std::size_t seed = 0;
3835  VULKAN_HPP_HASH_COMBINE( seed, displayPlaneInfo2KHR.sType );
3836  VULKAN_HPP_HASH_COMBINE( seed, displayPlaneInfo2KHR.pNext );
3837  VULKAN_HPP_HASH_COMBINE( seed, displayPlaneInfo2KHR.mode );
3838  VULKAN_HPP_HASH_COMBINE( seed, displayPlaneInfo2KHR.planeIndex );
3839  return seed;
3840  }
3841  };
3842 
3843  template <>
3844  struct hash<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR>
3845  {
3846  std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR const & displayPlanePropertiesKHR ) const VULKAN_HPP_NOEXCEPT
3847  {
3848  std::size_t seed = 0;
3849  VULKAN_HPP_HASH_COMBINE( seed, displayPlanePropertiesKHR.currentDisplay );
3850  VULKAN_HPP_HASH_COMBINE( seed, displayPlanePropertiesKHR.currentStackIndex );
3851  return seed;
3852  }
3853  };
3854 
3855  template <>
3856  struct hash<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR>
3857  {
3858  std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR const & displayPlaneProperties2KHR ) const VULKAN_HPP_NOEXCEPT
3859  {
3860  std::size_t seed = 0;
3861  VULKAN_HPP_HASH_COMBINE( seed, displayPlaneProperties2KHR.sType );
3862  VULKAN_HPP_HASH_COMBINE( seed, displayPlaneProperties2KHR.pNext );
3863  VULKAN_HPP_HASH_COMBINE( seed, displayPlaneProperties2KHR.displayPlaneProperties );
3864  return seed;
3865  }
3866  };
3867 
3868  template <>
3869  struct hash<VULKAN_HPP_NAMESPACE::DisplayPowerInfoEXT>
3870  {
3871  std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPowerInfoEXT const & displayPowerInfoEXT ) const VULKAN_HPP_NOEXCEPT
3872  {
3873  std::size_t seed = 0;
3874  VULKAN_HPP_HASH_COMBINE( seed, displayPowerInfoEXT.sType );
3875  VULKAN_HPP_HASH_COMBINE( seed, displayPowerInfoEXT.pNext );
3876  VULKAN_HPP_HASH_COMBINE( seed, displayPowerInfoEXT.powerState );
3877  return seed;
3878  }
3879  };
3880 
3881  template <>
3882  struct hash<VULKAN_HPP_NAMESPACE::DisplayPresentInfoKHR>
3883  {
3884  std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPresentInfoKHR const & displayPresentInfoKHR ) const VULKAN_HPP_NOEXCEPT
3885  {
3886  std::size_t seed = 0;
3887  VULKAN_HPP_HASH_COMBINE( seed, displayPresentInfoKHR.sType );
3888  VULKAN_HPP_HASH_COMBINE( seed, displayPresentInfoKHR.pNext );
3889  VULKAN_HPP_HASH_COMBINE( seed, displayPresentInfoKHR.srcRect );
3890  VULKAN_HPP_HASH_COMBINE( seed, displayPresentInfoKHR.dstRect );
3891  VULKAN_HPP_HASH_COMBINE( seed, displayPresentInfoKHR.persistent );
3892  return seed;
3893  }
3894  };
3895 
3896  template <>
3897  struct hash<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR>
3898  {
3899  std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR const & displayPropertiesKHR ) const VULKAN_HPP_NOEXCEPT
3900  {
3901  std::size_t seed = 0;
3902  VULKAN_HPP_HASH_COMBINE( seed, displayPropertiesKHR.display );
3903  for ( const char * p = displayPropertiesKHR.displayName; *p != '\0'; ++p )
3904  {
3905  VULKAN_HPP_HASH_COMBINE( seed, *p );
3906  }
3907  VULKAN_HPP_HASH_COMBINE( seed, displayPropertiesKHR.physicalDimensions );
3908  VULKAN_HPP_HASH_COMBINE( seed, displayPropertiesKHR.physicalResolution );
3909  VULKAN_HPP_HASH_COMBINE( seed, displayPropertiesKHR.supportedTransforms );
3910  VULKAN_HPP_HASH_COMBINE( seed, displayPropertiesKHR.planeReorderPossible );
3911  VULKAN_HPP_HASH_COMBINE( seed, displayPropertiesKHR.persistentContent );
3912  return seed;
3913  }
3914  };
3915 
3916  template <>
3917  struct hash<VULKAN_HPP_NAMESPACE::DisplayProperties2KHR>
3918  {
3919  std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayProperties2KHR const & displayProperties2KHR ) const VULKAN_HPP_NOEXCEPT
3920  {
3921  std::size_t seed = 0;
3922  VULKAN_HPP_HASH_COMBINE( seed, displayProperties2KHR.sType );
3923  VULKAN_HPP_HASH_COMBINE( seed, displayProperties2KHR.pNext );
3924  VULKAN_HPP_HASH_COMBINE( seed, displayProperties2KHR.displayProperties );
3925  return seed;
3926  }
3927  };
3928 
3929  template <>
3930  struct hash<VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR>
3931  {
3932  std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR const & displaySurfaceCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
3933  {
3934  std::size_t seed = 0;
3935  VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.sType );
3936  VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.pNext );
3937  VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.flags );
3938  VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.displayMode );
3939  VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.planeIndex );
3940  VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.planeStackIndex );
3941  VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.transform );
3942  VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.globalAlpha );
3943  VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.alphaMode );
3944  VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.imageExtent );
3945  return seed;
3946  }
3947  };
3948 
3949  template <>
3950  struct hash<VULKAN_HPP_NAMESPACE::DrawIndexedIndirectCommand>
3951  {
3952  std::size_t operator()( VULKAN_HPP_NAMESPACE::DrawIndexedIndirectCommand const & drawIndexedIndirectCommand ) const VULKAN_HPP_NOEXCEPT
3953  {
3954  std::size_t seed = 0;
3955  VULKAN_HPP_HASH_COMBINE( seed, drawIndexedIndirectCommand.indexCount );
3956  VULKAN_HPP_HASH_COMBINE( seed, drawIndexedIndirectCommand.instanceCount );
3957  VULKAN_HPP_HASH_COMBINE( seed, drawIndexedIndirectCommand.firstIndex );
3958  VULKAN_HPP_HASH_COMBINE( seed, drawIndexedIndirectCommand.vertexOffset );
3959  VULKAN_HPP_HASH_COMBINE( seed, drawIndexedIndirectCommand.firstInstance );
3960  return seed;
3961  }
3962  };
3963 
3964  template <>
3965  struct hash<VULKAN_HPP_NAMESPACE::DrawIndirectCommand>
3966  {
3967  std::size_t operator()( VULKAN_HPP_NAMESPACE::DrawIndirectCommand const & drawIndirectCommand ) const VULKAN_HPP_NOEXCEPT
3968  {
3969  std::size_t seed = 0;
3970  VULKAN_HPP_HASH_COMBINE( seed, drawIndirectCommand.vertexCount );
3971  VULKAN_HPP_HASH_COMBINE( seed, drawIndirectCommand.instanceCount );
3972  VULKAN_HPP_HASH_COMBINE( seed, drawIndirectCommand.firstVertex );
3973  VULKAN_HPP_HASH_COMBINE( seed, drawIndirectCommand.firstInstance );
3974  return seed;
3975  }
3976  };
3977 
3978  template <>
3979  struct hash<VULKAN_HPP_NAMESPACE::DrawMeshTasksIndirectCommandEXT>
3980  {
3981  std::size_t operator()( VULKAN_HPP_NAMESPACE::DrawMeshTasksIndirectCommandEXT const & drawMeshTasksIndirectCommandEXT ) const VULKAN_HPP_NOEXCEPT
3982  {
3983  std::size_t seed = 0;
3984  VULKAN_HPP_HASH_COMBINE( seed, drawMeshTasksIndirectCommandEXT.groupCountX );
3985  VULKAN_HPP_HASH_COMBINE( seed, drawMeshTasksIndirectCommandEXT.groupCountY );
3986  VULKAN_HPP_HASH_COMBINE( seed, drawMeshTasksIndirectCommandEXT.groupCountZ );
3987  return seed;
3988  }
3989  };
3990 
3991  template <>
3992  struct hash<VULKAN_HPP_NAMESPACE::DrawMeshTasksIndirectCommandNV>
3993  {
3994  std::size_t operator()( VULKAN_HPP_NAMESPACE::DrawMeshTasksIndirectCommandNV const & drawMeshTasksIndirectCommandNV ) const VULKAN_HPP_NOEXCEPT
3995  {
3996  std::size_t seed = 0;
3997  VULKAN_HPP_HASH_COMBINE( seed, drawMeshTasksIndirectCommandNV.taskCount );
3998  VULKAN_HPP_HASH_COMBINE( seed, drawMeshTasksIndirectCommandNV.firstTask );
3999  return seed;
4000  }
4001  };
4002 
4003  template <>
4004  struct hash<VULKAN_HPP_NAMESPACE::DrmFormatModifierProperties2EXT>
4005  {
4006  std::size_t operator()( VULKAN_HPP_NAMESPACE::DrmFormatModifierProperties2EXT const & drmFormatModifierProperties2EXT ) const VULKAN_HPP_NOEXCEPT
4007  {
4008  std::size_t seed = 0;
4009  VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierProperties2EXT.drmFormatModifier );
4010  VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierProperties2EXT.drmFormatModifierPlaneCount );
4011  VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierProperties2EXT.drmFormatModifierTilingFeatures );
4012  return seed;
4013  }
4014  };
4015 
4016  template <>
4017  struct hash<VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesEXT>
4018  {
4019  std::size_t operator()( VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesEXT const & drmFormatModifierPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
4020  {
4021  std::size_t seed = 0;
4022  VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesEXT.drmFormatModifier );
4023  VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesEXT.drmFormatModifierPlaneCount );
4024  VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesEXT.drmFormatModifierTilingFeatures );
4025  return seed;
4026  }
4027  };
4028 
4029  template <>
4030  struct hash<VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesList2EXT>
4031  {
4032  std::size_t operator()( VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesList2EXT const & drmFormatModifierPropertiesList2EXT ) const VULKAN_HPP_NOEXCEPT
4033  {
4034  std::size_t seed = 0;
4035  VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesList2EXT.sType );
4036  VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesList2EXT.pNext );
4037  VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesList2EXT.drmFormatModifierCount );
4038  VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesList2EXT.pDrmFormatModifierProperties );
4039  return seed;
4040  }
4041  };
4042 
4043  template <>
4044  struct hash<VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesListEXT>
4045  {
4046  std::size_t operator()( VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesListEXT const & drmFormatModifierPropertiesListEXT ) const VULKAN_HPP_NOEXCEPT
4047  {
4048  std::size_t seed = 0;
4049  VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesListEXT.sType );
4050  VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesListEXT.pNext );
4051  VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesListEXT.drmFormatModifierCount );
4052  VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesListEXT.pDrmFormatModifierProperties );
4053  return seed;
4054  }
4055  };
4056 
4057  template <>
4058  struct hash<VULKAN_HPP_NAMESPACE::EventCreateInfo>
4059  {
4060  std::size_t operator()( VULKAN_HPP_NAMESPACE::EventCreateInfo const & eventCreateInfo ) const VULKAN_HPP_NOEXCEPT
4061  {
4062  std::size_t seed = 0;
4063  VULKAN_HPP_HASH_COMBINE( seed, eventCreateInfo.sType );
4064  VULKAN_HPP_HASH_COMBINE( seed, eventCreateInfo.pNext );
4065  VULKAN_HPP_HASH_COMBINE( seed, eventCreateInfo.flags );
4066  return seed;
4067  }
4068  };
4069 
4070  template <>
4071  struct hash<VULKAN_HPP_NAMESPACE::ExportFenceCreateInfo>
4072  {
4073  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportFenceCreateInfo const & exportFenceCreateInfo ) const VULKAN_HPP_NOEXCEPT
4074  {
4075  std::size_t seed = 0;
4076  VULKAN_HPP_HASH_COMBINE( seed, exportFenceCreateInfo.sType );
4077  VULKAN_HPP_HASH_COMBINE( seed, exportFenceCreateInfo.pNext );
4078  VULKAN_HPP_HASH_COMBINE( seed, exportFenceCreateInfo.handleTypes );
4079  return seed;
4080  }
4081  };
4082 
4083 # if defined( VK_USE_PLATFORM_WIN32_KHR )
4084  template <>
4085  struct hash<VULKAN_HPP_NAMESPACE::ExportFenceWin32HandleInfoKHR>
4086  {
4087  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportFenceWin32HandleInfoKHR const & exportFenceWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT
4088  {
4089  std::size_t seed = 0;
4090  VULKAN_HPP_HASH_COMBINE( seed, exportFenceWin32HandleInfoKHR.sType );
4091  VULKAN_HPP_HASH_COMBINE( seed, exportFenceWin32HandleInfoKHR.pNext );
4092  VULKAN_HPP_HASH_COMBINE( seed, exportFenceWin32HandleInfoKHR.pAttributes );
4093  VULKAN_HPP_HASH_COMBINE( seed, exportFenceWin32HandleInfoKHR.dwAccess );
4094  VULKAN_HPP_HASH_COMBINE( seed, exportFenceWin32HandleInfoKHR.name );
4095  return seed;
4096  }
4097  };
4098 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
4099 
4100  template <>
4101  struct hash<VULKAN_HPP_NAMESPACE::ExportMemoryAllocateInfo>
4102  {
4103  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMemoryAllocateInfo const & exportMemoryAllocateInfo ) const VULKAN_HPP_NOEXCEPT
4104  {
4105  std::size_t seed = 0;
4106  VULKAN_HPP_HASH_COMBINE( seed, exportMemoryAllocateInfo.sType );
4107  VULKAN_HPP_HASH_COMBINE( seed, exportMemoryAllocateInfo.pNext );
4108  VULKAN_HPP_HASH_COMBINE( seed, exportMemoryAllocateInfo.handleTypes );
4109  return seed;
4110  }
4111  };
4112 
4113  template <>
4114  struct hash<VULKAN_HPP_NAMESPACE::ExportMemoryAllocateInfoNV>
4115  {
4116  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMemoryAllocateInfoNV const & exportMemoryAllocateInfoNV ) const VULKAN_HPP_NOEXCEPT
4117  {
4118  std::size_t seed = 0;
4119  VULKAN_HPP_HASH_COMBINE( seed, exportMemoryAllocateInfoNV.sType );
4120  VULKAN_HPP_HASH_COMBINE( seed, exportMemoryAllocateInfoNV.pNext );
4121  VULKAN_HPP_HASH_COMBINE( seed, exportMemoryAllocateInfoNV.handleTypes );
4122  return seed;
4123  }
4124  };
4125 
4126 # if defined( VK_USE_PLATFORM_WIN32_KHR )
4127  template <>
4128  struct hash<VULKAN_HPP_NAMESPACE::ExportMemoryWin32HandleInfoKHR>
4129  {
4130  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMemoryWin32HandleInfoKHR const & exportMemoryWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT
4131  {
4132  std::size_t seed = 0;
4133  VULKAN_HPP_HASH_COMBINE( seed, exportMemoryWin32HandleInfoKHR.sType );
4134  VULKAN_HPP_HASH_COMBINE( seed, exportMemoryWin32HandleInfoKHR.pNext );
4135  VULKAN_HPP_HASH_COMBINE( seed, exportMemoryWin32HandleInfoKHR.pAttributes );
4136  VULKAN_HPP_HASH_COMBINE( seed, exportMemoryWin32HandleInfoKHR.dwAccess );
4137  VULKAN_HPP_HASH_COMBINE( seed, exportMemoryWin32HandleInfoKHR.name );
4138  return seed;
4139  }
4140  };
4141 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
4142 
4143 # if defined( VK_USE_PLATFORM_WIN32_KHR )
4144  template <>
4145  struct hash<VULKAN_HPP_NAMESPACE::ExportMemoryWin32HandleInfoNV>
4146  {
4147  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMemoryWin32HandleInfoNV const & exportMemoryWin32HandleInfoNV ) const VULKAN_HPP_NOEXCEPT
4148  {
4149  std::size_t seed = 0;
4150  VULKAN_HPP_HASH_COMBINE( seed, exportMemoryWin32HandleInfoNV.sType );
4151  VULKAN_HPP_HASH_COMBINE( seed, exportMemoryWin32HandleInfoNV.pNext );
4152  VULKAN_HPP_HASH_COMBINE( seed, exportMemoryWin32HandleInfoNV.pAttributes );
4153  VULKAN_HPP_HASH_COMBINE( seed, exportMemoryWin32HandleInfoNV.dwAccess );
4154  return seed;
4155  }
4156  };
4157 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
4158 
4159 # if defined( VK_USE_PLATFORM_METAL_EXT )
4160  template <>
4161  struct hash<VULKAN_HPP_NAMESPACE::ExportMetalBufferInfoEXT>
4162  {
4163  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMetalBufferInfoEXT const & exportMetalBufferInfoEXT ) const VULKAN_HPP_NOEXCEPT
4164  {
4165  std::size_t seed = 0;
4166  VULKAN_HPP_HASH_COMBINE( seed, exportMetalBufferInfoEXT.sType );
4167  VULKAN_HPP_HASH_COMBINE( seed, exportMetalBufferInfoEXT.pNext );
4168  VULKAN_HPP_HASH_COMBINE( seed, exportMetalBufferInfoEXT.memory );
4169  VULKAN_HPP_HASH_COMBINE( seed, exportMetalBufferInfoEXT.mtlBuffer );
4170  return seed;
4171  }
4172  };
4173 # endif /*VK_USE_PLATFORM_METAL_EXT*/
4174 
4175 # if defined( VK_USE_PLATFORM_METAL_EXT )
4176  template <>
4177  struct hash<VULKAN_HPP_NAMESPACE::ExportMetalCommandQueueInfoEXT>
4178  {
4179  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMetalCommandQueueInfoEXT const & exportMetalCommandQueueInfoEXT ) const VULKAN_HPP_NOEXCEPT
4180  {
4181  std::size_t seed = 0;
4182  VULKAN_HPP_HASH_COMBINE( seed, exportMetalCommandQueueInfoEXT.sType );
4183  VULKAN_HPP_HASH_COMBINE( seed, exportMetalCommandQueueInfoEXT.pNext );
4184  VULKAN_HPP_HASH_COMBINE( seed, exportMetalCommandQueueInfoEXT.queue );
4185  VULKAN_HPP_HASH_COMBINE( seed, exportMetalCommandQueueInfoEXT.mtlCommandQueue );
4186  return seed;
4187  }
4188  };
4189 # endif /*VK_USE_PLATFORM_METAL_EXT*/
4190 
4191 # if defined( VK_USE_PLATFORM_METAL_EXT )
4192  template <>
4193  struct hash<VULKAN_HPP_NAMESPACE::ExportMetalDeviceInfoEXT>
4194  {
4195  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMetalDeviceInfoEXT const & exportMetalDeviceInfoEXT ) const VULKAN_HPP_NOEXCEPT
4196  {
4197  std::size_t seed = 0;
4198  VULKAN_HPP_HASH_COMBINE( seed, exportMetalDeviceInfoEXT.sType );
4199  VULKAN_HPP_HASH_COMBINE( seed, exportMetalDeviceInfoEXT.pNext );
4200  VULKAN_HPP_HASH_COMBINE( seed, exportMetalDeviceInfoEXT.mtlDevice );
4201  return seed;
4202  }
4203  };
4204 # endif /*VK_USE_PLATFORM_METAL_EXT*/
4205 
4206 # if defined( VK_USE_PLATFORM_METAL_EXT )
4207  template <>
4208  struct hash<VULKAN_HPP_NAMESPACE::ExportMetalIOSurfaceInfoEXT>
4209  {
4210  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMetalIOSurfaceInfoEXT const & exportMetalIOSurfaceInfoEXT ) const VULKAN_HPP_NOEXCEPT
4211  {
4212  std::size_t seed = 0;
4213  VULKAN_HPP_HASH_COMBINE( seed, exportMetalIOSurfaceInfoEXT.sType );
4214  VULKAN_HPP_HASH_COMBINE( seed, exportMetalIOSurfaceInfoEXT.pNext );
4215  VULKAN_HPP_HASH_COMBINE( seed, exportMetalIOSurfaceInfoEXT.image );
4216  VULKAN_HPP_HASH_COMBINE( seed, exportMetalIOSurfaceInfoEXT.ioSurface );
4217  return seed;
4218  }
4219  };
4220 # endif /*VK_USE_PLATFORM_METAL_EXT*/
4221 
4222 # if defined( VK_USE_PLATFORM_METAL_EXT )
4223  template <>
4224  struct hash<VULKAN_HPP_NAMESPACE::ExportMetalObjectCreateInfoEXT>
4225  {
4226  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMetalObjectCreateInfoEXT const & exportMetalObjectCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
4227  {
4228  std::size_t seed = 0;
4229  VULKAN_HPP_HASH_COMBINE( seed, exportMetalObjectCreateInfoEXT.sType );
4230  VULKAN_HPP_HASH_COMBINE( seed, exportMetalObjectCreateInfoEXT.pNext );
4231  VULKAN_HPP_HASH_COMBINE( seed, exportMetalObjectCreateInfoEXT.exportObjectType );
4232  return seed;
4233  }
4234  };
4235 # endif /*VK_USE_PLATFORM_METAL_EXT*/
4236 
4237 # if defined( VK_USE_PLATFORM_METAL_EXT )
4238  template <>
4239  struct hash<VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT>
4240  {
4241  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT const & exportMetalObjectsInfoEXT ) const VULKAN_HPP_NOEXCEPT
4242  {
4243  std::size_t seed = 0;
4244  VULKAN_HPP_HASH_COMBINE( seed, exportMetalObjectsInfoEXT.sType );
4245  VULKAN_HPP_HASH_COMBINE( seed, exportMetalObjectsInfoEXT.pNext );
4246  return seed;
4247  }
4248  };
4249 # endif /*VK_USE_PLATFORM_METAL_EXT*/
4250 
4251 # if defined( VK_USE_PLATFORM_METAL_EXT )
4252  template <>
4253  struct hash<VULKAN_HPP_NAMESPACE::ExportMetalSharedEventInfoEXT>
4254  {
4255  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMetalSharedEventInfoEXT const & exportMetalSharedEventInfoEXT ) const VULKAN_HPP_NOEXCEPT
4256  {
4257  std::size_t seed = 0;
4258  VULKAN_HPP_HASH_COMBINE( seed, exportMetalSharedEventInfoEXT.sType );
4259  VULKAN_HPP_HASH_COMBINE( seed, exportMetalSharedEventInfoEXT.pNext );
4260  VULKAN_HPP_HASH_COMBINE( seed, exportMetalSharedEventInfoEXT.semaphore );
4261  VULKAN_HPP_HASH_COMBINE( seed, exportMetalSharedEventInfoEXT.event );
4262  VULKAN_HPP_HASH_COMBINE( seed, exportMetalSharedEventInfoEXT.mtlSharedEvent );
4263  return seed;
4264  }
4265  };
4266 # endif /*VK_USE_PLATFORM_METAL_EXT*/
4267 
4268 # if defined( VK_USE_PLATFORM_METAL_EXT )
4269  template <>
4270  struct hash<VULKAN_HPP_NAMESPACE::ExportMetalTextureInfoEXT>
4271  {
4272  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMetalTextureInfoEXT const & exportMetalTextureInfoEXT ) const VULKAN_HPP_NOEXCEPT
4273  {
4274  std::size_t seed = 0;
4275  VULKAN_HPP_HASH_COMBINE( seed, exportMetalTextureInfoEXT.sType );
4276  VULKAN_HPP_HASH_COMBINE( seed, exportMetalTextureInfoEXT.pNext );
4277  VULKAN_HPP_HASH_COMBINE( seed, exportMetalTextureInfoEXT.image );
4278  VULKAN_HPP_HASH_COMBINE( seed, exportMetalTextureInfoEXT.imageView );
4279  VULKAN_HPP_HASH_COMBINE( seed, exportMetalTextureInfoEXT.bufferView );
4280  VULKAN_HPP_HASH_COMBINE( seed, exportMetalTextureInfoEXT.plane );
4281  VULKAN_HPP_HASH_COMBINE( seed, exportMetalTextureInfoEXT.mtlTexture );
4282  return seed;
4283  }
4284  };
4285 # endif /*VK_USE_PLATFORM_METAL_EXT*/
4286 
4287  template <>
4288  struct hash<VULKAN_HPP_NAMESPACE::ExportSemaphoreCreateInfo>
4289  {
4290  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportSemaphoreCreateInfo const & exportSemaphoreCreateInfo ) const VULKAN_HPP_NOEXCEPT
4291  {
4292  std::size_t seed = 0;
4293  VULKAN_HPP_HASH_COMBINE( seed, exportSemaphoreCreateInfo.sType );
4294  VULKAN_HPP_HASH_COMBINE( seed, exportSemaphoreCreateInfo.pNext );
4295  VULKAN_HPP_HASH_COMBINE( seed, exportSemaphoreCreateInfo.handleTypes );
4296  return seed;
4297  }
4298  };
4299 
4300 # if defined( VK_USE_PLATFORM_WIN32_KHR )
4301  template <>
4302  struct hash<VULKAN_HPP_NAMESPACE::ExportSemaphoreWin32HandleInfoKHR>
4303  {
4304  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportSemaphoreWin32HandleInfoKHR const & exportSemaphoreWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT
4305  {
4306  std::size_t seed = 0;
4307  VULKAN_HPP_HASH_COMBINE( seed, exportSemaphoreWin32HandleInfoKHR.sType );
4308  VULKAN_HPP_HASH_COMBINE( seed, exportSemaphoreWin32HandleInfoKHR.pNext );
4309  VULKAN_HPP_HASH_COMBINE( seed, exportSemaphoreWin32HandleInfoKHR.pAttributes );
4310  VULKAN_HPP_HASH_COMBINE( seed, exportSemaphoreWin32HandleInfoKHR.dwAccess );
4311  VULKAN_HPP_HASH_COMBINE( seed, exportSemaphoreWin32HandleInfoKHR.name );
4312  return seed;
4313  }
4314  };
4315 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
4316 
4317  template <>
4318  struct hash<VULKAN_HPP_NAMESPACE::ExtensionProperties>
4319  {
4320  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExtensionProperties const & extensionProperties ) const VULKAN_HPP_NOEXCEPT
4321  {
4322  std::size_t seed = 0;
4323  for ( size_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i )
4324  {
4325  VULKAN_HPP_HASH_COMBINE( seed, extensionProperties.extensionName[i] );
4326  }
4327  VULKAN_HPP_HASH_COMBINE( seed, extensionProperties.specVersion );
4328  return seed;
4329  }
4330  };
4331 
4332  template <>
4333  struct hash<VULKAN_HPP_NAMESPACE::ExternalMemoryProperties>
4334  {
4335  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalMemoryProperties const & externalMemoryProperties ) const VULKAN_HPP_NOEXCEPT
4336  {
4337  std::size_t seed = 0;
4338  VULKAN_HPP_HASH_COMBINE( seed, externalMemoryProperties.externalMemoryFeatures );
4339  VULKAN_HPP_HASH_COMBINE( seed, externalMemoryProperties.exportFromImportedHandleTypes );
4340  VULKAN_HPP_HASH_COMBINE( seed, externalMemoryProperties.compatibleHandleTypes );
4341  return seed;
4342  }
4343  };
4344 
4345  template <>
4346  struct hash<VULKAN_HPP_NAMESPACE::ExternalBufferProperties>
4347  {
4348  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalBufferProperties const & externalBufferProperties ) const VULKAN_HPP_NOEXCEPT
4349  {
4350  std::size_t seed = 0;
4351  VULKAN_HPP_HASH_COMBINE( seed, externalBufferProperties.sType );
4352  VULKAN_HPP_HASH_COMBINE( seed, externalBufferProperties.pNext );
4353  VULKAN_HPP_HASH_COMBINE( seed, externalBufferProperties.externalMemoryProperties );
4354  return seed;
4355  }
4356  };
4357 
4358  template <>
4359  struct hash<VULKAN_HPP_NAMESPACE::ExternalFenceProperties>
4360  {
4361  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalFenceProperties const & externalFenceProperties ) const VULKAN_HPP_NOEXCEPT
4362  {
4363  std::size_t seed = 0;
4364  VULKAN_HPP_HASH_COMBINE( seed, externalFenceProperties.sType );
4365  VULKAN_HPP_HASH_COMBINE( seed, externalFenceProperties.pNext );
4366  VULKAN_HPP_HASH_COMBINE( seed, externalFenceProperties.exportFromImportedHandleTypes );
4367  VULKAN_HPP_HASH_COMBINE( seed, externalFenceProperties.compatibleHandleTypes );
4368  VULKAN_HPP_HASH_COMBINE( seed, externalFenceProperties.externalFenceFeatures );
4369  return seed;
4370  }
4371  };
4372 
4373 # if defined( VK_USE_PLATFORM_ANDROID_KHR )
4374  template <>
4375  struct hash<VULKAN_HPP_NAMESPACE::ExternalFormatANDROID>
4376  {
4377  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalFormatANDROID const & externalFormatANDROID ) const VULKAN_HPP_NOEXCEPT
4378  {
4379  std::size_t seed = 0;
4380  VULKAN_HPP_HASH_COMBINE( seed, externalFormatANDROID.sType );
4381  VULKAN_HPP_HASH_COMBINE( seed, externalFormatANDROID.pNext );
4382  VULKAN_HPP_HASH_COMBINE( seed, externalFormatANDROID.externalFormat );
4383  return seed;
4384  }
4385  };
4386 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/
4387 
4388  template <>
4389  struct hash<VULKAN_HPP_NAMESPACE::ExternalImageFormatProperties>
4390  {
4391  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalImageFormatProperties const & externalImageFormatProperties ) const VULKAN_HPP_NOEXCEPT
4392  {
4393  std::size_t seed = 0;
4394  VULKAN_HPP_HASH_COMBINE( seed, externalImageFormatProperties.sType );
4395  VULKAN_HPP_HASH_COMBINE( seed, externalImageFormatProperties.pNext );
4396  VULKAN_HPP_HASH_COMBINE( seed, externalImageFormatProperties.externalMemoryProperties );
4397  return seed;
4398  }
4399  };
4400 
4401  template <>
4402  struct hash<VULKAN_HPP_NAMESPACE::ImageFormatProperties>
4403  {
4404  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageFormatProperties const & imageFormatProperties ) const VULKAN_HPP_NOEXCEPT
4405  {
4406  std::size_t seed = 0;
4407  VULKAN_HPP_HASH_COMBINE( seed, imageFormatProperties.maxExtent );
4408  VULKAN_HPP_HASH_COMBINE( seed, imageFormatProperties.maxMipLevels );
4409  VULKAN_HPP_HASH_COMBINE( seed, imageFormatProperties.maxArrayLayers );
4410  VULKAN_HPP_HASH_COMBINE( seed, imageFormatProperties.sampleCounts );
4411  VULKAN_HPP_HASH_COMBINE( seed, imageFormatProperties.maxResourceSize );
4412  return seed;
4413  }
4414  };
4415 
4416  template <>
4417  struct hash<VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV>
4418  {
4419  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV const & externalImageFormatPropertiesNV ) const VULKAN_HPP_NOEXCEPT
4420  {
4421  std::size_t seed = 0;
4422  VULKAN_HPP_HASH_COMBINE( seed, externalImageFormatPropertiesNV.imageFormatProperties );
4423  VULKAN_HPP_HASH_COMBINE( seed, externalImageFormatPropertiesNV.externalMemoryFeatures );
4424  VULKAN_HPP_HASH_COMBINE( seed, externalImageFormatPropertiesNV.exportFromImportedHandleTypes );
4425  VULKAN_HPP_HASH_COMBINE( seed, externalImageFormatPropertiesNV.compatibleHandleTypes );
4426  return seed;
4427  }
4428  };
4429 
4430  template <>
4431  struct hash<VULKAN_HPP_NAMESPACE::ExternalMemoryBufferCreateInfo>
4432  {
4433  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalMemoryBufferCreateInfo const & externalMemoryBufferCreateInfo ) const VULKAN_HPP_NOEXCEPT
4434  {
4435  std::size_t seed = 0;
4436  VULKAN_HPP_HASH_COMBINE( seed, externalMemoryBufferCreateInfo.sType );
4437  VULKAN_HPP_HASH_COMBINE( seed, externalMemoryBufferCreateInfo.pNext );
4438  VULKAN_HPP_HASH_COMBINE( seed, externalMemoryBufferCreateInfo.handleTypes );
4439  return seed;
4440  }
4441  };
4442 
4443  template <>
4444  struct hash<VULKAN_HPP_NAMESPACE::ExternalMemoryImageCreateInfo>
4445  {
4446  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalMemoryImageCreateInfo const & externalMemoryImageCreateInfo ) const VULKAN_HPP_NOEXCEPT
4447  {
4448  std::size_t seed = 0;
4449  VULKAN_HPP_HASH_COMBINE( seed, externalMemoryImageCreateInfo.sType );
4450  VULKAN_HPP_HASH_COMBINE( seed, externalMemoryImageCreateInfo.pNext );
4451  VULKAN_HPP_HASH_COMBINE( seed, externalMemoryImageCreateInfo.handleTypes );
4452  return seed;
4453  }
4454  };
4455 
4456  template <>
4457  struct hash<VULKAN_HPP_NAMESPACE::ExternalMemoryImageCreateInfoNV>
4458  {
4459  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalMemoryImageCreateInfoNV const & externalMemoryImageCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
4460  {
4461  std::size_t seed = 0;
4462  VULKAN_HPP_HASH_COMBINE( seed, externalMemoryImageCreateInfoNV.sType );
4463  VULKAN_HPP_HASH_COMBINE( seed, externalMemoryImageCreateInfoNV.pNext );
4464  VULKAN_HPP_HASH_COMBINE( seed, externalMemoryImageCreateInfoNV.handleTypes );
4465  return seed;
4466  }
4467  };
4468 
4469  template <>
4470  struct hash<VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties>
4471  {
4472  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties const & externalSemaphoreProperties ) const VULKAN_HPP_NOEXCEPT
4473  {
4474  std::size_t seed = 0;
4475  VULKAN_HPP_HASH_COMBINE( seed, externalSemaphoreProperties.sType );
4476  VULKAN_HPP_HASH_COMBINE( seed, externalSemaphoreProperties.pNext );
4477  VULKAN_HPP_HASH_COMBINE( seed, externalSemaphoreProperties.exportFromImportedHandleTypes );
4478  VULKAN_HPP_HASH_COMBINE( seed, externalSemaphoreProperties.compatibleHandleTypes );
4479  VULKAN_HPP_HASH_COMBINE( seed, externalSemaphoreProperties.externalSemaphoreFeatures );
4480  return seed;
4481  }
4482  };
4483 
4484  template <>
4485  struct hash<VULKAN_HPP_NAMESPACE::FenceCreateInfo>
4486  {
4487  std::size_t operator()( VULKAN_HPP_NAMESPACE::FenceCreateInfo const & fenceCreateInfo ) const VULKAN_HPP_NOEXCEPT
4488  {
4489  std::size_t seed = 0;
4490  VULKAN_HPP_HASH_COMBINE( seed, fenceCreateInfo.sType );
4491  VULKAN_HPP_HASH_COMBINE( seed, fenceCreateInfo.pNext );
4492  VULKAN_HPP_HASH_COMBINE( seed, fenceCreateInfo.flags );
4493  return seed;
4494  }
4495  };
4496 
4497  template <>
4498  struct hash<VULKAN_HPP_NAMESPACE::FenceGetFdInfoKHR>
4499  {
4500  std::size_t operator()( VULKAN_HPP_NAMESPACE::FenceGetFdInfoKHR const & fenceGetFdInfoKHR ) const VULKAN_HPP_NOEXCEPT
4501  {
4502  std::size_t seed = 0;
4503  VULKAN_HPP_HASH_COMBINE( seed, fenceGetFdInfoKHR.sType );
4504  VULKAN_HPP_HASH_COMBINE( seed, fenceGetFdInfoKHR.pNext );
4505  VULKAN_HPP_HASH_COMBINE( seed, fenceGetFdInfoKHR.fence );
4506  VULKAN_HPP_HASH_COMBINE( seed, fenceGetFdInfoKHR.handleType );
4507  return seed;
4508  }
4509  };
4510 
4511 # if defined( VK_USE_PLATFORM_WIN32_KHR )
4512  template <>
4513  struct hash<VULKAN_HPP_NAMESPACE::FenceGetWin32HandleInfoKHR>
4514  {
4515  std::size_t operator()( VULKAN_HPP_NAMESPACE::FenceGetWin32HandleInfoKHR const & fenceGetWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT
4516  {
4517  std::size_t seed = 0;
4518  VULKAN_HPP_HASH_COMBINE( seed, fenceGetWin32HandleInfoKHR.sType );
4519  VULKAN_HPP_HASH_COMBINE( seed, fenceGetWin32HandleInfoKHR.pNext );
4520  VULKAN_HPP_HASH_COMBINE( seed, fenceGetWin32HandleInfoKHR.fence );
4521  VULKAN_HPP_HASH_COMBINE( seed, fenceGetWin32HandleInfoKHR.handleType );
4522  return seed;
4523  }
4524  };
4525 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
4526 
4527  template <>
4528  struct hash<VULKAN_HPP_NAMESPACE::FilterCubicImageViewImageFormatPropertiesEXT>
4529  {
4530  std::size_t operator()( VULKAN_HPP_NAMESPACE::FilterCubicImageViewImageFormatPropertiesEXT const & filterCubicImageViewImageFormatPropertiesEXT ) const
4531  VULKAN_HPP_NOEXCEPT
4532  {
4533  std::size_t seed = 0;
4534  VULKAN_HPP_HASH_COMBINE( seed, filterCubicImageViewImageFormatPropertiesEXT.sType );
4535  VULKAN_HPP_HASH_COMBINE( seed, filterCubicImageViewImageFormatPropertiesEXT.pNext );
4536  VULKAN_HPP_HASH_COMBINE( seed, filterCubicImageViewImageFormatPropertiesEXT.filterCubic );
4537  VULKAN_HPP_HASH_COMBINE( seed, filterCubicImageViewImageFormatPropertiesEXT.filterCubicMinmax );
4538  return seed;
4539  }
4540  };
4541 
4542  template <>
4543  struct hash<VULKAN_HPP_NAMESPACE::FormatProperties>
4544  {
4545  std::size_t operator()( VULKAN_HPP_NAMESPACE::FormatProperties const & formatProperties ) const VULKAN_HPP_NOEXCEPT
4546  {
4547  std::size_t seed = 0;
4548  VULKAN_HPP_HASH_COMBINE( seed, formatProperties.linearTilingFeatures );
4549  VULKAN_HPP_HASH_COMBINE( seed, formatProperties.optimalTilingFeatures );
4550  VULKAN_HPP_HASH_COMBINE( seed, formatProperties.bufferFeatures );
4551  return seed;
4552  }
4553  };
4554 
4555  template <>
4556  struct hash<VULKAN_HPP_NAMESPACE::FormatProperties2>
4557  {
4558  std::size_t operator()( VULKAN_HPP_NAMESPACE::FormatProperties2 const & formatProperties2 ) const VULKAN_HPP_NOEXCEPT
4559  {
4560  std::size_t seed = 0;
4561  VULKAN_HPP_HASH_COMBINE( seed, formatProperties2.sType );
4562  VULKAN_HPP_HASH_COMBINE( seed, formatProperties2.pNext );
4563  VULKAN_HPP_HASH_COMBINE( seed, formatProperties2.formatProperties );
4564  return seed;
4565  }
4566  };
4567 
4568  template <>
4569  struct hash<VULKAN_HPP_NAMESPACE::FormatProperties3>
4570  {
4571  std::size_t operator()( VULKAN_HPP_NAMESPACE::FormatProperties3 const & formatProperties3 ) const VULKAN_HPP_NOEXCEPT
4572  {
4573  std::size_t seed = 0;
4574  VULKAN_HPP_HASH_COMBINE( seed, formatProperties3.sType );
4575  VULKAN_HPP_HASH_COMBINE( seed, formatProperties3.pNext );
4576  VULKAN_HPP_HASH_COMBINE( seed, formatProperties3.linearTilingFeatures );
4577  VULKAN_HPP_HASH_COMBINE( seed, formatProperties3.optimalTilingFeatures );
4578  VULKAN_HPP_HASH_COMBINE( seed, formatProperties3.bufferFeatures );
4579  return seed;
4580  }
4581  };
4582 
4583  template <>
4584  struct hash<VULKAN_HPP_NAMESPACE::FragmentShadingRateAttachmentInfoKHR>
4585  {
4586  std::size_t operator()( VULKAN_HPP_NAMESPACE::FragmentShadingRateAttachmentInfoKHR const & fragmentShadingRateAttachmentInfoKHR ) const VULKAN_HPP_NOEXCEPT
4587  {
4588  std::size_t seed = 0;
4589  VULKAN_HPP_HASH_COMBINE( seed, fragmentShadingRateAttachmentInfoKHR.sType );
4590  VULKAN_HPP_HASH_COMBINE( seed, fragmentShadingRateAttachmentInfoKHR.pNext );
4591  VULKAN_HPP_HASH_COMBINE( seed, fragmentShadingRateAttachmentInfoKHR.pFragmentShadingRateAttachment );
4592  VULKAN_HPP_HASH_COMBINE( seed, fragmentShadingRateAttachmentInfoKHR.shadingRateAttachmentTexelSize );
4593  return seed;
4594  }
4595  };
4596 
4597  template <>
4598  struct hash<VULKAN_HPP_NAMESPACE::FramebufferAttachmentImageInfo>
4599  {
4600  std::size_t operator()( VULKAN_HPP_NAMESPACE::FramebufferAttachmentImageInfo const & framebufferAttachmentImageInfo ) const VULKAN_HPP_NOEXCEPT
4601  {
4602  std::size_t seed = 0;
4603  VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentImageInfo.sType );
4604  VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentImageInfo.pNext );
4605  VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentImageInfo.flags );
4606  VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentImageInfo.usage );
4607  VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentImageInfo.width );
4608  VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentImageInfo.height );
4609  VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentImageInfo.layerCount );
4610  VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentImageInfo.viewFormatCount );
4611  VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentImageInfo.pViewFormats );
4612  return seed;
4613  }
4614  };
4615 
4616  template <>
4617  struct hash<VULKAN_HPP_NAMESPACE::FramebufferAttachmentsCreateInfo>
4618  {
4619  std::size_t operator()( VULKAN_HPP_NAMESPACE::FramebufferAttachmentsCreateInfo const & framebufferAttachmentsCreateInfo ) const VULKAN_HPP_NOEXCEPT
4620  {
4621  std::size_t seed = 0;
4622  VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentsCreateInfo.sType );
4623  VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentsCreateInfo.pNext );
4624  VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentsCreateInfo.attachmentImageInfoCount );
4625  VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentsCreateInfo.pAttachmentImageInfos );
4626  return seed;
4627  }
4628  };
4629 
4630  template <>
4631  struct hash<VULKAN_HPP_NAMESPACE::FramebufferCreateInfo>
4632  {
4633  std::size_t operator()( VULKAN_HPP_NAMESPACE::FramebufferCreateInfo const & framebufferCreateInfo ) const VULKAN_HPP_NOEXCEPT
4634  {
4635  std::size_t seed = 0;
4636  VULKAN_HPP_HASH_COMBINE( seed, framebufferCreateInfo.sType );
4637  VULKAN_HPP_HASH_COMBINE( seed, framebufferCreateInfo.pNext );
4638  VULKAN_HPP_HASH_COMBINE( seed, framebufferCreateInfo.flags );
4639  VULKAN_HPP_HASH_COMBINE( seed, framebufferCreateInfo.renderPass );
4640  VULKAN_HPP_HASH_COMBINE( seed, framebufferCreateInfo.attachmentCount );
4641  VULKAN_HPP_HASH_COMBINE( seed, framebufferCreateInfo.pAttachments );
4642  VULKAN_HPP_HASH_COMBINE( seed, framebufferCreateInfo.width );
4643  VULKAN_HPP_HASH_COMBINE( seed, framebufferCreateInfo.height );
4644  VULKAN_HPP_HASH_COMBINE( seed, framebufferCreateInfo.layers );
4645  return seed;
4646  }
4647  };
4648 
4649  template <>
4650  struct hash<VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV>
4651  {
4652  std::size_t operator()( VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV const & framebufferMixedSamplesCombinationNV ) const VULKAN_HPP_NOEXCEPT
4653  {
4654  std::size_t seed = 0;
4655  VULKAN_HPP_HASH_COMBINE( seed, framebufferMixedSamplesCombinationNV.sType );
4656  VULKAN_HPP_HASH_COMBINE( seed, framebufferMixedSamplesCombinationNV.pNext );
4657  VULKAN_HPP_HASH_COMBINE( seed, framebufferMixedSamplesCombinationNV.coverageReductionMode );
4658  VULKAN_HPP_HASH_COMBINE( seed, framebufferMixedSamplesCombinationNV.rasterizationSamples );
4659  VULKAN_HPP_HASH_COMBINE( seed, framebufferMixedSamplesCombinationNV.depthStencilSamples );
4660  VULKAN_HPP_HASH_COMBINE( seed, framebufferMixedSamplesCombinationNV.colorSamples );
4661  return seed;
4662  }
4663  };
4664 
4665  template <>
4666  struct hash<VULKAN_HPP_NAMESPACE::IndirectCommandsStreamNV>
4667  {
4668  std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectCommandsStreamNV const & indirectCommandsStreamNV ) const VULKAN_HPP_NOEXCEPT
4669  {
4670  std::size_t seed = 0;
4671  VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsStreamNV.buffer );
4672  VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsStreamNV.offset );
4673  return seed;
4674  }
4675  };
4676 
4677  template <>
4678  struct hash<VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV>
4679  {
4680  std::size_t operator()( VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV const & generatedCommandsInfoNV ) const VULKAN_HPP_NOEXCEPT
4681  {
4682  std::size_t seed = 0;
4683  VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.sType );
4684  VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.pNext );
4685  VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.pipelineBindPoint );
4686  VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.pipeline );
4687  VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.indirectCommandsLayout );
4688  VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.streamCount );
4689  VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.pStreams );
4690  VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.sequencesCount );
4691  VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.preprocessBuffer );
4692  VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.preprocessOffset );
4693  VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.preprocessSize );
4694  VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.sequencesCountBuffer );
4695  VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.sequencesCountOffset );
4696  VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.sequencesIndexBuffer );
4697  VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.sequencesIndexOffset );
4698  return seed;
4699  }
4700  };
4701 
4702  template <>
4703  struct hash<VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV>
4704  {
4705  std::size_t
4706  operator()( VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV const & generatedCommandsMemoryRequirementsInfoNV ) const VULKAN_HPP_NOEXCEPT
4707  {
4708  std::size_t seed = 0;
4709  VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsMemoryRequirementsInfoNV.sType );
4710  VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsMemoryRequirementsInfoNV.pNext );
4711  VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsMemoryRequirementsInfoNV.pipelineBindPoint );
4712  VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsMemoryRequirementsInfoNV.pipeline );
4713  VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsMemoryRequirementsInfoNV.indirectCommandsLayout );
4714  VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsMemoryRequirementsInfoNV.maxSequencesCount );
4715  return seed;
4716  }
4717  };
4718 
4719  template <>
4720  struct hash<VULKAN_HPP_NAMESPACE::VertexInputBindingDescription>
4721  {
4722  std::size_t operator()( VULKAN_HPP_NAMESPACE::VertexInputBindingDescription const & vertexInputBindingDescription ) const VULKAN_HPP_NOEXCEPT
4723  {
4724  std::size_t seed = 0;
4725  VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDescription.binding );
4726  VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDescription.stride );
4727  VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDescription.inputRate );
4728  return seed;
4729  }
4730  };
4731 
4732  template <>
4733  struct hash<VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription>
4734  {
4735  std::size_t operator()( VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription const & vertexInputAttributeDescription ) const VULKAN_HPP_NOEXCEPT
4736  {
4737  std::size_t seed = 0;
4738  VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription.location );
4739  VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription.binding );
4740  VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription.format );
4741  VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription.offset );
4742  return seed;
4743  }
4744  };
4745 
4746  template <>
4747  struct hash<VULKAN_HPP_NAMESPACE::PipelineVertexInputStateCreateInfo>
4748  {
4749  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineVertexInputStateCreateInfo const & pipelineVertexInputStateCreateInfo ) const VULKAN_HPP_NOEXCEPT
4750  {
4751  std::size_t seed = 0;
4752  VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputStateCreateInfo.sType );
4753  VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputStateCreateInfo.pNext );
4754  VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputStateCreateInfo.flags );
4755  VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputStateCreateInfo.vertexBindingDescriptionCount );
4756  VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputStateCreateInfo.pVertexBindingDescriptions );
4757  VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputStateCreateInfo.vertexAttributeDescriptionCount );
4758  VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputStateCreateInfo.pVertexAttributeDescriptions );
4759  return seed;
4760  }
4761  };
4762 
4763  template <>
4764  struct hash<VULKAN_HPP_NAMESPACE::PipelineInputAssemblyStateCreateInfo>
4765  {
4766  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineInputAssemblyStateCreateInfo const & pipelineInputAssemblyStateCreateInfo ) const VULKAN_HPP_NOEXCEPT
4767  {
4768  std::size_t seed = 0;
4769  VULKAN_HPP_HASH_COMBINE( seed, pipelineInputAssemblyStateCreateInfo.sType );
4770  VULKAN_HPP_HASH_COMBINE( seed, pipelineInputAssemblyStateCreateInfo.pNext );
4771  VULKAN_HPP_HASH_COMBINE( seed, pipelineInputAssemblyStateCreateInfo.flags );
4772  VULKAN_HPP_HASH_COMBINE( seed, pipelineInputAssemblyStateCreateInfo.topology );
4773  VULKAN_HPP_HASH_COMBINE( seed, pipelineInputAssemblyStateCreateInfo.primitiveRestartEnable );
4774  return seed;
4775  }
4776  };
4777 
4778  template <>
4779  struct hash<VULKAN_HPP_NAMESPACE::PipelineTessellationStateCreateInfo>
4780  {
4781  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineTessellationStateCreateInfo const & pipelineTessellationStateCreateInfo ) const VULKAN_HPP_NOEXCEPT
4782  {
4783  std::size_t seed = 0;
4784  VULKAN_HPP_HASH_COMBINE( seed, pipelineTessellationStateCreateInfo.sType );
4785  VULKAN_HPP_HASH_COMBINE( seed, pipelineTessellationStateCreateInfo.pNext );
4786  VULKAN_HPP_HASH_COMBINE( seed, pipelineTessellationStateCreateInfo.flags );
4787  VULKAN_HPP_HASH_COMBINE( seed, pipelineTessellationStateCreateInfo.patchControlPoints );
4788  return seed;
4789  }
4790  };
4791 
4792  template <>
4793  struct hash<VULKAN_HPP_NAMESPACE::PipelineViewportStateCreateInfo>
4794  {
4795  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineViewportStateCreateInfo const & pipelineViewportStateCreateInfo ) const VULKAN_HPP_NOEXCEPT
4796  {
4797  std::size_t seed = 0;
4798  VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportStateCreateInfo.sType );
4799  VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportStateCreateInfo.pNext );
4800  VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportStateCreateInfo.flags );
4801  VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportStateCreateInfo.viewportCount );
4802  VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportStateCreateInfo.pViewports );
4803  VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportStateCreateInfo.scissorCount );
4804  VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportStateCreateInfo.pScissors );
4805  return seed;
4806  }
4807  };
4808 
4809  template <>
4810  struct hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationStateCreateInfo>
4811  {
4812  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationStateCreateInfo const & pipelineRasterizationStateCreateInfo ) const VULKAN_HPP_NOEXCEPT
4813  {
4814  std::size_t seed = 0;
4815  VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.sType );
4816  VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.pNext );
4817  VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.flags );
4818  VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.depthClampEnable );
4819  VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.rasterizerDiscardEnable );
4820  VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.polygonMode );
4821  VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.cullMode );
4822  VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.frontFace );
4823  VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.depthBiasEnable );
4824  VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.depthBiasConstantFactor );
4825  VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.depthBiasClamp );
4826  VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.depthBiasSlopeFactor );
4827  VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.lineWidth );
4828  return seed;
4829  }
4830  };
4831 
4832  template <>
4833  struct hash<VULKAN_HPP_NAMESPACE::PipelineMultisampleStateCreateInfo>
4834  {
4835  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineMultisampleStateCreateInfo const & pipelineMultisampleStateCreateInfo ) const VULKAN_HPP_NOEXCEPT
4836  {
4837  std::size_t seed = 0;
4838  VULKAN_HPP_HASH_COMBINE( seed, pipelineMultisampleStateCreateInfo.sType );
4839  VULKAN_HPP_HASH_COMBINE( seed, pipelineMultisampleStateCreateInfo.pNext );
4840  VULKAN_HPP_HASH_COMBINE( seed, pipelineMultisampleStateCreateInfo.flags );
4841  VULKAN_HPP_HASH_COMBINE( seed, pipelineMultisampleStateCreateInfo.rasterizationSamples );
4842  VULKAN_HPP_HASH_COMBINE( seed, pipelineMultisampleStateCreateInfo.sampleShadingEnable );
4843  VULKAN_HPP_HASH_COMBINE( seed, pipelineMultisampleStateCreateInfo.minSampleShading );
4844  VULKAN_HPP_HASH_COMBINE( seed, pipelineMultisampleStateCreateInfo.pSampleMask );
4845  VULKAN_HPP_HASH_COMBINE( seed, pipelineMultisampleStateCreateInfo.alphaToCoverageEnable );
4846  VULKAN_HPP_HASH_COMBINE( seed, pipelineMultisampleStateCreateInfo.alphaToOneEnable );
4847  return seed;
4848  }
4849  };
4850 
4851  template <>
4852  struct hash<VULKAN_HPP_NAMESPACE::StencilOpState>
4853  {
4854  std::size_t operator()( VULKAN_HPP_NAMESPACE::StencilOpState const & stencilOpState ) const VULKAN_HPP_NOEXCEPT
4855  {
4856  std::size_t seed = 0;
4857  VULKAN_HPP_HASH_COMBINE( seed, stencilOpState.failOp );
4858  VULKAN_HPP_HASH_COMBINE( seed, stencilOpState.passOp );
4859  VULKAN_HPP_HASH_COMBINE( seed, stencilOpState.depthFailOp );
4860  VULKAN_HPP_HASH_COMBINE( seed, stencilOpState.compareOp );
4861  VULKAN_HPP_HASH_COMBINE( seed, stencilOpState.compareMask );
4862  VULKAN_HPP_HASH_COMBINE( seed, stencilOpState.writeMask );
4863  VULKAN_HPP_HASH_COMBINE( seed, stencilOpState.reference );
4864  return seed;
4865  }
4866  };
4867 
4868  template <>
4869  struct hash<VULKAN_HPP_NAMESPACE::PipelineDepthStencilStateCreateInfo>
4870  {
4871  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineDepthStencilStateCreateInfo const & pipelineDepthStencilStateCreateInfo ) const VULKAN_HPP_NOEXCEPT
4872  {
4873  std::size_t seed = 0;
4874  VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.sType );
4875  VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.pNext );
4876  VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.flags );
4877  VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.depthTestEnable );
4878  VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.depthWriteEnable );
4879  VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.depthCompareOp );
4880  VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.depthBoundsTestEnable );
4881  VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.stencilTestEnable );
4882  VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.front );
4883  VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.back );
4884  VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.minDepthBounds );
4885  VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.maxDepthBounds );
4886  return seed;
4887  }
4888  };
4889 
4890  template <>
4891  struct hash<VULKAN_HPP_NAMESPACE::PipelineColorBlendAttachmentState>
4892  {
4893  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineColorBlendAttachmentState const & pipelineColorBlendAttachmentState ) const VULKAN_HPP_NOEXCEPT
4894  {
4895  std::size_t seed = 0;
4896  VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAttachmentState.blendEnable );
4897  VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAttachmentState.srcColorBlendFactor );
4898  VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAttachmentState.dstColorBlendFactor );
4899  VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAttachmentState.colorBlendOp );
4900  VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAttachmentState.srcAlphaBlendFactor );
4901  VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAttachmentState.dstAlphaBlendFactor );
4902  VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAttachmentState.alphaBlendOp );
4903  VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAttachmentState.colorWriteMask );
4904  return seed;
4905  }
4906  };
4907 
4908  template <>
4909  struct hash<VULKAN_HPP_NAMESPACE::PipelineColorBlendStateCreateInfo>
4910  {
4911  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineColorBlendStateCreateInfo const & pipelineColorBlendStateCreateInfo ) const VULKAN_HPP_NOEXCEPT
4912  {
4913  std::size_t seed = 0;
4914  VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendStateCreateInfo.sType );
4915  VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendStateCreateInfo.pNext );
4916  VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendStateCreateInfo.flags );
4917  VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendStateCreateInfo.logicOpEnable );
4918  VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendStateCreateInfo.logicOp );
4919  VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendStateCreateInfo.attachmentCount );
4920  VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendStateCreateInfo.pAttachments );
4921  for ( size_t i = 0; i < 4; ++i )
4922  {
4923  VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendStateCreateInfo.blendConstants[i] );
4924  }
4925  return seed;
4926  }
4927  };
4928 
4929  template <>
4930  struct hash<VULKAN_HPP_NAMESPACE::PipelineDynamicStateCreateInfo>
4931  {
4932  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineDynamicStateCreateInfo const & pipelineDynamicStateCreateInfo ) const VULKAN_HPP_NOEXCEPT
4933  {
4934  std::size_t seed = 0;
4935  VULKAN_HPP_HASH_COMBINE( seed, pipelineDynamicStateCreateInfo.sType );
4936  VULKAN_HPP_HASH_COMBINE( seed, pipelineDynamicStateCreateInfo.pNext );
4937  VULKAN_HPP_HASH_COMBINE( seed, pipelineDynamicStateCreateInfo.flags );
4938  VULKAN_HPP_HASH_COMBINE( seed, pipelineDynamicStateCreateInfo.dynamicStateCount );
4939  VULKAN_HPP_HASH_COMBINE( seed, pipelineDynamicStateCreateInfo.pDynamicStates );
4940  return seed;
4941  }
4942  };
4943 
4944  template <>
4945  struct hash<VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo>
4946  {
4947  std::size_t operator()( VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo const & graphicsPipelineCreateInfo ) const VULKAN_HPP_NOEXCEPT
4948  {
4949  std::size_t seed = 0;
4950  VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.sType );
4951  VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pNext );
4952  VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.flags );
4953  VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.stageCount );
4954  VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pStages );
4955  VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pVertexInputState );
4956  VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pInputAssemblyState );
4957  VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pTessellationState );
4958  VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pViewportState );
4959  VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pRasterizationState );
4960  VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pMultisampleState );
4961  VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pDepthStencilState );
4962  VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pColorBlendState );
4963  VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pDynamicState );
4964  VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.layout );
4965  VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.renderPass );
4966  VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.subpass );
4967  VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.basePipelineHandle );
4968  VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.basePipelineIndex );
4969  return seed;
4970  }
4971  };
4972 
4973  template <>
4974  struct hash<VULKAN_HPP_NAMESPACE::GraphicsPipelineLibraryCreateInfoEXT>
4975  {
4976  std::size_t operator()( VULKAN_HPP_NAMESPACE::GraphicsPipelineLibraryCreateInfoEXT const & graphicsPipelineLibraryCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
4977  {
4978  std::size_t seed = 0;
4979  VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineLibraryCreateInfoEXT.sType );
4980  VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineLibraryCreateInfoEXT.pNext );
4981  VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineLibraryCreateInfoEXT.flags );
4982  return seed;
4983  }
4984  };
4985 
4986  template <>
4987  struct hash<VULKAN_HPP_NAMESPACE::GraphicsShaderGroupCreateInfoNV>
4988  {
4989  std::size_t operator()( VULKAN_HPP_NAMESPACE::GraphicsShaderGroupCreateInfoNV const & graphicsShaderGroupCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
4990  {
4991  std::size_t seed = 0;
4992  VULKAN_HPP_HASH_COMBINE( seed, graphicsShaderGroupCreateInfoNV.sType );
4993  VULKAN_HPP_HASH_COMBINE( seed, graphicsShaderGroupCreateInfoNV.pNext );
4994  VULKAN_HPP_HASH_COMBINE( seed, graphicsShaderGroupCreateInfoNV.stageCount );
4995  VULKAN_HPP_HASH_COMBINE( seed, graphicsShaderGroupCreateInfoNV.pStages );
4996  VULKAN_HPP_HASH_COMBINE( seed, graphicsShaderGroupCreateInfoNV.pVertexInputState );
4997  VULKAN_HPP_HASH_COMBINE( seed, graphicsShaderGroupCreateInfoNV.pTessellationState );
4998  return seed;
4999  }
5000  };
5001 
5002  template <>
5003  struct hash<VULKAN_HPP_NAMESPACE::GraphicsPipelineShaderGroupsCreateInfoNV>
5004  {
5005  std::size_t
5006  operator()( VULKAN_HPP_NAMESPACE::GraphicsPipelineShaderGroupsCreateInfoNV const & graphicsPipelineShaderGroupsCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
5007  {
5008  std::size_t seed = 0;
5009  VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineShaderGroupsCreateInfoNV.sType );
5010  VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineShaderGroupsCreateInfoNV.pNext );
5011  VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineShaderGroupsCreateInfoNV.groupCount );
5012  VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineShaderGroupsCreateInfoNV.pGroups );
5013  VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineShaderGroupsCreateInfoNV.pipelineCount );
5014  VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineShaderGroupsCreateInfoNV.pPipelines );
5015  return seed;
5016  }
5017  };
5018 
5019  template <>
5020  struct hash<VULKAN_HPP_NAMESPACE::XYColorEXT>
5021  {
5022  std::size_t operator()( VULKAN_HPP_NAMESPACE::XYColorEXT const & xYColorEXT ) const VULKAN_HPP_NOEXCEPT
5023  {
5024  std::size_t seed = 0;
5025  VULKAN_HPP_HASH_COMBINE( seed, xYColorEXT.x );
5026  VULKAN_HPP_HASH_COMBINE( seed, xYColorEXT.y );
5027  return seed;
5028  }
5029  };
5030 
5031  template <>
5032  struct hash<VULKAN_HPP_NAMESPACE::HdrMetadataEXT>
5033  {
5034  std::size_t operator()( VULKAN_HPP_NAMESPACE::HdrMetadataEXT const & hdrMetadataEXT ) const VULKAN_HPP_NOEXCEPT
5035  {
5036  std::size_t seed = 0;
5037  VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.sType );
5038  VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.pNext );
5039  VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.displayPrimaryRed );
5040  VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.displayPrimaryGreen );
5041  VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.displayPrimaryBlue );
5042  VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.whitePoint );
5043  VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.maxLuminance );
5044  VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.minLuminance );
5045  VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.maxContentLightLevel );
5046  VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.maxFrameAverageLightLevel );
5047  return seed;
5048  }
5049  };
5050 
5051  template <>
5052  struct hash<VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT>
5053  {
5054  std::size_t operator()( VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT const & headlessSurfaceCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
5055  {
5056  std::size_t seed = 0;
5057  VULKAN_HPP_HASH_COMBINE( seed, headlessSurfaceCreateInfoEXT.sType );
5058  VULKAN_HPP_HASH_COMBINE( seed, headlessSurfaceCreateInfoEXT.pNext );
5059  VULKAN_HPP_HASH_COMBINE( seed, headlessSurfaceCreateInfoEXT.flags );
5060  return seed;
5061  }
5062  };
5063 
5064 # if defined( VK_USE_PLATFORM_IOS_MVK )
5065  template <>
5066  struct hash<VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK>
5067  {
5068  std::size_t operator()( VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK const & iOSSurfaceCreateInfoMVK ) const VULKAN_HPP_NOEXCEPT
5069  {
5070  std::size_t seed = 0;
5071  VULKAN_HPP_HASH_COMBINE( seed, iOSSurfaceCreateInfoMVK.sType );
5072  VULKAN_HPP_HASH_COMBINE( seed, iOSSurfaceCreateInfoMVK.pNext );
5073  VULKAN_HPP_HASH_COMBINE( seed, iOSSurfaceCreateInfoMVK.flags );
5074  VULKAN_HPP_HASH_COMBINE( seed, iOSSurfaceCreateInfoMVK.pView );
5075  return seed;
5076  }
5077  };
5078 # endif /*VK_USE_PLATFORM_IOS_MVK*/
5079 
5080  template <>
5081  struct hash<VULKAN_HPP_NAMESPACE::ImageBlit>
5082  {
5083  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageBlit const & imageBlit ) const VULKAN_HPP_NOEXCEPT
5084  {
5085  std::size_t seed = 0;
5086  VULKAN_HPP_HASH_COMBINE( seed, imageBlit.srcSubresource );
5087  for ( size_t i = 0; i < 2; ++i )
5088  {
5089  VULKAN_HPP_HASH_COMBINE( seed, imageBlit.srcOffsets[i] );
5090  }
5091  VULKAN_HPP_HASH_COMBINE( seed, imageBlit.dstSubresource );
5092  for ( size_t i = 0; i < 2; ++i )
5093  {
5094  VULKAN_HPP_HASH_COMBINE( seed, imageBlit.dstOffsets[i] );
5095  }
5096  return seed;
5097  }
5098  };
5099 
5100  template <>
5101  struct hash<VULKAN_HPP_NAMESPACE::ImageCaptureDescriptorDataInfoEXT>
5102  {
5103  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageCaptureDescriptorDataInfoEXT const & imageCaptureDescriptorDataInfoEXT ) const VULKAN_HPP_NOEXCEPT
5104  {
5105  std::size_t seed = 0;
5106  VULKAN_HPP_HASH_COMBINE( seed, imageCaptureDescriptorDataInfoEXT.sType );
5107  VULKAN_HPP_HASH_COMBINE( seed, imageCaptureDescriptorDataInfoEXT.pNext );
5108  VULKAN_HPP_HASH_COMBINE( seed, imageCaptureDescriptorDataInfoEXT.image );
5109  return seed;
5110  }
5111  };
5112 
5113  template <>
5114  struct hash<VULKAN_HPP_NAMESPACE::ImageCompressionControlEXT>
5115  {
5116  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageCompressionControlEXT const & imageCompressionControlEXT ) const VULKAN_HPP_NOEXCEPT
5117  {
5118  std::size_t seed = 0;
5119  VULKAN_HPP_HASH_COMBINE( seed, imageCompressionControlEXT.sType );
5120  VULKAN_HPP_HASH_COMBINE( seed, imageCompressionControlEXT.pNext );
5121  VULKAN_HPP_HASH_COMBINE( seed, imageCompressionControlEXT.flags );
5122  VULKAN_HPP_HASH_COMBINE( seed, imageCompressionControlEXT.compressionControlPlaneCount );
5123  VULKAN_HPP_HASH_COMBINE( seed, imageCompressionControlEXT.pFixedRateFlags );
5124  return seed;
5125  }
5126  };
5127 
5128  template <>
5129  struct hash<VULKAN_HPP_NAMESPACE::ImageCompressionPropertiesEXT>
5130  {
5131  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageCompressionPropertiesEXT const & imageCompressionPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
5132  {
5133  std::size_t seed = 0;
5134  VULKAN_HPP_HASH_COMBINE( seed, imageCompressionPropertiesEXT.sType );
5135  VULKAN_HPP_HASH_COMBINE( seed, imageCompressionPropertiesEXT.pNext );
5136  VULKAN_HPP_HASH_COMBINE( seed, imageCompressionPropertiesEXT.imageCompressionFlags );
5137  VULKAN_HPP_HASH_COMBINE( seed, imageCompressionPropertiesEXT.imageCompressionFixedRateFlags );
5138  return seed;
5139  }
5140  };
5141 
5142 # if defined( VK_USE_PLATFORM_FUCHSIA )
5143  template <>
5144  struct hash<VULKAN_HPP_NAMESPACE::ImageFormatConstraintsInfoFUCHSIA>
5145  {
5146  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageFormatConstraintsInfoFUCHSIA const & imageFormatConstraintsInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT
5147  {
5148  std::size_t seed = 0;
5149  VULKAN_HPP_HASH_COMBINE( seed, imageFormatConstraintsInfoFUCHSIA.sType );
5150  VULKAN_HPP_HASH_COMBINE( seed, imageFormatConstraintsInfoFUCHSIA.pNext );
5151  VULKAN_HPP_HASH_COMBINE( seed, imageFormatConstraintsInfoFUCHSIA.imageCreateInfo );
5152  VULKAN_HPP_HASH_COMBINE( seed, imageFormatConstraintsInfoFUCHSIA.requiredFormatFeatures );
5153  VULKAN_HPP_HASH_COMBINE( seed, imageFormatConstraintsInfoFUCHSIA.flags );
5154  VULKAN_HPP_HASH_COMBINE( seed, imageFormatConstraintsInfoFUCHSIA.sysmemPixelFormat );
5155  VULKAN_HPP_HASH_COMBINE( seed, imageFormatConstraintsInfoFUCHSIA.colorSpaceCount );
5156  VULKAN_HPP_HASH_COMBINE( seed, imageFormatConstraintsInfoFUCHSIA.pColorSpaces );
5157  return seed;
5158  }
5159  };
5160 # endif /*VK_USE_PLATFORM_FUCHSIA*/
5161 
5162 # if defined( VK_USE_PLATFORM_FUCHSIA )
5163  template <>
5164  struct hash<VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFUCHSIA>
5165  {
5166  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFUCHSIA const & imageConstraintsInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT
5167  {
5168  std::size_t seed = 0;
5169  VULKAN_HPP_HASH_COMBINE( seed, imageConstraintsInfoFUCHSIA.sType );
5170  VULKAN_HPP_HASH_COMBINE( seed, imageConstraintsInfoFUCHSIA.pNext );
5171  VULKAN_HPP_HASH_COMBINE( seed, imageConstraintsInfoFUCHSIA.formatConstraintsCount );
5172  VULKAN_HPP_HASH_COMBINE( seed, imageConstraintsInfoFUCHSIA.pFormatConstraints );
5173  VULKAN_HPP_HASH_COMBINE( seed, imageConstraintsInfoFUCHSIA.bufferCollectionConstraints );
5174  VULKAN_HPP_HASH_COMBINE( seed, imageConstraintsInfoFUCHSIA.flags );
5175  return seed;
5176  }
5177  };
5178 # endif /*VK_USE_PLATFORM_FUCHSIA*/
5179 
5180  template <>
5181  struct hash<VULKAN_HPP_NAMESPACE::ImageCopy>
5182  {
5183  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageCopy const & imageCopy ) const VULKAN_HPP_NOEXCEPT
5184  {
5185  std::size_t seed = 0;
5186  VULKAN_HPP_HASH_COMBINE( seed, imageCopy.srcSubresource );
5187  VULKAN_HPP_HASH_COMBINE( seed, imageCopy.srcOffset );
5188  VULKAN_HPP_HASH_COMBINE( seed, imageCopy.dstSubresource );
5189  VULKAN_HPP_HASH_COMBINE( seed, imageCopy.dstOffset );
5190  VULKAN_HPP_HASH_COMBINE( seed, imageCopy.extent );
5191  return seed;
5192  }
5193  };
5194 
5195  template <>
5196  struct hash<VULKAN_HPP_NAMESPACE::SubresourceLayout>
5197  {
5198  std::size_t operator()( VULKAN_HPP_NAMESPACE::SubresourceLayout const & subresourceLayout ) const VULKAN_HPP_NOEXCEPT
5199  {
5200  std::size_t seed = 0;
5201  VULKAN_HPP_HASH_COMBINE( seed, subresourceLayout.offset );
5202  VULKAN_HPP_HASH_COMBINE( seed, subresourceLayout.size );
5203  VULKAN_HPP_HASH_COMBINE( seed, subresourceLayout.rowPitch );
5204  VULKAN_HPP_HASH_COMBINE( seed, subresourceLayout.arrayPitch );
5205  VULKAN_HPP_HASH_COMBINE( seed, subresourceLayout.depthPitch );
5206  return seed;
5207  }
5208  };
5209 
5210  template <>
5211  struct hash<VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierExplicitCreateInfoEXT>
5212  {
5213  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierExplicitCreateInfoEXT const & imageDrmFormatModifierExplicitCreateInfoEXT ) const
5214  VULKAN_HPP_NOEXCEPT
5215  {
5216  std::size_t seed = 0;
5217  VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierExplicitCreateInfoEXT.sType );
5218  VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierExplicitCreateInfoEXT.pNext );
5219  VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierExplicitCreateInfoEXT.drmFormatModifier );
5220  VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierExplicitCreateInfoEXT.drmFormatModifierPlaneCount );
5221  VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierExplicitCreateInfoEXT.pPlaneLayouts );
5222  return seed;
5223  }
5224  };
5225 
5226  template <>
5227  struct hash<VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierListCreateInfoEXT>
5228  {
5229  std::size_t
5230  operator()( VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierListCreateInfoEXT const & imageDrmFormatModifierListCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
5231  {
5232  std::size_t seed = 0;
5233  VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierListCreateInfoEXT.sType );
5234  VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierListCreateInfoEXT.pNext );
5235  VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierListCreateInfoEXT.drmFormatModifierCount );
5236  VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierListCreateInfoEXT.pDrmFormatModifiers );
5237  return seed;
5238  }
5239  };
5240 
5241  template <>
5242  struct hash<VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT>
5243  {
5244  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT const & imageDrmFormatModifierPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
5245  {
5246  std::size_t seed = 0;
5247  VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierPropertiesEXT.sType );
5248  VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierPropertiesEXT.pNext );
5249  VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierPropertiesEXT.drmFormatModifier );
5250  return seed;
5251  }
5252  };
5253 
5254  template <>
5255  struct hash<VULKAN_HPP_NAMESPACE::ImageFormatListCreateInfo>
5256  {
5257  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageFormatListCreateInfo const & imageFormatListCreateInfo ) const VULKAN_HPP_NOEXCEPT
5258  {
5259  std::size_t seed = 0;
5260  VULKAN_HPP_HASH_COMBINE( seed, imageFormatListCreateInfo.sType );
5261  VULKAN_HPP_HASH_COMBINE( seed, imageFormatListCreateInfo.pNext );
5262  VULKAN_HPP_HASH_COMBINE( seed, imageFormatListCreateInfo.viewFormatCount );
5263  VULKAN_HPP_HASH_COMBINE( seed, imageFormatListCreateInfo.pViewFormats );
5264  return seed;
5265  }
5266  };
5267 
5268  template <>
5269  struct hash<VULKAN_HPP_NAMESPACE::ImageFormatProperties2>
5270  {
5271  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageFormatProperties2 const & imageFormatProperties2 ) const VULKAN_HPP_NOEXCEPT
5272  {
5273  std::size_t seed = 0;
5274  VULKAN_HPP_HASH_COMBINE( seed, imageFormatProperties2.sType );
5275  VULKAN_HPP_HASH_COMBINE( seed, imageFormatProperties2.pNext );
5276  VULKAN_HPP_HASH_COMBINE( seed, imageFormatProperties2.imageFormatProperties );
5277  return seed;
5278  }
5279  };
5280 
5281  template <>
5282  struct hash<VULKAN_HPP_NAMESPACE::ImageMemoryBarrier>
5283  {
5284  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageMemoryBarrier const & imageMemoryBarrier ) const VULKAN_HPP_NOEXCEPT
5285  {
5286  std::size_t seed = 0;
5287  VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.sType );
5288  VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.pNext );
5289  VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.srcAccessMask );
5290  VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.dstAccessMask );
5291  VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.oldLayout );
5292  VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.newLayout );
5293  VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.srcQueueFamilyIndex );
5294  VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.dstQueueFamilyIndex );
5295  VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.image );
5296  VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.subresourceRange );
5297  return seed;
5298  }
5299  };
5300 
5301  template <>
5302  struct hash<VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2>
5303  {
5304  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 const & imageMemoryRequirementsInfo2 ) const VULKAN_HPP_NOEXCEPT
5305  {
5306  std::size_t seed = 0;
5307  VULKAN_HPP_HASH_COMBINE( seed, imageMemoryRequirementsInfo2.sType );
5308  VULKAN_HPP_HASH_COMBINE( seed, imageMemoryRequirementsInfo2.pNext );
5309  VULKAN_HPP_HASH_COMBINE( seed, imageMemoryRequirementsInfo2.image );
5310  return seed;
5311  }
5312  };
5313 
5314 # if defined( VK_USE_PLATFORM_FUCHSIA )
5315  template <>
5316  struct hash<VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA>
5317  {
5318  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA const & imagePipeSurfaceCreateInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT
5319  {
5320  std::size_t seed = 0;
5321  VULKAN_HPP_HASH_COMBINE( seed, imagePipeSurfaceCreateInfoFUCHSIA.sType );
5322  VULKAN_HPP_HASH_COMBINE( seed, imagePipeSurfaceCreateInfoFUCHSIA.pNext );
5323  VULKAN_HPP_HASH_COMBINE( seed, imagePipeSurfaceCreateInfoFUCHSIA.flags );
5324  VULKAN_HPP_HASH_COMBINE( seed, imagePipeSurfaceCreateInfoFUCHSIA.imagePipeHandle );
5325  return seed;
5326  }
5327  };
5328 # endif /*VK_USE_PLATFORM_FUCHSIA*/
5329 
5330  template <>
5331  struct hash<VULKAN_HPP_NAMESPACE::ImagePlaneMemoryRequirementsInfo>
5332  {
5333  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImagePlaneMemoryRequirementsInfo const & imagePlaneMemoryRequirementsInfo ) const VULKAN_HPP_NOEXCEPT
5334  {
5335  std::size_t seed = 0;
5336  VULKAN_HPP_HASH_COMBINE( seed, imagePlaneMemoryRequirementsInfo.sType );
5337  VULKAN_HPP_HASH_COMBINE( seed, imagePlaneMemoryRequirementsInfo.pNext );
5338  VULKAN_HPP_HASH_COMBINE( seed, imagePlaneMemoryRequirementsInfo.planeAspect );
5339  return seed;
5340  }
5341  };
5342 
5343  template <>
5344  struct hash<VULKAN_HPP_NAMESPACE::ImageResolve>
5345  {
5346  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageResolve const & imageResolve ) const VULKAN_HPP_NOEXCEPT
5347  {
5348  std::size_t seed = 0;
5349  VULKAN_HPP_HASH_COMBINE( seed, imageResolve.srcSubresource );
5350  VULKAN_HPP_HASH_COMBINE( seed, imageResolve.srcOffset );
5351  VULKAN_HPP_HASH_COMBINE( seed, imageResolve.dstSubresource );
5352  VULKAN_HPP_HASH_COMBINE( seed, imageResolve.dstOffset );
5353  VULKAN_HPP_HASH_COMBINE( seed, imageResolve.extent );
5354  return seed;
5355  }
5356  };
5357 
5358  template <>
5359  struct hash<VULKAN_HPP_NAMESPACE::ImageResolve2>
5360  {
5361  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageResolve2 const & imageResolve2 ) const VULKAN_HPP_NOEXCEPT
5362  {
5363  std::size_t seed = 0;
5364  VULKAN_HPP_HASH_COMBINE( seed, imageResolve2.sType );
5365  VULKAN_HPP_HASH_COMBINE( seed, imageResolve2.pNext );
5366  VULKAN_HPP_HASH_COMBINE( seed, imageResolve2.srcSubresource );
5367  VULKAN_HPP_HASH_COMBINE( seed, imageResolve2.srcOffset );
5368  VULKAN_HPP_HASH_COMBINE( seed, imageResolve2.dstSubresource );
5369  VULKAN_HPP_HASH_COMBINE( seed, imageResolve2.dstOffset );
5370  VULKAN_HPP_HASH_COMBINE( seed, imageResolve2.extent );
5371  return seed;
5372  }
5373  };
5374 
5375  template <>
5376  struct hash<VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2>
5377  {
5378  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 const & imageSparseMemoryRequirementsInfo2 ) const VULKAN_HPP_NOEXCEPT
5379  {
5380  std::size_t seed = 0;
5381  VULKAN_HPP_HASH_COMBINE( seed, imageSparseMemoryRequirementsInfo2.sType );
5382  VULKAN_HPP_HASH_COMBINE( seed, imageSparseMemoryRequirementsInfo2.pNext );
5383  VULKAN_HPP_HASH_COMBINE( seed, imageSparseMemoryRequirementsInfo2.image );
5384  return seed;
5385  }
5386  };
5387 
5388  template <>
5389  struct hash<VULKAN_HPP_NAMESPACE::ImageStencilUsageCreateInfo>
5390  {
5391  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageStencilUsageCreateInfo const & imageStencilUsageCreateInfo ) const VULKAN_HPP_NOEXCEPT
5392  {
5393  std::size_t seed = 0;
5394  VULKAN_HPP_HASH_COMBINE( seed, imageStencilUsageCreateInfo.sType );
5395  VULKAN_HPP_HASH_COMBINE( seed, imageStencilUsageCreateInfo.pNext );
5396  VULKAN_HPP_HASH_COMBINE( seed, imageStencilUsageCreateInfo.stencilUsage );
5397  return seed;
5398  }
5399  };
5400 
5401  template <>
5402  struct hash<VULKAN_HPP_NAMESPACE::ImageSubresource2EXT>
5403  {
5404  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageSubresource2EXT const & imageSubresource2EXT ) const VULKAN_HPP_NOEXCEPT
5405  {
5406  std::size_t seed = 0;
5407  VULKAN_HPP_HASH_COMBINE( seed, imageSubresource2EXT.sType );
5408  VULKAN_HPP_HASH_COMBINE( seed, imageSubresource2EXT.pNext );
5409  VULKAN_HPP_HASH_COMBINE( seed, imageSubresource2EXT.imageSubresource );
5410  return seed;
5411  }
5412  };
5413 
5414  template <>
5415  struct hash<VULKAN_HPP_NAMESPACE::ImageSwapchainCreateInfoKHR>
5416  {
5417  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageSwapchainCreateInfoKHR const & imageSwapchainCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
5418  {
5419  std::size_t seed = 0;
5420  VULKAN_HPP_HASH_COMBINE( seed, imageSwapchainCreateInfoKHR.sType );
5421  VULKAN_HPP_HASH_COMBINE( seed, imageSwapchainCreateInfoKHR.pNext );
5422  VULKAN_HPP_HASH_COMBINE( seed, imageSwapchainCreateInfoKHR.swapchain );
5423  return seed;
5424  }
5425  };
5426 
5427  template <>
5428  struct hash<VULKAN_HPP_NAMESPACE::ImageViewASTCDecodeModeEXT>
5429  {
5430  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewASTCDecodeModeEXT const & imageViewASTCDecodeModeEXT ) const VULKAN_HPP_NOEXCEPT
5431  {
5432  std::size_t seed = 0;
5433  VULKAN_HPP_HASH_COMBINE( seed, imageViewASTCDecodeModeEXT.sType );
5434  VULKAN_HPP_HASH_COMBINE( seed, imageViewASTCDecodeModeEXT.pNext );
5435  VULKAN_HPP_HASH_COMBINE( seed, imageViewASTCDecodeModeEXT.decodeMode );
5436  return seed;
5437  }
5438  };
5439 
5440  template <>
5441  struct hash<VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX>
5442  {
5443  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX const & imageViewAddressPropertiesNVX ) const VULKAN_HPP_NOEXCEPT
5444  {
5445  std::size_t seed = 0;
5446  VULKAN_HPP_HASH_COMBINE( seed, imageViewAddressPropertiesNVX.sType );
5447  VULKAN_HPP_HASH_COMBINE( seed, imageViewAddressPropertiesNVX.pNext );
5448  VULKAN_HPP_HASH_COMBINE( seed, imageViewAddressPropertiesNVX.deviceAddress );
5449  VULKAN_HPP_HASH_COMBINE( seed, imageViewAddressPropertiesNVX.size );
5450  return seed;
5451  }
5452  };
5453 
5454  template <>
5455  struct hash<VULKAN_HPP_NAMESPACE::ImageViewCaptureDescriptorDataInfoEXT>
5456  {
5457  std::size_t
5458  operator()( VULKAN_HPP_NAMESPACE::ImageViewCaptureDescriptorDataInfoEXT const & imageViewCaptureDescriptorDataInfoEXT ) const VULKAN_HPP_NOEXCEPT
5459  {
5460  std::size_t seed = 0;
5461  VULKAN_HPP_HASH_COMBINE( seed, imageViewCaptureDescriptorDataInfoEXT.sType );
5462  VULKAN_HPP_HASH_COMBINE( seed, imageViewCaptureDescriptorDataInfoEXT.pNext );
5463  VULKAN_HPP_HASH_COMBINE( seed, imageViewCaptureDescriptorDataInfoEXT.imageView );
5464  return seed;
5465  }
5466  };
5467 
5468  template <>
5469  struct hash<VULKAN_HPP_NAMESPACE::ImageViewCreateInfo>
5470  {
5471  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewCreateInfo const & imageViewCreateInfo ) const VULKAN_HPP_NOEXCEPT
5472  {
5473  std::size_t seed = 0;
5474  VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.sType );
5475  VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.pNext );
5476  VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.flags );
5477  VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.image );
5478  VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.viewType );
5479  VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.format );
5480  VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.components );
5481  VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.subresourceRange );
5482  return seed;
5483  }
5484  };
5485 
5486  template <>
5487  struct hash<VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX>
5488  {
5489  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX const & imageViewHandleInfoNVX ) const VULKAN_HPP_NOEXCEPT
5490  {
5491  std::size_t seed = 0;
5492  VULKAN_HPP_HASH_COMBINE( seed, imageViewHandleInfoNVX.sType );
5493  VULKAN_HPP_HASH_COMBINE( seed, imageViewHandleInfoNVX.pNext );
5494  VULKAN_HPP_HASH_COMBINE( seed, imageViewHandleInfoNVX.imageView );
5495  VULKAN_HPP_HASH_COMBINE( seed, imageViewHandleInfoNVX.descriptorType );
5496  VULKAN_HPP_HASH_COMBINE( seed, imageViewHandleInfoNVX.sampler );
5497  return seed;
5498  }
5499  };
5500 
5501  template <>
5502  struct hash<VULKAN_HPP_NAMESPACE::ImageViewMinLodCreateInfoEXT>
5503  {
5504  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewMinLodCreateInfoEXT const & imageViewMinLodCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
5505  {
5506  std::size_t seed = 0;
5507  VULKAN_HPP_HASH_COMBINE( seed, imageViewMinLodCreateInfoEXT.sType );
5508  VULKAN_HPP_HASH_COMBINE( seed, imageViewMinLodCreateInfoEXT.pNext );
5509  VULKAN_HPP_HASH_COMBINE( seed, imageViewMinLodCreateInfoEXT.minLod );
5510  return seed;
5511  }
5512  };
5513 
5514  template <>
5515  struct hash<VULKAN_HPP_NAMESPACE::ImageViewSampleWeightCreateInfoQCOM>
5516  {
5517  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewSampleWeightCreateInfoQCOM const & imageViewSampleWeightCreateInfoQCOM ) const VULKAN_HPP_NOEXCEPT
5518  {
5519  std::size_t seed = 0;
5520  VULKAN_HPP_HASH_COMBINE( seed, imageViewSampleWeightCreateInfoQCOM.sType );
5521  VULKAN_HPP_HASH_COMBINE( seed, imageViewSampleWeightCreateInfoQCOM.pNext );
5522  VULKAN_HPP_HASH_COMBINE( seed, imageViewSampleWeightCreateInfoQCOM.filterCenter );
5523  VULKAN_HPP_HASH_COMBINE( seed, imageViewSampleWeightCreateInfoQCOM.filterSize );
5524  VULKAN_HPP_HASH_COMBINE( seed, imageViewSampleWeightCreateInfoQCOM.numPhases );
5525  return seed;
5526  }
5527  };
5528 
5529  template <>
5530  struct hash<VULKAN_HPP_NAMESPACE::ImageViewUsageCreateInfo>
5531  {
5532  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewUsageCreateInfo const & imageViewUsageCreateInfo ) const VULKAN_HPP_NOEXCEPT
5533  {
5534  std::size_t seed = 0;
5535  VULKAN_HPP_HASH_COMBINE( seed, imageViewUsageCreateInfo.sType );
5536  VULKAN_HPP_HASH_COMBINE( seed, imageViewUsageCreateInfo.pNext );
5537  VULKAN_HPP_HASH_COMBINE( seed, imageViewUsageCreateInfo.usage );
5538  return seed;
5539  }
5540  };
5541 
5542 # if defined( VK_USE_PLATFORM_ANDROID_KHR )
5543  template <>
5544  struct hash<VULKAN_HPP_NAMESPACE::ImportAndroidHardwareBufferInfoANDROID>
5545  {
5546  std::size_t
5547  operator()( VULKAN_HPP_NAMESPACE::ImportAndroidHardwareBufferInfoANDROID const & importAndroidHardwareBufferInfoANDROID ) const VULKAN_HPP_NOEXCEPT
5548  {
5549  std::size_t seed = 0;
5550  VULKAN_HPP_HASH_COMBINE( seed, importAndroidHardwareBufferInfoANDROID.sType );
5551  VULKAN_HPP_HASH_COMBINE( seed, importAndroidHardwareBufferInfoANDROID.pNext );
5552  VULKAN_HPP_HASH_COMBINE( seed, importAndroidHardwareBufferInfoANDROID.buffer );
5553  return seed;
5554  }
5555  };
5556 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/
5557 
5558  template <>
5559  struct hash<VULKAN_HPP_NAMESPACE::ImportFenceFdInfoKHR>
5560  {
5561  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportFenceFdInfoKHR const & importFenceFdInfoKHR ) const VULKAN_HPP_NOEXCEPT
5562  {
5563  std::size_t seed = 0;
5564  VULKAN_HPP_HASH_COMBINE( seed, importFenceFdInfoKHR.sType );
5565  VULKAN_HPP_HASH_COMBINE( seed, importFenceFdInfoKHR.pNext );
5566  VULKAN_HPP_HASH_COMBINE( seed, importFenceFdInfoKHR.fence );
5567  VULKAN_HPP_HASH_COMBINE( seed, importFenceFdInfoKHR.flags );
5568  VULKAN_HPP_HASH_COMBINE( seed, importFenceFdInfoKHR.handleType );
5569  VULKAN_HPP_HASH_COMBINE( seed, importFenceFdInfoKHR.fd );
5570  return seed;
5571  }
5572  };
5573 
5574 # if defined( VK_USE_PLATFORM_WIN32_KHR )
5575  template <>
5576  struct hash<VULKAN_HPP_NAMESPACE::ImportFenceWin32HandleInfoKHR>
5577  {
5578  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportFenceWin32HandleInfoKHR const & importFenceWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT
5579  {
5580  std::size_t seed = 0;
5581  VULKAN_HPP_HASH_COMBINE( seed, importFenceWin32HandleInfoKHR.sType );
5582  VULKAN_HPP_HASH_COMBINE( seed, importFenceWin32HandleInfoKHR.pNext );
5583  VULKAN_HPP_HASH_COMBINE( seed, importFenceWin32HandleInfoKHR.fence );
5584  VULKAN_HPP_HASH_COMBINE( seed, importFenceWin32HandleInfoKHR.flags );
5585  VULKAN_HPP_HASH_COMBINE( seed, importFenceWin32HandleInfoKHR.handleType );
5586  VULKAN_HPP_HASH_COMBINE( seed, importFenceWin32HandleInfoKHR.handle );
5587  VULKAN_HPP_HASH_COMBINE( seed, importFenceWin32HandleInfoKHR.name );
5588  return seed;
5589  }
5590  };
5591 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
5592 
5593 # if defined( VK_USE_PLATFORM_FUCHSIA )
5594  template <>
5595  struct hash<VULKAN_HPP_NAMESPACE::ImportMemoryBufferCollectionFUCHSIA>
5596  {
5597  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMemoryBufferCollectionFUCHSIA const & importMemoryBufferCollectionFUCHSIA ) const VULKAN_HPP_NOEXCEPT
5598  {
5599  std::size_t seed = 0;
5600  VULKAN_HPP_HASH_COMBINE( seed, importMemoryBufferCollectionFUCHSIA.sType );
5601  VULKAN_HPP_HASH_COMBINE( seed, importMemoryBufferCollectionFUCHSIA.pNext );
5602  VULKAN_HPP_HASH_COMBINE( seed, importMemoryBufferCollectionFUCHSIA.collection );
5603  VULKAN_HPP_HASH_COMBINE( seed, importMemoryBufferCollectionFUCHSIA.index );
5604  return seed;
5605  }
5606  };
5607 # endif /*VK_USE_PLATFORM_FUCHSIA*/
5608 
5609  template <>
5610  struct hash<VULKAN_HPP_NAMESPACE::ImportMemoryFdInfoKHR>
5611  {
5612  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMemoryFdInfoKHR const & importMemoryFdInfoKHR ) const VULKAN_HPP_NOEXCEPT
5613  {
5614  std::size_t seed = 0;
5615  VULKAN_HPP_HASH_COMBINE( seed, importMemoryFdInfoKHR.sType );
5616  VULKAN_HPP_HASH_COMBINE( seed, importMemoryFdInfoKHR.pNext );
5617  VULKAN_HPP_HASH_COMBINE( seed, importMemoryFdInfoKHR.handleType );
5618  VULKAN_HPP_HASH_COMBINE( seed, importMemoryFdInfoKHR.fd );
5619  return seed;
5620  }
5621  };
5622 
5623  template <>
5624  struct hash<VULKAN_HPP_NAMESPACE::ImportMemoryHostPointerInfoEXT>
5625  {
5626  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMemoryHostPointerInfoEXT const & importMemoryHostPointerInfoEXT ) const VULKAN_HPP_NOEXCEPT
5627  {
5628  std::size_t seed = 0;
5629  VULKAN_HPP_HASH_COMBINE( seed, importMemoryHostPointerInfoEXT.sType );
5630  VULKAN_HPP_HASH_COMBINE( seed, importMemoryHostPointerInfoEXT.pNext );
5631  VULKAN_HPP_HASH_COMBINE( seed, importMemoryHostPointerInfoEXT.handleType );
5632  VULKAN_HPP_HASH_COMBINE( seed, importMemoryHostPointerInfoEXT.pHostPointer );
5633  return seed;
5634  }
5635  };
5636 
5637 # if defined( VK_USE_PLATFORM_WIN32_KHR )
5638  template <>
5639  struct hash<VULKAN_HPP_NAMESPACE::ImportMemoryWin32HandleInfoKHR>
5640  {
5641  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMemoryWin32HandleInfoKHR const & importMemoryWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT
5642  {
5643  std::size_t seed = 0;
5644  VULKAN_HPP_HASH_COMBINE( seed, importMemoryWin32HandleInfoKHR.sType );
5645  VULKAN_HPP_HASH_COMBINE( seed, importMemoryWin32HandleInfoKHR.pNext );
5646  VULKAN_HPP_HASH_COMBINE( seed, importMemoryWin32HandleInfoKHR.handleType );
5647  VULKAN_HPP_HASH_COMBINE( seed, importMemoryWin32HandleInfoKHR.handle );
5648  VULKAN_HPP_HASH_COMBINE( seed, importMemoryWin32HandleInfoKHR.name );
5649  return seed;
5650  }
5651  };
5652 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
5653 
5654 # if defined( VK_USE_PLATFORM_WIN32_KHR )
5655  template <>
5656  struct hash<VULKAN_HPP_NAMESPACE::ImportMemoryWin32HandleInfoNV>
5657  {
5658  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMemoryWin32HandleInfoNV const & importMemoryWin32HandleInfoNV ) const VULKAN_HPP_NOEXCEPT
5659  {
5660  std::size_t seed = 0;
5661  VULKAN_HPP_HASH_COMBINE( seed, importMemoryWin32HandleInfoNV.sType );
5662  VULKAN_HPP_HASH_COMBINE( seed, importMemoryWin32HandleInfoNV.pNext );
5663  VULKAN_HPP_HASH_COMBINE( seed, importMemoryWin32HandleInfoNV.handleType );
5664  VULKAN_HPP_HASH_COMBINE( seed, importMemoryWin32HandleInfoNV.handle );
5665  return seed;
5666  }
5667  };
5668 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
5669 
5670 # if defined( VK_USE_PLATFORM_FUCHSIA )
5671  template <>
5672  struct hash<VULKAN_HPP_NAMESPACE::ImportMemoryZirconHandleInfoFUCHSIA>
5673  {
5674  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMemoryZirconHandleInfoFUCHSIA const & importMemoryZirconHandleInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT
5675  {
5676  std::size_t seed = 0;
5677  VULKAN_HPP_HASH_COMBINE( seed, importMemoryZirconHandleInfoFUCHSIA.sType );
5678  VULKAN_HPP_HASH_COMBINE( seed, importMemoryZirconHandleInfoFUCHSIA.pNext );
5679  VULKAN_HPP_HASH_COMBINE( seed, importMemoryZirconHandleInfoFUCHSIA.handleType );
5680  VULKAN_HPP_HASH_COMBINE( seed, importMemoryZirconHandleInfoFUCHSIA.handle );
5681  return seed;
5682  }
5683  };
5684 # endif /*VK_USE_PLATFORM_FUCHSIA*/
5685 
5686 # if defined( VK_USE_PLATFORM_METAL_EXT )
5687  template <>
5688  struct hash<VULKAN_HPP_NAMESPACE::ImportMetalBufferInfoEXT>
5689  {
5690  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMetalBufferInfoEXT const & importMetalBufferInfoEXT ) const VULKAN_HPP_NOEXCEPT
5691  {
5692  std::size_t seed = 0;
5693  VULKAN_HPP_HASH_COMBINE( seed, importMetalBufferInfoEXT.sType );
5694  VULKAN_HPP_HASH_COMBINE( seed, importMetalBufferInfoEXT.pNext );
5695  VULKAN_HPP_HASH_COMBINE( seed, importMetalBufferInfoEXT.mtlBuffer );
5696  return seed;
5697  }
5698  };
5699 # endif /*VK_USE_PLATFORM_METAL_EXT*/
5700 
5701 # if defined( VK_USE_PLATFORM_METAL_EXT )
5702  template <>
5703  struct hash<VULKAN_HPP_NAMESPACE::ImportMetalIOSurfaceInfoEXT>
5704  {
5705  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMetalIOSurfaceInfoEXT const & importMetalIOSurfaceInfoEXT ) const VULKAN_HPP_NOEXCEPT
5706  {
5707  std::size_t seed = 0;
5708  VULKAN_HPP_HASH_COMBINE( seed, importMetalIOSurfaceInfoEXT.sType );
5709  VULKAN_HPP_HASH_COMBINE( seed, importMetalIOSurfaceInfoEXT.pNext );
5710  VULKAN_HPP_HASH_COMBINE( seed, importMetalIOSurfaceInfoEXT.ioSurface );
5711  return seed;
5712  }
5713  };
5714 # endif /*VK_USE_PLATFORM_METAL_EXT*/
5715 
5716 # if defined( VK_USE_PLATFORM_METAL_EXT )
5717  template <>
5718  struct hash<VULKAN_HPP_NAMESPACE::ImportMetalSharedEventInfoEXT>
5719  {
5720  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMetalSharedEventInfoEXT const & importMetalSharedEventInfoEXT ) const VULKAN_HPP_NOEXCEPT
5721  {
5722  std::size_t seed = 0;
5723  VULKAN_HPP_HASH_COMBINE( seed, importMetalSharedEventInfoEXT.sType );
5724  VULKAN_HPP_HASH_COMBINE( seed, importMetalSharedEventInfoEXT.pNext );
5725  VULKAN_HPP_HASH_COMBINE( seed, importMetalSharedEventInfoEXT.mtlSharedEvent );
5726  return seed;
5727  }
5728  };
5729 # endif /*VK_USE_PLATFORM_METAL_EXT*/
5730 
5731 # if defined( VK_USE_PLATFORM_METAL_EXT )
5732  template <>
5733  struct hash<VULKAN_HPP_NAMESPACE::ImportMetalTextureInfoEXT>
5734  {
5735  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMetalTextureInfoEXT const & importMetalTextureInfoEXT ) const VULKAN_HPP_NOEXCEPT
5736  {
5737  std::size_t seed = 0;
5738  VULKAN_HPP_HASH_COMBINE( seed, importMetalTextureInfoEXT.sType );
5739  VULKAN_HPP_HASH_COMBINE( seed, importMetalTextureInfoEXT.pNext );
5740  VULKAN_HPP_HASH_COMBINE( seed, importMetalTextureInfoEXT.plane );
5741  VULKAN_HPP_HASH_COMBINE( seed, importMetalTextureInfoEXT.mtlTexture );
5742  return seed;
5743  }
5744  };
5745 # endif /*VK_USE_PLATFORM_METAL_EXT*/
5746 
5747  template <>
5748  struct hash<VULKAN_HPP_NAMESPACE::ImportSemaphoreFdInfoKHR>
5749  {
5750  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportSemaphoreFdInfoKHR const & importSemaphoreFdInfoKHR ) const VULKAN_HPP_NOEXCEPT
5751  {
5752  std::size_t seed = 0;
5753  VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreFdInfoKHR.sType );
5754  VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreFdInfoKHR.pNext );
5755  VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreFdInfoKHR.semaphore );
5756  VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreFdInfoKHR.flags );
5757  VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreFdInfoKHR.handleType );
5758  VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreFdInfoKHR.fd );
5759  return seed;
5760  }
5761  };
5762 
5763 # if defined( VK_USE_PLATFORM_WIN32_KHR )
5764  template <>
5765  struct hash<VULKAN_HPP_NAMESPACE::ImportSemaphoreWin32HandleInfoKHR>
5766  {
5767  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportSemaphoreWin32HandleInfoKHR const & importSemaphoreWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT
5768  {
5769  std::size_t seed = 0;
5770  VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreWin32HandleInfoKHR.sType );
5771  VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreWin32HandleInfoKHR.pNext );
5772  VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreWin32HandleInfoKHR.semaphore );
5773  VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreWin32HandleInfoKHR.flags );
5774  VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreWin32HandleInfoKHR.handleType );
5775  VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreWin32HandleInfoKHR.handle );
5776  VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreWin32HandleInfoKHR.name );
5777  return seed;
5778  }
5779  };
5780 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
5781 
5782 # if defined( VK_USE_PLATFORM_FUCHSIA )
5783  template <>
5784  struct hash<VULKAN_HPP_NAMESPACE::ImportSemaphoreZirconHandleInfoFUCHSIA>
5785  {
5786  std::size_t
5787  operator()( VULKAN_HPP_NAMESPACE::ImportSemaphoreZirconHandleInfoFUCHSIA const & importSemaphoreZirconHandleInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT
5788  {
5789  std::size_t seed = 0;
5790  VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreZirconHandleInfoFUCHSIA.sType );
5791  VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreZirconHandleInfoFUCHSIA.pNext );
5792  VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreZirconHandleInfoFUCHSIA.semaphore );
5793  VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreZirconHandleInfoFUCHSIA.flags );
5794  VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreZirconHandleInfoFUCHSIA.handleType );
5795  VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreZirconHandleInfoFUCHSIA.zirconHandle );
5796  return seed;
5797  }
5798  };
5799 # endif /*VK_USE_PLATFORM_FUCHSIA*/
5800 
5801  template <>
5802  struct hash<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutTokenNV>
5803  {
5804  std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutTokenNV const & indirectCommandsLayoutTokenNV ) const VULKAN_HPP_NOEXCEPT
5805  {
5806  std::size_t seed = 0;
5807  VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.sType );
5808  VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.pNext );
5809  VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.tokenType );
5810  VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.stream );
5811  VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.offset );
5812  VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.vertexBindingUnit );
5813  VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.vertexDynamicStride );
5814  VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.pushconstantPipelineLayout );
5815  VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.pushconstantShaderStageFlags );
5816  VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.pushconstantOffset );
5817  VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.pushconstantSize );
5818  VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.indirectStateFlags );
5819  VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.indexTypeCount );
5820  VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.pIndexTypes );
5821  VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.pIndexTypeValues );
5822  return seed;
5823  }
5824  };
5825 
5826  template <>
5827  struct hash<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV>
5828  {
5829  std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV const & indirectCommandsLayoutCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
5830  {
5831  std::size_t seed = 0;
5832  VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoNV.sType );
5833  VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoNV.pNext );
5834  VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoNV.flags );
5835  VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoNV.pipelineBindPoint );
5836  VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoNV.tokenCount );
5837  VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoNV.pTokens );
5838  VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoNV.streamCount );
5839  VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoNV.pStreamStrides );
5840  return seed;
5841  }
5842  };
5843 
5844  template <>
5845  struct hash<VULKAN_HPP_NAMESPACE::InitializePerformanceApiInfoINTEL>
5846  {
5847  std::size_t operator()( VULKAN_HPP_NAMESPACE::InitializePerformanceApiInfoINTEL const & initializePerformanceApiInfoINTEL ) const VULKAN_HPP_NOEXCEPT
5848  {
5849  std::size_t seed = 0;
5850  VULKAN_HPP_HASH_COMBINE( seed, initializePerformanceApiInfoINTEL.sType );
5851  VULKAN_HPP_HASH_COMBINE( seed, initializePerformanceApiInfoINTEL.pNext );
5852  VULKAN_HPP_HASH_COMBINE( seed, initializePerformanceApiInfoINTEL.pUserData );
5853  return seed;
5854  }
5855  };
5856 
5857  template <>
5858  struct hash<VULKAN_HPP_NAMESPACE::InputAttachmentAspectReference>
5859  {
5860  std::size_t operator()( VULKAN_HPP_NAMESPACE::InputAttachmentAspectReference const & inputAttachmentAspectReference ) const VULKAN_HPP_NOEXCEPT
5861  {
5862  std::size_t seed = 0;
5863  VULKAN_HPP_HASH_COMBINE( seed, inputAttachmentAspectReference.subpass );
5864  VULKAN_HPP_HASH_COMBINE( seed, inputAttachmentAspectReference.inputAttachmentIndex );
5865  VULKAN_HPP_HASH_COMBINE( seed, inputAttachmentAspectReference.aspectMask );
5866  return seed;
5867  }
5868  };
5869 
5870  template <>
5871  struct hash<VULKAN_HPP_NAMESPACE::InstanceCreateInfo>
5872  {
5873  std::size_t operator()( VULKAN_HPP_NAMESPACE::InstanceCreateInfo const & instanceCreateInfo ) const VULKAN_HPP_NOEXCEPT
5874  {
5875  std::size_t seed = 0;
5876  VULKAN_HPP_HASH_COMBINE( seed, instanceCreateInfo.sType );
5877  VULKAN_HPP_HASH_COMBINE( seed, instanceCreateInfo.pNext );
5878  VULKAN_HPP_HASH_COMBINE( seed, instanceCreateInfo.flags );
5879  VULKAN_HPP_HASH_COMBINE( seed, instanceCreateInfo.pApplicationInfo );
5880  VULKAN_HPP_HASH_COMBINE( seed, instanceCreateInfo.enabledLayerCount );
5881  for ( size_t i = 0; i < instanceCreateInfo.enabledLayerCount; ++i )
5882  {
5883  for ( const char * p = instanceCreateInfo.ppEnabledLayerNames[i]; *p != '\0'; ++p )
5884  {
5885  VULKAN_HPP_HASH_COMBINE( seed, *p );
5886  }
5887  }
5888  VULKAN_HPP_HASH_COMBINE( seed, instanceCreateInfo.enabledExtensionCount );
5889  for ( size_t i = 0; i < instanceCreateInfo.enabledExtensionCount; ++i )
5890  {
5891  for ( const char * p = instanceCreateInfo.ppEnabledExtensionNames[i]; *p != '\0'; ++p )
5892  {
5893  VULKAN_HPP_HASH_COMBINE( seed, *p );
5894  }
5895  }
5896  return seed;
5897  }
5898  };
5899 
5900  template <>
5901  struct hash<VULKAN_HPP_NAMESPACE::LayerProperties>
5902  {
5903  std::size_t operator()( VULKAN_HPP_NAMESPACE::LayerProperties const & layerProperties ) const VULKAN_HPP_NOEXCEPT
5904  {
5905  std::size_t seed = 0;
5906  for ( size_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i )
5907  {
5908  VULKAN_HPP_HASH_COMBINE( seed, layerProperties.layerName[i] );
5909  }
5910  VULKAN_HPP_HASH_COMBINE( seed, layerProperties.specVersion );
5911  VULKAN_HPP_HASH_COMBINE( seed, layerProperties.implementationVersion );
5912  for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i )
5913  {
5914  VULKAN_HPP_HASH_COMBINE( seed, layerProperties.description[i] );
5915  }
5916  return seed;
5917  }
5918  };
5919 
5920 # if defined( VK_USE_PLATFORM_MACOS_MVK )
5921  template <>
5922  struct hash<VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK>
5923  {
5924  std::size_t operator()( VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK const & macOSSurfaceCreateInfoMVK ) const VULKAN_HPP_NOEXCEPT
5925  {
5926  std::size_t seed = 0;
5927  VULKAN_HPP_HASH_COMBINE( seed, macOSSurfaceCreateInfoMVK.sType );
5928  VULKAN_HPP_HASH_COMBINE( seed, macOSSurfaceCreateInfoMVK.pNext );
5929  VULKAN_HPP_HASH_COMBINE( seed, macOSSurfaceCreateInfoMVK.flags );
5930  VULKAN_HPP_HASH_COMBINE( seed, macOSSurfaceCreateInfoMVK.pView );
5931  return seed;
5932  }
5933  };
5934 # endif /*VK_USE_PLATFORM_MACOS_MVK*/
5935 
5936  template <>
5937  struct hash<VULKAN_HPP_NAMESPACE::MappedMemoryRange>
5938  {
5939  std::size_t operator()( VULKAN_HPP_NAMESPACE::MappedMemoryRange const & mappedMemoryRange ) const VULKAN_HPP_NOEXCEPT
5940  {
5941  std::size_t seed = 0;
5942  VULKAN_HPP_HASH_COMBINE( seed, mappedMemoryRange.sType );
5943  VULKAN_HPP_HASH_COMBINE( seed, mappedMemoryRange.pNext );
5944  VULKAN_HPP_HASH_COMBINE( seed, mappedMemoryRange.memory );
5945  VULKAN_HPP_HASH_COMBINE( seed, mappedMemoryRange.offset );
5946  VULKAN_HPP_HASH_COMBINE( seed, mappedMemoryRange.size );
5947  return seed;
5948  }
5949  };
5950 
5951  template <>
5952  struct hash<VULKAN_HPP_NAMESPACE::MemoryAllocateFlagsInfo>
5953  {
5954  std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryAllocateFlagsInfo const & memoryAllocateFlagsInfo ) const VULKAN_HPP_NOEXCEPT
5955  {
5956  std::size_t seed = 0;
5957  VULKAN_HPP_HASH_COMBINE( seed, memoryAllocateFlagsInfo.sType );
5958  VULKAN_HPP_HASH_COMBINE( seed, memoryAllocateFlagsInfo.pNext );
5959  VULKAN_HPP_HASH_COMBINE( seed, memoryAllocateFlagsInfo.flags );
5960  VULKAN_HPP_HASH_COMBINE( seed, memoryAllocateFlagsInfo.deviceMask );
5961  return seed;
5962  }
5963  };
5964 
5965  template <>
5966  struct hash<VULKAN_HPP_NAMESPACE::MemoryAllocateInfo>
5967  {
5968  std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryAllocateInfo const & memoryAllocateInfo ) const VULKAN_HPP_NOEXCEPT
5969  {
5970  std::size_t seed = 0;
5971  VULKAN_HPP_HASH_COMBINE( seed, memoryAllocateInfo.sType );
5972  VULKAN_HPP_HASH_COMBINE( seed, memoryAllocateInfo.pNext );
5973  VULKAN_HPP_HASH_COMBINE( seed, memoryAllocateInfo.allocationSize );
5974  VULKAN_HPP_HASH_COMBINE( seed, memoryAllocateInfo.memoryTypeIndex );
5975  return seed;
5976  }
5977  };
5978 
5979  template <>
5980  struct hash<VULKAN_HPP_NAMESPACE::MemoryBarrier>
5981  {
5982  std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryBarrier const & memoryBarrier ) const VULKAN_HPP_NOEXCEPT
5983  {
5984  std::size_t seed = 0;
5985  VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier.sType );
5986  VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier.pNext );
5987  VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier.srcAccessMask );
5988  VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier.dstAccessMask );
5989  return seed;
5990  }
5991  };
5992 
5993  template <>
5994  struct hash<VULKAN_HPP_NAMESPACE::MemoryDedicatedAllocateInfo>
5995  {
5996  std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryDedicatedAllocateInfo const & memoryDedicatedAllocateInfo ) const VULKAN_HPP_NOEXCEPT
5997  {
5998  std::size_t seed = 0;
5999  VULKAN_HPP_HASH_COMBINE( seed, memoryDedicatedAllocateInfo.sType );
6000  VULKAN_HPP_HASH_COMBINE( seed, memoryDedicatedAllocateInfo.pNext );
6001  VULKAN_HPP_HASH_COMBINE( seed, memoryDedicatedAllocateInfo.image );
6002  VULKAN_HPP_HASH_COMBINE( seed, memoryDedicatedAllocateInfo.buffer );
6003  return seed;
6004  }
6005  };
6006 
6007  template <>
6008  struct hash<VULKAN_HPP_NAMESPACE::MemoryDedicatedRequirements>
6009  {
6010  std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryDedicatedRequirements const & memoryDedicatedRequirements ) const VULKAN_HPP_NOEXCEPT
6011  {
6012  std::size_t seed = 0;
6013  VULKAN_HPP_HASH_COMBINE( seed, memoryDedicatedRequirements.sType );
6014  VULKAN_HPP_HASH_COMBINE( seed, memoryDedicatedRequirements.pNext );
6015  VULKAN_HPP_HASH_COMBINE( seed, memoryDedicatedRequirements.prefersDedicatedAllocation );
6016  VULKAN_HPP_HASH_COMBINE( seed, memoryDedicatedRequirements.requiresDedicatedAllocation );
6017  return seed;
6018  }
6019  };
6020 
6021  template <>
6022  struct hash<VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR>
6023  {
6024  std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR const & memoryFdPropertiesKHR ) const VULKAN_HPP_NOEXCEPT
6025  {
6026  std::size_t seed = 0;
6027  VULKAN_HPP_HASH_COMBINE( seed, memoryFdPropertiesKHR.sType );
6028  VULKAN_HPP_HASH_COMBINE( seed, memoryFdPropertiesKHR.pNext );
6029  VULKAN_HPP_HASH_COMBINE( seed, memoryFdPropertiesKHR.memoryTypeBits );
6030  return seed;
6031  }
6032  };
6033 
6034 # if defined( VK_USE_PLATFORM_ANDROID_KHR )
6035  template <>
6036  struct hash<VULKAN_HPP_NAMESPACE::MemoryGetAndroidHardwareBufferInfoANDROID>
6037  {
6038  std::size_t
6039  operator()( VULKAN_HPP_NAMESPACE::MemoryGetAndroidHardwareBufferInfoANDROID const & memoryGetAndroidHardwareBufferInfoANDROID ) const VULKAN_HPP_NOEXCEPT
6040  {
6041  std::size_t seed = 0;
6042  VULKAN_HPP_HASH_COMBINE( seed, memoryGetAndroidHardwareBufferInfoANDROID.sType );
6043  VULKAN_HPP_HASH_COMBINE( seed, memoryGetAndroidHardwareBufferInfoANDROID.pNext );
6044  VULKAN_HPP_HASH_COMBINE( seed, memoryGetAndroidHardwareBufferInfoANDROID.memory );
6045  return seed;
6046  }
6047  };
6048 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/
6049 
6050  template <>
6051  struct hash<VULKAN_HPP_NAMESPACE::MemoryGetFdInfoKHR>
6052  {
6053  std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryGetFdInfoKHR const & memoryGetFdInfoKHR ) const VULKAN_HPP_NOEXCEPT
6054  {
6055  std::size_t seed = 0;
6056  VULKAN_HPP_HASH_COMBINE( seed, memoryGetFdInfoKHR.sType );
6057  VULKAN_HPP_HASH_COMBINE( seed, memoryGetFdInfoKHR.pNext );
6058  VULKAN_HPP_HASH_COMBINE( seed, memoryGetFdInfoKHR.memory );
6059  VULKAN_HPP_HASH_COMBINE( seed, memoryGetFdInfoKHR.handleType );
6060  return seed;
6061  }
6062  };
6063 
6064  template <>
6065  struct hash<VULKAN_HPP_NAMESPACE::MemoryGetRemoteAddressInfoNV>
6066  {
6067  std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryGetRemoteAddressInfoNV const & memoryGetRemoteAddressInfoNV ) const VULKAN_HPP_NOEXCEPT
6068  {
6069  std::size_t seed = 0;
6070  VULKAN_HPP_HASH_COMBINE( seed, memoryGetRemoteAddressInfoNV.sType );
6071  VULKAN_HPP_HASH_COMBINE( seed, memoryGetRemoteAddressInfoNV.pNext );
6072  VULKAN_HPP_HASH_COMBINE( seed, memoryGetRemoteAddressInfoNV.memory );
6073  VULKAN_HPP_HASH_COMBINE( seed, memoryGetRemoteAddressInfoNV.handleType );
6074  return seed;
6075  }
6076  };
6077 
6078 # if defined( VK_USE_PLATFORM_WIN32_KHR )
6079  template <>
6080  struct hash<VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR>
6081  {
6082  std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR const & memoryGetWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT
6083  {
6084  std::size_t seed = 0;
6085  VULKAN_HPP_HASH_COMBINE( seed, memoryGetWin32HandleInfoKHR.sType );
6086  VULKAN_HPP_HASH_COMBINE( seed, memoryGetWin32HandleInfoKHR.pNext );
6087  VULKAN_HPP_HASH_COMBINE( seed, memoryGetWin32HandleInfoKHR.memory );
6088  VULKAN_HPP_HASH_COMBINE( seed, memoryGetWin32HandleInfoKHR.handleType );
6089  return seed;
6090  }
6091  };
6092 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
6093 
6094 # if defined( VK_USE_PLATFORM_FUCHSIA )
6095  template <>
6096  struct hash<VULKAN_HPP_NAMESPACE::MemoryGetZirconHandleInfoFUCHSIA>
6097  {
6098  std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryGetZirconHandleInfoFUCHSIA const & memoryGetZirconHandleInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT
6099  {
6100  std::size_t seed = 0;
6101  VULKAN_HPP_HASH_COMBINE( seed, memoryGetZirconHandleInfoFUCHSIA.sType );
6102  VULKAN_HPP_HASH_COMBINE( seed, memoryGetZirconHandleInfoFUCHSIA.pNext );
6103  VULKAN_HPP_HASH_COMBINE( seed, memoryGetZirconHandleInfoFUCHSIA.memory );
6104  VULKAN_HPP_HASH_COMBINE( seed, memoryGetZirconHandleInfoFUCHSIA.handleType );
6105  return seed;
6106  }
6107  };
6108 # endif /*VK_USE_PLATFORM_FUCHSIA*/
6109 
6110  template <>
6111  struct hash<VULKAN_HPP_NAMESPACE::MemoryHeap>
6112  {
6113  std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryHeap const & memoryHeap ) const VULKAN_HPP_NOEXCEPT
6114  {
6115  std::size_t seed = 0;
6116  VULKAN_HPP_HASH_COMBINE( seed, memoryHeap.size );
6117  VULKAN_HPP_HASH_COMBINE( seed, memoryHeap.flags );
6118  return seed;
6119  }
6120  };
6121 
6122  template <>
6123  struct hash<VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT>
6124  {
6125  std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT const & memoryHostPointerPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
6126  {
6127  std::size_t seed = 0;
6128  VULKAN_HPP_HASH_COMBINE( seed, memoryHostPointerPropertiesEXT.sType );
6129  VULKAN_HPP_HASH_COMBINE( seed, memoryHostPointerPropertiesEXT.pNext );
6130  VULKAN_HPP_HASH_COMBINE( seed, memoryHostPointerPropertiesEXT.memoryTypeBits );
6131  return seed;
6132  }
6133  };
6134 
6135  template <>
6136  struct hash<VULKAN_HPP_NAMESPACE::MemoryOpaqueCaptureAddressAllocateInfo>
6137  {
6138  std::size_t
6139  operator()( VULKAN_HPP_NAMESPACE::MemoryOpaqueCaptureAddressAllocateInfo const & memoryOpaqueCaptureAddressAllocateInfo ) const VULKAN_HPP_NOEXCEPT
6140  {
6141  std::size_t seed = 0;
6142  VULKAN_HPP_HASH_COMBINE( seed, memoryOpaqueCaptureAddressAllocateInfo.sType );
6143  VULKAN_HPP_HASH_COMBINE( seed, memoryOpaqueCaptureAddressAllocateInfo.pNext );
6144  VULKAN_HPP_HASH_COMBINE( seed, memoryOpaqueCaptureAddressAllocateInfo.opaqueCaptureAddress );
6145  return seed;
6146  }
6147  };
6148 
6149  template <>
6150  struct hash<VULKAN_HPP_NAMESPACE::MemoryPriorityAllocateInfoEXT>
6151  {
6152  std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryPriorityAllocateInfoEXT const & memoryPriorityAllocateInfoEXT ) const VULKAN_HPP_NOEXCEPT
6153  {
6154  std::size_t seed = 0;
6155  VULKAN_HPP_HASH_COMBINE( seed, memoryPriorityAllocateInfoEXT.sType );
6156  VULKAN_HPP_HASH_COMBINE( seed, memoryPriorityAllocateInfoEXT.pNext );
6157  VULKAN_HPP_HASH_COMBINE( seed, memoryPriorityAllocateInfoEXT.priority );
6158  return seed;
6159  }
6160  };
6161 
6162  template <>
6163  struct hash<VULKAN_HPP_NAMESPACE::MemoryRequirements>
6164  {
6165  std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryRequirements const & memoryRequirements ) const VULKAN_HPP_NOEXCEPT
6166  {
6167  std::size_t seed = 0;
6168  VULKAN_HPP_HASH_COMBINE( seed, memoryRequirements.size );
6169  VULKAN_HPP_HASH_COMBINE( seed, memoryRequirements.alignment );
6170  VULKAN_HPP_HASH_COMBINE( seed, memoryRequirements.memoryTypeBits );
6171  return seed;
6172  }
6173  };
6174 
6175  template <>
6176  struct hash<VULKAN_HPP_NAMESPACE::MemoryRequirements2>
6177  {
6178  std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryRequirements2 const & memoryRequirements2 ) const VULKAN_HPP_NOEXCEPT
6179  {
6180  std::size_t seed = 0;
6181  VULKAN_HPP_HASH_COMBINE( seed, memoryRequirements2.sType );
6182  VULKAN_HPP_HASH_COMBINE( seed, memoryRequirements2.pNext );
6183  VULKAN_HPP_HASH_COMBINE( seed, memoryRequirements2.memoryRequirements );
6184  return seed;
6185  }
6186  };
6187 
6188  template <>
6189  struct hash<VULKAN_HPP_NAMESPACE::MemoryType>
6190  {
6191  std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryType const & memoryType ) const VULKAN_HPP_NOEXCEPT
6192  {
6193  std::size_t seed = 0;
6194  VULKAN_HPP_HASH_COMBINE( seed, memoryType.propertyFlags );
6195  VULKAN_HPP_HASH_COMBINE( seed, memoryType.heapIndex );
6196  return seed;
6197  }
6198  };
6199 
6200 # if defined( VK_USE_PLATFORM_WIN32_KHR )
6201  template <>
6202  struct hash<VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR>
6203  {
6204  std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR const & memoryWin32HandlePropertiesKHR ) const VULKAN_HPP_NOEXCEPT
6205  {
6206  std::size_t seed = 0;
6207  VULKAN_HPP_HASH_COMBINE( seed, memoryWin32HandlePropertiesKHR.sType );
6208  VULKAN_HPP_HASH_COMBINE( seed, memoryWin32HandlePropertiesKHR.pNext );
6209  VULKAN_HPP_HASH_COMBINE( seed, memoryWin32HandlePropertiesKHR.memoryTypeBits );
6210  return seed;
6211  }
6212  };
6213 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
6214 
6215 # if defined( VK_USE_PLATFORM_FUCHSIA )
6216  template <>
6217  struct hash<VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA>
6218  {
6219  std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA const & memoryZirconHandlePropertiesFUCHSIA ) const VULKAN_HPP_NOEXCEPT
6220  {
6221  std::size_t seed = 0;
6222  VULKAN_HPP_HASH_COMBINE( seed, memoryZirconHandlePropertiesFUCHSIA.sType );
6223  VULKAN_HPP_HASH_COMBINE( seed, memoryZirconHandlePropertiesFUCHSIA.pNext );
6224  VULKAN_HPP_HASH_COMBINE( seed, memoryZirconHandlePropertiesFUCHSIA.memoryTypeBits );
6225  return seed;
6226  }
6227  };
6228 # endif /*VK_USE_PLATFORM_FUCHSIA*/
6229 
6230 # if defined( VK_USE_PLATFORM_METAL_EXT )
6231  template <>
6232  struct hash<VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT>
6233  {
6234  std::size_t operator()( VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT const & metalSurfaceCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
6235  {
6236  std::size_t seed = 0;
6237  VULKAN_HPP_HASH_COMBINE( seed, metalSurfaceCreateInfoEXT.sType );
6238  VULKAN_HPP_HASH_COMBINE( seed, metalSurfaceCreateInfoEXT.pNext );
6239  VULKAN_HPP_HASH_COMBINE( seed, metalSurfaceCreateInfoEXT.flags );
6240  VULKAN_HPP_HASH_COMBINE( seed, metalSurfaceCreateInfoEXT.pLayer );
6241  return seed;
6242  }
6243  };
6244 # endif /*VK_USE_PLATFORM_METAL_EXT*/
6245 
6246  template <>
6247  struct hash<VULKAN_HPP_NAMESPACE::MicromapBuildSizesInfoEXT>
6248  {
6249  std::size_t operator()( VULKAN_HPP_NAMESPACE::MicromapBuildSizesInfoEXT const & micromapBuildSizesInfoEXT ) const VULKAN_HPP_NOEXCEPT
6250  {
6251  std::size_t seed = 0;
6252  VULKAN_HPP_HASH_COMBINE( seed, micromapBuildSizesInfoEXT.sType );
6253  VULKAN_HPP_HASH_COMBINE( seed, micromapBuildSizesInfoEXT.pNext );
6254  VULKAN_HPP_HASH_COMBINE( seed, micromapBuildSizesInfoEXT.micromapSize );
6255  VULKAN_HPP_HASH_COMBINE( seed, micromapBuildSizesInfoEXT.buildScratchSize );
6256  VULKAN_HPP_HASH_COMBINE( seed, micromapBuildSizesInfoEXT.discardable );
6257  return seed;
6258  }
6259  };
6260 
6261  template <>
6262  struct hash<VULKAN_HPP_NAMESPACE::MicromapCreateInfoEXT>
6263  {
6264  std::size_t operator()( VULKAN_HPP_NAMESPACE::MicromapCreateInfoEXT const & micromapCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
6265  {
6266  std::size_t seed = 0;
6267  VULKAN_HPP_HASH_COMBINE( seed, micromapCreateInfoEXT.sType );
6268  VULKAN_HPP_HASH_COMBINE( seed, micromapCreateInfoEXT.pNext );
6269  VULKAN_HPP_HASH_COMBINE( seed, micromapCreateInfoEXT.createFlags );
6270  VULKAN_HPP_HASH_COMBINE( seed, micromapCreateInfoEXT.buffer );
6271  VULKAN_HPP_HASH_COMBINE( seed, micromapCreateInfoEXT.offset );
6272  VULKAN_HPP_HASH_COMBINE( seed, micromapCreateInfoEXT.size );
6273  VULKAN_HPP_HASH_COMBINE( seed, micromapCreateInfoEXT.type );
6274  VULKAN_HPP_HASH_COMBINE( seed, micromapCreateInfoEXT.deviceAddress );
6275  return seed;
6276  }
6277  };
6278 
6279  template <>
6280  struct hash<VULKAN_HPP_NAMESPACE::MicromapTriangleEXT>
6281  {
6282  std::size_t operator()( VULKAN_HPP_NAMESPACE::MicromapTriangleEXT const & micromapTriangleEXT ) const VULKAN_HPP_NOEXCEPT
6283  {
6284  std::size_t seed = 0;
6285  VULKAN_HPP_HASH_COMBINE( seed, micromapTriangleEXT.dataOffset );
6286  VULKAN_HPP_HASH_COMBINE( seed, micromapTriangleEXT.subdivisionLevel );
6287  VULKAN_HPP_HASH_COMBINE( seed, micromapTriangleEXT.format );
6288  return seed;
6289  }
6290  };
6291 
6292  template <>
6293  struct hash<VULKAN_HPP_NAMESPACE::MicromapVersionInfoEXT>
6294  {
6295  std::size_t operator()( VULKAN_HPP_NAMESPACE::MicromapVersionInfoEXT const & micromapVersionInfoEXT ) const VULKAN_HPP_NOEXCEPT
6296  {
6297  std::size_t seed = 0;
6298  VULKAN_HPP_HASH_COMBINE( seed, micromapVersionInfoEXT.sType );
6299  VULKAN_HPP_HASH_COMBINE( seed, micromapVersionInfoEXT.pNext );
6300  VULKAN_HPP_HASH_COMBINE( seed, micromapVersionInfoEXT.pVersionData );
6301  return seed;
6302  }
6303  };
6304 
6305  template <>
6306  struct hash<VULKAN_HPP_NAMESPACE::MultiDrawIndexedInfoEXT>
6307  {
6308  std::size_t operator()( VULKAN_HPP_NAMESPACE::MultiDrawIndexedInfoEXT const & multiDrawIndexedInfoEXT ) const VULKAN_HPP_NOEXCEPT
6309  {
6310  std::size_t seed = 0;
6311  VULKAN_HPP_HASH_COMBINE( seed, multiDrawIndexedInfoEXT.firstIndex );
6312  VULKAN_HPP_HASH_COMBINE( seed, multiDrawIndexedInfoEXT.indexCount );
6313  VULKAN_HPP_HASH_COMBINE( seed, multiDrawIndexedInfoEXT.vertexOffset );
6314  return seed;
6315  }
6316  };
6317 
6318  template <>
6319  struct hash<VULKAN_HPP_NAMESPACE::MultiDrawInfoEXT>
6320  {
6321  std::size_t operator()( VULKAN_HPP_NAMESPACE::MultiDrawInfoEXT const & multiDrawInfoEXT ) const VULKAN_HPP_NOEXCEPT
6322  {
6323  std::size_t seed = 0;
6324  VULKAN_HPP_HASH_COMBINE( seed, multiDrawInfoEXT.firstVertex );
6325  VULKAN_HPP_HASH_COMBINE( seed, multiDrawInfoEXT.vertexCount );
6326  return seed;
6327  }
6328  };
6329 
6330  template <>
6331  struct hash<VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT>
6332  {
6333  std::size_t operator()( VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT const & multisamplePropertiesEXT ) const VULKAN_HPP_NOEXCEPT
6334  {
6335  std::size_t seed = 0;
6336  VULKAN_HPP_HASH_COMBINE( seed, multisamplePropertiesEXT.sType );
6337  VULKAN_HPP_HASH_COMBINE( seed, multisamplePropertiesEXT.pNext );
6338  VULKAN_HPP_HASH_COMBINE( seed, multisamplePropertiesEXT.maxSampleLocationGridSize );
6339  return seed;
6340  }
6341  };
6342 
6343  template <>
6344  struct hash<VULKAN_HPP_NAMESPACE::MultisampledRenderToSingleSampledInfoEXT>
6345  {
6346  std::size_t
6347  operator()( VULKAN_HPP_NAMESPACE::MultisampledRenderToSingleSampledInfoEXT const & multisampledRenderToSingleSampledInfoEXT ) const VULKAN_HPP_NOEXCEPT
6348  {
6349  std::size_t seed = 0;
6350  VULKAN_HPP_HASH_COMBINE( seed, multisampledRenderToSingleSampledInfoEXT.sType );
6351  VULKAN_HPP_HASH_COMBINE( seed, multisampledRenderToSingleSampledInfoEXT.pNext );
6352  VULKAN_HPP_HASH_COMBINE( seed, multisampledRenderToSingleSampledInfoEXT.multisampledRenderToSingleSampledEnable );
6353  VULKAN_HPP_HASH_COMBINE( seed, multisampledRenderToSingleSampledInfoEXT.rasterizationSamples );
6354  return seed;
6355  }
6356  };
6357 
6358  template <>
6359  struct hash<VULKAN_HPP_NAMESPACE::MultiviewPerViewAttributesInfoNVX>
6360  {
6361  std::size_t operator()( VULKAN_HPP_NAMESPACE::MultiviewPerViewAttributesInfoNVX const & multiviewPerViewAttributesInfoNVX ) const VULKAN_HPP_NOEXCEPT
6362  {
6363  std::size_t seed = 0;
6364  VULKAN_HPP_HASH_COMBINE( seed, multiviewPerViewAttributesInfoNVX.sType );
6365  VULKAN_HPP_HASH_COMBINE( seed, multiviewPerViewAttributesInfoNVX.pNext );
6366  VULKAN_HPP_HASH_COMBINE( seed, multiviewPerViewAttributesInfoNVX.perViewAttributes );
6367  VULKAN_HPP_HASH_COMBINE( seed, multiviewPerViewAttributesInfoNVX.perViewAttributesPositionXOnly );
6368  return seed;
6369  }
6370  };
6371 
6372  template <>
6373  struct hash<VULKAN_HPP_NAMESPACE::MutableDescriptorTypeListEXT>
6374  {
6375  std::size_t operator()( VULKAN_HPP_NAMESPACE::MutableDescriptorTypeListEXT const & mutableDescriptorTypeListEXT ) const VULKAN_HPP_NOEXCEPT
6376  {
6377  std::size_t seed = 0;
6378  VULKAN_HPP_HASH_COMBINE( seed, mutableDescriptorTypeListEXT.descriptorTypeCount );
6379  VULKAN_HPP_HASH_COMBINE( seed, mutableDescriptorTypeListEXT.pDescriptorTypes );
6380  return seed;
6381  }
6382  };
6383 
6384  template <>
6385  struct hash<VULKAN_HPP_NAMESPACE::MutableDescriptorTypeCreateInfoEXT>
6386  {
6387  std::size_t operator()( VULKAN_HPP_NAMESPACE::MutableDescriptorTypeCreateInfoEXT const & mutableDescriptorTypeCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
6388  {
6389  std::size_t seed = 0;
6390  VULKAN_HPP_HASH_COMBINE( seed, mutableDescriptorTypeCreateInfoEXT.sType );
6391  VULKAN_HPP_HASH_COMBINE( seed, mutableDescriptorTypeCreateInfoEXT.pNext );
6392  VULKAN_HPP_HASH_COMBINE( seed, mutableDescriptorTypeCreateInfoEXT.mutableDescriptorTypeListCount );
6393  VULKAN_HPP_HASH_COMBINE( seed, mutableDescriptorTypeCreateInfoEXT.pMutableDescriptorTypeLists );
6394  return seed;
6395  }
6396  };
6397 
6398  template <>
6399  struct hash<VULKAN_HPP_NAMESPACE::OpaqueCaptureDescriptorDataCreateInfoEXT>
6400  {
6401  std::size_t
6402  operator()( VULKAN_HPP_NAMESPACE::OpaqueCaptureDescriptorDataCreateInfoEXT const & opaqueCaptureDescriptorDataCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
6403  {
6404  std::size_t seed = 0;
6405  VULKAN_HPP_HASH_COMBINE( seed, opaqueCaptureDescriptorDataCreateInfoEXT.sType );
6406  VULKAN_HPP_HASH_COMBINE( seed, opaqueCaptureDescriptorDataCreateInfoEXT.pNext );
6407  VULKAN_HPP_HASH_COMBINE( seed, opaqueCaptureDescriptorDataCreateInfoEXT.opaqueCaptureDescriptorData );
6408  return seed;
6409  }
6410  };
6411 
6412  template <>
6413  struct hash<VULKAN_HPP_NAMESPACE::OpticalFlowExecuteInfoNV>
6414  {
6415  std::size_t operator()( VULKAN_HPP_NAMESPACE::OpticalFlowExecuteInfoNV const & opticalFlowExecuteInfoNV ) const VULKAN_HPP_NOEXCEPT
6416  {
6417  std::size_t seed = 0;
6418  VULKAN_HPP_HASH_COMBINE( seed, opticalFlowExecuteInfoNV.sType );
6419  VULKAN_HPP_HASH_COMBINE( seed, opticalFlowExecuteInfoNV.pNext );
6420  VULKAN_HPP_HASH_COMBINE( seed, opticalFlowExecuteInfoNV.flags );
6421  VULKAN_HPP_HASH_COMBINE( seed, opticalFlowExecuteInfoNV.regionCount );
6422  VULKAN_HPP_HASH_COMBINE( seed, opticalFlowExecuteInfoNV.pRegions );
6423  return seed;
6424  }
6425  };
6426 
6427  template <>
6428  struct hash<VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatInfoNV>
6429  {
6430  std::size_t operator()( VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatInfoNV const & opticalFlowImageFormatInfoNV ) const VULKAN_HPP_NOEXCEPT
6431  {
6432  std::size_t seed = 0;
6433  VULKAN_HPP_HASH_COMBINE( seed, opticalFlowImageFormatInfoNV.sType );
6434  VULKAN_HPP_HASH_COMBINE( seed, opticalFlowImageFormatInfoNV.pNext );
6435  VULKAN_HPP_HASH_COMBINE( seed, opticalFlowImageFormatInfoNV.usage );
6436  return seed;
6437  }
6438  };
6439 
6440  template <>
6441  struct hash<VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV>
6442  {
6443  std::size_t operator()( VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV const & opticalFlowImageFormatPropertiesNV ) const VULKAN_HPP_NOEXCEPT
6444  {
6445  std::size_t seed = 0;
6446  VULKAN_HPP_HASH_COMBINE( seed, opticalFlowImageFormatPropertiesNV.sType );
6447  VULKAN_HPP_HASH_COMBINE( seed, opticalFlowImageFormatPropertiesNV.pNext );
6448  VULKAN_HPP_HASH_COMBINE( seed, opticalFlowImageFormatPropertiesNV.format );
6449  return seed;
6450  }
6451  };
6452 
6453  template <>
6454  struct hash<VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreateInfoNV>
6455  {
6456  std::size_t operator()( VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreateInfoNV const & opticalFlowSessionCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
6457  {
6458  std::size_t seed = 0;
6459  VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.sType );
6460  VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.pNext );
6461  VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.width );
6462  VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.height );
6463  VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.imageFormat );
6464  VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.flowVectorFormat );
6465  VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.costFormat );
6466  VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.outputGridSize );
6467  VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.hintGridSize );
6468  VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.performanceLevel );
6469  VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.flags );
6470  return seed;
6471  }
6472  };
6473 
6474  template <>
6475  struct hash<VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreatePrivateDataInfoNV>
6476  {
6477  std::size_t
6478  operator()( VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreatePrivateDataInfoNV const & opticalFlowSessionCreatePrivateDataInfoNV ) const VULKAN_HPP_NOEXCEPT
6479  {
6480  std::size_t seed = 0;
6481  VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreatePrivateDataInfoNV.sType );
6482  VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreatePrivateDataInfoNV.pNext );
6483  VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreatePrivateDataInfoNV.id );
6484  VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreatePrivateDataInfoNV.size );
6485  VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreatePrivateDataInfoNV.pPrivateData );
6486  return seed;
6487  }
6488  };
6489 
6490  template <>
6491  struct hash<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE>
6492  {
6493  std::size_t operator()( VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE const & pastPresentationTimingGOOGLE ) const VULKAN_HPP_NOEXCEPT
6494  {
6495  std::size_t seed = 0;
6496  VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingGOOGLE.presentID );
6497  VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingGOOGLE.desiredPresentTime );
6498  VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingGOOGLE.actualPresentTime );
6499  VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingGOOGLE.earliestPresentTime );
6500  VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingGOOGLE.presentMargin );
6501  return seed;
6502  }
6503  };
6504 
6505  template <>
6506  struct hash<VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL>
6507  {
6508  std::size_t
6509  operator()( VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL const & performanceConfigurationAcquireInfoINTEL ) const VULKAN_HPP_NOEXCEPT
6510  {
6511  std::size_t seed = 0;
6512  VULKAN_HPP_HASH_COMBINE( seed, performanceConfigurationAcquireInfoINTEL.sType );
6513  VULKAN_HPP_HASH_COMBINE( seed, performanceConfigurationAcquireInfoINTEL.pNext );
6514  VULKAN_HPP_HASH_COMBINE( seed, performanceConfigurationAcquireInfoINTEL.type );
6515  return seed;
6516  }
6517  };
6518 
6519  template <>
6520  struct hash<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR>
6521  {
6522  std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR const & performanceCounterDescriptionKHR ) const VULKAN_HPP_NOEXCEPT
6523  {
6524  std::size_t seed = 0;
6525  VULKAN_HPP_HASH_COMBINE( seed, performanceCounterDescriptionKHR.sType );
6526  VULKAN_HPP_HASH_COMBINE( seed, performanceCounterDescriptionKHR.pNext );
6527  VULKAN_HPP_HASH_COMBINE( seed, performanceCounterDescriptionKHR.flags );
6528  for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i )
6529  {
6530  VULKAN_HPP_HASH_COMBINE( seed, performanceCounterDescriptionKHR.name[i] );
6531  }
6532  for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i )
6533  {
6534  VULKAN_HPP_HASH_COMBINE( seed, performanceCounterDescriptionKHR.category[i] );
6535  }
6536  for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i )
6537  {
6538  VULKAN_HPP_HASH_COMBINE( seed, performanceCounterDescriptionKHR.description[i] );
6539  }
6540  return seed;
6541  }
6542  };
6543 
6544  template <>
6545  struct hash<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR>
6546  {
6547  std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceCounterKHR const & performanceCounterKHR ) const VULKAN_HPP_NOEXCEPT
6548  {
6549  std::size_t seed = 0;
6550  VULKAN_HPP_HASH_COMBINE( seed, performanceCounterKHR.sType );
6551  VULKAN_HPP_HASH_COMBINE( seed, performanceCounterKHR.pNext );
6552  VULKAN_HPP_HASH_COMBINE( seed, performanceCounterKHR.unit );
6553  VULKAN_HPP_HASH_COMBINE( seed, performanceCounterKHR.scope );
6554  VULKAN_HPP_HASH_COMBINE( seed, performanceCounterKHR.storage );
6555  for ( size_t i = 0; i < VK_UUID_SIZE; ++i )
6556  {
6557  VULKAN_HPP_HASH_COMBINE( seed, performanceCounterKHR.uuid[i] );
6558  }
6559  return seed;
6560  }
6561  };
6562 
6563  template <>
6564  struct hash<VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL>
6565  {
6566  std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL const & performanceMarkerInfoINTEL ) const VULKAN_HPP_NOEXCEPT
6567  {
6568  std::size_t seed = 0;
6569  VULKAN_HPP_HASH_COMBINE( seed, performanceMarkerInfoINTEL.sType );
6570  VULKAN_HPP_HASH_COMBINE( seed, performanceMarkerInfoINTEL.pNext );
6571  VULKAN_HPP_HASH_COMBINE( seed, performanceMarkerInfoINTEL.marker );
6572  return seed;
6573  }
6574  };
6575 
6576  template <>
6577  struct hash<VULKAN_HPP_NAMESPACE::PerformanceOverrideInfoINTEL>
6578  {
6579  std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceOverrideInfoINTEL const & performanceOverrideInfoINTEL ) const VULKAN_HPP_NOEXCEPT
6580  {
6581  std::size_t seed = 0;
6582  VULKAN_HPP_HASH_COMBINE( seed, performanceOverrideInfoINTEL.sType );
6583  VULKAN_HPP_HASH_COMBINE( seed, performanceOverrideInfoINTEL.pNext );
6584  VULKAN_HPP_HASH_COMBINE( seed, performanceOverrideInfoINTEL.type );
6585  VULKAN_HPP_HASH_COMBINE( seed, performanceOverrideInfoINTEL.enable );
6586  VULKAN_HPP_HASH_COMBINE( seed, performanceOverrideInfoINTEL.parameter );
6587  return seed;
6588  }
6589  };
6590 
6591  template <>
6592  struct hash<VULKAN_HPP_NAMESPACE::PerformanceQuerySubmitInfoKHR>
6593  {
6594  std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceQuerySubmitInfoKHR const & performanceQuerySubmitInfoKHR ) const VULKAN_HPP_NOEXCEPT
6595  {
6596  std::size_t seed = 0;
6597  VULKAN_HPP_HASH_COMBINE( seed, performanceQuerySubmitInfoKHR.sType );
6598  VULKAN_HPP_HASH_COMBINE( seed, performanceQuerySubmitInfoKHR.pNext );
6599  VULKAN_HPP_HASH_COMBINE( seed, performanceQuerySubmitInfoKHR.counterPassIndex );
6600  return seed;
6601  }
6602  };
6603 
6604  template <>
6605  struct hash<VULKAN_HPP_NAMESPACE::PerformanceStreamMarkerInfoINTEL>
6606  {
6607  std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceStreamMarkerInfoINTEL const & performanceStreamMarkerInfoINTEL ) const VULKAN_HPP_NOEXCEPT
6608  {
6609  std::size_t seed = 0;
6610  VULKAN_HPP_HASH_COMBINE( seed, performanceStreamMarkerInfoINTEL.sType );
6611  VULKAN_HPP_HASH_COMBINE( seed, performanceStreamMarkerInfoINTEL.pNext );
6612  VULKAN_HPP_HASH_COMBINE( seed, performanceStreamMarkerInfoINTEL.marker );
6613  return seed;
6614  }
6615  };
6616 
6617  template <>
6618  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevice16BitStorageFeatures>
6619  {
6620  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevice16BitStorageFeatures const & physicalDevice16BitStorageFeatures ) const VULKAN_HPP_NOEXCEPT
6621  {
6622  std::size_t seed = 0;
6623  VULKAN_HPP_HASH_COMBINE( seed, physicalDevice16BitStorageFeatures.sType );
6624  VULKAN_HPP_HASH_COMBINE( seed, physicalDevice16BitStorageFeatures.pNext );
6625  VULKAN_HPP_HASH_COMBINE( seed, physicalDevice16BitStorageFeatures.storageBuffer16BitAccess );
6626  VULKAN_HPP_HASH_COMBINE( seed, physicalDevice16BitStorageFeatures.uniformAndStorageBuffer16BitAccess );
6627  VULKAN_HPP_HASH_COMBINE( seed, physicalDevice16BitStorageFeatures.storagePushConstant16 );
6628  VULKAN_HPP_HASH_COMBINE( seed, physicalDevice16BitStorageFeatures.storageInputOutput16 );
6629  return seed;
6630  }
6631  };
6632 
6633  template <>
6634  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevice4444FormatsFeaturesEXT>
6635  {
6636  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevice4444FormatsFeaturesEXT const & physicalDevice4444FormatsFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
6637  {
6638  std::size_t seed = 0;
6639  VULKAN_HPP_HASH_COMBINE( seed, physicalDevice4444FormatsFeaturesEXT.sType );
6640  VULKAN_HPP_HASH_COMBINE( seed, physicalDevice4444FormatsFeaturesEXT.pNext );
6641  VULKAN_HPP_HASH_COMBINE( seed, physicalDevice4444FormatsFeaturesEXT.formatA4R4G4B4 );
6642  VULKAN_HPP_HASH_COMBINE( seed, physicalDevice4444FormatsFeaturesEXT.formatA4B4G4R4 );
6643  return seed;
6644  }
6645  };
6646 
6647  template <>
6648  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevice8BitStorageFeatures>
6649  {
6650  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevice8BitStorageFeatures const & physicalDevice8BitStorageFeatures ) const VULKAN_HPP_NOEXCEPT
6651  {
6652  std::size_t seed = 0;
6653  VULKAN_HPP_HASH_COMBINE( seed, physicalDevice8BitStorageFeatures.sType );
6654  VULKAN_HPP_HASH_COMBINE( seed, physicalDevice8BitStorageFeatures.pNext );
6655  VULKAN_HPP_HASH_COMBINE( seed, physicalDevice8BitStorageFeatures.storageBuffer8BitAccess );
6656  VULKAN_HPP_HASH_COMBINE( seed, physicalDevice8BitStorageFeatures.uniformAndStorageBuffer8BitAccess );
6657  VULKAN_HPP_HASH_COMBINE( seed, physicalDevice8BitStorageFeatures.storagePushConstant8 );
6658  return seed;
6659  }
6660  };
6661 
6662  template <>
6663  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceASTCDecodeFeaturesEXT>
6664  {
6665  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceASTCDecodeFeaturesEXT const & physicalDeviceASTCDecodeFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
6666  {
6667  std::size_t seed = 0;
6668  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceASTCDecodeFeaturesEXT.sType );
6669  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceASTCDecodeFeaturesEXT.pNext );
6670  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceASTCDecodeFeaturesEXT.decodeModeSharedExponent );
6671  return seed;
6672  }
6673  };
6674 
6675  template <>
6676  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceAccelerationStructureFeaturesKHR>
6677  {
6678  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceAccelerationStructureFeaturesKHR const & physicalDeviceAccelerationStructureFeaturesKHR ) const
6679  VULKAN_HPP_NOEXCEPT
6680  {
6681  std::size_t seed = 0;
6682  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructureFeaturesKHR.sType );
6683  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructureFeaturesKHR.pNext );
6684  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructureFeaturesKHR.accelerationStructure );
6685  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructureFeaturesKHR.accelerationStructureCaptureReplay );
6686  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructureFeaturesKHR.accelerationStructureIndirectBuild );
6687  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructureFeaturesKHR.accelerationStructureHostCommands );
6688  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructureFeaturesKHR.descriptorBindingAccelerationStructureUpdateAfterBind );
6689  return seed;
6690  }
6691  };
6692 
6693  template <>
6694  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceAccelerationStructurePropertiesKHR>
6695  {
6696  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceAccelerationStructurePropertiesKHR const & physicalDeviceAccelerationStructurePropertiesKHR )
6697  const VULKAN_HPP_NOEXCEPT
6698  {
6699  std::size_t seed = 0;
6700  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.sType );
6701  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.pNext );
6702  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.maxGeometryCount );
6703  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.maxInstanceCount );
6704  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.maxPrimitiveCount );
6705  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.maxPerStageDescriptorAccelerationStructures );
6706  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.maxPerStageDescriptorUpdateAfterBindAccelerationStructures );
6707  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.maxDescriptorSetAccelerationStructures );
6708  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.maxDescriptorSetUpdateAfterBindAccelerationStructures );
6709  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.minAccelerationStructureScratchOffsetAlignment );
6710  return seed;
6711  }
6712  };
6713 
6714  template <>
6715  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceAddressBindingReportFeaturesEXT>
6716  {
6717  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceAddressBindingReportFeaturesEXT const & physicalDeviceAddressBindingReportFeaturesEXT ) const
6718  VULKAN_HPP_NOEXCEPT
6719  {
6720  std::size_t seed = 0;
6721  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAddressBindingReportFeaturesEXT.sType );
6722  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAddressBindingReportFeaturesEXT.pNext );
6723  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAddressBindingReportFeaturesEXT.reportAddressBinding );
6724  return seed;
6725  }
6726  };
6727 
6728  template <>
6729  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceAmigoProfilingFeaturesSEC>
6730  {
6731  std::size_t
6732  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceAmigoProfilingFeaturesSEC const & physicalDeviceAmigoProfilingFeaturesSEC ) const VULKAN_HPP_NOEXCEPT
6733  {
6734  std::size_t seed = 0;
6735  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAmigoProfilingFeaturesSEC.sType );
6736  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAmigoProfilingFeaturesSEC.pNext );
6737  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAmigoProfilingFeaturesSEC.amigoProfiling );
6738  return seed;
6739  }
6740  };
6741 
6742  template <>
6743  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT>
6744  {
6745  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT const &
6746  physicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
6747  {
6748  std::size_t seed = 0;
6749  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT.sType );
6750  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT.pNext );
6751  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT.attachmentFeedbackLoopLayout );
6752  return seed;
6753  }
6754  };
6755 
6756  template <>
6757  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceBlendOperationAdvancedFeaturesEXT>
6758  {
6759  std::size_t operator()(
6760  VULKAN_HPP_NAMESPACE::PhysicalDeviceBlendOperationAdvancedFeaturesEXT const & physicalDeviceBlendOperationAdvancedFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
6761  {
6762  std::size_t seed = 0;
6763  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedFeaturesEXT.sType );
6764  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedFeaturesEXT.pNext );
6765  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedFeaturesEXT.advancedBlendCoherentOperations );
6766  return seed;
6767  }
6768  };
6769 
6770  template <>
6771  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceBlendOperationAdvancedPropertiesEXT>
6772  {
6773  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceBlendOperationAdvancedPropertiesEXT const & physicalDeviceBlendOperationAdvancedPropertiesEXT )
6774  const VULKAN_HPP_NOEXCEPT
6775  {
6776  std::size_t seed = 0;
6777  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.sType );
6778  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.pNext );
6779  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendMaxColorAttachments );
6780  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendIndependentBlend );
6781  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendNonPremultipliedSrcColor );
6782  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendNonPremultipliedDstColor );
6783  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendCorrelatedOverlap );
6784  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendAllOperations );
6785  return seed;
6786  }
6787  };
6788 
6789  template <>
6790  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceBorderColorSwizzleFeaturesEXT>
6791  {
6792  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceBorderColorSwizzleFeaturesEXT const & physicalDeviceBorderColorSwizzleFeaturesEXT ) const
6793  VULKAN_HPP_NOEXCEPT
6794  {
6795  std::size_t seed = 0;
6796  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBorderColorSwizzleFeaturesEXT.sType );
6797  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBorderColorSwizzleFeaturesEXT.pNext );
6798  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBorderColorSwizzleFeaturesEXT.borderColorSwizzle );
6799  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBorderColorSwizzleFeaturesEXT.borderColorSwizzleFromImage );
6800  return seed;
6801  }
6802  };
6803 
6804  template <>
6805  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceBufferDeviceAddressFeatures>
6806  {
6807  std::size_t
6808  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceBufferDeviceAddressFeatures const & physicalDeviceBufferDeviceAddressFeatures ) const VULKAN_HPP_NOEXCEPT
6809  {
6810  std::size_t seed = 0;
6811  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeatures.sType );
6812  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeatures.pNext );
6813  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeatures.bufferDeviceAddress );
6814  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeatures.bufferDeviceAddressCaptureReplay );
6815  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeatures.bufferDeviceAddressMultiDevice );
6816  return seed;
6817  }
6818  };
6819 
6820  template <>
6821  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceBufferDeviceAddressFeaturesEXT>
6822  {
6823  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceBufferDeviceAddressFeaturesEXT const & physicalDeviceBufferDeviceAddressFeaturesEXT ) const
6824  VULKAN_HPP_NOEXCEPT
6825  {
6826  std::size_t seed = 0;
6827  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeaturesEXT.sType );
6828  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeaturesEXT.pNext );
6829  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeaturesEXT.bufferDeviceAddress );
6830  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeaturesEXT.bufferDeviceAddressCaptureReplay );
6831  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeaturesEXT.bufferDeviceAddressMultiDevice );
6832  return seed;
6833  }
6834  };
6835 
6836  template <>
6837  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCoherentMemoryFeaturesAMD>
6838  {
6839  std::size_t
6840  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCoherentMemoryFeaturesAMD const & physicalDeviceCoherentMemoryFeaturesAMD ) const VULKAN_HPP_NOEXCEPT
6841  {
6842  std::size_t seed = 0;
6843  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCoherentMemoryFeaturesAMD.sType );
6844  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCoherentMemoryFeaturesAMD.pNext );
6845  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCoherentMemoryFeaturesAMD.deviceCoherentMemory );
6846  return seed;
6847  }
6848  };
6849 
6850  template <>
6851  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceColorWriteEnableFeaturesEXT>
6852  {
6853  std::size_t
6854  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceColorWriteEnableFeaturesEXT const & physicalDeviceColorWriteEnableFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
6855  {
6856  std::size_t seed = 0;
6857  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceColorWriteEnableFeaturesEXT.sType );
6858  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceColorWriteEnableFeaturesEXT.pNext );
6859  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceColorWriteEnableFeaturesEXT.colorWriteEnable );
6860  return seed;
6861  }
6862  };
6863 
6864  template <>
6865  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceComputeShaderDerivativesFeaturesNV>
6866  {
6867  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceComputeShaderDerivativesFeaturesNV const & physicalDeviceComputeShaderDerivativesFeaturesNV )
6868  const VULKAN_HPP_NOEXCEPT
6869  {
6870  std::size_t seed = 0;
6871  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceComputeShaderDerivativesFeaturesNV.sType );
6872  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceComputeShaderDerivativesFeaturesNV.pNext );
6873  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceComputeShaderDerivativesFeaturesNV.computeDerivativeGroupQuads );
6874  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceComputeShaderDerivativesFeaturesNV.computeDerivativeGroupLinear );
6875  return seed;
6876  }
6877  };
6878 
6879  template <>
6880  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceConditionalRenderingFeaturesEXT>
6881  {
6882  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceConditionalRenderingFeaturesEXT const & physicalDeviceConditionalRenderingFeaturesEXT ) const
6883  VULKAN_HPP_NOEXCEPT
6884  {
6885  std::size_t seed = 0;
6886  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConditionalRenderingFeaturesEXT.sType );
6887  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConditionalRenderingFeaturesEXT.pNext );
6888  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConditionalRenderingFeaturesEXT.conditionalRendering );
6889  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConditionalRenderingFeaturesEXT.inheritedConditionalRendering );
6890  return seed;
6891  }
6892  };
6893 
6894  template <>
6895  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceConservativeRasterizationPropertiesEXT>
6896  {
6897  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceConservativeRasterizationPropertiesEXT const &
6898  physicalDeviceConservativeRasterizationPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
6899  {
6900  std::size_t seed = 0;
6901  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.sType );
6902  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.pNext );
6903  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.primitiveOverestimationSize );
6904  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.maxExtraPrimitiveOverestimationSize );
6905  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.extraPrimitiveOverestimationSizeGranularity );
6906  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.primitiveUnderestimation );
6907  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.conservativePointAndLineRasterization );
6908  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.degenerateTrianglesRasterized );
6909  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.degenerateLinesRasterized );
6910  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.fullyCoveredFragmentShaderInputVariable );
6911  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.conservativeRasterizationPostDepthCoverage );
6912  return seed;
6913  }
6914  };
6915 
6916  template <>
6917  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixFeaturesNV>
6918  {
6919  std::size_t
6920  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixFeaturesNV const & physicalDeviceCooperativeMatrixFeaturesNV ) const VULKAN_HPP_NOEXCEPT
6921  {
6922  std::size_t seed = 0;
6923  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixFeaturesNV.sType );
6924  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixFeaturesNV.pNext );
6925  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixFeaturesNV.cooperativeMatrix );
6926  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixFeaturesNV.cooperativeMatrixRobustBufferAccess );
6927  return seed;
6928  }
6929  };
6930 
6931  template <>
6932  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixPropertiesNV>
6933  {
6934  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixPropertiesNV const & physicalDeviceCooperativeMatrixPropertiesNV ) const
6935  VULKAN_HPP_NOEXCEPT
6936  {
6937  std::size_t seed = 0;
6938  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixPropertiesNV.sType );
6939  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixPropertiesNV.pNext );
6940  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixPropertiesNV.cooperativeMatrixSupportedStages );
6941  return seed;
6942  }
6943  };
6944 
6945  template <>
6946  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectFeaturesNV>
6947  {
6948  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectFeaturesNV const & physicalDeviceCopyMemoryIndirectFeaturesNV ) const
6949  VULKAN_HPP_NOEXCEPT
6950  {
6951  std::size_t seed = 0;
6952  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCopyMemoryIndirectFeaturesNV.sType );
6953  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCopyMemoryIndirectFeaturesNV.pNext );
6954  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCopyMemoryIndirectFeaturesNV.indirectCopy );
6955  return seed;
6956  }
6957  };
6958 
6959  template <>
6960  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectPropertiesNV>
6961  {
6962  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectPropertiesNV const & physicalDeviceCopyMemoryIndirectPropertiesNV ) const
6963  VULKAN_HPP_NOEXCEPT
6964  {
6965  std::size_t seed = 0;
6966  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCopyMemoryIndirectPropertiesNV.sType );
6967  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCopyMemoryIndirectPropertiesNV.pNext );
6968  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCopyMemoryIndirectPropertiesNV.supportedQueues );
6969  return seed;
6970  }
6971  };
6972 
6973  template <>
6974  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCornerSampledImageFeaturesNV>
6975  {
6976  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCornerSampledImageFeaturesNV const & physicalDeviceCornerSampledImageFeaturesNV ) const
6977  VULKAN_HPP_NOEXCEPT
6978  {
6979  std::size_t seed = 0;
6980  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCornerSampledImageFeaturesNV.sType );
6981  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCornerSampledImageFeaturesNV.pNext );
6982  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCornerSampledImageFeaturesNV.cornerSampledImage );
6983  return seed;
6984  }
6985  };
6986 
6987  template <>
6988  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCoverageReductionModeFeaturesNV>
6989  {
6990  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCoverageReductionModeFeaturesNV const & physicalDeviceCoverageReductionModeFeaturesNV ) const
6991  VULKAN_HPP_NOEXCEPT
6992  {
6993  std::size_t seed = 0;
6994  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCoverageReductionModeFeaturesNV.sType );
6995  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCoverageReductionModeFeaturesNV.pNext );
6996  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCoverageReductionModeFeaturesNV.coverageReductionMode );
6997  return seed;
6998  }
6999  };
7000 
7001  template <>
7002  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomBorderColorFeaturesEXT>
7003  {
7004  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomBorderColorFeaturesEXT const & physicalDeviceCustomBorderColorFeaturesEXT ) const
7005  VULKAN_HPP_NOEXCEPT
7006  {
7007  std::size_t seed = 0;
7008  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCustomBorderColorFeaturesEXT.sType );
7009  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCustomBorderColorFeaturesEXT.pNext );
7010  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCustomBorderColorFeaturesEXT.customBorderColors );
7011  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCustomBorderColorFeaturesEXT.customBorderColorWithoutFormat );
7012  return seed;
7013  }
7014  };
7015 
7016  template <>
7017  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomBorderColorPropertiesEXT>
7018  {
7019  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomBorderColorPropertiesEXT const & physicalDeviceCustomBorderColorPropertiesEXT ) const
7020  VULKAN_HPP_NOEXCEPT
7021  {
7022  std::size_t seed = 0;
7023  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCustomBorderColorPropertiesEXT.sType );
7024  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCustomBorderColorPropertiesEXT.pNext );
7025  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCustomBorderColorPropertiesEXT.maxCustomBorderColorSamplers );
7026  return seed;
7027  }
7028  };
7029 
7030  template <>
7031  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV>
7032  {
7033  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const &
7034  physicalDeviceDedicatedAllocationImageAliasingFeaturesNV ) const VULKAN_HPP_NOEXCEPT
7035  {
7036  std::size_t seed = 0;
7037  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDedicatedAllocationImageAliasingFeaturesNV.sType );
7038  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDedicatedAllocationImageAliasingFeaturesNV.pNext );
7039  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDedicatedAllocationImageAliasingFeaturesNV.dedicatedAllocationImageAliasing );
7040  return seed;
7041  }
7042  };
7043 
7044  template <>
7045  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClampZeroOneFeaturesEXT>
7046  {
7047  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClampZeroOneFeaturesEXT const & physicalDeviceDepthClampZeroOneFeaturesEXT ) const
7048  VULKAN_HPP_NOEXCEPT
7049  {
7050  std::size_t seed = 0;
7051  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClampZeroOneFeaturesEXT.sType );
7052  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClampZeroOneFeaturesEXT.pNext );
7053  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClampZeroOneFeaturesEXT.depthClampZeroOne );
7054  return seed;
7055  }
7056  };
7057 
7058  template <>
7059  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClipControlFeaturesEXT>
7060  {
7061  std::size_t
7062  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClipControlFeaturesEXT const & physicalDeviceDepthClipControlFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
7063  {
7064  std::size_t seed = 0;
7065  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClipControlFeaturesEXT.sType );
7066  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClipControlFeaturesEXT.pNext );
7067  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClipControlFeaturesEXT.depthClipControl );
7068  return seed;
7069  }
7070  };
7071 
7072  template <>
7073  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClipEnableFeaturesEXT>
7074  {
7075  std::size_t
7076  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClipEnableFeaturesEXT const & physicalDeviceDepthClipEnableFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
7077  {
7078  std::size_t seed = 0;
7079  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClipEnableFeaturesEXT.sType );
7080  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClipEnableFeaturesEXT.pNext );
7081  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClipEnableFeaturesEXT.depthClipEnable );
7082  return seed;
7083  }
7084  };
7085 
7086  template <>
7087  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthStencilResolveProperties>
7088  {
7089  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthStencilResolveProperties const & physicalDeviceDepthStencilResolveProperties ) const
7090  VULKAN_HPP_NOEXCEPT
7091  {
7092  std::size_t seed = 0;
7093  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthStencilResolveProperties.sType );
7094  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthStencilResolveProperties.pNext );
7095  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthStencilResolveProperties.supportedDepthResolveModes );
7096  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthStencilResolveProperties.supportedStencilResolveModes );
7097  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthStencilResolveProperties.independentResolveNone );
7098  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthStencilResolveProperties.independentResolve );
7099  return seed;
7100  }
7101  };
7102 
7103  template <>
7104  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT>
7105  {
7106  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT const &
7107  physicalDeviceDescriptorBufferDensityMapPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
7108  {
7109  std::size_t seed = 0;
7110  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferDensityMapPropertiesEXT.sType );
7111  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferDensityMapPropertiesEXT.pNext );
7112  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferDensityMapPropertiesEXT.combinedImageSamplerDensityMapDescriptorSize );
7113  return seed;
7114  }
7115  };
7116 
7117  template <>
7118  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferFeaturesEXT>
7119  {
7120  std::size_t
7121  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferFeaturesEXT const & physicalDeviceDescriptorBufferFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
7122  {
7123  std::size_t seed = 0;
7124  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferFeaturesEXT.sType );
7125  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferFeaturesEXT.pNext );
7126  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferFeaturesEXT.descriptorBuffer );
7127  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferFeaturesEXT.descriptorBufferCaptureReplay );
7128  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferFeaturesEXT.descriptorBufferImageLayoutIgnored );
7129  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferFeaturesEXT.descriptorBufferPushDescriptors );
7130  return seed;
7131  }
7132  };
7133 
7134  template <>
7135  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferPropertiesEXT>
7136  {
7137  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferPropertiesEXT const & physicalDeviceDescriptorBufferPropertiesEXT ) const
7138  VULKAN_HPP_NOEXCEPT
7139  {
7140  std::size_t seed = 0;
7141  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.sType );
7142  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.pNext );
7143  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.combinedImageSamplerDescriptorSingleArray );
7144  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.bufferlessPushDescriptors );
7145  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.allowSamplerImageViewPostSubmitCreation );
7146  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.descriptorBufferOffsetAlignment );
7147  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.maxDescriptorBufferBindings );
7148  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.maxResourceDescriptorBufferBindings );
7149  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.maxSamplerDescriptorBufferBindings );
7150  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.maxEmbeddedImmutableSamplerBindings );
7151  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.maxEmbeddedImmutableSamplers );
7152  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.bufferCaptureReplayDescriptorDataSize );
7153  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.imageCaptureReplayDescriptorDataSize );
7154  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.imageViewCaptureReplayDescriptorDataSize );
7155  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.samplerCaptureReplayDescriptorDataSize );
7156  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.accelerationStructureCaptureReplayDescriptorDataSize );
7157  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.samplerDescriptorSize );
7158  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.combinedImageSamplerDescriptorSize );
7159  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.sampledImageDescriptorSize );
7160  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.storageImageDescriptorSize );
7161  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.uniformTexelBufferDescriptorSize );
7162  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.robustUniformTexelBufferDescriptorSize );
7163  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.storageTexelBufferDescriptorSize );
7164  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.robustStorageTexelBufferDescriptorSize );
7165  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.uniformBufferDescriptorSize );
7166  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.robustUniformBufferDescriptorSize );
7167  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.storageBufferDescriptorSize );
7168  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.robustStorageBufferDescriptorSize );
7169  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.inputAttachmentDescriptorSize );
7170  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.accelerationStructureDescriptorSize );
7171  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.maxSamplerDescriptorBufferRange );
7172  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.maxResourceDescriptorBufferRange );
7173  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.samplerDescriptorBufferAddressSpaceSize );
7174  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.resourceDescriptorBufferAddressSpaceSize );
7175  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.descriptorBufferAddressSpaceSize );
7176  return seed;
7177  }
7178  };
7179 
7180  template <>
7181  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorIndexingFeatures>
7182  {
7183  std::size_t
7184  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorIndexingFeatures const & physicalDeviceDescriptorIndexingFeatures ) const VULKAN_HPP_NOEXCEPT
7185  {
7186  std::size_t seed = 0;
7187  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.sType );
7188  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.pNext );
7189  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderInputAttachmentArrayDynamicIndexing );
7190  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderUniformTexelBufferArrayDynamicIndexing );
7191  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderStorageTexelBufferArrayDynamicIndexing );
7192  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderUniformBufferArrayNonUniformIndexing );
7193  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderSampledImageArrayNonUniformIndexing );
7194  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderStorageBufferArrayNonUniformIndexing );
7195  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderStorageImageArrayNonUniformIndexing );
7196  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderInputAttachmentArrayNonUniformIndexing );
7197  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderUniformTexelBufferArrayNonUniformIndexing );
7198  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderStorageTexelBufferArrayNonUniformIndexing );
7199  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingUniformBufferUpdateAfterBind );
7200  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingSampledImageUpdateAfterBind );
7201  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingStorageImageUpdateAfterBind );
7202  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingStorageBufferUpdateAfterBind );
7203  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingUniformTexelBufferUpdateAfterBind );
7204  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingStorageTexelBufferUpdateAfterBind );
7205  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingUpdateUnusedWhilePending );
7206  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingPartiallyBound );
7207  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingVariableDescriptorCount );
7208  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.runtimeDescriptorArray );
7209  return seed;
7210  }
7211  };
7212 
7213  template <>
7214  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorIndexingProperties>
7215  {
7216  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorIndexingProperties const & physicalDeviceDescriptorIndexingProperties ) const
7217  VULKAN_HPP_NOEXCEPT
7218  {
7219  std::size_t seed = 0;
7220  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.sType );
7221  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.pNext );
7222  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxUpdateAfterBindDescriptorsInAllPools );
7223  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.shaderUniformBufferArrayNonUniformIndexingNative );
7224  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.shaderSampledImageArrayNonUniformIndexingNative );
7225  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.shaderStorageBufferArrayNonUniformIndexingNative );
7226  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.shaderStorageImageArrayNonUniformIndexingNative );
7227  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.shaderInputAttachmentArrayNonUniformIndexingNative );
7228  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.robustBufferAccessUpdateAfterBind );
7229  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.quadDivergentImplicitLod );
7230  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindSamplers );
7231  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindUniformBuffers );
7232  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindStorageBuffers );
7233  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindSampledImages );
7234  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindStorageImages );
7235  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindInputAttachments );
7236  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxPerStageUpdateAfterBindResources );
7237  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindSamplers );
7238  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindUniformBuffers );
7239  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic );
7240  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindStorageBuffers );
7241  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic );
7242  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindSampledImages );
7243  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindStorageImages );
7244  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindInputAttachments );
7245  return seed;
7246  }
7247  };
7248 
7249  template <>
7250  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE>
7251  {
7252  std::size_t
7253  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE const & physicalDeviceDescriptorSetHostMappingFeaturesVALVE ) const
7254  VULKAN_HPP_NOEXCEPT
7255  {
7256  std::size_t seed = 0;
7257  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorSetHostMappingFeaturesVALVE.sType );
7258  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorSetHostMappingFeaturesVALVE.pNext );
7259  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorSetHostMappingFeaturesVALVE.descriptorSetHostMapping );
7260  return seed;
7261  }
7262  };
7263 
7264  template <>
7265  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsFeaturesNV>
7266  {
7267  std::size_t operator()(
7268  VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsFeaturesNV const & physicalDeviceDeviceGeneratedCommandsFeaturesNV ) const VULKAN_HPP_NOEXCEPT
7269  {
7270  std::size_t seed = 0;
7271  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsFeaturesNV.sType );
7272  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsFeaturesNV.pNext );
7273  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsFeaturesNV.deviceGeneratedCommands );
7274  return seed;
7275  }
7276  };
7277 
7278  template <>
7279  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsPropertiesNV>
7280  {
7281  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsPropertiesNV const & physicalDeviceDeviceGeneratedCommandsPropertiesNV )
7282  const VULKAN_HPP_NOEXCEPT
7283  {
7284  std::size_t seed = 0;
7285  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.sType );
7286  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.pNext );
7287  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxGraphicsShaderGroupCount );
7288  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxIndirectSequenceCount );
7289  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxIndirectCommandsTokenCount );
7290  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxIndirectCommandsStreamCount );
7291  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxIndirectCommandsTokenOffset );
7292  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxIndirectCommandsStreamStride );
7293  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.minSequencesCountBufferOffsetAlignment );
7294  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.minSequencesIndexBufferOffsetAlignment );
7295  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.minIndirectCommandsBufferOffsetAlignment );
7296  return seed;
7297  }
7298  };
7299 
7300  template <>
7301  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceMemoryReportFeaturesEXT>
7302  {
7303  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceMemoryReportFeaturesEXT const & physicalDeviceDeviceMemoryReportFeaturesEXT ) const
7304  VULKAN_HPP_NOEXCEPT
7305  {
7306  std::size_t seed = 0;
7307  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceMemoryReportFeaturesEXT.sType );
7308  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceMemoryReportFeaturesEXT.pNext );
7309  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceMemoryReportFeaturesEXT.deviceMemoryReport );
7310  return seed;
7311  }
7312  };
7313 
7314  template <>
7315  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDiagnosticsConfigFeaturesNV>
7316  {
7317  std::size_t
7318  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDiagnosticsConfigFeaturesNV const & physicalDeviceDiagnosticsConfigFeaturesNV ) const VULKAN_HPP_NOEXCEPT
7319  {
7320  std::size_t seed = 0;
7321  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDiagnosticsConfigFeaturesNV.sType );
7322  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDiagnosticsConfigFeaturesNV.pNext );
7323  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDiagnosticsConfigFeaturesNV.diagnosticsConfig );
7324  return seed;
7325  }
7326  };
7327 
7328  template <>
7329  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDiscardRectanglePropertiesEXT>
7330  {
7331  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDiscardRectanglePropertiesEXT const & physicalDeviceDiscardRectanglePropertiesEXT ) const
7332  VULKAN_HPP_NOEXCEPT
7333  {
7334  std::size_t seed = 0;
7335  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDiscardRectanglePropertiesEXT.sType );
7336  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDiscardRectanglePropertiesEXT.pNext );
7337  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDiscardRectanglePropertiesEXT.maxDiscardRectangles );
7338  return seed;
7339  }
7340  };
7341 
7342  template <>
7343  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDriverProperties>
7344  {
7345  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDriverProperties const & physicalDeviceDriverProperties ) const VULKAN_HPP_NOEXCEPT
7346  {
7347  std::size_t seed = 0;
7348  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDriverProperties.sType );
7349  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDriverProperties.pNext );
7350  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDriverProperties.driverID );
7351  for ( size_t i = 0; i < VK_MAX_DRIVER_NAME_SIZE; ++i )
7352  {
7353  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDriverProperties.driverName[i] );
7354  }
7355  for ( size_t i = 0; i < VK_MAX_DRIVER_INFO_SIZE; ++i )
7356  {
7357  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDriverProperties.driverInfo[i] );
7358  }
7359  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDriverProperties.conformanceVersion );
7360  return seed;
7361  }
7362  };
7363 
7364  template <>
7365  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDrmPropertiesEXT>
7366  {
7367  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDrmPropertiesEXT const & physicalDeviceDrmPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
7368  {
7369  std::size_t seed = 0;
7370  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDrmPropertiesEXT.sType );
7371  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDrmPropertiesEXT.pNext );
7372  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDrmPropertiesEXT.hasPrimary );
7373  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDrmPropertiesEXT.hasRender );
7374  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDrmPropertiesEXT.primaryMajor );
7375  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDrmPropertiesEXT.primaryMinor );
7376  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDrmPropertiesEXT.renderMajor );
7377  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDrmPropertiesEXT.renderMinor );
7378  return seed;
7379  }
7380  };
7381 
7382  template <>
7383  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingFeatures>
7384  {
7385  std::size_t
7386  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingFeatures const & physicalDeviceDynamicRenderingFeatures ) const VULKAN_HPP_NOEXCEPT
7387  {
7388  std::size_t seed = 0;
7389  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDynamicRenderingFeatures.sType );
7390  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDynamicRenderingFeatures.pNext );
7391  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDynamicRenderingFeatures.dynamicRendering );
7392  return seed;
7393  }
7394  };
7395 
7396  template <>
7397  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExclusiveScissorFeaturesNV>
7398  {
7399  std::size_t
7400  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExclusiveScissorFeaturesNV const & physicalDeviceExclusiveScissorFeaturesNV ) const VULKAN_HPP_NOEXCEPT
7401  {
7402  std::size_t seed = 0;
7403  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExclusiveScissorFeaturesNV.sType );
7404  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExclusiveScissorFeaturesNV.pNext );
7405  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExclusiveScissorFeaturesNV.exclusiveScissor );
7406  return seed;
7407  }
7408  };
7409 
7410  template <>
7411  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState2FeaturesEXT>
7412  {
7413  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState2FeaturesEXT const & physicalDeviceExtendedDynamicState2FeaturesEXT ) const
7414  VULKAN_HPP_NOEXCEPT
7415  {
7416  std::size_t seed = 0;
7417  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState2FeaturesEXT.sType );
7418  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState2FeaturesEXT.pNext );
7419  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState2FeaturesEXT.extendedDynamicState2 );
7420  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState2FeaturesEXT.extendedDynamicState2LogicOp );
7421  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState2FeaturesEXT.extendedDynamicState2PatchControlPoints );
7422  return seed;
7423  }
7424  };
7425 
7426  template <>
7427  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState3FeaturesEXT>
7428  {
7429  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState3FeaturesEXT const & physicalDeviceExtendedDynamicState3FeaturesEXT ) const
7430  VULKAN_HPP_NOEXCEPT
7431  {
7432  std::size_t seed = 0;
7433  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.sType );
7434  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.pNext );
7435  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3TessellationDomainOrigin );
7436  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3DepthClampEnable );
7437  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3PolygonMode );
7438  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3RasterizationSamples );
7439  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3SampleMask );
7440  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3AlphaToCoverageEnable );
7441  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3AlphaToOneEnable );
7442  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3LogicOpEnable );
7443  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ColorBlendEnable );
7444  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ColorBlendEquation );
7445  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ColorWriteMask );
7446  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3RasterizationStream );
7447  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ConservativeRasterizationMode );
7448  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ExtraPrimitiveOverestimationSize );
7449  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3DepthClipEnable );
7450  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3SampleLocationsEnable );
7451  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ColorBlendAdvanced );
7452  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ProvokingVertexMode );
7453  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3LineRasterizationMode );
7454  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3LineStippleEnable );
7455  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3DepthClipNegativeOneToOne );
7456  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ViewportWScalingEnable );
7457  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ViewportSwizzle );
7458  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3CoverageToColorEnable );
7459  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3CoverageToColorLocation );
7460  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3CoverageModulationMode );
7461  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3CoverageModulationTableEnable );
7462  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3CoverageModulationTable );
7463  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3CoverageReductionMode );
7464  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3RepresentativeFragmentTestEnable );
7465  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ShadingRateImageEnable );
7466  return seed;
7467  }
7468  };
7469 
7470  template <>
7471  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState3PropertiesEXT>
7472  {
7473  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState3PropertiesEXT const & physicalDeviceExtendedDynamicState3PropertiesEXT )
7474  const VULKAN_HPP_NOEXCEPT
7475  {
7476  std::size_t seed = 0;
7477  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3PropertiesEXT.sType );
7478  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3PropertiesEXT.pNext );
7479  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3PropertiesEXT.dynamicPrimitiveTopologyUnrestricted );
7480  return seed;
7481  }
7482  };
7483 
7484  template <>
7485  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicStateFeaturesEXT>
7486  {
7487  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicStateFeaturesEXT const & physicalDeviceExtendedDynamicStateFeaturesEXT ) const
7488  VULKAN_HPP_NOEXCEPT
7489  {
7490  std::size_t seed = 0;
7491  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicStateFeaturesEXT.sType );
7492  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicStateFeaturesEXT.pNext );
7493  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicStateFeaturesEXT.extendedDynamicState );
7494  return seed;
7495  }
7496  };
7497 
7498  template <>
7499  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo>
7500  {
7501  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo const & physicalDeviceExternalBufferInfo ) const VULKAN_HPP_NOEXCEPT
7502  {
7503  std::size_t seed = 0;
7504  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalBufferInfo.sType );
7505  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalBufferInfo.pNext );
7506  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalBufferInfo.flags );
7507  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalBufferInfo.usage );
7508  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalBufferInfo.handleType );
7509  return seed;
7510  }
7511  };
7512 
7513  template <>
7514  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo>
7515  {
7516  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo const & physicalDeviceExternalFenceInfo ) const VULKAN_HPP_NOEXCEPT
7517  {
7518  std::size_t seed = 0;
7519  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFenceInfo.sType );
7520  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFenceInfo.pNext );
7521  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFenceInfo.handleType );
7522  return seed;
7523  }
7524  };
7525 
7526  template <>
7527  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalImageFormatInfo>
7528  {
7529  std::size_t
7530  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalImageFormatInfo const & physicalDeviceExternalImageFormatInfo ) const VULKAN_HPP_NOEXCEPT
7531  {
7532  std::size_t seed = 0;
7533  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalImageFormatInfo.sType );
7534  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalImageFormatInfo.pNext );
7535  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalImageFormatInfo.handleType );
7536  return seed;
7537  }
7538  };
7539 
7540  template <>
7541  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryHostPropertiesEXT>
7542  {
7543  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryHostPropertiesEXT const & physicalDeviceExternalMemoryHostPropertiesEXT ) const
7544  VULKAN_HPP_NOEXCEPT
7545  {
7546  std::size_t seed = 0;
7547  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalMemoryHostPropertiesEXT.sType );
7548  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalMemoryHostPropertiesEXT.pNext );
7549  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalMemoryHostPropertiesEXT.minImportedHostPointerAlignment );
7550  return seed;
7551  }
7552  };
7553 
7554  template <>
7555  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryRDMAFeaturesNV>
7556  {
7557  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryRDMAFeaturesNV const & physicalDeviceExternalMemoryRDMAFeaturesNV ) const
7558  VULKAN_HPP_NOEXCEPT
7559  {
7560  std::size_t seed = 0;
7561  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalMemoryRDMAFeaturesNV.sType );
7562  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalMemoryRDMAFeaturesNV.pNext );
7563  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalMemoryRDMAFeaturesNV.externalMemoryRDMA );
7564  return seed;
7565  }
7566  };
7567 
7568  template <>
7569  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo>
7570  {
7571  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo const & physicalDeviceExternalSemaphoreInfo ) const VULKAN_HPP_NOEXCEPT
7572  {
7573  std::size_t seed = 0;
7574  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalSemaphoreInfo.sType );
7575  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalSemaphoreInfo.pNext );
7576  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalSemaphoreInfo.handleType );
7577  return seed;
7578  }
7579  };
7580 
7581  template <>
7582  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFaultFeaturesEXT>
7583  {
7584  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFaultFeaturesEXT const & physicalDeviceFaultFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
7585  {
7586  std::size_t seed = 0;
7587  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFaultFeaturesEXT.sType );
7588  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFaultFeaturesEXT.pNext );
7589  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFaultFeaturesEXT.deviceFault );
7590  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFaultFeaturesEXT.deviceFaultVendorBinary );
7591  return seed;
7592  }
7593  };
7594 
7595  template <>
7596  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2>
7597  {
7598  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 const & physicalDeviceFeatures2 ) const VULKAN_HPP_NOEXCEPT
7599  {
7600  std::size_t seed = 0;
7601  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures2.sType );
7602  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures2.pNext );
7603  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures2.features );
7604  return seed;
7605  }
7606  };
7607 
7608  template <>
7609  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFloatControlsProperties>
7610  {
7611  std::size_t
7612  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFloatControlsProperties const & physicalDeviceFloatControlsProperties ) const VULKAN_HPP_NOEXCEPT
7613  {
7614  std::size_t seed = 0;
7615  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.sType );
7616  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.pNext );
7617  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.denormBehaviorIndependence );
7618  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.roundingModeIndependence );
7619  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderSignedZeroInfNanPreserveFloat16 );
7620  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderSignedZeroInfNanPreserveFloat32 );
7621  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderSignedZeroInfNanPreserveFloat64 );
7622  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderDenormPreserveFloat16 );
7623  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderDenormPreserveFloat32 );
7624  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderDenormPreserveFloat64 );
7625  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderDenormFlushToZeroFloat16 );
7626  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderDenormFlushToZeroFloat32 );
7627  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderDenormFlushToZeroFloat64 );
7628  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTEFloat16 );
7629  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTEFloat32 );
7630  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTEFloat64 );
7631  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTZFloat16 );
7632  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTZFloat32 );
7633  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTZFloat64 );
7634  return seed;
7635  }
7636  };
7637 
7638  template <>
7639  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMap2FeaturesEXT>
7640  {
7641  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMap2FeaturesEXT const & physicalDeviceFragmentDensityMap2FeaturesEXT ) const
7642  VULKAN_HPP_NOEXCEPT
7643  {
7644  std::size_t seed = 0;
7645  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMap2FeaturesEXT.sType );
7646  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMap2FeaturesEXT.pNext );
7647  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMap2FeaturesEXT.fragmentDensityMapDeferred );
7648  return seed;
7649  }
7650  };
7651 
7652  template <>
7653  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMap2PropertiesEXT>
7654  {
7655  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMap2PropertiesEXT const & physicalDeviceFragmentDensityMap2PropertiesEXT ) const
7656  VULKAN_HPP_NOEXCEPT
7657  {
7658  std::size_t seed = 0;
7659  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMap2PropertiesEXT.sType );
7660  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMap2PropertiesEXT.pNext );
7661  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMap2PropertiesEXT.subsampledLoads );
7662  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMap2PropertiesEXT.subsampledCoarseReconstructionEarlyAccess );
7663  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMap2PropertiesEXT.maxSubsampledArrayLayers );
7664  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMap2PropertiesEXT.maxDescriptorSetSubsampledSamplers );
7665  return seed;
7666  }
7667  };
7668 
7669  template <>
7670  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapFeaturesEXT>
7671  {
7672  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapFeaturesEXT const & physicalDeviceFragmentDensityMapFeaturesEXT ) const
7673  VULKAN_HPP_NOEXCEPT
7674  {
7675  std::size_t seed = 0;
7676  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapFeaturesEXT.sType );
7677  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapFeaturesEXT.pNext );
7678  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapFeaturesEXT.fragmentDensityMap );
7679  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapFeaturesEXT.fragmentDensityMapDynamic );
7680  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapFeaturesEXT.fragmentDensityMapNonSubsampledImages );
7681  return seed;
7682  }
7683  };
7684 
7685  template <>
7686  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM>
7687  {
7688  std::size_t
7689  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM const & physicalDeviceFragmentDensityMapOffsetFeaturesQCOM ) const
7690  VULKAN_HPP_NOEXCEPT
7691  {
7692  std::size_t seed = 0;
7693  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetFeaturesQCOM.sType );
7694  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetFeaturesQCOM.pNext );
7695  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetFeaturesQCOM.fragmentDensityMapOffset );
7696  return seed;
7697  }
7698  };
7699 
7700  template <>
7701  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM>
7702  {
7703  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM const &
7704  physicalDeviceFragmentDensityMapOffsetPropertiesQCOM ) const VULKAN_HPP_NOEXCEPT
7705  {
7706  std::size_t seed = 0;
7707  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetPropertiesQCOM.sType );
7708  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetPropertiesQCOM.pNext );
7709  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetPropertiesQCOM.fragmentDensityOffsetGranularity );
7710  return seed;
7711  }
7712  };
7713 
7714  template <>
7715  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapPropertiesEXT>
7716  {
7717  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapPropertiesEXT const & physicalDeviceFragmentDensityMapPropertiesEXT ) const
7718  VULKAN_HPP_NOEXCEPT
7719  {
7720  std::size_t seed = 0;
7721  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapPropertiesEXT.sType );
7722  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapPropertiesEXT.pNext );
7723  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapPropertiesEXT.minFragmentDensityTexelSize );
7724  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapPropertiesEXT.maxFragmentDensityTexelSize );
7725  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapPropertiesEXT.fragmentDensityInvocations );
7726  return seed;
7727  }
7728  };
7729 
7730  template <>
7731  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderBarycentricFeaturesKHR>
7732  {
7733  std::size_t
7734  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderBarycentricFeaturesKHR const & physicalDeviceFragmentShaderBarycentricFeaturesKHR ) const
7735  VULKAN_HPP_NOEXCEPT
7736  {
7737  std::size_t seed = 0;
7738  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderBarycentricFeaturesKHR.sType );
7739  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderBarycentricFeaturesKHR.pNext );
7740  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderBarycentricFeaturesKHR.fragmentShaderBarycentric );
7741  return seed;
7742  }
7743  };
7744 
7745  template <>
7746  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderBarycentricPropertiesKHR>
7747  {
7748  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderBarycentricPropertiesKHR const &
7749  physicalDeviceFragmentShaderBarycentricPropertiesKHR ) const VULKAN_HPP_NOEXCEPT
7750  {
7751  std::size_t seed = 0;
7752  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderBarycentricPropertiesKHR.sType );
7753  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderBarycentricPropertiesKHR.pNext );
7754  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderBarycentricPropertiesKHR.triStripVertexOrderIndependentOfProvokingVertex );
7755  return seed;
7756  }
7757  };
7758 
7759  template <>
7760  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderInterlockFeaturesEXT>
7761  {
7762  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderInterlockFeaturesEXT const & physicalDeviceFragmentShaderInterlockFeaturesEXT )
7763  const VULKAN_HPP_NOEXCEPT
7764  {
7765  std::size_t seed = 0;
7766  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderInterlockFeaturesEXT.sType );
7767  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderInterlockFeaturesEXT.pNext );
7768  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderInterlockFeaturesEXT.fragmentShaderSampleInterlock );
7769  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderInterlockFeaturesEXT.fragmentShaderPixelInterlock );
7770  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderInterlockFeaturesEXT.fragmentShaderShadingRateInterlock );
7771  return seed;
7772  }
7773  };
7774 
7775  template <>
7776  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateEnumsFeaturesNV>
7777  {
7778  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateEnumsFeaturesNV const & physicalDeviceFragmentShadingRateEnumsFeaturesNV )
7779  const VULKAN_HPP_NOEXCEPT
7780  {
7781  std::size_t seed = 0;
7782  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateEnumsFeaturesNV.sType );
7783  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateEnumsFeaturesNV.pNext );
7784  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateEnumsFeaturesNV.fragmentShadingRateEnums );
7785  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateEnumsFeaturesNV.supersampleFragmentShadingRates );
7786  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateEnumsFeaturesNV.noInvocationFragmentShadingRates );
7787  return seed;
7788  }
7789  };
7790 
7791  template <>
7792  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateEnumsPropertiesNV>
7793  {
7794  std::size_t
7795  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateEnumsPropertiesNV const & physicalDeviceFragmentShadingRateEnumsPropertiesNV ) const
7796  VULKAN_HPP_NOEXCEPT
7797  {
7798  std::size_t seed = 0;
7799  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateEnumsPropertiesNV.sType );
7800  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateEnumsPropertiesNV.pNext );
7801  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateEnumsPropertiesNV.maxFragmentShadingRateInvocationCount );
7802  return seed;
7803  }
7804  };
7805 
7806  template <>
7807  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateFeaturesKHR>
7808  {
7809  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateFeaturesKHR const & physicalDeviceFragmentShadingRateFeaturesKHR ) const
7810  VULKAN_HPP_NOEXCEPT
7811  {
7812  std::size_t seed = 0;
7813  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateFeaturesKHR.sType );
7814  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateFeaturesKHR.pNext );
7815  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateFeaturesKHR.pipelineFragmentShadingRate );
7816  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateFeaturesKHR.primitiveFragmentShadingRate );
7817  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateFeaturesKHR.attachmentFragmentShadingRate );
7818  return seed;
7819  }
7820  };
7821 
7822  template <>
7823  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR>
7824  {
7825  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR const & physicalDeviceFragmentShadingRateKHR ) const VULKAN_HPP_NOEXCEPT
7826  {
7827  std::size_t seed = 0;
7828  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateKHR.sType );
7829  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateKHR.pNext );
7830  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateKHR.sampleCounts );
7831  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateKHR.fragmentSize );
7832  return seed;
7833  }
7834  };
7835 
7836  template <>
7837  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRatePropertiesKHR>
7838  {
7839  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRatePropertiesKHR const & physicalDeviceFragmentShadingRatePropertiesKHR ) const
7840  VULKAN_HPP_NOEXCEPT
7841  {
7842  std::size_t seed = 0;
7843  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.sType );
7844  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.pNext );
7845  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.minFragmentShadingRateAttachmentTexelSize );
7846  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentShadingRateAttachmentTexelSize );
7847  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentShadingRateAttachmentTexelSizeAspectRatio );
7848  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.primitiveFragmentShadingRateWithMultipleViewports );
7849  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.layeredShadingRateAttachments );
7850  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateNonTrivialCombinerOps );
7851  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentSize );
7852  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentSizeAspectRatio );
7853  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentShadingRateCoverageSamples );
7854  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentShadingRateRasterizationSamples );
7855  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithShaderDepthStencilWrites );
7856  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithSampleMask );
7857  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithShaderSampleMask );
7858  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithConservativeRasterization );
7859  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithFragmentShaderInterlock );
7860  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithCustomSampleLocations );
7861  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateStrictMultiplyCombiner );
7862  return seed;
7863  }
7864  };
7865 
7866  template <>
7867  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceGlobalPriorityQueryFeaturesKHR>
7868  {
7869  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceGlobalPriorityQueryFeaturesKHR const & physicalDeviceGlobalPriorityQueryFeaturesKHR ) const
7870  VULKAN_HPP_NOEXCEPT
7871  {
7872  std::size_t seed = 0;
7873  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGlobalPriorityQueryFeaturesKHR.sType );
7874  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGlobalPriorityQueryFeaturesKHR.pNext );
7875  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGlobalPriorityQueryFeaturesKHR.globalPriorityQuery );
7876  return seed;
7877  }
7878  };
7879 
7880  template <>
7881  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT>
7882  {
7883  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT const & physicalDeviceGraphicsPipelineLibraryFeaturesEXT )
7884  const VULKAN_HPP_NOEXCEPT
7885  {
7886  std::size_t seed = 0;
7887  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGraphicsPipelineLibraryFeaturesEXT.sType );
7888  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGraphicsPipelineLibraryFeaturesEXT.pNext );
7889  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGraphicsPipelineLibraryFeaturesEXT.graphicsPipelineLibrary );
7890  return seed;
7891  }
7892  };
7893 
7894  template <>
7895  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT>
7896  {
7897  std::size_t
7898  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT const & physicalDeviceGraphicsPipelineLibraryPropertiesEXT ) const
7899  VULKAN_HPP_NOEXCEPT
7900  {
7901  std::size_t seed = 0;
7902  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGraphicsPipelineLibraryPropertiesEXT.sType );
7903  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGraphicsPipelineLibraryPropertiesEXT.pNext );
7904  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGraphicsPipelineLibraryPropertiesEXT.graphicsPipelineLibraryFastLinking );
7905  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGraphicsPipelineLibraryPropertiesEXT.graphicsPipelineLibraryIndependentInterpolationDecoration );
7906  return seed;
7907  }
7908  };
7909 
7910  template <>
7911  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties>
7912  {
7913  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties const & physicalDeviceGroupProperties ) const VULKAN_HPP_NOEXCEPT
7914  {
7915  std::size_t seed = 0;
7916  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGroupProperties.sType );
7917  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGroupProperties.pNext );
7918  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGroupProperties.physicalDeviceCount );
7919  for ( size_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; ++i )
7920  {
7921  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGroupProperties.physicalDevices[i] );
7922  }
7923  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGroupProperties.subsetAllocation );
7924  return seed;
7925  }
7926  };
7927 
7928  template <>
7929  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceHostQueryResetFeatures>
7930  {
7931  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceHostQueryResetFeatures const & physicalDeviceHostQueryResetFeatures ) const VULKAN_HPP_NOEXCEPT
7932  {
7933  std::size_t seed = 0;
7934  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostQueryResetFeatures.sType );
7935  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostQueryResetFeatures.pNext );
7936  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostQueryResetFeatures.hostQueryReset );
7937  return seed;
7938  }
7939  };
7940 
7941  template <>
7942  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceIDProperties>
7943  {
7944  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceIDProperties const & physicalDeviceIDProperties ) const VULKAN_HPP_NOEXCEPT
7945  {
7946  std::size_t seed = 0;
7947  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIDProperties.sType );
7948  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIDProperties.pNext );
7949  for ( size_t i = 0; i < VK_UUID_SIZE; ++i )
7950  {
7951  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIDProperties.deviceUUID[i] );
7952  }
7953  for ( size_t i = 0; i < VK_UUID_SIZE; ++i )
7954  {
7955  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIDProperties.driverUUID[i] );
7956  }
7957  for ( size_t i = 0; i < VK_LUID_SIZE; ++i )
7958  {
7959  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIDProperties.deviceLUID[i] );
7960  }
7961  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIDProperties.deviceNodeMask );
7962  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIDProperties.deviceLUIDValid );
7963  return seed;
7964  }
7965  };
7966 
7967  template <>
7968  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImage2DViewOf3DFeaturesEXT>
7969  {
7970  std::size_t
7971  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImage2DViewOf3DFeaturesEXT const & physicalDeviceImage2DViewOf3DFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
7972  {
7973  std::size_t seed = 0;
7974  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImage2DViewOf3DFeaturesEXT.sType );
7975  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImage2DViewOf3DFeaturesEXT.pNext );
7976  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImage2DViewOf3DFeaturesEXT.image2DViewOf3D );
7977  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImage2DViewOf3DFeaturesEXT.sampler2DViewOf3D );
7978  return seed;
7979  }
7980  };
7981 
7982  template <>
7983  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageCompressionControlFeaturesEXT>
7984  {
7985  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageCompressionControlFeaturesEXT const & physicalDeviceImageCompressionControlFeaturesEXT )
7986  const VULKAN_HPP_NOEXCEPT
7987  {
7988  std::size_t seed = 0;
7989  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageCompressionControlFeaturesEXT.sType );
7990  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageCompressionControlFeaturesEXT.pNext );
7991  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageCompressionControlFeaturesEXT.imageCompressionControl );
7992  return seed;
7993  }
7994  };
7995 
7996  template <>
7997  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT>
7998  {
7999  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT const &
8000  physicalDeviceImageCompressionControlSwapchainFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
8001  {
8002  std::size_t seed = 0;
8003  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageCompressionControlSwapchainFeaturesEXT.sType );
8004  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageCompressionControlSwapchainFeaturesEXT.pNext );
8005  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageCompressionControlSwapchainFeaturesEXT.imageCompressionControlSwapchain );
8006  return seed;
8007  }
8008  };
8009 
8010  template <>
8011  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageDrmFormatModifierInfoEXT>
8012  {
8013  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageDrmFormatModifierInfoEXT const & physicalDeviceImageDrmFormatModifierInfoEXT ) const
8014  VULKAN_HPP_NOEXCEPT
8015  {
8016  std::size_t seed = 0;
8017  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageDrmFormatModifierInfoEXT.sType );
8018  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageDrmFormatModifierInfoEXT.pNext );
8019  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageDrmFormatModifierInfoEXT.drmFormatModifier );
8020  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageDrmFormatModifierInfoEXT.sharingMode );
8021  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageDrmFormatModifierInfoEXT.queueFamilyIndexCount );
8022  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageDrmFormatModifierInfoEXT.pQueueFamilyIndices );
8023  return seed;
8024  }
8025  };
8026 
8027  template <>
8028  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2>
8029  {
8030  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 const & physicalDeviceImageFormatInfo2 ) const VULKAN_HPP_NOEXCEPT
8031  {
8032  std::size_t seed = 0;
8033  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageFormatInfo2.sType );
8034  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageFormatInfo2.pNext );
8035  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageFormatInfo2.format );
8036  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageFormatInfo2.type );
8037  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageFormatInfo2.tiling );
8038  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageFormatInfo2.usage );
8039  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageFormatInfo2.flags );
8040  return seed;
8041  }
8042  };
8043 
8044  template <>
8045  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessingFeaturesQCOM>
8046  {
8047  std::size_t
8048  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessingFeaturesQCOM const & physicalDeviceImageProcessingFeaturesQCOM ) const VULKAN_HPP_NOEXCEPT
8049  {
8050  std::size_t seed = 0;
8051  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingFeaturesQCOM.sType );
8052  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingFeaturesQCOM.pNext );
8053  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingFeaturesQCOM.textureSampleWeighted );
8054  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingFeaturesQCOM.textureBoxFilter );
8055  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingFeaturesQCOM.textureBlockMatch );
8056  return seed;
8057  }
8058  };
8059 
8060  template <>
8061  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessingPropertiesQCOM>
8062  {
8063  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessingPropertiesQCOM const & physicalDeviceImageProcessingPropertiesQCOM ) const
8064  VULKAN_HPP_NOEXCEPT
8065  {
8066  std::size_t seed = 0;
8067  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingPropertiesQCOM.sType );
8068  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingPropertiesQCOM.pNext );
8069  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingPropertiesQCOM.maxWeightFilterPhases );
8070  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingPropertiesQCOM.maxWeightFilterDimension );
8071  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingPropertiesQCOM.maxBlockMatchRegion );
8072  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingPropertiesQCOM.maxBoxFilterBlockSize );
8073  return seed;
8074  }
8075  };
8076 
8077  template <>
8078  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageRobustnessFeatures>
8079  {
8080  std::size_t
8081  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageRobustnessFeatures const & physicalDeviceImageRobustnessFeatures ) const VULKAN_HPP_NOEXCEPT
8082  {
8083  std::size_t seed = 0;
8084  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageRobustnessFeatures.sType );
8085  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageRobustnessFeatures.pNext );
8086  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageRobustnessFeatures.robustImageAccess );
8087  return seed;
8088  }
8089  };
8090 
8091  template <>
8092  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageViewImageFormatInfoEXT>
8093  {
8094  std::size_t
8095  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageViewImageFormatInfoEXT const & physicalDeviceImageViewImageFormatInfoEXT ) const VULKAN_HPP_NOEXCEPT
8096  {
8097  std::size_t seed = 0;
8098  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageViewImageFormatInfoEXT.sType );
8099  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageViewImageFormatInfoEXT.pNext );
8100  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageViewImageFormatInfoEXT.imageViewType );
8101  return seed;
8102  }
8103  };
8104 
8105  template <>
8106  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageViewMinLodFeaturesEXT>
8107  {
8108  std::size_t
8109  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageViewMinLodFeaturesEXT const & physicalDeviceImageViewMinLodFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
8110  {
8111  std::size_t seed = 0;
8112  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageViewMinLodFeaturesEXT.sType );
8113  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageViewMinLodFeaturesEXT.pNext );
8114  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageViewMinLodFeaturesEXT.minLod );
8115  return seed;
8116  }
8117  };
8118 
8119  template <>
8120  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImagelessFramebufferFeatures>
8121  {
8122  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImagelessFramebufferFeatures const & physicalDeviceImagelessFramebufferFeatures ) const
8123  VULKAN_HPP_NOEXCEPT
8124  {
8125  std::size_t seed = 0;
8126  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImagelessFramebufferFeatures.sType );
8127  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImagelessFramebufferFeatures.pNext );
8128  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImagelessFramebufferFeatures.imagelessFramebuffer );
8129  return seed;
8130  }
8131  };
8132 
8133  template <>
8134  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceIndexTypeUint8FeaturesEXT>
8135  {
8136  std::size_t
8137  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceIndexTypeUint8FeaturesEXT const & physicalDeviceIndexTypeUint8FeaturesEXT ) const VULKAN_HPP_NOEXCEPT
8138  {
8139  std::size_t seed = 0;
8140  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIndexTypeUint8FeaturesEXT.sType );
8141  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIndexTypeUint8FeaturesEXT.pNext );
8142  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIndexTypeUint8FeaturesEXT.indexTypeUint8 );
8143  return seed;
8144  }
8145  };
8146 
8147  template <>
8148  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceInheritedViewportScissorFeaturesNV>
8149  {
8150  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceInheritedViewportScissorFeaturesNV const & physicalDeviceInheritedViewportScissorFeaturesNV )
8151  const VULKAN_HPP_NOEXCEPT
8152  {
8153  std::size_t seed = 0;
8154  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInheritedViewportScissorFeaturesNV.sType );
8155  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInheritedViewportScissorFeaturesNV.pNext );
8156  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInheritedViewportScissorFeaturesNV.inheritedViewportScissor2D );
8157  return seed;
8158  }
8159  };
8160 
8161  template <>
8162  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceInlineUniformBlockFeatures>
8163  {
8164  std::size_t
8165  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceInlineUniformBlockFeatures const & physicalDeviceInlineUniformBlockFeatures ) const VULKAN_HPP_NOEXCEPT
8166  {
8167  std::size_t seed = 0;
8168  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockFeatures.sType );
8169  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockFeatures.pNext );
8170  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockFeatures.inlineUniformBlock );
8171  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockFeatures.descriptorBindingInlineUniformBlockUpdateAfterBind );
8172  return seed;
8173  }
8174  };
8175 
8176  template <>
8177  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceInlineUniformBlockProperties>
8178  {
8179  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceInlineUniformBlockProperties const & physicalDeviceInlineUniformBlockProperties ) const
8180  VULKAN_HPP_NOEXCEPT
8181  {
8182  std::size_t seed = 0;
8183  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockProperties.sType );
8184  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockProperties.pNext );
8185  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockProperties.maxInlineUniformBlockSize );
8186  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockProperties.maxPerStageDescriptorInlineUniformBlocks );
8187  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockProperties.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks );
8188  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockProperties.maxDescriptorSetInlineUniformBlocks );
8189  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockProperties.maxDescriptorSetUpdateAfterBindInlineUniformBlocks );
8190  return seed;
8191  }
8192  };
8193 
8194  template <>
8195  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceInvocationMaskFeaturesHUAWEI>
8196  {
8197  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceInvocationMaskFeaturesHUAWEI const & physicalDeviceInvocationMaskFeaturesHUAWEI ) const
8198  VULKAN_HPP_NOEXCEPT
8199  {
8200  std::size_t seed = 0;
8201  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInvocationMaskFeaturesHUAWEI.sType );
8202  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInvocationMaskFeaturesHUAWEI.pNext );
8203  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInvocationMaskFeaturesHUAWEI.invocationMask );
8204  return seed;
8205  }
8206  };
8207 
8208  template <>
8209  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLegacyDitheringFeaturesEXT>
8210  {
8211  std::size_t
8212  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLegacyDitheringFeaturesEXT const & physicalDeviceLegacyDitheringFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
8213  {
8214  std::size_t seed = 0;
8215  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyDitheringFeaturesEXT.sType );
8216  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyDitheringFeaturesEXT.pNext );
8217  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyDitheringFeaturesEXT.legacyDithering );
8218  return seed;
8219  }
8220  };
8221 
8222  template <>
8223  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLimits>
8224  {
8225  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLimits const & physicalDeviceLimits ) const VULKAN_HPP_NOEXCEPT
8226  {
8227  std::size_t seed = 0;
8228  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxImageDimension1D );
8229  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxImageDimension2D );
8230  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxImageDimension3D );
8231  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxImageDimensionCube );
8232  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxImageArrayLayers );
8233  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTexelBufferElements );
8234  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxUniformBufferRange );
8235  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxStorageBufferRange );
8236  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxPushConstantsSize );
8237  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxMemoryAllocationCount );
8238  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxSamplerAllocationCount );
8239  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.bufferImageGranularity );
8240  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.sparseAddressSpaceSize );
8241  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxBoundDescriptorSets );
8242  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxPerStageDescriptorSamplers );
8243  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxPerStageDescriptorUniformBuffers );
8244  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxPerStageDescriptorStorageBuffers );
8245  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxPerStageDescriptorSampledImages );
8246  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxPerStageDescriptorStorageImages );
8247  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxPerStageDescriptorInputAttachments );
8248  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxPerStageResources );
8249  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDescriptorSetSamplers );
8250  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDescriptorSetUniformBuffers );
8251  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDescriptorSetUniformBuffersDynamic );
8252  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDescriptorSetStorageBuffers );
8253  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDescriptorSetStorageBuffersDynamic );
8254  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDescriptorSetSampledImages );
8255  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDescriptorSetStorageImages );
8256  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDescriptorSetInputAttachments );
8257  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxVertexInputAttributes );
8258  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxVertexInputBindings );
8259  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxVertexInputAttributeOffset );
8260  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxVertexInputBindingStride );
8261  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxVertexOutputComponents );
8262  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTessellationGenerationLevel );
8263  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTessellationPatchSize );
8264  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTessellationControlPerVertexInputComponents );
8265  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTessellationControlPerVertexOutputComponents );
8266  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTessellationControlPerPatchOutputComponents );
8267  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTessellationControlTotalOutputComponents );
8268  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTessellationEvaluationInputComponents );
8269  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTessellationEvaluationOutputComponents );
8270  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxGeometryShaderInvocations );
8271  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxGeometryInputComponents );
8272  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxGeometryOutputComponents );
8273  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxGeometryOutputVertices );
8274  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxGeometryTotalOutputComponents );
8275  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxFragmentInputComponents );
8276  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxFragmentOutputAttachments );
8277  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxFragmentDualSrcAttachments );
8278  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxFragmentCombinedOutputResources );
8279  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxComputeSharedMemorySize );
8280  for ( size_t i = 0; i < 3; ++i )
8281  {
8282  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxComputeWorkGroupCount[i] );
8283  }
8284  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxComputeWorkGroupInvocations );
8285  for ( size_t i = 0; i < 3; ++i )
8286  {
8287  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxComputeWorkGroupSize[i] );
8288  }
8289  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.subPixelPrecisionBits );
8290  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.subTexelPrecisionBits );
8291  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.mipmapPrecisionBits );
8292  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDrawIndexedIndexValue );
8293  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDrawIndirectCount );
8294  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxSamplerLodBias );
8295  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxSamplerAnisotropy );
8296  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxViewports );
8297  for ( size_t i = 0; i < 2; ++i )
8298  {
8299  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxViewportDimensions[i] );
8300  }
8301  for ( size_t i = 0; i < 2; ++i )
8302  {
8303  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.viewportBoundsRange[i] );
8304  }
8305  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.viewportSubPixelBits );
8306  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.minMemoryMapAlignment );
8307  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.minTexelBufferOffsetAlignment );
8308  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.minUniformBufferOffsetAlignment );
8309  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.minStorageBufferOffsetAlignment );
8310  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.minTexelOffset );
8311  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTexelOffset );
8312  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.minTexelGatherOffset );
8313  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTexelGatherOffset );
8314  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.minInterpolationOffset );
8315  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxInterpolationOffset );
8316  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.subPixelInterpolationOffsetBits );
8317  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxFramebufferWidth );
8318  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxFramebufferHeight );
8319  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxFramebufferLayers );
8320  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.framebufferColorSampleCounts );
8321  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.framebufferDepthSampleCounts );
8322  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.framebufferStencilSampleCounts );
8323  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.framebufferNoAttachmentsSampleCounts );
8324  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxColorAttachments );
8325  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.sampledImageColorSampleCounts );
8326  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.sampledImageIntegerSampleCounts );
8327  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.sampledImageDepthSampleCounts );
8328  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.sampledImageStencilSampleCounts );
8329  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.storageImageSampleCounts );
8330  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxSampleMaskWords );
8331  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.timestampComputeAndGraphics );
8332  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.timestampPeriod );
8333  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxClipDistances );
8334  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxCullDistances );
8335  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxCombinedClipAndCullDistances );
8336  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.discreteQueuePriorities );
8337  for ( size_t i = 0; i < 2; ++i )
8338  {
8339  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.pointSizeRange[i] );
8340  }
8341  for ( size_t i = 0; i < 2; ++i )
8342  {
8343  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.lineWidthRange[i] );
8344  }
8345  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.pointSizeGranularity );
8346  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.lineWidthGranularity );
8347  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.strictLines );
8348  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.standardSampleLocations );
8349  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.optimalBufferCopyOffsetAlignment );
8350  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.optimalBufferCopyRowPitchAlignment );
8351  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.nonCoherentAtomSize );
8352  return seed;
8353  }
8354  };
8355 
8356  template <>
8357  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationFeaturesEXT>
8358  {
8359  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationFeaturesEXT const & physicalDeviceLineRasterizationFeaturesEXT ) const
8360  VULKAN_HPP_NOEXCEPT
8361  {
8362  std::size_t seed = 0;
8363  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeaturesEXT.sType );
8364  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeaturesEXT.pNext );
8365  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeaturesEXT.rectangularLines );
8366  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeaturesEXT.bresenhamLines );
8367  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeaturesEXT.smoothLines );
8368  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeaturesEXT.stippledRectangularLines );
8369  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeaturesEXT.stippledBresenhamLines );
8370  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeaturesEXT.stippledSmoothLines );
8371  return seed;
8372  }
8373  };
8374 
8375  template <>
8376  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationPropertiesEXT>
8377  {
8378  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationPropertiesEXT const & physicalDeviceLineRasterizationPropertiesEXT ) const
8379  VULKAN_HPP_NOEXCEPT
8380  {
8381  std::size_t seed = 0;
8382  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationPropertiesEXT.sType );
8383  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationPropertiesEXT.pNext );
8384  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationPropertiesEXT.lineSubPixelPrecisionBits );
8385  return seed;
8386  }
8387  };
8388 
8389  template <>
8390  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLinearColorAttachmentFeaturesNV>
8391  {
8392  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLinearColorAttachmentFeaturesNV const & physicalDeviceLinearColorAttachmentFeaturesNV ) const
8393  VULKAN_HPP_NOEXCEPT
8394  {
8395  std::size_t seed = 0;
8396  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLinearColorAttachmentFeaturesNV.sType );
8397  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLinearColorAttachmentFeaturesNV.pNext );
8398  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLinearColorAttachmentFeaturesNV.linearColorAttachment );
8399  return seed;
8400  }
8401  };
8402 
8403  template <>
8404  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance3Properties>
8405  {
8406  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance3Properties const & physicalDeviceMaintenance3Properties ) const VULKAN_HPP_NOEXCEPT
8407  {
8408  std::size_t seed = 0;
8409  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance3Properties.sType );
8410  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance3Properties.pNext );
8411  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance3Properties.maxPerSetDescriptors );
8412  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance3Properties.maxMemoryAllocationSize );
8413  return seed;
8414  }
8415  };
8416 
8417  template <>
8418  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance4Features>
8419  {
8420  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance4Features const & physicalDeviceMaintenance4Features ) const VULKAN_HPP_NOEXCEPT
8421  {
8422  std::size_t seed = 0;
8423  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance4Features.sType );
8424  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance4Features.pNext );
8425  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance4Features.maintenance4 );
8426  return seed;
8427  }
8428  };
8429 
8430  template <>
8431  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance4Properties>
8432  {
8433  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance4Properties const & physicalDeviceMaintenance4Properties ) const VULKAN_HPP_NOEXCEPT
8434  {
8435  std::size_t seed = 0;
8436  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance4Properties.sType );
8437  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance4Properties.pNext );
8438  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance4Properties.maxBufferSize );
8439  return seed;
8440  }
8441  };
8442 
8443  template <>
8444  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryBudgetPropertiesEXT>
8445  {
8446  std::size_t
8447  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryBudgetPropertiesEXT const & physicalDeviceMemoryBudgetPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
8448  {
8449  std::size_t seed = 0;
8450  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryBudgetPropertiesEXT.sType );
8451  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryBudgetPropertiesEXT.pNext );
8452  for ( size_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i )
8453  {
8454  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryBudgetPropertiesEXT.heapBudget[i] );
8455  }
8456  for ( size_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i )
8457  {
8458  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryBudgetPropertiesEXT.heapUsage[i] );
8459  }
8460  return seed;
8461  }
8462  };
8463 
8464  template <>
8465  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryDecompressionFeaturesNV>
8466  {
8467  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryDecompressionFeaturesNV const & physicalDeviceMemoryDecompressionFeaturesNV ) const
8468  VULKAN_HPP_NOEXCEPT
8469  {
8470  std::size_t seed = 0;
8471  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionFeaturesNV.sType );
8472  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionFeaturesNV.pNext );
8473  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionFeaturesNV.memoryDecompression );
8474  return seed;
8475  }
8476  };
8477 
8478  template <>
8479  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryDecompressionPropertiesNV>
8480  {
8481  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryDecompressionPropertiesNV const & physicalDeviceMemoryDecompressionPropertiesNV ) const
8482  VULKAN_HPP_NOEXCEPT
8483  {
8484  std::size_t seed = 0;
8485  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionPropertiesNV.sType );
8486  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionPropertiesNV.pNext );
8487  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionPropertiesNV.decompressionMethods );
8488  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionPropertiesNV.maxDecompressionIndirectCount );
8489  return seed;
8490  }
8491  };
8492 
8493  template <>
8494  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryPriorityFeaturesEXT>
8495  {
8496  std::size_t
8497  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryPriorityFeaturesEXT const & physicalDeviceMemoryPriorityFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
8498  {
8499  std::size_t seed = 0;
8500  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryPriorityFeaturesEXT.sType );
8501  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryPriorityFeaturesEXT.pNext );
8502  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryPriorityFeaturesEXT.memoryPriority );
8503  return seed;
8504  }
8505  };
8506 
8507  template <>
8508  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties>
8509  {
8510  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties const & physicalDeviceMemoryProperties ) const VULKAN_HPP_NOEXCEPT
8511  {
8512  std::size_t seed = 0;
8513  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryProperties.memoryTypeCount );
8514  for ( size_t i = 0; i < VK_MAX_MEMORY_TYPES; ++i )
8515  {
8516  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryProperties.memoryTypes[i] );
8517  }
8518  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryProperties.memoryHeapCount );
8519  for ( size_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i )
8520  {
8521  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryProperties.memoryHeaps[i] );
8522  }
8523  return seed;
8524  }
8525  };
8526 
8527  template <>
8528  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2>
8529  {
8530  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 const & physicalDeviceMemoryProperties2 ) const VULKAN_HPP_NOEXCEPT
8531  {
8532  std::size_t seed = 0;
8533  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryProperties2.sType );
8534  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryProperties2.pNext );
8535  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryProperties2.memoryProperties );
8536  return seed;
8537  }
8538  };
8539 
8540  template <>
8541  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderFeaturesEXT>
8542  {
8543  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderFeaturesEXT const & physicalDeviceMeshShaderFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
8544  {
8545  std::size_t seed = 0;
8546  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesEXT.sType );
8547  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesEXT.pNext );
8548  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesEXT.taskShader );
8549  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesEXT.meshShader );
8550  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesEXT.multiviewMeshShader );
8551  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesEXT.primitiveFragmentShadingRateMeshShader );
8552  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesEXT.meshShaderQueries );
8553  return seed;
8554  }
8555  };
8556 
8557  template <>
8558  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderFeaturesNV>
8559  {
8560  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderFeaturesNV const & physicalDeviceMeshShaderFeaturesNV ) const VULKAN_HPP_NOEXCEPT
8561  {
8562  std::size_t seed = 0;
8563  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesNV.sType );
8564  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesNV.pNext );
8565  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesNV.taskShader );
8566  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesNV.meshShader );
8567  return seed;
8568  }
8569  };
8570 
8571  template <>
8572  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderPropertiesEXT>
8573  {
8574  std::size_t
8575  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderPropertiesEXT const & physicalDeviceMeshShaderPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
8576  {
8577  std::size_t seed = 0;
8578  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.sType );
8579  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.pNext );
8580  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxTaskWorkGroupTotalCount );
8581  for ( size_t i = 0; i < 3; ++i )
8582  {
8583  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxTaskWorkGroupCount[i] );
8584  }
8585  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxTaskWorkGroupInvocations );
8586  for ( size_t i = 0; i < 3; ++i )
8587  {
8588  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxTaskWorkGroupSize[i] );
8589  }
8590  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxTaskPayloadSize );
8591  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxTaskSharedMemorySize );
8592  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxTaskPayloadAndSharedMemorySize );
8593  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshWorkGroupTotalCount );
8594  for ( size_t i = 0; i < 3; ++i )
8595  {
8596  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshWorkGroupCount[i] );
8597  }
8598  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshWorkGroupInvocations );
8599  for ( size_t i = 0; i < 3; ++i )
8600  {
8601  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshWorkGroupSize[i] );
8602  }
8603  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshSharedMemorySize );
8604  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshPayloadAndSharedMemorySize );
8605  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshOutputMemorySize );
8606  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshPayloadAndOutputMemorySize );
8607  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshOutputComponents );
8608  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshOutputVertices );
8609  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshOutputPrimitives );
8610  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshOutputLayers );
8611  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshMultiviewViewCount );
8612  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.meshOutputPerVertexGranularity );
8613  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.meshOutputPerPrimitiveGranularity );
8614  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxPreferredTaskWorkGroupInvocations );
8615  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxPreferredMeshWorkGroupInvocations );
8616  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.prefersLocalInvocationVertexOutput );
8617  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.prefersLocalInvocationPrimitiveOutput );
8618  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.prefersCompactVertexOutput );
8619  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.prefersCompactPrimitiveOutput );
8620  return seed;
8621  }
8622  };
8623 
8624  template <>
8625  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderPropertiesNV>
8626  {
8627  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderPropertiesNV const & physicalDeviceMeshShaderPropertiesNV ) const VULKAN_HPP_NOEXCEPT
8628  {
8629  std::size_t seed = 0;
8630  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.sType );
8631  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.pNext );
8632  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxDrawMeshTasksCount );
8633  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxTaskWorkGroupInvocations );
8634  for ( size_t i = 0; i < 3; ++i )
8635  {
8636  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxTaskWorkGroupSize[i] );
8637  }
8638  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxTaskTotalMemorySize );
8639  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxTaskOutputCount );
8640  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxMeshWorkGroupInvocations );
8641  for ( size_t i = 0; i < 3; ++i )
8642  {
8643  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxMeshWorkGroupSize[i] );
8644  }
8645  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxMeshTotalMemorySize );
8646  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxMeshOutputVertices );
8647  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxMeshOutputPrimitives );
8648  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxMeshMultiviewViewCount );
8649  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.meshOutputPerVertexGranularity );
8650  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.meshOutputPerPrimitiveGranularity );
8651  return seed;
8652  }
8653  };
8654 
8655  template <>
8656  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiDrawFeaturesEXT>
8657  {
8658  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiDrawFeaturesEXT const & physicalDeviceMultiDrawFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
8659  {
8660  std::size_t seed = 0;
8661  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiDrawFeaturesEXT.sType );
8662  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiDrawFeaturesEXT.pNext );
8663  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiDrawFeaturesEXT.multiDraw );
8664  return seed;
8665  }
8666  };
8667 
8668  template <>
8669  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiDrawPropertiesEXT>
8670  {
8671  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiDrawPropertiesEXT const & physicalDeviceMultiDrawPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
8672  {
8673  std::size_t seed = 0;
8674  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiDrawPropertiesEXT.sType );
8675  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiDrawPropertiesEXT.pNext );
8676  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiDrawPropertiesEXT.maxMultiDrawCount );
8677  return seed;
8678  }
8679  };
8680 
8681  template <>
8682  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT>
8683  {
8684  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT const &
8685  physicalDeviceMultisampledRenderToSingleSampledFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
8686  {
8687  std::size_t seed = 0;
8688  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultisampledRenderToSingleSampledFeaturesEXT.sType );
8689  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultisampledRenderToSingleSampledFeaturesEXT.pNext );
8690  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultisampledRenderToSingleSampledFeaturesEXT.multisampledRenderToSingleSampled );
8691  return seed;
8692  }
8693  };
8694 
8695  template <>
8696  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewFeatures>
8697  {
8698  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewFeatures const & physicalDeviceMultiviewFeatures ) const VULKAN_HPP_NOEXCEPT
8699  {
8700  std::size_t seed = 0;
8701  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewFeatures.sType );
8702  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewFeatures.pNext );
8703  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewFeatures.multiview );
8704  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewFeatures.multiviewGeometryShader );
8705  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewFeatures.multiviewTessellationShader );
8706  return seed;
8707  }
8708  };
8709 
8710  template <>
8711  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX>
8712  {
8713  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const &
8714  physicalDeviceMultiviewPerViewAttributesPropertiesNVX ) const VULKAN_HPP_NOEXCEPT
8715  {
8716  std::size_t seed = 0;
8717  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewAttributesPropertiesNVX.sType );
8718  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewAttributesPropertiesNVX.pNext );
8719  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewAttributesPropertiesNVX.perViewPositionAllComponents );
8720  return seed;
8721  }
8722  };
8723 
8724  template <>
8725  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM>
8726  {
8727  std::size_t
8728  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM const & physicalDeviceMultiviewPerViewViewportsFeaturesQCOM ) const
8729  VULKAN_HPP_NOEXCEPT
8730  {
8731  std::size_t seed = 0;
8732  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewViewportsFeaturesQCOM.sType );
8733  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewViewportsFeaturesQCOM.pNext );
8734  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewViewportsFeaturesQCOM.multiviewPerViewViewports );
8735  return seed;
8736  }
8737  };
8738 
8739  template <>
8740  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewProperties>
8741  {
8742  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewProperties const & physicalDeviceMultiviewProperties ) const VULKAN_HPP_NOEXCEPT
8743  {
8744  std::size_t seed = 0;
8745  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewProperties.sType );
8746  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewProperties.pNext );
8747  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewProperties.maxMultiviewViewCount );
8748  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewProperties.maxMultiviewInstanceIndex );
8749  return seed;
8750  }
8751  };
8752 
8753  template <>
8754  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMutableDescriptorTypeFeaturesEXT>
8755  {
8756  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMutableDescriptorTypeFeaturesEXT const & physicalDeviceMutableDescriptorTypeFeaturesEXT ) const
8757  VULKAN_HPP_NOEXCEPT
8758  {
8759  std::size_t seed = 0;
8760  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMutableDescriptorTypeFeaturesEXT.sType );
8761  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMutableDescriptorTypeFeaturesEXT.pNext );
8762  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMutableDescriptorTypeFeaturesEXT.mutableDescriptorType );
8763  return seed;
8764  }
8765  };
8766 
8767  template <>
8768  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceNonSeamlessCubeMapFeaturesEXT>
8769  {
8770  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceNonSeamlessCubeMapFeaturesEXT const & physicalDeviceNonSeamlessCubeMapFeaturesEXT ) const
8771  VULKAN_HPP_NOEXCEPT
8772  {
8773  std::size_t seed = 0;
8774  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNonSeamlessCubeMapFeaturesEXT.sType );
8775  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNonSeamlessCubeMapFeaturesEXT.pNext );
8776  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNonSeamlessCubeMapFeaturesEXT.nonSeamlessCubeMap );
8777  return seed;
8778  }
8779  };
8780 
8781  template <>
8782  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceOpacityMicromapFeaturesEXT>
8783  {
8784  std::size_t
8785  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceOpacityMicromapFeaturesEXT const & physicalDeviceOpacityMicromapFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
8786  {
8787  std::size_t seed = 0;
8788  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapFeaturesEXT.sType );
8789  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapFeaturesEXT.pNext );
8790  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapFeaturesEXT.micromap );
8791  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapFeaturesEXT.micromapCaptureReplay );
8792  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapFeaturesEXT.micromapHostCommands );
8793  return seed;
8794  }
8795  };
8796 
8797  template <>
8798  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceOpacityMicromapPropertiesEXT>
8799  {
8800  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceOpacityMicromapPropertiesEXT const & physicalDeviceOpacityMicromapPropertiesEXT ) const
8801  VULKAN_HPP_NOEXCEPT
8802  {
8803  std::size_t seed = 0;
8804  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapPropertiesEXT.sType );
8805  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapPropertiesEXT.pNext );
8806  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapPropertiesEXT.maxOpacity2StateSubdivisionLevel );
8807  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapPropertiesEXT.maxOpacity4StateSubdivisionLevel );
8808  return seed;
8809  }
8810  };
8811 
8812  template <>
8813  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceOpticalFlowFeaturesNV>
8814  {
8815  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceOpticalFlowFeaturesNV const & physicalDeviceOpticalFlowFeaturesNV ) const VULKAN_HPP_NOEXCEPT
8816  {
8817  std::size_t seed = 0;
8818  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowFeaturesNV.sType );
8819  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowFeaturesNV.pNext );
8820  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowFeaturesNV.opticalFlow );
8821  return seed;
8822  }
8823  };
8824 
8825  template <>
8826  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceOpticalFlowPropertiesNV>
8827  {
8828  std::size_t
8829  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceOpticalFlowPropertiesNV const & physicalDeviceOpticalFlowPropertiesNV ) const VULKAN_HPP_NOEXCEPT
8830  {
8831  std::size_t seed = 0;
8832  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.sType );
8833  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.pNext );
8834  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.supportedOutputGridSizes );
8835  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.supportedHintGridSizes );
8836  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.hintSupported );
8837  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.costSupported );
8838  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.bidirectionalFlowSupported );
8839  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.globalFlowSupported );
8840  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.minWidth );
8841  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.minHeight );
8842  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.maxWidth );
8843  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.maxHeight );
8844  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.maxNumRegionsOfInterest );
8845  return seed;
8846  }
8847  };
8848 
8849  template <>
8850  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePCIBusInfoPropertiesEXT>
8851  {
8852  std::size_t
8853  operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePCIBusInfoPropertiesEXT const & physicalDevicePCIBusInfoPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
8854  {
8855  std::size_t seed = 0;
8856  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePCIBusInfoPropertiesEXT.sType );
8857  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePCIBusInfoPropertiesEXT.pNext );
8858  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePCIBusInfoPropertiesEXT.pciDomain );
8859  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePCIBusInfoPropertiesEXT.pciBus );
8860  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePCIBusInfoPropertiesEXT.pciDevice );
8861  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePCIBusInfoPropertiesEXT.pciFunction );
8862  return seed;
8863  }
8864  };
8865 
8866  template <>
8867  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT>
8868  {
8869  std::size_t
8870  operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT const & physicalDevicePageableDeviceLocalMemoryFeaturesEXT ) const
8871  VULKAN_HPP_NOEXCEPT
8872  {
8873  std::size_t seed = 0;
8874  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePageableDeviceLocalMemoryFeaturesEXT.sType );
8875  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePageableDeviceLocalMemoryFeaturesEXT.pNext );
8876  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePageableDeviceLocalMemoryFeaturesEXT.pageableDeviceLocalMemory );
8877  return seed;
8878  }
8879  };
8880 
8881  template <>
8882  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceQueryFeaturesKHR>
8883  {
8884  std::size_t
8885  operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceQueryFeaturesKHR const & physicalDevicePerformanceQueryFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
8886  {
8887  std::size_t seed = 0;
8888  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceQueryFeaturesKHR.sType );
8889  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceQueryFeaturesKHR.pNext );
8890  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceQueryFeaturesKHR.performanceCounterQueryPools );
8891  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceQueryFeaturesKHR.performanceCounterMultipleQueryPools );
8892  return seed;
8893  }
8894  };
8895 
8896  template <>
8897  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceQueryPropertiesKHR>
8898  {
8899  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceQueryPropertiesKHR const & physicalDevicePerformanceQueryPropertiesKHR ) const
8900  VULKAN_HPP_NOEXCEPT
8901  {
8902  std::size_t seed = 0;
8903  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceQueryPropertiesKHR.sType );
8904  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceQueryPropertiesKHR.pNext );
8905  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceQueryPropertiesKHR.allowCommandBufferQueryCopies );
8906  return seed;
8907  }
8908  };
8909 
8910  template <>
8911  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineCreationCacheControlFeatures>
8912  {
8913  std::size_t
8914  operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineCreationCacheControlFeatures const & physicalDevicePipelineCreationCacheControlFeatures ) const
8915  VULKAN_HPP_NOEXCEPT
8916  {
8917  std::size_t seed = 0;
8918  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineCreationCacheControlFeatures.sType );
8919  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineCreationCacheControlFeatures.pNext );
8920  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineCreationCacheControlFeatures.pipelineCreationCacheControl );
8921  return seed;
8922  }
8923  };
8924 
8925  template <>
8926  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR>
8927  {
8928  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR const &
8929  physicalDevicePipelineExecutablePropertiesFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
8930  {
8931  std::size_t seed = 0;
8932  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineExecutablePropertiesFeaturesKHR.sType );
8933  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineExecutablePropertiesFeaturesKHR.pNext );
8934  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineExecutablePropertiesFeaturesKHR.pipelineExecutableInfo );
8935  return seed;
8936  }
8937  };
8938 
8939  template <>
8940  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelinePropertiesFeaturesEXT>
8941  {
8942  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelinePropertiesFeaturesEXT const & physicalDevicePipelinePropertiesFeaturesEXT ) const
8943  VULKAN_HPP_NOEXCEPT
8944  {
8945  std::size_t seed = 0;
8946  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelinePropertiesFeaturesEXT.sType );
8947  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelinePropertiesFeaturesEXT.pNext );
8948  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelinePropertiesFeaturesEXT.pipelinePropertiesIdentifier );
8949  return seed;
8950  }
8951  };
8952 
8953  template <>
8954  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineProtectedAccessFeaturesEXT>
8955  {
8956  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineProtectedAccessFeaturesEXT const & physicalDevicePipelineProtectedAccessFeaturesEXT )
8957  const VULKAN_HPP_NOEXCEPT
8958  {
8959  std::size_t seed = 0;
8960  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineProtectedAccessFeaturesEXT.sType );
8961  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineProtectedAccessFeaturesEXT.pNext );
8962  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineProtectedAccessFeaturesEXT.pipelineProtectedAccess );
8963  return seed;
8964  }
8965  };
8966 
8967  template <>
8968  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineRobustnessFeaturesEXT>
8969  {
8970  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineRobustnessFeaturesEXT const & physicalDevicePipelineRobustnessFeaturesEXT ) const
8971  VULKAN_HPP_NOEXCEPT
8972  {
8973  std::size_t seed = 0;
8974  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineRobustnessFeaturesEXT.sType );
8975  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineRobustnessFeaturesEXT.pNext );
8976  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineRobustnessFeaturesEXT.pipelineRobustness );
8977  return seed;
8978  }
8979  };
8980 
8981  template <>
8982  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineRobustnessPropertiesEXT>
8983  {
8984  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineRobustnessPropertiesEXT const & physicalDevicePipelineRobustnessPropertiesEXT ) const
8985  VULKAN_HPP_NOEXCEPT
8986  {
8987  std::size_t seed = 0;
8988  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineRobustnessPropertiesEXT.sType );
8989  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineRobustnessPropertiesEXT.pNext );
8990  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineRobustnessPropertiesEXT.defaultRobustnessStorageBuffers );
8991  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineRobustnessPropertiesEXT.defaultRobustnessUniformBuffers );
8992  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineRobustnessPropertiesEXT.defaultRobustnessVertexInputs );
8993  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineRobustnessPropertiesEXT.defaultRobustnessImages );
8994  return seed;
8995  }
8996  };
8997 
8998  template <>
8999  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePointClippingProperties>
9000  {
9001  std::size_t
9002  operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePointClippingProperties const & physicalDevicePointClippingProperties ) const VULKAN_HPP_NOEXCEPT
9003  {
9004  std::size_t seed = 0;
9005  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePointClippingProperties.sType );
9006  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePointClippingProperties.pNext );
9007  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePointClippingProperties.pointClippingBehavior );
9008  return seed;
9009  }
9010  };
9011 
9012 # if defined( VK_ENABLE_BETA_EXTENSIONS )
9013  template <>
9014  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePortabilitySubsetFeaturesKHR>
9015  {
9016  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePortabilitySubsetFeaturesKHR const & physicalDevicePortabilitySubsetFeaturesKHR ) const
9017  VULKAN_HPP_NOEXCEPT
9018  {
9019  std::size_t seed = 0;
9020  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.sType );
9021  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.pNext );
9022  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.constantAlphaColorBlendFactors );
9023  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.events );
9024  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.imageViewFormatReinterpretation );
9025  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.imageViewFormatSwizzle );
9026  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.imageView2DOn3DImage );
9027  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.multisampleArrayImage );
9028  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.mutableComparisonSamplers );
9029  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.pointPolygons );
9030  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.samplerMipLodBias );
9031  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.separateStencilMaskRef );
9032  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.shaderSampleRateInterpolationFunctions );
9033  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.tessellationIsolines );
9034  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.tessellationPointMode );
9035  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.triangleFans );
9036  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.vertexAttributeAccessBeyondStride );
9037  return seed;
9038  }
9039  };
9040 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
9041 
9042 # if defined( VK_ENABLE_BETA_EXTENSIONS )
9043  template <>
9044  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePortabilitySubsetPropertiesKHR>
9045  {
9046  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePortabilitySubsetPropertiesKHR const & physicalDevicePortabilitySubsetPropertiesKHR ) const
9047  VULKAN_HPP_NOEXCEPT
9048  {
9049  std::size_t seed = 0;
9050  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetPropertiesKHR.sType );
9051  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetPropertiesKHR.pNext );
9052  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetPropertiesKHR.minVertexInputBindingStrideAlignment );
9053  return seed;
9054  }
9055  };
9056 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
9057 
9058  template <>
9059  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePresentBarrierFeaturesNV>
9060  {
9061  std::size_t
9062  operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePresentBarrierFeaturesNV const & physicalDevicePresentBarrierFeaturesNV ) const VULKAN_HPP_NOEXCEPT
9063  {
9064  std::size_t seed = 0;
9065  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentBarrierFeaturesNV.sType );
9066  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentBarrierFeaturesNV.pNext );
9067  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentBarrierFeaturesNV.presentBarrier );
9068  return seed;
9069  }
9070  };
9071 
9072  template <>
9073  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePresentIdFeaturesKHR>
9074  {
9075  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePresentIdFeaturesKHR const & physicalDevicePresentIdFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
9076  {
9077  std::size_t seed = 0;
9078  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentIdFeaturesKHR.sType );
9079  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentIdFeaturesKHR.pNext );
9080  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentIdFeaturesKHR.presentId );
9081  return seed;
9082  }
9083  };
9084 
9085  template <>
9086  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePresentWaitFeaturesKHR>
9087  {
9088  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePresentWaitFeaturesKHR const & physicalDevicePresentWaitFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
9089  {
9090  std::size_t seed = 0;
9091  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentWaitFeaturesKHR.sType );
9092  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentWaitFeaturesKHR.pNext );
9093  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentWaitFeaturesKHR.presentWait );
9094  return seed;
9095  }
9096  };
9097 
9098  template <>
9099  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT>
9100  {
9101  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT const &
9102  physicalDevicePrimitiveTopologyListRestartFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
9103  {
9104  std::size_t seed = 0;
9105  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrimitiveTopologyListRestartFeaturesEXT.sType );
9106  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrimitiveTopologyListRestartFeaturesEXT.pNext );
9107  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrimitiveTopologyListRestartFeaturesEXT.primitiveTopologyListRestart );
9108  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrimitiveTopologyListRestartFeaturesEXT.primitiveTopologyPatchListRestart );
9109  return seed;
9110  }
9111  };
9112 
9113  template <>
9114  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT>
9115  {
9116  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT const & physicalDevicePrimitivesGeneratedQueryFeaturesEXT )
9117  const VULKAN_HPP_NOEXCEPT
9118  {
9119  std::size_t seed = 0;
9120  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrimitivesGeneratedQueryFeaturesEXT.sType );
9121  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrimitivesGeneratedQueryFeaturesEXT.pNext );
9122  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrimitivesGeneratedQueryFeaturesEXT.primitivesGeneratedQuery );
9123  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrimitivesGeneratedQueryFeaturesEXT.primitivesGeneratedQueryWithRasterizerDiscard );
9124  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrimitivesGeneratedQueryFeaturesEXT.primitivesGeneratedQueryWithNonZeroStreams );
9125  return seed;
9126  }
9127  };
9128 
9129  template <>
9130  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePrivateDataFeatures>
9131  {
9132  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePrivateDataFeatures const & physicalDevicePrivateDataFeatures ) const VULKAN_HPP_NOEXCEPT
9133  {
9134  std::size_t seed = 0;
9135  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrivateDataFeatures.sType );
9136  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrivateDataFeatures.pNext );
9137  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrivateDataFeatures.privateData );
9138  return seed;
9139  }
9140  };
9141 
9142  template <>
9143  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseProperties>
9144  {
9145  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseProperties const & physicalDeviceSparseProperties ) const VULKAN_HPP_NOEXCEPT
9146  {
9147  std::size_t seed = 0;
9148  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseProperties.residencyStandard2DBlockShape );
9149  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseProperties.residencyStandard2DMultisampleBlockShape );
9150  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseProperties.residencyStandard3DBlockShape );
9151  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseProperties.residencyAlignedMipSize );
9152  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseProperties.residencyNonResidentStrict );
9153  return seed;
9154  }
9155  };
9156 
9157  template <>
9158  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties>
9159  {
9160  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties const & physicalDeviceProperties ) const VULKAN_HPP_NOEXCEPT
9161  {
9162  std::size_t seed = 0;
9163  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.apiVersion );
9164  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.driverVersion );
9165  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.vendorID );
9166  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.deviceID );
9167  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.deviceType );
9168  for ( size_t i = 0; i < VK_MAX_PHYSICAL_DEVICE_NAME_SIZE; ++i )
9169  {
9170  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.deviceName[i] );
9171  }
9172  for ( size_t i = 0; i < VK_UUID_SIZE; ++i )
9173  {
9174  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.pipelineCacheUUID[i] );
9175  }
9176  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.limits );
9177  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.sparseProperties );
9178  return seed;
9179  }
9180  };
9181 
9182  template <>
9183  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2>
9184  {
9185  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 const & physicalDeviceProperties2 ) const VULKAN_HPP_NOEXCEPT
9186  {
9187  std::size_t seed = 0;
9188  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties2.sType );
9189  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties2.pNext );
9190  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties2.properties );
9191  return seed;
9192  }
9193  };
9194 
9195  template <>
9196  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceProtectedMemoryFeatures>
9197  {
9198  std::size_t
9199  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProtectedMemoryFeatures const & physicalDeviceProtectedMemoryFeatures ) const VULKAN_HPP_NOEXCEPT
9200  {
9201  std::size_t seed = 0;
9202  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProtectedMemoryFeatures.sType );
9203  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProtectedMemoryFeatures.pNext );
9204  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProtectedMemoryFeatures.protectedMemory );
9205  return seed;
9206  }
9207  };
9208 
9209  template <>
9210  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceProtectedMemoryProperties>
9211  {
9212  std::size_t
9213  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProtectedMemoryProperties const & physicalDeviceProtectedMemoryProperties ) const VULKAN_HPP_NOEXCEPT
9214  {
9215  std::size_t seed = 0;
9216  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProtectedMemoryProperties.sType );
9217  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProtectedMemoryProperties.pNext );
9218  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProtectedMemoryProperties.protectedNoFault );
9219  return seed;
9220  }
9221  };
9222 
9223  template <>
9224  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceProvokingVertexFeaturesEXT>
9225  {
9226  std::size_t
9227  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProvokingVertexFeaturesEXT const & physicalDeviceProvokingVertexFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
9228  {
9229  std::size_t seed = 0;
9230  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProvokingVertexFeaturesEXT.sType );
9231  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProvokingVertexFeaturesEXT.pNext );
9232  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProvokingVertexFeaturesEXT.provokingVertexLast );
9233  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProvokingVertexFeaturesEXT.transformFeedbackPreservesProvokingVertex );
9234  return seed;
9235  }
9236  };
9237 
9238  template <>
9239  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceProvokingVertexPropertiesEXT>
9240  {
9241  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProvokingVertexPropertiesEXT const & physicalDeviceProvokingVertexPropertiesEXT ) const
9242  VULKAN_HPP_NOEXCEPT
9243  {
9244  std::size_t seed = 0;
9245  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProvokingVertexPropertiesEXT.sType );
9246  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProvokingVertexPropertiesEXT.pNext );
9247  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProvokingVertexPropertiesEXT.provokingVertexModePerPipeline );
9248  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProvokingVertexPropertiesEXT.transformFeedbackPreservesTriangleFanProvokingVertex );
9249  return seed;
9250  }
9251  };
9252 
9253  template <>
9254  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePushDescriptorPropertiesKHR>
9255  {
9256  std::size_t
9257  operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePushDescriptorPropertiesKHR const & physicalDevicePushDescriptorPropertiesKHR ) const VULKAN_HPP_NOEXCEPT
9258  {
9259  std::size_t seed = 0;
9260  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePushDescriptorPropertiesKHR.sType );
9261  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePushDescriptorPropertiesKHR.pNext );
9262  VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePushDescriptorPropertiesKHR.maxPushDescriptors );
9263  return seed;
9264  }
9265  };
9266 
9267  template <>
9268  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRGBA10X6FormatsFeaturesEXT>
9269  {
9270  std::size_t
9271  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRGBA10X6FormatsFeaturesEXT const & physicalDeviceRGBA10X6FormatsFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
9272  {
9273  std::size_t seed = 0;
9274  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRGBA10X6FormatsFeaturesEXT.sType );
9275  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRGBA10X6FormatsFeaturesEXT.pNext );
9276  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRGBA10X6FormatsFeaturesEXT.formatRgba10x6WithoutYCbCrSampler );
9277  return seed;
9278  }
9279  };
9280 
9281  template <>
9282  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT>
9283  {
9284  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT const &
9285  physicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
9286  {
9287  std::size_t seed = 0;
9288  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT.sType );
9289  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT.pNext );
9290  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT.rasterizationOrderColorAttachmentAccess );
9291  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT.rasterizationOrderDepthAttachmentAccess );
9292  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT.rasterizationOrderStencilAttachmentAccess );
9293  return seed;
9294  }
9295  };
9296 
9297  template <>
9298  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayQueryFeaturesKHR>
9299  {
9300  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayQueryFeaturesKHR const & physicalDeviceRayQueryFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
9301  {
9302  std::size_t seed = 0;
9303  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayQueryFeaturesKHR.sType );
9304  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayQueryFeaturesKHR.pNext );
9305  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayQueryFeaturesKHR.rayQuery );
9306  return seed;
9307  }
9308  };
9309 
9310  template <>
9311  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderFeaturesNV>
9312  {
9313  std::size_t
9314  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderFeaturesNV const & physicalDeviceRayTracingInvocationReorderFeaturesNV ) const
9315  VULKAN_HPP_NOEXCEPT
9316  {
9317  std::size_t seed = 0;
9318  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderFeaturesNV.sType );
9319  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderFeaturesNV.pNext );
9320  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderFeaturesNV.rayTracingInvocationReorder );
9321  return seed;
9322  }
9323  };
9324 
9325  template <>
9326  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderPropertiesNV>
9327  {
9328  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderPropertiesNV const &
9329  physicalDeviceRayTracingInvocationReorderPropertiesNV ) const VULKAN_HPP_NOEXCEPT
9330  {
9331  std::size_t seed = 0;
9332  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderPropertiesNV.sType );
9333  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderPropertiesNV.pNext );
9334  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderPropertiesNV.rayTracingInvocationReorderReorderingHint );
9335  return seed;
9336  }
9337  };
9338 
9339  template <>
9340  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingMaintenance1FeaturesKHR>
9341  {
9342  std::size_t operator()(
9343  VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingMaintenance1FeaturesKHR const & physicalDeviceRayTracingMaintenance1FeaturesKHR ) const VULKAN_HPP_NOEXCEPT
9344  {
9345  std::size_t seed = 0;
9346  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingMaintenance1FeaturesKHR.sType );
9347  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingMaintenance1FeaturesKHR.pNext );
9348  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingMaintenance1FeaturesKHR.rayTracingMaintenance1 );
9349  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingMaintenance1FeaturesKHR.rayTracingPipelineTraceRaysIndirect2 );
9350  return seed;
9351  }
9352  };
9353 
9354  template <>
9355  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingMotionBlurFeaturesNV>
9356  {
9357  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingMotionBlurFeaturesNV const & physicalDeviceRayTracingMotionBlurFeaturesNV ) const
9358  VULKAN_HPP_NOEXCEPT
9359  {
9360  std::size_t seed = 0;
9361  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingMotionBlurFeaturesNV.sType );
9362  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingMotionBlurFeaturesNV.pNext );
9363  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingMotionBlurFeaturesNV.rayTracingMotionBlur );
9364  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingMotionBlurFeaturesNV.rayTracingMotionBlurPipelineTraceRaysIndirect );
9365  return seed;
9366  }
9367  };
9368 
9369  template <>
9370  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPipelineFeaturesKHR>
9371  {
9372  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPipelineFeaturesKHR const & physicalDeviceRayTracingPipelineFeaturesKHR ) const
9373  VULKAN_HPP_NOEXCEPT
9374  {
9375  std::size_t seed = 0;
9376  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelineFeaturesKHR.sType );
9377  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelineFeaturesKHR.pNext );
9378  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelineFeaturesKHR.rayTracingPipeline );
9379  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelineFeaturesKHR.rayTracingPipelineShaderGroupHandleCaptureReplay );
9380  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelineFeaturesKHR.rayTracingPipelineShaderGroupHandleCaptureReplayMixed );
9381  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelineFeaturesKHR.rayTracingPipelineTraceRaysIndirect );
9382  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelineFeaturesKHR.rayTraversalPrimitiveCulling );
9383  return seed;
9384  }
9385  };
9386 
9387  template <>
9388  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPipelinePropertiesKHR>
9389  {
9390  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPipelinePropertiesKHR const & physicalDeviceRayTracingPipelinePropertiesKHR ) const
9391  VULKAN_HPP_NOEXCEPT
9392  {
9393  std::size_t seed = 0;
9394  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.sType );
9395  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.pNext );
9396  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.shaderGroupHandleSize );
9397  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.maxRayRecursionDepth );
9398  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.maxShaderGroupStride );
9399  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.shaderGroupBaseAlignment );
9400  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.shaderGroupHandleCaptureReplaySize );
9401  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.maxRayDispatchInvocationCount );
9402  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.shaderGroupHandleAlignment );
9403  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.maxRayHitAttributeSize );
9404  return seed;
9405  }
9406  };
9407 
9408  template <>
9409  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPropertiesNV>
9410  {
9411  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPropertiesNV const & physicalDeviceRayTracingPropertiesNV ) const VULKAN_HPP_NOEXCEPT
9412  {
9413  std::size_t seed = 0;
9414  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.sType );
9415  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.pNext );
9416  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.shaderGroupHandleSize );
9417  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.maxRecursionDepth );
9418  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.maxShaderGroupStride );
9419  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.shaderGroupBaseAlignment );
9420  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.maxGeometryCount );
9421  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.maxInstanceCount );
9422  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.maxTriangleCount );
9423  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.maxDescriptorSetAccelerationStructures );
9424  return seed;
9425  }
9426  };
9427 
9428  template <>
9429  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRepresentativeFragmentTestFeaturesNV>
9430  {
9431  std::size_t
9432  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRepresentativeFragmentTestFeaturesNV const & physicalDeviceRepresentativeFragmentTestFeaturesNV ) const
9433  VULKAN_HPP_NOEXCEPT
9434  {
9435  std::size_t seed = 0;
9436  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRepresentativeFragmentTestFeaturesNV.sType );
9437  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRepresentativeFragmentTestFeaturesNV.pNext );
9438  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRepresentativeFragmentTestFeaturesNV.representativeFragmentTest );
9439  return seed;
9440  }
9441  };
9442 
9443  template <>
9444  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2FeaturesEXT>
9445  {
9446  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2FeaturesEXT const & physicalDeviceRobustness2FeaturesEXT ) const VULKAN_HPP_NOEXCEPT
9447  {
9448  std::size_t seed = 0;
9449  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2FeaturesEXT.sType );
9450  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2FeaturesEXT.pNext );
9451  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2FeaturesEXT.robustBufferAccess2 );
9452  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2FeaturesEXT.robustImageAccess2 );
9453  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2FeaturesEXT.nullDescriptor );
9454  return seed;
9455  }
9456  };
9457 
9458  template <>
9459  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2PropertiesEXT>
9460  {
9461  std::size_t
9462  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2PropertiesEXT const & physicalDeviceRobustness2PropertiesEXT ) const VULKAN_HPP_NOEXCEPT
9463  {
9464  std::size_t seed = 0;
9465  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2PropertiesEXT.sType );
9466  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2PropertiesEXT.pNext );
9467  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2PropertiesEXT.robustStorageBufferAccessSizeAlignment );
9468  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2PropertiesEXT.robustUniformBufferAccessSizeAlignment );
9469  return seed;
9470  }
9471  };
9472 
9473  template <>
9474  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSampleLocationsPropertiesEXT>
9475  {
9476  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSampleLocationsPropertiesEXT const & physicalDeviceSampleLocationsPropertiesEXT ) const
9477  VULKAN_HPP_NOEXCEPT
9478  {
9479  std::size_t seed = 0;
9480  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSampleLocationsPropertiesEXT.sType );
9481  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSampleLocationsPropertiesEXT.pNext );
9482  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSampleLocationsPropertiesEXT.sampleLocationSampleCounts );
9483  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSampleLocationsPropertiesEXT.maxSampleLocationGridSize );
9484  for ( size_t i = 0; i < 2; ++i )
9485  {
9486  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSampleLocationsPropertiesEXT.sampleLocationCoordinateRange[i] );
9487  }
9488  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSampleLocationsPropertiesEXT.sampleLocationSubPixelBits );
9489  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSampleLocationsPropertiesEXT.variableSampleLocations );
9490  return seed;
9491  }
9492  };
9493 
9494  template <>
9495  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSamplerFilterMinmaxProperties>
9496  {
9497  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSamplerFilterMinmaxProperties const & physicalDeviceSamplerFilterMinmaxProperties ) const
9498  VULKAN_HPP_NOEXCEPT
9499  {
9500  std::size_t seed = 0;
9501  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSamplerFilterMinmaxProperties.sType );
9502  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSamplerFilterMinmaxProperties.pNext );
9503  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSamplerFilterMinmaxProperties.filterMinmaxSingleComponentFormats );
9504  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSamplerFilterMinmaxProperties.filterMinmaxImageComponentMapping );
9505  return seed;
9506  }
9507  };
9508 
9509  template <>
9510  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSamplerYcbcrConversionFeatures>
9511  {
9512  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSamplerYcbcrConversionFeatures const & physicalDeviceSamplerYcbcrConversionFeatures ) const
9513  VULKAN_HPP_NOEXCEPT
9514  {
9515  std::size_t seed = 0;
9516  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSamplerYcbcrConversionFeatures.sType );
9517  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSamplerYcbcrConversionFeatures.pNext );
9518  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSamplerYcbcrConversionFeatures.samplerYcbcrConversion );
9519  return seed;
9520  }
9521  };
9522 
9523  template <>
9524  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceScalarBlockLayoutFeatures>
9525  {
9526  std::size_t
9527  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceScalarBlockLayoutFeatures const & physicalDeviceScalarBlockLayoutFeatures ) const VULKAN_HPP_NOEXCEPT
9528  {
9529  std::size_t seed = 0;
9530  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceScalarBlockLayoutFeatures.sType );
9531  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceScalarBlockLayoutFeatures.pNext );
9532  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceScalarBlockLayoutFeatures.scalarBlockLayout );
9533  return seed;
9534  }
9535  };
9536 
9537  template <>
9538  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSeparateDepthStencilLayoutsFeatures>
9539  {
9540  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSeparateDepthStencilLayoutsFeatures const & physicalDeviceSeparateDepthStencilLayoutsFeatures )
9541  const VULKAN_HPP_NOEXCEPT
9542  {
9543  std::size_t seed = 0;
9544  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSeparateDepthStencilLayoutsFeatures.sType );
9545  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSeparateDepthStencilLayoutsFeatures.pNext );
9546  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSeparateDepthStencilLayoutsFeatures.separateDepthStencilLayouts );
9547  return seed;
9548  }
9549  };
9550 
9551  template <>
9552  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloat2FeaturesEXT>
9553  {
9554  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloat2FeaturesEXT const & physicalDeviceShaderAtomicFloat2FeaturesEXT ) const
9555  VULKAN_HPP_NOEXCEPT
9556  {
9557  std::size_t seed = 0;
9558  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.sType );
9559  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.pNext );
9560  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderBufferFloat16Atomics );
9561  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderBufferFloat16AtomicAdd );
9562  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderBufferFloat16AtomicMinMax );
9563  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderBufferFloat32AtomicMinMax );
9564  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderBufferFloat64AtomicMinMax );
9565  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderSharedFloat16Atomics );
9566  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderSharedFloat16AtomicAdd );
9567  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderSharedFloat16AtomicMinMax );
9568  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderSharedFloat32AtomicMinMax );
9569  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderSharedFloat64AtomicMinMax );
9570  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderImageFloat32AtomicMinMax );
9571  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.sparseImageFloat32AtomicMinMax );
9572  return seed;
9573  }
9574  };
9575 
9576  template <>
9577  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloatFeaturesEXT>
9578  {
9579  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloatFeaturesEXT const & physicalDeviceShaderAtomicFloatFeaturesEXT ) const
9580  VULKAN_HPP_NOEXCEPT
9581  {
9582  std::size_t seed = 0;
9583  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.sType );
9584  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.pNext );
9585  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderBufferFloat32Atomics );
9586  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderBufferFloat32AtomicAdd );
9587  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderBufferFloat64Atomics );
9588  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderBufferFloat64AtomicAdd );
9589  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderSharedFloat32Atomics );
9590  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderSharedFloat32AtomicAdd );
9591  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderSharedFloat64Atomics );
9592  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderSharedFloat64AtomicAdd );
9593  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderImageFloat32Atomics );
9594  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderImageFloat32AtomicAdd );
9595  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.sparseImageFloat32Atomics );
9596  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.sparseImageFloat32AtomicAdd );
9597  return seed;
9598  }
9599  };
9600 
9601  template <>
9602  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicInt64Features>
9603  {
9604  std::size_t
9605  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicInt64Features const & physicalDeviceShaderAtomicInt64Features ) const VULKAN_HPP_NOEXCEPT
9606  {
9607  std::size_t seed = 0;
9608  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicInt64Features.sType );
9609  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicInt64Features.pNext );
9610  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicInt64Features.shaderBufferInt64Atomics );
9611  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicInt64Features.shaderSharedInt64Atomics );
9612  return seed;
9613  }
9614  };
9615 
9616  template <>
9617  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderClockFeaturesKHR>
9618  {
9619  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderClockFeaturesKHR const & physicalDeviceShaderClockFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
9620  {
9621  std::size_t seed = 0;
9622  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderClockFeaturesKHR.sType );
9623  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderClockFeaturesKHR.pNext );
9624  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderClockFeaturesKHR.shaderSubgroupClock );
9625  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderClockFeaturesKHR.shaderDeviceClock );
9626  return seed;
9627  }
9628  };
9629 
9630  template <>
9631  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCoreBuiltinsFeaturesARM>
9632  {
9633  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCoreBuiltinsFeaturesARM const & physicalDeviceShaderCoreBuiltinsFeaturesARM ) const
9634  VULKAN_HPP_NOEXCEPT
9635  {
9636  std::size_t seed = 0;
9637  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreBuiltinsFeaturesARM.sType );
9638  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreBuiltinsFeaturesARM.pNext );
9639  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreBuiltinsFeaturesARM.shaderCoreBuiltins );
9640  return seed;
9641  }
9642  };
9643 
9644  template <>
9645  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCoreBuiltinsPropertiesARM>
9646  {
9647  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCoreBuiltinsPropertiesARM const & physicalDeviceShaderCoreBuiltinsPropertiesARM ) const
9648  VULKAN_HPP_NOEXCEPT
9649  {
9650  std::size_t seed = 0;
9651  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreBuiltinsPropertiesARM.sType );
9652  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreBuiltinsPropertiesARM.pNext );
9653  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreBuiltinsPropertiesARM.shaderCoreMask );
9654  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreBuiltinsPropertiesARM.shaderCoreCount );
9655  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreBuiltinsPropertiesARM.shaderWarpsPerCore );
9656  return seed;
9657  }
9658  };
9659 
9660  template <>
9661  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCoreProperties2AMD>
9662  {
9663  std::size_t
9664  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCoreProperties2AMD const & physicalDeviceShaderCoreProperties2AMD ) const VULKAN_HPP_NOEXCEPT
9665  {
9666  std::size_t seed = 0;
9667  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreProperties2AMD.sType );
9668  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreProperties2AMD.pNext );
9669  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreProperties2AMD.shaderCoreFeatures );
9670  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreProperties2AMD.activeComputeUnitCount );
9671  return seed;
9672  }
9673  };
9674 
9675  template <>
9676  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCorePropertiesAMD>
9677  {
9678  std::size_t
9679  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCorePropertiesAMD const & physicalDeviceShaderCorePropertiesAMD ) const VULKAN_HPP_NOEXCEPT
9680  {
9681  std::size_t seed = 0;
9682  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.sType );
9683  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.pNext );
9684  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.shaderEngineCount );
9685  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.shaderArraysPerEngineCount );
9686  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.computeUnitsPerShaderArray );
9687  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.simdPerComputeUnit );
9688  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.wavefrontsPerSimd );
9689  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.wavefrontSize );
9690  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.sgprsPerSimd );
9691  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.minSgprAllocation );
9692  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.maxSgprAllocation );
9693  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.sgprAllocationGranularity );
9694  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.vgprsPerSimd );
9695  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.minVgprAllocation );
9696  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.maxVgprAllocation );
9697  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.vgprAllocationGranularity );
9698  return seed;
9699  }
9700  };
9701 
9702  template <>
9703  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderDemoteToHelperInvocationFeatures>
9704  {
9705  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderDemoteToHelperInvocationFeatures const &
9706  physicalDeviceShaderDemoteToHelperInvocationFeatures ) const VULKAN_HPP_NOEXCEPT
9707  {
9708  std::size_t seed = 0;
9709  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderDemoteToHelperInvocationFeatures.sType );
9710  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderDemoteToHelperInvocationFeatures.pNext );
9711  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderDemoteToHelperInvocationFeatures.shaderDemoteToHelperInvocation );
9712  return seed;
9713  }
9714  };
9715 
9716  template <>
9717  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderDrawParametersFeatures>
9718  {
9719  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderDrawParametersFeatures const & physicalDeviceShaderDrawParametersFeatures ) const
9720  VULKAN_HPP_NOEXCEPT
9721  {
9722  std::size_t seed = 0;
9723  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderDrawParametersFeatures.sType );
9724  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderDrawParametersFeatures.pNext );
9725  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderDrawParametersFeatures.shaderDrawParameters );
9726  return seed;
9727  }
9728  };
9729 
9730  template <>
9731  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD>
9732  {
9733  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD const &
9734  physicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD ) const VULKAN_HPP_NOEXCEPT
9735  {
9736  std::size_t seed = 0;
9737  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD.sType );
9738  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD.pNext );
9739  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD.shaderEarlyAndLateFragmentTests );
9740  return seed;
9741  }
9742  };
9743 
9744  template <>
9745  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFloat16Int8Features>
9746  {
9747  std::size_t
9748  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFloat16Int8Features const & physicalDeviceShaderFloat16Int8Features ) const VULKAN_HPP_NOEXCEPT
9749  {
9750  std::size_t seed = 0;
9751  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFloat16Int8Features.sType );
9752  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFloat16Int8Features.pNext );
9753  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFloat16Int8Features.shaderFloat16 );
9754  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFloat16Int8Features.shaderInt8 );
9755  return seed;
9756  }
9757  };
9758 
9759  template <>
9760  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderImageAtomicInt64FeaturesEXT>
9761  {
9762  std::size_t operator()(
9763  VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderImageAtomicInt64FeaturesEXT const & physicalDeviceShaderImageAtomicInt64FeaturesEXT ) const VULKAN_HPP_NOEXCEPT
9764  {
9765  std::size_t seed = 0;
9766  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderImageAtomicInt64FeaturesEXT.sType );
9767  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderImageAtomicInt64FeaturesEXT.pNext );
9768  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderImageAtomicInt64FeaturesEXT.shaderImageInt64Atomics );
9769  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderImageAtomicInt64FeaturesEXT.sparseImageInt64Atomics );
9770  return seed;
9771  }
9772  };
9773 
9774  template <>
9775  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderImageFootprintFeaturesNV>
9776  {
9777  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderImageFootprintFeaturesNV const & physicalDeviceShaderImageFootprintFeaturesNV ) const
9778  VULKAN_HPP_NOEXCEPT
9779  {
9780  std::size_t seed = 0;
9781  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderImageFootprintFeaturesNV.sType );
9782  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderImageFootprintFeaturesNV.pNext );
9783  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderImageFootprintFeaturesNV.imageFootprint );
9784  return seed;
9785  }
9786  };
9787 
9788  template <>
9789  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerDotProductFeatures>
9790  {
9791  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerDotProductFeatures const & physicalDeviceShaderIntegerDotProductFeatures ) const
9792  VULKAN_HPP_NOEXCEPT
9793  {
9794  std::size_t seed = 0;
9795  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductFeatures.sType );
9796  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductFeatures.pNext );
9797  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductFeatures.shaderIntegerDotProduct );
9798  return seed;
9799  }
9800  };
9801 
9802  template <>
9803  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerDotProductProperties>
9804  {
9805  std::size_t operator()(
9806  VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerDotProductProperties const & physicalDeviceShaderIntegerDotProductProperties ) const VULKAN_HPP_NOEXCEPT
9807  {
9808  std::size_t seed = 0;
9809  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.sType );
9810  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.pNext );
9811  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct8BitUnsignedAccelerated );
9812  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct8BitSignedAccelerated );
9813  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct8BitMixedSignednessAccelerated );
9814  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct4x8BitPackedUnsignedAccelerated );
9815  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct4x8BitPackedSignedAccelerated );
9816  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct4x8BitPackedMixedSignednessAccelerated );
9817  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct16BitUnsignedAccelerated );
9818  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct16BitSignedAccelerated );
9819  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct16BitMixedSignednessAccelerated );
9820  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct32BitUnsignedAccelerated );
9821  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct32BitSignedAccelerated );
9822  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct32BitMixedSignednessAccelerated );
9823  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct64BitUnsignedAccelerated );
9824  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct64BitSignedAccelerated );
9825  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct64BitMixedSignednessAccelerated );
9826  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating8BitUnsignedAccelerated );
9827  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating8BitSignedAccelerated );
9828  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated );
9829  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated );
9830  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated );
9831  VULKAN_HPP_HASH_COMBINE( seed,
9832  physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated );
9833  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating16BitUnsignedAccelerated );
9834  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating16BitSignedAccelerated );
9835  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated );
9836  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating32BitUnsignedAccelerated );
9837  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating32BitSignedAccelerated );
9838  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated );
9839  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating64BitUnsignedAccelerated );
9840  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating64BitSignedAccelerated );
9841  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated );
9842  return seed;
9843  }
9844  };
9845 
9846  template <>
9847  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL>
9848  {
9849  std::size_t
9850  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const & physicalDeviceShaderIntegerFunctions2FeaturesINTEL ) const
9851  VULKAN_HPP_NOEXCEPT
9852  {
9853  std::size_t seed = 0;
9854  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerFunctions2FeaturesINTEL.sType );
9855  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerFunctions2FeaturesINTEL.pNext );
9856  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerFunctions2FeaturesINTEL.shaderIntegerFunctions2 );
9857  return seed;
9858  }
9859  };
9860 
9861  template <>
9862  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderModuleIdentifierFeaturesEXT>
9863  {
9864  std::size_t operator()(
9865  VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderModuleIdentifierFeaturesEXT const & physicalDeviceShaderModuleIdentifierFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
9866  {
9867  std::size_t seed = 0;
9868  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderModuleIdentifierFeaturesEXT.sType );
9869  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderModuleIdentifierFeaturesEXT.pNext );
9870  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderModuleIdentifierFeaturesEXT.shaderModuleIdentifier );
9871  return seed;
9872  }
9873  };
9874 
9875  template <>
9876  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderModuleIdentifierPropertiesEXT>
9877  {
9878  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderModuleIdentifierPropertiesEXT const & physicalDeviceShaderModuleIdentifierPropertiesEXT )
9879  const VULKAN_HPP_NOEXCEPT
9880  {
9881  std::size_t seed = 0;
9882  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderModuleIdentifierPropertiesEXT.sType );
9883  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderModuleIdentifierPropertiesEXT.pNext );
9884  for ( size_t i = 0; i < VK_UUID_SIZE; ++i )
9885  {
9886  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderModuleIdentifierPropertiesEXT.shaderModuleIdentifierAlgorithmUUID[i] );
9887  }
9888  return seed;
9889  }
9890  };
9891 
9892  template <>
9893  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSMBuiltinsFeaturesNV>
9894  {
9895  std::size_t
9896  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSMBuiltinsFeaturesNV const & physicalDeviceShaderSMBuiltinsFeaturesNV ) const VULKAN_HPP_NOEXCEPT
9897  {
9898  std::size_t seed = 0;
9899  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSMBuiltinsFeaturesNV.sType );
9900  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSMBuiltinsFeaturesNV.pNext );
9901  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSMBuiltinsFeaturesNV.shaderSMBuiltins );
9902  return seed;
9903  }
9904  };
9905 
9906  template <>
9907  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSMBuiltinsPropertiesNV>
9908  {
9909  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSMBuiltinsPropertiesNV const & physicalDeviceShaderSMBuiltinsPropertiesNV ) const
9910  VULKAN_HPP_NOEXCEPT
9911  {
9912  std::size_t seed = 0;
9913  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSMBuiltinsPropertiesNV.sType );
9914  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSMBuiltinsPropertiesNV.pNext );
9915  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSMBuiltinsPropertiesNV.shaderSMCount );
9916  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSMBuiltinsPropertiesNV.shaderWarpsPerSM );
9917  return seed;
9918  }
9919  };
9920 
9921  template <>
9922  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupExtendedTypesFeatures>
9923  {
9924  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupExtendedTypesFeatures const & physicalDeviceShaderSubgroupExtendedTypesFeatures )
9925  const VULKAN_HPP_NOEXCEPT
9926  {
9927  std::size_t seed = 0;
9928  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupExtendedTypesFeatures.sType );
9929  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupExtendedTypesFeatures.pNext );
9930  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupExtendedTypesFeatures.shaderSubgroupExtendedTypes );
9931  return seed;
9932  }
9933  };
9934 
9935  template <>
9936  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR>
9937  {
9938  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR const &
9939  physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
9940  {
9941  std::size_t seed = 0;
9942  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR.sType );
9943  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR.pNext );
9944  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR.shaderSubgroupUniformControlFlow );
9945  return seed;
9946  }
9947  };
9948 
9949  template <>
9950  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderTerminateInvocationFeatures>
9951  {
9952  std::size_t operator()(
9953  VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderTerminateInvocationFeatures const & physicalDeviceShaderTerminateInvocationFeatures ) const VULKAN_HPP_NOEXCEPT
9954  {
9955  std::size_t seed = 0;
9956  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTerminateInvocationFeatures.sType );
9957  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTerminateInvocationFeatures.pNext );
9958  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTerminateInvocationFeatures.shaderTerminateInvocation );
9959  return seed;
9960  }
9961  };
9962 
9963  template <>
9964  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShadingRateImageFeaturesNV>
9965  {
9966  std::size_t
9967  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShadingRateImageFeaturesNV const & physicalDeviceShadingRateImageFeaturesNV ) const VULKAN_HPP_NOEXCEPT
9968  {
9969  std::size_t seed = 0;
9970  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShadingRateImageFeaturesNV.sType );
9971  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShadingRateImageFeaturesNV.pNext );
9972  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShadingRateImageFeaturesNV.shadingRateImage );
9973  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShadingRateImageFeaturesNV.shadingRateCoarseSampleOrder );
9974  return seed;
9975  }
9976  };
9977 
9978  template <>
9979  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShadingRateImagePropertiesNV>
9980  {
9981  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShadingRateImagePropertiesNV const & physicalDeviceShadingRateImagePropertiesNV ) const
9982  VULKAN_HPP_NOEXCEPT
9983  {
9984  std::size_t seed = 0;
9985  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShadingRateImagePropertiesNV.sType );
9986  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShadingRateImagePropertiesNV.pNext );
9987  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShadingRateImagePropertiesNV.shadingRateTexelSize );
9988  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShadingRateImagePropertiesNV.shadingRatePaletteSize );
9989  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShadingRateImagePropertiesNV.shadingRateMaxCoarseSamples );
9990  return seed;
9991  }
9992  };
9993 
9994  template <>
9995  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2>
9996  {
9997  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 const & physicalDeviceSparseImageFormatInfo2 ) const VULKAN_HPP_NOEXCEPT
9998  {
9999  std::size_t seed = 0;
10000  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseImageFormatInfo2.sType );
10001  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseImageFormatInfo2.pNext );
10002  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseImageFormatInfo2.format );
10003  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseImageFormatInfo2.type );
10004  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseImageFormatInfo2.samples );
10005  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseImageFormatInfo2.usage );
10006  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseImageFormatInfo2.tiling );
10007  return seed;
10008  }
10009  };
10010 
10011  template <>
10012  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupProperties>
10013  {
10014  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupProperties const & physicalDeviceSubgroupProperties ) const VULKAN_HPP_NOEXCEPT
10015  {
10016  std::size_t seed = 0;
10017  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupProperties.sType );
10018  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupProperties.pNext );
10019  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupProperties.subgroupSize );
10020  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupProperties.supportedStages );
10021  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupProperties.supportedOperations );
10022  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupProperties.quadOperationsInAllStages );
10023  return seed;
10024  }
10025  };
10026 
10027  template <>
10028  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupSizeControlFeatures>
10029  {
10030  std::size_t
10031  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupSizeControlFeatures const & physicalDeviceSubgroupSizeControlFeatures ) const VULKAN_HPP_NOEXCEPT
10032  {
10033  std::size_t seed = 0;
10034  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlFeatures.sType );
10035  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlFeatures.pNext );
10036  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlFeatures.subgroupSizeControl );
10037  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlFeatures.computeFullSubgroups );
10038  return seed;
10039  }
10040  };
10041 
10042  template <>
10043  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupSizeControlProperties>
10044  {
10045  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupSizeControlProperties const & physicalDeviceSubgroupSizeControlProperties ) const
10046  VULKAN_HPP_NOEXCEPT
10047  {
10048  std::size_t seed = 0;
10049  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlProperties.sType );
10050  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlProperties.pNext );
10051  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlProperties.minSubgroupSize );
10052  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlProperties.maxSubgroupSize );
10053  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlProperties.maxComputeWorkgroupSubgroups );
10054  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlProperties.requiredSubgroupSizeStages );
10055  return seed;
10056  }
10057  };
10058 
10059  template <>
10060  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassMergeFeedbackFeaturesEXT>
10061  {
10062  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassMergeFeedbackFeaturesEXT const & physicalDeviceSubpassMergeFeedbackFeaturesEXT ) const
10063  VULKAN_HPP_NOEXCEPT
10064  {
10065  std::size_t seed = 0;
10066  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubpassMergeFeedbackFeaturesEXT.sType );
10067  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubpassMergeFeedbackFeaturesEXT.pNext );
10068  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubpassMergeFeedbackFeaturesEXT.subpassMergeFeedback );
10069  return seed;
10070  }
10071  };
10072 
10073  template <>
10074  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassShadingFeaturesHUAWEI>
10075  {
10076  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassShadingFeaturesHUAWEI const & physicalDeviceSubpassShadingFeaturesHUAWEI ) const
10077  VULKAN_HPP_NOEXCEPT
10078  {
10079  std::size_t seed = 0;
10080  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubpassShadingFeaturesHUAWEI.sType );
10081  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubpassShadingFeaturesHUAWEI.pNext );
10082  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubpassShadingFeaturesHUAWEI.subpassShading );
10083  return seed;
10084  }
10085  };
10086 
10087  template <>
10088  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassShadingPropertiesHUAWEI>
10089  {
10090  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassShadingPropertiesHUAWEI const & physicalDeviceSubpassShadingPropertiesHUAWEI ) const
10091  VULKAN_HPP_NOEXCEPT
10092  {
10093  std::size_t seed = 0;
10094  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubpassShadingPropertiesHUAWEI.sType );
10095  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubpassShadingPropertiesHUAWEI.pNext );
10096  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubpassShadingPropertiesHUAWEI.maxSubpassShadingWorkgroupSizeAspectRatio );
10097  return seed;
10098  }
10099  };
10100 
10101  template <>
10102  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR>
10103  {
10104  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR const & physicalDeviceSurfaceInfo2KHR ) const VULKAN_HPP_NOEXCEPT
10105  {
10106  std::size_t seed = 0;
10107  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSurfaceInfo2KHR.sType );
10108  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSurfaceInfo2KHR.pNext );
10109  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSurfaceInfo2KHR.surface );
10110  return seed;
10111  }
10112  };
10113 
10114  template <>
10115  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSynchronization2Features>
10116  {
10117  std::size_t
10118  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSynchronization2Features const & physicalDeviceSynchronization2Features ) const VULKAN_HPP_NOEXCEPT
10119  {
10120  std::size_t seed = 0;
10121  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSynchronization2Features.sType );
10122  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSynchronization2Features.pNext );
10123  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSynchronization2Features.synchronization2 );
10124  return seed;
10125  }
10126  };
10127 
10128  template <>
10129  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTexelBufferAlignmentFeaturesEXT>
10130  {
10131  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTexelBufferAlignmentFeaturesEXT const & physicalDeviceTexelBufferAlignmentFeaturesEXT ) const
10132  VULKAN_HPP_NOEXCEPT
10133  {
10134  std::size_t seed = 0;
10135  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTexelBufferAlignmentFeaturesEXT.sType );
10136  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTexelBufferAlignmentFeaturesEXT.pNext );
10137  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTexelBufferAlignmentFeaturesEXT.texelBufferAlignment );
10138  return seed;
10139  }
10140  };
10141 
10142  template <>
10143  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTexelBufferAlignmentProperties>
10144  {
10145  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTexelBufferAlignmentProperties const & physicalDeviceTexelBufferAlignmentProperties ) const
10146  VULKAN_HPP_NOEXCEPT
10147  {
10148  std::size_t seed = 0;
10149  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTexelBufferAlignmentProperties.sType );
10150  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTexelBufferAlignmentProperties.pNext );
10151  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTexelBufferAlignmentProperties.storageTexelBufferOffsetAlignmentBytes );
10152  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTexelBufferAlignmentProperties.storageTexelBufferOffsetSingleTexelAlignment );
10153  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTexelBufferAlignmentProperties.uniformTexelBufferOffsetAlignmentBytes );
10154  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTexelBufferAlignmentProperties.uniformTexelBufferOffsetSingleTexelAlignment );
10155  return seed;
10156  }
10157  };
10158 
10159  template <>
10160  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTextureCompressionASTCHDRFeatures>
10161  {
10162  std::size_t operator()(
10163  VULKAN_HPP_NAMESPACE::PhysicalDeviceTextureCompressionASTCHDRFeatures const & physicalDeviceTextureCompressionASTCHDRFeatures ) const VULKAN_HPP_NOEXCEPT
10164  {
10165  std::size_t seed = 0;
10166  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTextureCompressionASTCHDRFeatures.sType );
10167  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTextureCompressionASTCHDRFeatures.pNext );
10168  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTextureCompressionASTCHDRFeatures.textureCompressionASTC_HDR );
10169  return seed;
10170  }
10171  };
10172 
10173  template <>
10174  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTilePropertiesFeaturesQCOM>
10175  {
10176  std::size_t
10177  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTilePropertiesFeaturesQCOM const & physicalDeviceTilePropertiesFeaturesQCOM ) const VULKAN_HPP_NOEXCEPT
10178  {
10179  std::size_t seed = 0;
10180  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTilePropertiesFeaturesQCOM.sType );
10181  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTilePropertiesFeaturesQCOM.pNext );
10182  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTilePropertiesFeaturesQCOM.tileProperties );
10183  return seed;
10184  }
10185  };
10186 
10187  template <>
10188  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTimelineSemaphoreFeatures>
10189  {
10190  std::size_t
10191  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTimelineSemaphoreFeatures const & physicalDeviceTimelineSemaphoreFeatures ) const VULKAN_HPP_NOEXCEPT
10192  {
10193  std::size_t seed = 0;
10194  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTimelineSemaphoreFeatures.sType );
10195  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTimelineSemaphoreFeatures.pNext );
10196  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTimelineSemaphoreFeatures.timelineSemaphore );
10197  return seed;
10198  }
10199  };
10200 
10201  template <>
10202  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTimelineSemaphoreProperties>
10203  {
10204  std::size_t
10205  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTimelineSemaphoreProperties const & physicalDeviceTimelineSemaphoreProperties ) const VULKAN_HPP_NOEXCEPT
10206  {
10207  std::size_t seed = 0;
10208  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTimelineSemaphoreProperties.sType );
10209  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTimelineSemaphoreProperties.pNext );
10210  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTimelineSemaphoreProperties.maxTimelineSemaphoreValueDifference );
10211  return seed;
10212  }
10213  };
10214 
10215  template <>
10216  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties>
10217  {
10218  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties const & physicalDeviceToolProperties ) const VULKAN_HPP_NOEXCEPT
10219  {
10220  std::size_t seed = 0;
10221  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceToolProperties.sType );
10222  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceToolProperties.pNext );
10223  for ( size_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i )
10224  {
10225  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceToolProperties.name[i] );
10226  }
10227  for ( size_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i )
10228  {
10229  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceToolProperties.version[i] );
10230  }
10231  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceToolProperties.purposes );
10232  for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i )
10233  {
10234  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceToolProperties.description[i] );
10235  }
10236  for ( size_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i )
10237  {
10238  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceToolProperties.layer[i] );
10239  }
10240  return seed;
10241  }
10242  };
10243 
10244  template <>
10245  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTransformFeedbackFeaturesEXT>
10246  {
10247  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTransformFeedbackFeaturesEXT const & physicalDeviceTransformFeedbackFeaturesEXT ) const
10248  VULKAN_HPP_NOEXCEPT
10249  {
10250  std::size_t seed = 0;
10251  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackFeaturesEXT.sType );
10252  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackFeaturesEXT.pNext );
10253  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackFeaturesEXT.transformFeedback );
10254  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackFeaturesEXT.geometryStreams );
10255  return seed;
10256  }
10257  };
10258 
10259  template <>
10260  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTransformFeedbackPropertiesEXT>
10261  {
10262  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTransformFeedbackPropertiesEXT const & physicalDeviceTransformFeedbackPropertiesEXT ) const
10263  VULKAN_HPP_NOEXCEPT
10264  {
10265  std::size_t seed = 0;
10266  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.sType );
10267  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.pNext );
10268  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackStreams );
10269  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackBuffers );
10270  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackBufferSize );
10271  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackStreamDataSize );
10272  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackBufferDataSize );
10273  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackBufferDataStride );
10274  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.transformFeedbackQueries );
10275  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.transformFeedbackStreamsLinesTriangles );
10276  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.transformFeedbackRasterizationStreamSelect );
10277  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.transformFeedbackDraw );
10278  return seed;
10279  }
10280  };
10281 
10282  template <>
10283  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceUniformBufferStandardLayoutFeatures>
10284  {
10285  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceUniformBufferStandardLayoutFeatures const & physicalDeviceUniformBufferStandardLayoutFeatures )
10286  const VULKAN_HPP_NOEXCEPT
10287  {
10288  std::size_t seed = 0;
10289  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceUniformBufferStandardLayoutFeatures.sType );
10290  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceUniformBufferStandardLayoutFeatures.pNext );
10291  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceUniformBufferStandardLayoutFeatures.uniformBufferStandardLayout );
10292  return seed;
10293  }
10294  };
10295 
10296  template <>
10297  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVariablePointersFeatures>
10298  {
10299  std::size_t
10300  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVariablePointersFeatures const & physicalDeviceVariablePointersFeatures ) const VULKAN_HPP_NOEXCEPT
10301  {
10302  std::size_t seed = 0;
10303  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVariablePointersFeatures.sType );
10304  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVariablePointersFeatures.pNext );
10305  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVariablePointersFeatures.variablePointersStorageBuffer );
10306  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVariablePointersFeatures.variablePointers );
10307  return seed;
10308  }
10309  };
10310 
10311  template <>
10312  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorFeaturesEXT>
10313  {
10314  std::size_t operator()(
10315  VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorFeaturesEXT const & physicalDeviceVertexAttributeDivisorFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
10316  {
10317  std::size_t seed = 0;
10318  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorFeaturesEXT.sType );
10319  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorFeaturesEXT.pNext );
10320  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorFeaturesEXT.vertexAttributeInstanceRateDivisor );
10321  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorFeaturesEXT.vertexAttributeInstanceRateZeroDivisor );
10322  return seed;
10323  }
10324  };
10325 
10326  template <>
10327  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorPropertiesEXT>
10328  {
10329  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorPropertiesEXT const & physicalDeviceVertexAttributeDivisorPropertiesEXT )
10330  const VULKAN_HPP_NOEXCEPT
10331  {
10332  std::size_t seed = 0;
10333  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorPropertiesEXT.sType );
10334  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorPropertiesEXT.pNext );
10335  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorPropertiesEXT.maxVertexAttribDivisor );
10336  return seed;
10337  }
10338  };
10339 
10340  template <>
10341  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexInputDynamicStateFeaturesEXT>
10342  {
10343  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexInputDynamicStateFeaturesEXT const & physicalDeviceVertexInputDynamicStateFeaturesEXT )
10344  const VULKAN_HPP_NOEXCEPT
10345  {
10346  std::size_t seed = 0;
10347  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexInputDynamicStateFeaturesEXT.sType );
10348  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexInputDynamicStateFeaturesEXT.pNext );
10349  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexInputDynamicStateFeaturesEXT.vertexInputDynamicState );
10350  return seed;
10351  }
10352  };
10353 
10354 # if defined( VK_ENABLE_BETA_EXTENSIONS )
10355  template <>
10356  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR>
10357  {
10358  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR const & physicalDeviceVideoFormatInfoKHR ) const VULKAN_HPP_NOEXCEPT
10359  {
10360  std::size_t seed = 0;
10361  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoFormatInfoKHR.sType );
10362  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoFormatInfoKHR.pNext );
10363  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoFormatInfoKHR.imageUsage );
10364  return seed;
10365  }
10366  };
10367 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
10368 
10369  template <>
10370  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan11Features>
10371  {
10372  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan11Features const & physicalDeviceVulkan11Features ) const VULKAN_HPP_NOEXCEPT
10373  {
10374  std::size_t seed = 0;
10375  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.sType );
10376  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.pNext );
10377  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.storageBuffer16BitAccess );
10378  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.uniformAndStorageBuffer16BitAccess );
10379  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.storagePushConstant16 );
10380  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.storageInputOutput16 );
10381  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.multiview );
10382  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.multiviewGeometryShader );
10383  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.multiviewTessellationShader );
10384  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.variablePointersStorageBuffer );
10385  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.variablePointers );
10386  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.protectedMemory );
10387  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.samplerYcbcrConversion );
10388  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.shaderDrawParameters );
10389  return seed;
10390  }
10391  };
10392 
10393  template <>
10394  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan11Properties>
10395  {
10396  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan11Properties const & physicalDeviceVulkan11Properties ) const VULKAN_HPP_NOEXCEPT
10397  {
10398  std::size_t seed = 0;
10399  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.sType );
10400  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.pNext );
10401  for ( size_t i = 0; i < VK_UUID_SIZE; ++i )
10402  {
10403  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.deviceUUID[i] );
10404  }
10405  for ( size_t i = 0; i < VK_UUID_SIZE; ++i )
10406  {
10407  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.driverUUID[i] );
10408  }
10409  for ( size_t i = 0; i < VK_LUID_SIZE; ++i )
10410  {
10411  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.deviceLUID[i] );
10412  }
10413  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.deviceNodeMask );
10414  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.deviceLUIDValid );
10415  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.subgroupSize );
10416  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.subgroupSupportedStages );
10417  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.subgroupSupportedOperations );
10418  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.subgroupQuadOperationsInAllStages );
10419  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.pointClippingBehavior );
10420  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.maxMultiviewViewCount );
10421  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.maxMultiviewInstanceIndex );
10422  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.protectedNoFault );
10423  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.maxPerSetDescriptors );
10424  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.maxMemoryAllocationSize );
10425  return seed;
10426  }
10427  };
10428 
10429  template <>
10430  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan12Features>
10431  {
10432  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan12Features const & physicalDeviceVulkan12Features ) const VULKAN_HPP_NOEXCEPT
10433  {
10434  std::size_t seed = 0;
10435  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.sType );
10436  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.pNext );
10437  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.samplerMirrorClampToEdge );
10438  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.drawIndirectCount );
10439  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.storageBuffer8BitAccess );
10440  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.uniformAndStorageBuffer8BitAccess );
10441  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.storagePushConstant8 );
10442  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderBufferInt64Atomics );
10443  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderSharedInt64Atomics );
10444  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderFloat16 );
10445  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderInt8 );
10446  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorIndexing );
10447  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderInputAttachmentArrayDynamicIndexing );
10448  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderUniformTexelBufferArrayDynamicIndexing );
10449  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderStorageTexelBufferArrayDynamicIndexing );
10450  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderUniformBufferArrayNonUniformIndexing );
10451  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderSampledImageArrayNonUniformIndexing );
10452  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderStorageBufferArrayNonUniformIndexing );
10453  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderStorageImageArrayNonUniformIndexing );
10454  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderInputAttachmentArrayNonUniformIndexing );
10455  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderUniformTexelBufferArrayNonUniformIndexing );
10456  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderStorageTexelBufferArrayNonUniformIndexing );
10457  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorBindingUniformBufferUpdateAfterBind );
10458  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorBindingSampledImageUpdateAfterBind );
10459  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorBindingStorageImageUpdateAfterBind );
10460  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorBindingStorageBufferUpdateAfterBind );
10461  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorBindingUniformTexelBufferUpdateAfterBind );
10462  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorBindingStorageTexelBufferUpdateAfterBind );
10463  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorBindingUpdateUnusedWhilePending );
10464  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorBindingPartiallyBound );
10465  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorBindingVariableDescriptorCount );
10466  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.runtimeDescriptorArray );
10467  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.samplerFilterMinmax );
10468  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.scalarBlockLayout );
10469  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.imagelessFramebuffer );
10470  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.uniformBufferStandardLayout );
10471  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderSubgroupExtendedTypes );
10472  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.separateDepthStencilLayouts );
10473  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.hostQueryReset );
10474  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.timelineSemaphore );
10475  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.bufferDeviceAddress );
10476  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.bufferDeviceAddressCaptureReplay );
10477  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.bufferDeviceAddressMultiDevice );
10478  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.vulkanMemoryModel );
10479  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.vulkanMemoryModelDeviceScope );
10480  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.vulkanMemoryModelAvailabilityVisibilityChains );
10481  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderOutputViewportIndex );
10482  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderOutputLayer );
10483  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.subgroupBroadcastDynamicId );
10484  return seed;
10485  }
10486  };
10487 
10488  template <>
10489  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan12Properties>
10490  {
10491  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan12Properties const & physicalDeviceVulkan12Properties ) const VULKAN_HPP_NOEXCEPT
10492  {
10493  std::size_t seed = 0;
10494  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.sType );
10495  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.pNext );
10496  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.driverID );
10497  for ( size_t i = 0; i < VK_MAX_DRIVER_NAME_SIZE; ++i )
10498  {
10499  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.driverName[i] );
10500  }
10501  for ( size_t i = 0; i < VK_MAX_DRIVER_INFO_SIZE; ++i )
10502  {
10503  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.driverInfo[i] );
10504  }
10505  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.conformanceVersion );
10506  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.denormBehaviorIndependence );
10507  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.roundingModeIndependence );
10508  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderSignedZeroInfNanPreserveFloat16 );
10509  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderSignedZeroInfNanPreserveFloat32 );
10510  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderSignedZeroInfNanPreserveFloat64 );
10511  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderDenormPreserveFloat16 );
10512  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderDenormPreserveFloat32 );
10513  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderDenormPreserveFloat64 );
10514  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderDenormFlushToZeroFloat16 );
10515  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderDenormFlushToZeroFloat32 );
10516  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderDenormFlushToZeroFloat64 );
10517  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTEFloat16 );
10518  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTEFloat32 );
10519  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTEFloat64 );
10520  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTZFloat16 );
10521  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTZFloat32 );
10522  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTZFloat64 );
10523  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxUpdateAfterBindDescriptorsInAllPools );
10524  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderUniformBufferArrayNonUniformIndexingNative );
10525  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderSampledImageArrayNonUniformIndexingNative );
10526  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderStorageBufferArrayNonUniformIndexingNative );
10527  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderStorageImageArrayNonUniformIndexingNative );
10528  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderInputAttachmentArrayNonUniformIndexingNative );
10529  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.robustBufferAccessUpdateAfterBind );
10530  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.quadDivergentImplicitLod );
10531  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindSamplers );
10532  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindUniformBuffers );
10533  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindStorageBuffers );
10534  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindSampledImages );
10535  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindStorageImages );
10536  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindInputAttachments );
10537  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxPerStageUpdateAfterBindResources );
10538  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindSamplers );
10539  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindUniformBuffers );
10540  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic );
10541  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindStorageBuffers );
10542  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic );
10543  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindSampledImages );
10544  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindStorageImages );
10545  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindInputAttachments );
10546  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.supportedDepthResolveModes );
10547  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.supportedStencilResolveModes );
10548  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.independentResolveNone );
10549  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.independentResolve );
10550  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.filterMinmaxSingleComponentFormats );
10551  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.filterMinmaxImageComponentMapping );
10552  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxTimelineSemaphoreValueDifference );
10553  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.framebufferIntegerColorSampleCounts );
10554  return seed;
10555  }
10556  };
10557 
10558  template <>
10559  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan13Features>
10560  {
10561  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan13Features const & physicalDeviceVulkan13Features ) const VULKAN_HPP_NOEXCEPT
10562  {
10563  std::size_t seed = 0;
10564  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.sType );
10565  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.pNext );
10566  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.robustImageAccess );
10567  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.inlineUniformBlock );
10568  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.descriptorBindingInlineUniformBlockUpdateAfterBind );
10569  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.pipelineCreationCacheControl );
10570  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.privateData );
10571  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.shaderDemoteToHelperInvocation );
10572  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.shaderTerminateInvocation );
10573  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.subgroupSizeControl );
10574  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.computeFullSubgroups );
10575  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.synchronization2 );
10576  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.textureCompressionASTC_HDR );
10577  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.shaderZeroInitializeWorkgroupMemory );
10578  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.dynamicRendering );
10579  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.shaderIntegerDotProduct );
10580  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.maintenance4 );
10581  return seed;
10582  }
10583  };
10584 
10585  template <>
10586  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan13Properties>
10587  {
10588  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan13Properties const & physicalDeviceVulkan13Properties ) const VULKAN_HPP_NOEXCEPT
10589  {
10590  std::size_t seed = 0;
10591  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.sType );
10592  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.pNext );
10593  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.minSubgroupSize );
10594  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.maxSubgroupSize );
10595  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.maxComputeWorkgroupSubgroups );
10596  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.requiredSubgroupSizeStages );
10597  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.maxInlineUniformBlockSize );
10598  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.maxPerStageDescriptorInlineUniformBlocks );
10599  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks );
10600  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.maxDescriptorSetInlineUniformBlocks );
10601  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.maxDescriptorSetUpdateAfterBindInlineUniformBlocks );
10602  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.maxInlineUniformTotalSize );
10603  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct8BitUnsignedAccelerated );
10604  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct8BitSignedAccelerated );
10605  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct8BitMixedSignednessAccelerated );
10606  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct4x8BitPackedUnsignedAccelerated );
10607  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct4x8BitPackedSignedAccelerated );
10608  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct4x8BitPackedMixedSignednessAccelerated );
10609  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct16BitUnsignedAccelerated );
10610  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct16BitSignedAccelerated );
10611  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct16BitMixedSignednessAccelerated );
10612  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct32BitUnsignedAccelerated );
10613  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct32BitSignedAccelerated );
10614  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct32BitMixedSignednessAccelerated );
10615  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct64BitUnsignedAccelerated );
10616  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct64BitSignedAccelerated );
10617  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct64BitMixedSignednessAccelerated );
10618  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating8BitUnsignedAccelerated );
10619  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating8BitSignedAccelerated );
10620  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated );
10621  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated );
10622  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated );
10623  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated );
10624  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating16BitUnsignedAccelerated );
10625  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating16BitSignedAccelerated );
10626  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated );
10627  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating32BitUnsignedAccelerated );
10628  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating32BitSignedAccelerated );
10629  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated );
10630  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating64BitUnsignedAccelerated );
10631  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating64BitSignedAccelerated );
10632  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated );
10633  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.storageTexelBufferOffsetAlignmentBytes );
10634  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.storageTexelBufferOffsetSingleTexelAlignment );
10635  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.uniformTexelBufferOffsetAlignmentBytes );
10636  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.uniformTexelBufferOffsetSingleTexelAlignment );
10637  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.maxBufferSize );
10638  return seed;
10639  }
10640  };
10641 
10642  template <>
10643  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkanMemoryModelFeatures>
10644  {
10645  std::size_t
10646  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkanMemoryModelFeatures const & physicalDeviceVulkanMemoryModelFeatures ) const VULKAN_HPP_NOEXCEPT
10647  {
10648  std::size_t seed = 0;
10649  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkanMemoryModelFeatures.sType );
10650  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkanMemoryModelFeatures.pNext );
10651  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkanMemoryModelFeatures.vulkanMemoryModel );
10652  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkanMemoryModelFeatures.vulkanMemoryModelDeviceScope );
10653  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkanMemoryModelFeatures.vulkanMemoryModelAvailabilityVisibilityChains );
10654  return seed;
10655  }
10656  };
10657 
10658  template <>
10659  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR>
10660  {
10661  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR const &
10662  physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
10663  {
10664  std::size_t seed = 0;
10665  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.sType );
10666  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.pNext );
10667  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.workgroupMemoryExplicitLayout );
10668  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.workgroupMemoryExplicitLayoutScalarBlockLayout );
10669  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.workgroupMemoryExplicitLayout8BitAccess );
10670  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.workgroupMemoryExplicitLayout16BitAccess );
10671  return seed;
10672  }
10673  };
10674 
10675  template <>
10676  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT>
10677  {
10678  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT const & physicalDeviceYcbcr2Plane444FormatsFeaturesEXT ) const
10679  VULKAN_HPP_NOEXCEPT
10680  {
10681  std::size_t seed = 0;
10682  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceYcbcr2Plane444FormatsFeaturesEXT.sType );
10683  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceYcbcr2Plane444FormatsFeaturesEXT.pNext );
10684  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceYcbcr2Plane444FormatsFeaturesEXT.ycbcr2plane444Formats );
10685  return seed;
10686  }
10687  };
10688 
10689  template <>
10690  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcrImageArraysFeaturesEXT>
10691  {
10692  std::size_t
10693  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcrImageArraysFeaturesEXT const & physicalDeviceYcbcrImageArraysFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
10694  {
10695  std::size_t seed = 0;
10696  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceYcbcrImageArraysFeaturesEXT.sType );
10697  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceYcbcrImageArraysFeaturesEXT.pNext );
10698  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceYcbcrImageArraysFeaturesEXT.ycbcrImageArrays );
10699  return seed;
10700  }
10701  };
10702 
10703  template <>
10704  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures>
10705  {
10706  std::size_t
10707  operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures const & physicalDeviceZeroInitializeWorkgroupMemoryFeatures ) const
10708  VULKAN_HPP_NOEXCEPT
10709  {
10710  std::size_t seed = 0;
10711  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceZeroInitializeWorkgroupMemoryFeatures.sType );
10712  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceZeroInitializeWorkgroupMemoryFeatures.pNext );
10713  VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceZeroInitializeWorkgroupMemoryFeatures.shaderZeroInitializeWorkgroupMemory );
10714  return seed;
10715  }
10716  };
10717 
10718  template <>
10719  struct hash<VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo>
10720  {
10721  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo const & pipelineCacheCreateInfo ) const VULKAN_HPP_NOEXCEPT
10722  {
10723  std::size_t seed = 0;
10724  VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheCreateInfo.sType );
10725  VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheCreateInfo.pNext );
10726  VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheCreateInfo.flags );
10727  VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheCreateInfo.initialDataSize );
10728  VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheCreateInfo.pInitialData );
10729  return seed;
10730  }
10731  };
10732 
10733  template <>
10734  struct hash<VULKAN_HPP_NAMESPACE::PipelineCacheHeaderVersionOne>
10735  {
10736  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCacheHeaderVersionOne const & pipelineCacheHeaderVersionOne ) const VULKAN_HPP_NOEXCEPT
10737  {
10738  std::size_t seed = 0;
10739  VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheHeaderVersionOne.headerSize );
10740  VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheHeaderVersionOne.headerVersion );
10741  VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheHeaderVersionOne.vendorID );
10742  VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheHeaderVersionOne.deviceID );
10743  for ( size_t i = 0; i < VK_UUID_SIZE; ++i )
10744  {
10745  VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheHeaderVersionOne.pipelineCacheUUID[i] );
10746  }
10747  return seed;
10748  }
10749  };
10750 
10751  template <>
10752  struct hash<VULKAN_HPP_NAMESPACE::PipelineColorBlendAdvancedStateCreateInfoEXT>
10753  {
10754  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineColorBlendAdvancedStateCreateInfoEXT const & pipelineColorBlendAdvancedStateCreateInfoEXT ) const
10755  VULKAN_HPP_NOEXCEPT
10756  {
10757  std::size_t seed = 0;
10758  VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAdvancedStateCreateInfoEXT.sType );
10759  VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAdvancedStateCreateInfoEXT.pNext );
10760  VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAdvancedStateCreateInfoEXT.srcPremultiplied );
10761  VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAdvancedStateCreateInfoEXT.dstPremultiplied );
10762  VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAdvancedStateCreateInfoEXT.blendOverlap );
10763  return seed;
10764  }
10765  };
10766 
10767  template <>
10768  struct hash<VULKAN_HPP_NAMESPACE::PipelineColorWriteCreateInfoEXT>
10769  {
10770  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineColorWriteCreateInfoEXT const & pipelineColorWriteCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
10771  {
10772  std::size_t seed = 0;
10773  VULKAN_HPP_HASH_COMBINE( seed, pipelineColorWriteCreateInfoEXT.sType );
10774  VULKAN_HPP_HASH_COMBINE( seed, pipelineColorWriteCreateInfoEXT.pNext );
10775  VULKAN_HPP_HASH_COMBINE( seed, pipelineColorWriteCreateInfoEXT.attachmentCount );
10776  VULKAN_HPP_HASH_COMBINE( seed, pipelineColorWriteCreateInfoEXT.pColorWriteEnables );
10777  return seed;
10778  }
10779  };
10780 
10781  template <>
10782  struct hash<VULKAN_HPP_NAMESPACE::PipelineCompilerControlCreateInfoAMD>
10783  {
10784  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCompilerControlCreateInfoAMD const & pipelineCompilerControlCreateInfoAMD ) const VULKAN_HPP_NOEXCEPT
10785  {
10786  std::size_t seed = 0;
10787  VULKAN_HPP_HASH_COMBINE( seed, pipelineCompilerControlCreateInfoAMD.sType );
10788  VULKAN_HPP_HASH_COMBINE( seed, pipelineCompilerControlCreateInfoAMD.pNext );
10789  VULKAN_HPP_HASH_COMBINE( seed, pipelineCompilerControlCreateInfoAMD.compilerControlFlags );
10790  return seed;
10791  }
10792  };
10793 
10794  template <>
10795  struct hash<VULKAN_HPP_NAMESPACE::PipelineCoverageModulationStateCreateInfoNV>
10796  {
10797  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCoverageModulationStateCreateInfoNV const & pipelineCoverageModulationStateCreateInfoNV ) const
10798  VULKAN_HPP_NOEXCEPT
10799  {
10800  std::size_t seed = 0;
10801  VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageModulationStateCreateInfoNV.sType );
10802  VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageModulationStateCreateInfoNV.pNext );
10803  VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageModulationStateCreateInfoNV.flags );
10804  VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageModulationStateCreateInfoNV.coverageModulationMode );
10805  VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageModulationStateCreateInfoNV.coverageModulationTableEnable );
10806  VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageModulationStateCreateInfoNV.coverageModulationTableCount );
10807  VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageModulationStateCreateInfoNV.pCoverageModulationTable );
10808  return seed;
10809  }
10810  };
10811 
10812  template <>
10813  struct hash<VULKAN_HPP_NAMESPACE::PipelineCoverageReductionStateCreateInfoNV>
10814  {
10815  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCoverageReductionStateCreateInfoNV const & pipelineCoverageReductionStateCreateInfoNV ) const
10816  VULKAN_HPP_NOEXCEPT
10817  {
10818  std::size_t seed = 0;
10819  VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageReductionStateCreateInfoNV.sType );
10820  VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageReductionStateCreateInfoNV.pNext );
10821  VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageReductionStateCreateInfoNV.flags );
10822  VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageReductionStateCreateInfoNV.coverageReductionMode );
10823  return seed;
10824  }
10825  };
10826 
10827  template <>
10828  struct hash<VULKAN_HPP_NAMESPACE::PipelineCoverageToColorStateCreateInfoNV>
10829  {
10830  std::size_t
10831  operator()( VULKAN_HPP_NAMESPACE::PipelineCoverageToColorStateCreateInfoNV const & pipelineCoverageToColorStateCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
10832  {
10833  std::size_t seed = 0;
10834  VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageToColorStateCreateInfoNV.sType );
10835  VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageToColorStateCreateInfoNV.pNext );
10836  VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageToColorStateCreateInfoNV.flags );
10837  VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageToColorStateCreateInfoNV.coverageToColorEnable );
10838  VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageToColorStateCreateInfoNV.coverageToColorLocation );
10839  return seed;
10840  }
10841  };
10842 
10843  template <>
10844  struct hash<VULKAN_HPP_NAMESPACE::PipelineCreationFeedback>
10845  {
10846  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCreationFeedback const & pipelineCreationFeedback ) const VULKAN_HPP_NOEXCEPT
10847  {
10848  std::size_t seed = 0;
10849  VULKAN_HPP_HASH_COMBINE( seed, pipelineCreationFeedback.flags );
10850  VULKAN_HPP_HASH_COMBINE( seed, pipelineCreationFeedback.duration );
10851  return seed;
10852  }
10853  };
10854 
10855  template <>
10856  struct hash<VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackCreateInfo>
10857  {
10858  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackCreateInfo const & pipelineCreationFeedbackCreateInfo ) const VULKAN_HPP_NOEXCEPT
10859  {
10860  std::size_t seed = 0;
10861  VULKAN_HPP_HASH_COMBINE( seed, pipelineCreationFeedbackCreateInfo.sType );
10862  VULKAN_HPP_HASH_COMBINE( seed, pipelineCreationFeedbackCreateInfo.pNext );
10863  VULKAN_HPP_HASH_COMBINE( seed, pipelineCreationFeedbackCreateInfo.pPipelineCreationFeedback );
10864  VULKAN_HPP_HASH_COMBINE( seed, pipelineCreationFeedbackCreateInfo.pipelineStageCreationFeedbackCount );
10865  VULKAN_HPP_HASH_COMBINE( seed, pipelineCreationFeedbackCreateInfo.pPipelineStageCreationFeedbacks );
10866  return seed;
10867  }
10868  };
10869 
10870  template <>
10871  struct hash<VULKAN_HPP_NAMESPACE::PipelineDiscardRectangleStateCreateInfoEXT>
10872  {
10873  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineDiscardRectangleStateCreateInfoEXT const & pipelineDiscardRectangleStateCreateInfoEXT ) const
10874  VULKAN_HPP_NOEXCEPT
10875  {
10876  std::size_t seed = 0;
10877  VULKAN_HPP_HASH_COMBINE( seed, pipelineDiscardRectangleStateCreateInfoEXT.sType );
10878  VULKAN_HPP_HASH_COMBINE( seed, pipelineDiscardRectangleStateCreateInfoEXT.pNext );
10879  VULKAN_HPP_HASH_COMBINE( seed, pipelineDiscardRectangleStateCreateInfoEXT.flags );
10880  VULKAN_HPP_HASH_COMBINE( seed, pipelineDiscardRectangleStateCreateInfoEXT.discardRectangleMode );
10881  VULKAN_HPP_HASH_COMBINE( seed, pipelineDiscardRectangleStateCreateInfoEXT.discardRectangleCount );
10882  VULKAN_HPP_HASH_COMBINE( seed, pipelineDiscardRectangleStateCreateInfoEXT.pDiscardRectangles );
10883  return seed;
10884  }
10885  };
10886 
10887  template <>
10888  struct hash<VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR>
10889  {
10890  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR const & pipelineExecutableInfoKHR ) const VULKAN_HPP_NOEXCEPT
10891  {
10892  std::size_t seed = 0;
10893  VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInfoKHR.sType );
10894  VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInfoKHR.pNext );
10895  VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInfoKHR.pipeline );
10896  VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInfoKHR.executableIndex );
10897  return seed;
10898  }
10899  };
10900 
10901  template <>
10902  struct hash<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR>
10903  {
10904  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR const & pipelineExecutableInternalRepresentationKHR ) const
10905  VULKAN_HPP_NOEXCEPT
10906  {
10907  std::size_t seed = 0;
10908  VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInternalRepresentationKHR.sType );
10909  VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInternalRepresentationKHR.pNext );
10910  for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i )
10911  {
10912  VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInternalRepresentationKHR.name[i] );
10913  }
10914  for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i )
10915  {
10916  VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInternalRepresentationKHR.description[i] );
10917  }
10918  VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInternalRepresentationKHR.isText );
10919  VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInternalRepresentationKHR.dataSize );
10920  VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInternalRepresentationKHR.pData );
10921  return seed;
10922  }
10923  };
10924 
10925  template <>
10926  struct hash<VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR>
10927  {
10928  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR const & pipelineExecutablePropertiesKHR ) const VULKAN_HPP_NOEXCEPT
10929  {
10930  std::size_t seed = 0;
10931  VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutablePropertiesKHR.sType );
10932  VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutablePropertiesKHR.pNext );
10933  VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutablePropertiesKHR.stages );
10934  for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i )
10935  {
10936  VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutablePropertiesKHR.name[i] );
10937  }
10938  for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i )
10939  {
10940  VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutablePropertiesKHR.description[i] );
10941  }
10942  VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutablePropertiesKHR.subgroupSize );
10943  return seed;
10944  }
10945  };
10946 
10947  template <>
10948  struct hash<VULKAN_HPP_NAMESPACE::PipelineFragmentShadingRateEnumStateCreateInfoNV>
10949  {
10950  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineFragmentShadingRateEnumStateCreateInfoNV const & pipelineFragmentShadingRateEnumStateCreateInfoNV )
10951  const VULKAN_HPP_NOEXCEPT
10952  {
10953  std::size_t seed = 0;
10954  VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentShadingRateEnumStateCreateInfoNV.sType );
10955  VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentShadingRateEnumStateCreateInfoNV.pNext );
10956  VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentShadingRateEnumStateCreateInfoNV.shadingRateType );
10957  VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentShadingRateEnumStateCreateInfoNV.shadingRate );
10958  for ( size_t i = 0; i < 2; ++i )
10959  {
10960  VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentShadingRateEnumStateCreateInfoNV.combinerOps[i] );
10961  }
10962  return seed;
10963  }
10964  };
10965 
10966  template <>
10967  struct hash<VULKAN_HPP_NAMESPACE::PipelineFragmentShadingRateStateCreateInfoKHR>
10968  {
10969  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineFragmentShadingRateStateCreateInfoKHR const & pipelineFragmentShadingRateStateCreateInfoKHR ) const
10970  VULKAN_HPP_NOEXCEPT
10971  {
10972  std::size_t seed = 0;
10973  VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentShadingRateStateCreateInfoKHR.sType );
10974  VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentShadingRateStateCreateInfoKHR.pNext );
10975  VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentShadingRateStateCreateInfoKHR.fragmentSize );
10976  for ( size_t i = 0; i < 2; ++i )
10977  {
10978  VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentShadingRateStateCreateInfoKHR.combinerOps[i] );
10979  }
10980  return seed;
10981  }
10982  };
10983 
10984  template <>
10985  struct hash<VULKAN_HPP_NAMESPACE::PipelineInfoKHR>
10986  {
10987  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineInfoKHR const & pipelineInfoKHR ) const VULKAN_HPP_NOEXCEPT
10988  {
10989  std::size_t seed = 0;
10990  VULKAN_HPP_HASH_COMBINE( seed, pipelineInfoKHR.sType );
10991  VULKAN_HPP_HASH_COMBINE( seed, pipelineInfoKHR.pNext );
10992  VULKAN_HPP_HASH_COMBINE( seed, pipelineInfoKHR.pipeline );
10993  return seed;
10994  }
10995  };
10996 
10997  template <>
10998  struct hash<VULKAN_HPP_NAMESPACE::PushConstantRange>
10999  {
11000  std::size_t operator()( VULKAN_HPP_NAMESPACE::PushConstantRange const & pushConstantRange ) const VULKAN_HPP_NOEXCEPT
11001  {
11002  std::size_t seed = 0;
11003  VULKAN_HPP_HASH_COMBINE( seed, pushConstantRange.stageFlags );
11004  VULKAN_HPP_HASH_COMBINE( seed, pushConstantRange.offset );
11005  VULKAN_HPP_HASH_COMBINE( seed, pushConstantRange.size );
11006  return seed;
11007  }
11008  };
11009 
11010  template <>
11011  struct hash<VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo>
11012  {
11013  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo const & pipelineLayoutCreateInfo ) const VULKAN_HPP_NOEXCEPT
11014  {
11015  std::size_t seed = 0;
11016  VULKAN_HPP_HASH_COMBINE( seed, pipelineLayoutCreateInfo.sType );
11017  VULKAN_HPP_HASH_COMBINE( seed, pipelineLayoutCreateInfo.pNext );
11018  VULKAN_HPP_HASH_COMBINE( seed, pipelineLayoutCreateInfo.flags );
11019  VULKAN_HPP_HASH_COMBINE( seed, pipelineLayoutCreateInfo.setLayoutCount );
11020  VULKAN_HPP_HASH_COMBINE( seed, pipelineLayoutCreateInfo.pSetLayouts );
11021  VULKAN_HPP_HASH_COMBINE( seed, pipelineLayoutCreateInfo.pushConstantRangeCount );
11022  VULKAN_HPP_HASH_COMBINE( seed, pipelineLayoutCreateInfo.pPushConstantRanges );
11023  return seed;
11024  }
11025  };
11026 
11027  template <>
11028  struct hash<VULKAN_HPP_NAMESPACE::PipelineLibraryCreateInfoKHR>
11029  {
11030  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineLibraryCreateInfoKHR const & pipelineLibraryCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
11031  {
11032  std::size_t seed = 0;
11033  VULKAN_HPP_HASH_COMBINE( seed, pipelineLibraryCreateInfoKHR.sType );
11034  VULKAN_HPP_HASH_COMBINE( seed, pipelineLibraryCreateInfoKHR.pNext );
11035  VULKAN_HPP_HASH_COMBINE( seed, pipelineLibraryCreateInfoKHR.libraryCount );
11036  VULKAN_HPP_HASH_COMBINE( seed, pipelineLibraryCreateInfoKHR.pLibraries );
11037  return seed;
11038  }
11039  };
11040 
11041  template <>
11042  struct hash<VULKAN_HPP_NAMESPACE::PipelinePropertiesIdentifierEXT>
11043  {
11044  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelinePropertiesIdentifierEXT const & pipelinePropertiesIdentifierEXT ) const VULKAN_HPP_NOEXCEPT
11045  {
11046  std::size_t seed = 0;
11047  VULKAN_HPP_HASH_COMBINE( seed, pipelinePropertiesIdentifierEXT.sType );
11048  VULKAN_HPP_HASH_COMBINE( seed, pipelinePropertiesIdentifierEXT.pNext );
11049  for ( size_t i = 0; i < VK_UUID_SIZE; ++i )
11050  {
11051  VULKAN_HPP_HASH_COMBINE( seed, pipelinePropertiesIdentifierEXT.pipelineIdentifier[i] );
11052  }
11053  return seed;
11054  }
11055  };
11056 
11057  template <>
11058  struct hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationConservativeStateCreateInfoEXT>
11059  {
11060  std::size_t
11061  operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationConservativeStateCreateInfoEXT const & pipelineRasterizationConservativeStateCreateInfoEXT ) const
11062  VULKAN_HPP_NOEXCEPT
11063  {
11064  std::size_t seed = 0;
11065  VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationConservativeStateCreateInfoEXT.sType );
11066  VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationConservativeStateCreateInfoEXT.pNext );
11067  VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationConservativeStateCreateInfoEXT.flags );
11068  VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationConservativeStateCreateInfoEXT.conservativeRasterizationMode );
11069  VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationConservativeStateCreateInfoEXT.extraPrimitiveOverestimationSize );
11070  return seed;
11071  }
11072  };
11073 
11074  template <>
11075  struct hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationDepthClipStateCreateInfoEXT>
11076  {
11077  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationDepthClipStateCreateInfoEXT const & pipelineRasterizationDepthClipStateCreateInfoEXT )
11078  const VULKAN_HPP_NOEXCEPT
11079  {
11080  std::size_t seed = 0;
11081  VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationDepthClipStateCreateInfoEXT.sType );
11082  VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationDepthClipStateCreateInfoEXT.pNext );
11083  VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationDepthClipStateCreateInfoEXT.flags );
11084  VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationDepthClipStateCreateInfoEXT.depthClipEnable );
11085  return seed;
11086  }
11087  };
11088 
11089  template <>
11090  struct hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationLineStateCreateInfoEXT>
11091  {
11092  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationLineStateCreateInfoEXT const & pipelineRasterizationLineStateCreateInfoEXT ) const
11093  VULKAN_HPP_NOEXCEPT
11094  {
11095  std::size_t seed = 0;
11096  VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfoEXT.sType );
11097  VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfoEXT.pNext );
11098  VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfoEXT.lineRasterizationMode );
11099  VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfoEXT.stippledLineEnable );
11100  VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfoEXT.lineStippleFactor );
11101  VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfoEXT.lineStipplePattern );
11102  return seed;
11103  }
11104  };
11105 
11106  template <>
11107  struct hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationProvokingVertexStateCreateInfoEXT>
11108  {
11109  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationProvokingVertexStateCreateInfoEXT const &
11110  pipelineRasterizationProvokingVertexStateCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
11111  {
11112  std::size_t seed = 0;
11113  VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationProvokingVertexStateCreateInfoEXT.sType );
11114  VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationProvokingVertexStateCreateInfoEXT.pNext );
11115  VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationProvokingVertexStateCreateInfoEXT.provokingVertexMode );
11116  return seed;
11117  }
11118  };
11119 
11120  template <>
11121  struct hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationStateRasterizationOrderAMD>
11122  {
11123  std::size_t operator()(
11124  VULKAN_HPP_NAMESPACE::PipelineRasterizationStateRasterizationOrderAMD const & pipelineRasterizationStateRasterizationOrderAMD ) const VULKAN_HPP_NOEXCEPT
11125  {
11126  std::size_t seed = 0;
11127  VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateRasterizationOrderAMD.sType );
11128  VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateRasterizationOrderAMD.pNext );
11129  VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateRasterizationOrderAMD.rasterizationOrder );
11130  return seed;
11131  }
11132  };
11133 
11134  template <>
11135  struct hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationStateStreamCreateInfoEXT>
11136  {
11137  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationStateStreamCreateInfoEXT const & pipelineRasterizationStateStreamCreateInfoEXT ) const
11138  VULKAN_HPP_NOEXCEPT
11139  {
11140  std::size_t seed = 0;
11141  VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateStreamCreateInfoEXT.sType );
11142  VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateStreamCreateInfoEXT.pNext );
11143  VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateStreamCreateInfoEXT.flags );
11144  VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateStreamCreateInfoEXT.rasterizationStream );
11145  return seed;
11146  }
11147  };
11148 
11149  template <>
11150  struct hash<VULKAN_HPP_NAMESPACE::PipelineRenderingCreateInfo>
11151  {
11152  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRenderingCreateInfo const & pipelineRenderingCreateInfo ) const VULKAN_HPP_NOEXCEPT
11153  {
11154  std::size_t seed = 0;
11155  VULKAN_HPP_HASH_COMBINE( seed, pipelineRenderingCreateInfo.sType );
11156  VULKAN_HPP_HASH_COMBINE( seed, pipelineRenderingCreateInfo.pNext );
11157  VULKAN_HPP_HASH_COMBINE( seed, pipelineRenderingCreateInfo.viewMask );
11158  VULKAN_HPP_HASH_COMBINE( seed, pipelineRenderingCreateInfo.colorAttachmentCount );
11159  VULKAN_HPP_HASH_COMBINE( seed, pipelineRenderingCreateInfo.pColorAttachmentFormats );
11160  VULKAN_HPP_HASH_COMBINE( seed, pipelineRenderingCreateInfo.depthAttachmentFormat );
11161  VULKAN_HPP_HASH_COMBINE( seed, pipelineRenderingCreateInfo.stencilAttachmentFormat );
11162  return seed;
11163  }
11164  };
11165 
11166  template <>
11167  struct hash<VULKAN_HPP_NAMESPACE::PipelineRepresentativeFragmentTestStateCreateInfoNV>
11168  {
11169  std::size_t
11170  operator()( VULKAN_HPP_NAMESPACE::PipelineRepresentativeFragmentTestStateCreateInfoNV const & pipelineRepresentativeFragmentTestStateCreateInfoNV ) const
11171  VULKAN_HPP_NOEXCEPT
11172  {
11173  std::size_t seed = 0;
11174  VULKAN_HPP_HASH_COMBINE( seed, pipelineRepresentativeFragmentTestStateCreateInfoNV.sType );
11175  VULKAN_HPP_HASH_COMBINE( seed, pipelineRepresentativeFragmentTestStateCreateInfoNV.pNext );
11176  VULKAN_HPP_HASH_COMBINE( seed, pipelineRepresentativeFragmentTestStateCreateInfoNV.representativeFragmentTestEnable );
11177  return seed;
11178  }
11179  };
11180 
11181  template <>
11182  struct hash<VULKAN_HPP_NAMESPACE::PipelineRobustnessCreateInfoEXT>
11183  {
11184  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRobustnessCreateInfoEXT const & pipelineRobustnessCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
11185  {
11186  std::size_t seed = 0;
11187  VULKAN_HPP_HASH_COMBINE( seed, pipelineRobustnessCreateInfoEXT.sType );
11188  VULKAN_HPP_HASH_COMBINE( seed, pipelineRobustnessCreateInfoEXT.pNext );
11189  VULKAN_HPP_HASH_COMBINE( seed, pipelineRobustnessCreateInfoEXT.storageBuffers );
11190  VULKAN_HPP_HASH_COMBINE( seed, pipelineRobustnessCreateInfoEXT.uniformBuffers );
11191  VULKAN_HPP_HASH_COMBINE( seed, pipelineRobustnessCreateInfoEXT.vertexInputs );
11192  VULKAN_HPP_HASH_COMBINE( seed, pipelineRobustnessCreateInfoEXT.images );
11193  return seed;
11194  }
11195  };
11196 
11197  template <>
11198  struct hash<VULKAN_HPP_NAMESPACE::PipelineSampleLocationsStateCreateInfoEXT>
11199  {
11200  std::size_t
11201  operator()( VULKAN_HPP_NAMESPACE::PipelineSampleLocationsStateCreateInfoEXT const & pipelineSampleLocationsStateCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
11202  {
11203  std::size_t seed = 0;
11204  VULKAN_HPP_HASH_COMBINE( seed, pipelineSampleLocationsStateCreateInfoEXT.sType );
11205  VULKAN_HPP_HASH_COMBINE( seed, pipelineSampleLocationsStateCreateInfoEXT.pNext );
11206  VULKAN_HPP_HASH_COMBINE( seed, pipelineSampleLocationsStateCreateInfoEXT.sampleLocationsEnable );
11207  VULKAN_HPP_HASH_COMBINE( seed, pipelineSampleLocationsStateCreateInfoEXT.sampleLocationsInfo );
11208  return seed;
11209  }
11210  };
11211 
11212  template <>
11213  struct hash<VULKAN_HPP_NAMESPACE::PipelineShaderStageModuleIdentifierCreateInfoEXT>
11214  {
11215  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineShaderStageModuleIdentifierCreateInfoEXT const & pipelineShaderStageModuleIdentifierCreateInfoEXT )
11216  const VULKAN_HPP_NOEXCEPT
11217  {
11218  std::size_t seed = 0;
11219  VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageModuleIdentifierCreateInfoEXT.sType );
11220  VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageModuleIdentifierCreateInfoEXT.pNext );
11221  VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageModuleIdentifierCreateInfoEXT.identifierSize );
11222  VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageModuleIdentifierCreateInfoEXT.pIdentifier );
11223  return seed;
11224  }
11225  };
11226 
11227  template <>
11228  struct hash<VULKAN_HPP_NAMESPACE::PipelineShaderStageRequiredSubgroupSizeCreateInfo>
11229  {
11230  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineShaderStageRequiredSubgroupSizeCreateInfo const & pipelineShaderStageRequiredSubgroupSizeCreateInfo )
11231  const VULKAN_HPP_NOEXCEPT
11232  {
11233  std::size_t seed = 0;
11234  VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageRequiredSubgroupSizeCreateInfo.sType );
11235  VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageRequiredSubgroupSizeCreateInfo.pNext );
11236  VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageRequiredSubgroupSizeCreateInfo.requiredSubgroupSize );
11237  return seed;
11238  }
11239  };
11240 
11241  template <>
11242  struct hash<VULKAN_HPP_NAMESPACE::PipelineTessellationDomainOriginStateCreateInfo>
11243  {
11244  std::size_t operator()(
11245  VULKAN_HPP_NAMESPACE::PipelineTessellationDomainOriginStateCreateInfo const & pipelineTessellationDomainOriginStateCreateInfo ) const VULKAN_HPP_NOEXCEPT
11246  {
11247  std::size_t seed = 0;
11248  VULKAN_HPP_HASH_COMBINE( seed, pipelineTessellationDomainOriginStateCreateInfo.sType );
11249  VULKAN_HPP_HASH_COMBINE( seed, pipelineTessellationDomainOriginStateCreateInfo.pNext );
11250  VULKAN_HPP_HASH_COMBINE( seed, pipelineTessellationDomainOriginStateCreateInfo.domainOrigin );
11251  return seed;
11252  }
11253  };
11254 
11255  template <>
11256  struct hash<VULKAN_HPP_NAMESPACE::VertexInputBindingDivisorDescriptionEXT>
11257  {
11258  std::size_t
11259  operator()( VULKAN_HPP_NAMESPACE::VertexInputBindingDivisorDescriptionEXT const & vertexInputBindingDivisorDescriptionEXT ) const VULKAN_HPP_NOEXCEPT
11260  {
11261  std::size_t seed = 0;
11262  VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDivisorDescriptionEXT.binding );
11263  VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDivisorDescriptionEXT.divisor );
11264  return seed;
11265  }
11266  };
11267 
11268  template <>
11269  struct hash<VULKAN_HPP_NAMESPACE::PipelineVertexInputDivisorStateCreateInfoEXT>
11270  {
11271  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineVertexInputDivisorStateCreateInfoEXT const & pipelineVertexInputDivisorStateCreateInfoEXT ) const
11272  VULKAN_HPP_NOEXCEPT
11273  {
11274  std::size_t seed = 0;
11275  VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputDivisorStateCreateInfoEXT.sType );
11276  VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputDivisorStateCreateInfoEXT.pNext );
11277  VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputDivisorStateCreateInfoEXT.vertexBindingDivisorCount );
11278  VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputDivisorStateCreateInfoEXT.pVertexBindingDivisors );
11279  return seed;
11280  }
11281  };
11282 
11283  template <>
11284  struct hash<VULKAN_HPP_NAMESPACE::PipelineViewportCoarseSampleOrderStateCreateInfoNV>
11285  {
11286  std::size_t
11287  operator()( VULKAN_HPP_NAMESPACE::PipelineViewportCoarseSampleOrderStateCreateInfoNV const & pipelineViewportCoarseSampleOrderStateCreateInfoNV ) const
11288  VULKAN_HPP_NOEXCEPT
11289  {
11290  std::size_t seed = 0;
11291  VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportCoarseSampleOrderStateCreateInfoNV.sType );
11292  VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportCoarseSampleOrderStateCreateInfoNV.pNext );
11293  VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportCoarseSampleOrderStateCreateInfoNV.sampleOrderType );
11294  VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportCoarseSampleOrderStateCreateInfoNV.customSampleOrderCount );
11295  VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportCoarseSampleOrderStateCreateInfoNV.pCustomSampleOrders );
11296  return seed;
11297  }
11298  };
11299 
11300  template <>
11301  struct hash<VULKAN_HPP_NAMESPACE::PipelineViewportDepthClipControlCreateInfoEXT>
11302  {
11303  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineViewportDepthClipControlCreateInfoEXT const & pipelineViewportDepthClipControlCreateInfoEXT ) const
11304  VULKAN_HPP_NOEXCEPT
11305  {
11306  std::size_t seed = 0;
11307  VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportDepthClipControlCreateInfoEXT.sType );
11308  VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportDepthClipControlCreateInfoEXT.pNext );
11309  VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportDepthClipControlCreateInfoEXT.negativeOneToOne );
11310  return seed;
11311  }
11312  };
11313 
11314  template <>
11315  struct hash<VULKAN_HPP_NAMESPACE::PipelineViewportExclusiveScissorStateCreateInfoNV>
11316  {
11317  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineViewportExclusiveScissorStateCreateInfoNV const & pipelineViewportExclusiveScissorStateCreateInfoNV )
11318  const VULKAN_HPP_NOEXCEPT
11319  {
11320  std::size_t seed = 0;
11321  VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportExclusiveScissorStateCreateInfoNV.sType );
11322  VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportExclusiveScissorStateCreateInfoNV.pNext );
11323  VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportExclusiveScissorStateCreateInfoNV.exclusiveScissorCount );
11324  VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportExclusiveScissorStateCreateInfoNV.pExclusiveScissors );
11325  return seed;
11326  }
11327  };
11328 
11329  template <>
11330  struct hash<VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV>
11331  {
11332  std::size_t operator()( VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV const & shadingRatePaletteNV ) const VULKAN_HPP_NOEXCEPT
11333  {
11334  std::size_t seed = 0;
11335  VULKAN_HPP_HASH_COMBINE( seed, shadingRatePaletteNV.shadingRatePaletteEntryCount );
11336  VULKAN_HPP_HASH_COMBINE( seed, shadingRatePaletteNV.pShadingRatePaletteEntries );
11337  return seed;
11338  }
11339  };
11340 
11341  template <>
11342  struct hash<VULKAN_HPP_NAMESPACE::PipelineViewportShadingRateImageStateCreateInfoNV>
11343  {
11344  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineViewportShadingRateImageStateCreateInfoNV const & pipelineViewportShadingRateImageStateCreateInfoNV )
11345  const VULKAN_HPP_NOEXCEPT
11346  {
11347  std::size_t seed = 0;
11348  VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportShadingRateImageStateCreateInfoNV.sType );
11349  VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportShadingRateImageStateCreateInfoNV.pNext );
11350  VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportShadingRateImageStateCreateInfoNV.shadingRateImageEnable );
11351  VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportShadingRateImageStateCreateInfoNV.viewportCount );
11352  VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportShadingRateImageStateCreateInfoNV.pShadingRatePalettes );
11353  return seed;
11354  }
11355  };
11356 
11357  template <>
11358  struct hash<VULKAN_HPP_NAMESPACE::ViewportSwizzleNV>
11359  {
11360  std::size_t operator()( VULKAN_HPP_NAMESPACE::ViewportSwizzleNV const & viewportSwizzleNV ) const VULKAN_HPP_NOEXCEPT
11361  {
11362  std::size_t seed = 0;
11363  VULKAN_HPP_HASH_COMBINE( seed, viewportSwizzleNV.x );
11364  VULKAN_HPP_HASH_COMBINE( seed, viewportSwizzleNV.y );
11365  VULKAN_HPP_HASH_COMBINE( seed, viewportSwizzleNV.z );
11366  VULKAN_HPP_HASH_COMBINE( seed, viewportSwizzleNV.w );
11367  return seed;
11368  }
11369  };
11370 
11371  template <>
11372  struct hash<VULKAN_HPP_NAMESPACE::PipelineViewportSwizzleStateCreateInfoNV>
11373  {
11374  std::size_t
11375  operator()( VULKAN_HPP_NAMESPACE::PipelineViewportSwizzleStateCreateInfoNV const & pipelineViewportSwizzleStateCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
11376  {
11377  std::size_t seed = 0;
11378  VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportSwizzleStateCreateInfoNV.sType );
11379  VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportSwizzleStateCreateInfoNV.pNext );
11380  VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportSwizzleStateCreateInfoNV.flags );
11381  VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportSwizzleStateCreateInfoNV.viewportCount );
11382  VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportSwizzleStateCreateInfoNV.pViewportSwizzles );
11383  return seed;
11384  }
11385  };
11386 
11387  template <>
11388  struct hash<VULKAN_HPP_NAMESPACE::ViewportWScalingNV>
11389  {
11390  std::size_t operator()( VULKAN_HPP_NAMESPACE::ViewportWScalingNV const & viewportWScalingNV ) const VULKAN_HPP_NOEXCEPT
11391  {
11392  std::size_t seed = 0;
11393  VULKAN_HPP_HASH_COMBINE( seed, viewportWScalingNV.xcoeff );
11394  VULKAN_HPP_HASH_COMBINE( seed, viewportWScalingNV.ycoeff );
11395  return seed;
11396  }
11397  };
11398 
11399  template <>
11400  struct hash<VULKAN_HPP_NAMESPACE::PipelineViewportWScalingStateCreateInfoNV>
11401  {
11402  std::size_t
11403  operator()( VULKAN_HPP_NAMESPACE::PipelineViewportWScalingStateCreateInfoNV const & pipelineViewportWScalingStateCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
11404  {
11405  std::size_t seed = 0;
11406  VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportWScalingStateCreateInfoNV.sType );
11407  VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportWScalingStateCreateInfoNV.pNext );
11408  VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportWScalingStateCreateInfoNV.viewportWScalingEnable );
11409  VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportWScalingStateCreateInfoNV.viewportCount );
11410  VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportWScalingStateCreateInfoNV.pViewportWScalings );
11411  return seed;
11412  }
11413  };
11414 
11415 # if defined( VK_USE_PLATFORM_GGP )
11416  template <>
11417  struct hash<VULKAN_HPP_NAMESPACE::PresentFrameTokenGGP>
11418  {
11419  std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentFrameTokenGGP const & presentFrameTokenGGP ) const VULKAN_HPP_NOEXCEPT
11420  {
11421  std::size_t seed = 0;
11422  VULKAN_HPP_HASH_COMBINE( seed, presentFrameTokenGGP.sType );
11423  VULKAN_HPP_HASH_COMBINE( seed, presentFrameTokenGGP.pNext );
11424  VULKAN_HPP_HASH_COMBINE( seed, presentFrameTokenGGP.frameToken );
11425  return seed;
11426  }
11427  };
11428 # endif /*VK_USE_PLATFORM_GGP*/
11429 
11430  template <>
11431  struct hash<VULKAN_HPP_NAMESPACE::PresentIdKHR>
11432  {
11433  std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentIdKHR const & presentIdKHR ) const VULKAN_HPP_NOEXCEPT
11434  {
11435  std::size_t seed = 0;
11436  VULKAN_HPP_HASH_COMBINE( seed, presentIdKHR.sType );
11437  VULKAN_HPP_HASH_COMBINE( seed, presentIdKHR.pNext );
11438  VULKAN_HPP_HASH_COMBINE( seed, presentIdKHR.swapchainCount );
11439  VULKAN_HPP_HASH_COMBINE( seed, presentIdKHR.pPresentIds );
11440  return seed;
11441  }
11442  };
11443 
11444  template <>
11445  struct hash<VULKAN_HPP_NAMESPACE::PresentInfoKHR>
11446  {
11447  std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentInfoKHR const & presentInfoKHR ) const VULKAN_HPP_NOEXCEPT
11448  {
11449  std::size_t seed = 0;
11450  VULKAN_HPP_HASH_COMBINE( seed, presentInfoKHR.sType );
11451  VULKAN_HPP_HASH_COMBINE( seed, presentInfoKHR.pNext );
11452  VULKAN_HPP_HASH_COMBINE( seed, presentInfoKHR.waitSemaphoreCount );
11453  VULKAN_HPP_HASH_COMBINE( seed, presentInfoKHR.pWaitSemaphores );
11454  VULKAN_HPP_HASH_COMBINE( seed, presentInfoKHR.swapchainCount );
11455  VULKAN_HPP_HASH_COMBINE( seed, presentInfoKHR.pSwapchains );
11456  VULKAN_HPP_HASH_COMBINE( seed, presentInfoKHR.pImageIndices );
11457  VULKAN_HPP_HASH_COMBINE( seed, presentInfoKHR.pResults );
11458  return seed;
11459  }
11460  };
11461 
11462  template <>
11463  struct hash<VULKAN_HPP_NAMESPACE::RectLayerKHR>
11464  {
11465  std::size_t operator()( VULKAN_HPP_NAMESPACE::RectLayerKHR const & rectLayerKHR ) const VULKAN_HPP_NOEXCEPT
11466  {
11467  std::size_t seed = 0;
11468  VULKAN_HPP_HASH_COMBINE( seed, rectLayerKHR.offset );
11469  VULKAN_HPP_HASH_COMBINE( seed, rectLayerKHR.extent );
11470  VULKAN_HPP_HASH_COMBINE( seed, rectLayerKHR.layer );
11471  return seed;
11472  }
11473  };
11474 
11475  template <>
11476  struct hash<VULKAN_HPP_NAMESPACE::PresentRegionKHR>
11477  {
11478  std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentRegionKHR const & presentRegionKHR ) const VULKAN_HPP_NOEXCEPT
11479  {
11480  std::size_t seed = 0;
11481  VULKAN_HPP_HASH_COMBINE( seed, presentRegionKHR.rectangleCount );
11482  VULKAN_HPP_HASH_COMBINE( seed, presentRegionKHR.pRectangles );
11483  return seed;
11484  }
11485  };
11486 
11487  template <>
11488  struct hash<VULKAN_HPP_NAMESPACE::PresentRegionsKHR>
11489  {
11490  std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentRegionsKHR const & presentRegionsKHR ) const VULKAN_HPP_NOEXCEPT
11491  {
11492  std::size_t seed = 0;
11493  VULKAN_HPP_HASH_COMBINE( seed, presentRegionsKHR.sType );
11494  VULKAN_HPP_HASH_COMBINE( seed, presentRegionsKHR.pNext );
11495  VULKAN_HPP_HASH_COMBINE( seed, presentRegionsKHR.swapchainCount );
11496  VULKAN_HPP_HASH_COMBINE( seed, presentRegionsKHR.pRegions );
11497  return seed;
11498  }
11499  };
11500 
11501  template <>
11502  struct hash<VULKAN_HPP_NAMESPACE::PresentTimeGOOGLE>
11503  {
11504  std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentTimeGOOGLE const & presentTimeGOOGLE ) const VULKAN_HPP_NOEXCEPT
11505  {
11506  std::size_t seed = 0;
11507  VULKAN_HPP_HASH_COMBINE( seed, presentTimeGOOGLE.presentID );
11508  VULKAN_HPP_HASH_COMBINE( seed, presentTimeGOOGLE.desiredPresentTime );
11509  return seed;
11510  }
11511  };
11512 
11513  template <>
11514  struct hash<VULKAN_HPP_NAMESPACE::PresentTimesInfoGOOGLE>
11515  {
11516  std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentTimesInfoGOOGLE const & presentTimesInfoGOOGLE ) const VULKAN_HPP_NOEXCEPT
11517  {
11518  std::size_t seed = 0;
11519  VULKAN_HPP_HASH_COMBINE( seed, presentTimesInfoGOOGLE.sType );
11520  VULKAN_HPP_HASH_COMBINE( seed, presentTimesInfoGOOGLE.pNext );
11521  VULKAN_HPP_HASH_COMBINE( seed, presentTimesInfoGOOGLE.swapchainCount );
11522  VULKAN_HPP_HASH_COMBINE( seed, presentTimesInfoGOOGLE.pTimes );
11523  return seed;
11524  }
11525  };
11526 
11527  template <>
11528  struct hash<VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo>
11529  {
11530  std::size_t operator()( VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo const & privateDataSlotCreateInfo ) const VULKAN_HPP_NOEXCEPT
11531  {
11532  std::size_t seed = 0;
11533  VULKAN_HPP_HASH_COMBINE( seed, privateDataSlotCreateInfo.sType );
11534  VULKAN_HPP_HASH_COMBINE( seed, privateDataSlotCreateInfo.pNext );
11535  VULKAN_HPP_HASH_COMBINE( seed, privateDataSlotCreateInfo.flags );
11536  return seed;
11537  }
11538  };
11539 
11540  template <>
11541  struct hash<VULKAN_HPP_NAMESPACE::ProtectedSubmitInfo>
11542  {
11543  std::size_t operator()( VULKAN_HPP_NAMESPACE::ProtectedSubmitInfo const & protectedSubmitInfo ) const VULKAN_HPP_NOEXCEPT
11544  {
11545  std::size_t seed = 0;
11546  VULKAN_HPP_HASH_COMBINE( seed, protectedSubmitInfo.sType );
11547  VULKAN_HPP_HASH_COMBINE( seed, protectedSubmitInfo.pNext );
11548  VULKAN_HPP_HASH_COMBINE( seed, protectedSubmitInfo.protectedSubmit );
11549  return seed;
11550  }
11551  };
11552 
11553  template <>
11554  struct hash<VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo>
11555  {
11556  std::size_t operator()( VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo const & queryPoolCreateInfo ) const VULKAN_HPP_NOEXCEPT
11557  {
11558  std::size_t seed = 0;
11559  VULKAN_HPP_HASH_COMBINE( seed, queryPoolCreateInfo.sType );
11560  VULKAN_HPP_HASH_COMBINE( seed, queryPoolCreateInfo.pNext );
11561  VULKAN_HPP_HASH_COMBINE( seed, queryPoolCreateInfo.flags );
11562  VULKAN_HPP_HASH_COMBINE( seed, queryPoolCreateInfo.queryType );
11563  VULKAN_HPP_HASH_COMBINE( seed, queryPoolCreateInfo.queryCount );
11564  VULKAN_HPP_HASH_COMBINE( seed, queryPoolCreateInfo.pipelineStatistics );
11565  return seed;
11566  }
11567  };
11568 
11569  template <>
11570  struct hash<VULKAN_HPP_NAMESPACE::QueryPoolPerformanceCreateInfoKHR>
11571  {
11572  std::size_t operator()( VULKAN_HPP_NAMESPACE::QueryPoolPerformanceCreateInfoKHR const & queryPoolPerformanceCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
11573  {
11574  std::size_t seed = 0;
11575  VULKAN_HPP_HASH_COMBINE( seed, queryPoolPerformanceCreateInfoKHR.sType );
11576  VULKAN_HPP_HASH_COMBINE( seed, queryPoolPerformanceCreateInfoKHR.pNext );
11577  VULKAN_HPP_HASH_COMBINE( seed, queryPoolPerformanceCreateInfoKHR.queueFamilyIndex );
11578  VULKAN_HPP_HASH_COMBINE( seed, queryPoolPerformanceCreateInfoKHR.counterIndexCount );
11579  VULKAN_HPP_HASH_COMBINE( seed, queryPoolPerformanceCreateInfoKHR.pCounterIndices );
11580  return seed;
11581  }
11582  };
11583 
11584  template <>
11585  struct hash<VULKAN_HPP_NAMESPACE::QueryPoolPerformanceQueryCreateInfoINTEL>
11586  {
11587  std::size_t
11588  operator()( VULKAN_HPP_NAMESPACE::QueryPoolPerformanceQueryCreateInfoINTEL const & queryPoolPerformanceQueryCreateInfoINTEL ) const VULKAN_HPP_NOEXCEPT
11589  {
11590  std::size_t seed = 0;
11591  VULKAN_HPP_HASH_COMBINE( seed, queryPoolPerformanceQueryCreateInfoINTEL.sType );
11592  VULKAN_HPP_HASH_COMBINE( seed, queryPoolPerformanceQueryCreateInfoINTEL.pNext );
11593  VULKAN_HPP_HASH_COMBINE( seed, queryPoolPerformanceQueryCreateInfoINTEL.performanceCountersSampling );
11594  return seed;
11595  }
11596  };
11597 
11598  template <>
11599  struct hash<VULKAN_HPP_NAMESPACE::QueueFamilyCheckpointProperties2NV>
11600  {
11601  std::size_t operator()( VULKAN_HPP_NAMESPACE::QueueFamilyCheckpointProperties2NV const & queueFamilyCheckpointProperties2NV ) const VULKAN_HPP_NOEXCEPT
11602  {
11603  std::size_t seed = 0;
11604  VULKAN_HPP_HASH_COMBINE( seed, queueFamilyCheckpointProperties2NV.sType );
11605  VULKAN_HPP_HASH_COMBINE( seed, queueFamilyCheckpointProperties2NV.pNext );
11606  VULKAN_HPP_HASH_COMBINE( seed, queueFamilyCheckpointProperties2NV.checkpointExecutionStageMask );
11607  return seed;
11608  }
11609  };
11610 
11611  template <>
11612  struct hash<VULKAN_HPP_NAMESPACE::QueueFamilyCheckpointPropertiesNV>
11613  {
11614  std::size_t operator()( VULKAN_HPP_NAMESPACE::QueueFamilyCheckpointPropertiesNV const & queueFamilyCheckpointPropertiesNV ) const VULKAN_HPP_NOEXCEPT
11615  {
11616  std::size_t seed = 0;
11617  VULKAN_HPP_HASH_COMBINE( seed, queueFamilyCheckpointPropertiesNV.sType );
11618  VULKAN_HPP_HASH_COMBINE( seed, queueFamilyCheckpointPropertiesNV.pNext );
11619  VULKAN_HPP_HASH_COMBINE( seed, queueFamilyCheckpointPropertiesNV.checkpointExecutionStageMask );
11620  return seed;
11621  }
11622  };
11623 
11624  template <>
11625  struct hash<VULKAN_HPP_NAMESPACE::QueueFamilyGlobalPriorityPropertiesKHR>
11626  {
11627  std::size_t
11628  operator()( VULKAN_HPP_NAMESPACE::QueueFamilyGlobalPriorityPropertiesKHR const & queueFamilyGlobalPriorityPropertiesKHR ) const VULKAN_HPP_NOEXCEPT
11629  {
11630  std::size_t seed = 0;
11631  VULKAN_HPP_HASH_COMBINE( seed, queueFamilyGlobalPriorityPropertiesKHR.sType );
11632  VULKAN_HPP_HASH_COMBINE( seed, queueFamilyGlobalPriorityPropertiesKHR.pNext );
11633  VULKAN_HPP_HASH_COMBINE( seed, queueFamilyGlobalPriorityPropertiesKHR.priorityCount );
11634  for ( size_t i = 0; i < VK_MAX_GLOBAL_PRIORITY_SIZE_KHR; ++i )
11635  {
11636  VULKAN_HPP_HASH_COMBINE( seed, queueFamilyGlobalPriorityPropertiesKHR.priorities[i] );
11637  }
11638  return seed;
11639  }
11640  };
11641 
11642  template <>
11643  struct hash<VULKAN_HPP_NAMESPACE::QueueFamilyProperties>
11644  {
11645  std::size_t operator()( VULKAN_HPP_NAMESPACE::QueueFamilyProperties const & queueFamilyProperties ) const VULKAN_HPP_NOEXCEPT
11646  {
11647  std::size_t seed = 0;
11648  VULKAN_HPP_HASH_COMBINE( seed, queueFamilyProperties.queueFlags );
11649  VULKAN_HPP_HASH_COMBINE( seed, queueFamilyProperties.queueCount );
11650  VULKAN_HPP_HASH_COMBINE( seed, queueFamilyProperties.timestampValidBits );
11651  VULKAN_HPP_HASH_COMBINE( seed, queueFamilyProperties.minImageTransferGranularity );
11652  return seed;
11653  }
11654  };
11655 
11656  template <>
11657  struct hash<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>
11658  {
11659  std::size_t operator()( VULKAN_HPP_NAMESPACE::QueueFamilyProperties2 const & queueFamilyProperties2 ) const VULKAN_HPP_NOEXCEPT
11660  {
11661  std::size_t seed = 0;
11662  VULKAN_HPP_HASH_COMBINE( seed, queueFamilyProperties2.sType );
11663  VULKAN_HPP_HASH_COMBINE( seed, queueFamilyProperties2.pNext );
11664  VULKAN_HPP_HASH_COMBINE( seed, queueFamilyProperties2.queueFamilyProperties );
11665  return seed;
11666  }
11667  };
11668 
11669 # if defined( VK_ENABLE_BETA_EXTENSIONS )
11670  template <>
11671  struct hash<VULKAN_HPP_NAMESPACE::QueueFamilyQueryResultStatusPropertiesKHR>
11672  {
11673  std::size_t
11674  operator()( VULKAN_HPP_NAMESPACE::QueueFamilyQueryResultStatusPropertiesKHR const & queueFamilyQueryResultStatusPropertiesKHR ) const VULKAN_HPP_NOEXCEPT
11675  {
11676  std::size_t seed = 0;
11677  VULKAN_HPP_HASH_COMBINE( seed, queueFamilyQueryResultStatusPropertiesKHR.sType );
11678  VULKAN_HPP_HASH_COMBINE( seed, queueFamilyQueryResultStatusPropertiesKHR.pNext );
11679  VULKAN_HPP_HASH_COMBINE( seed, queueFamilyQueryResultStatusPropertiesKHR.queryResultStatusSupport );
11680  return seed;
11681  }
11682  };
11683 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
11684 
11685 # if defined( VK_ENABLE_BETA_EXTENSIONS )
11686  template <>
11687  struct hash<VULKAN_HPP_NAMESPACE::QueueFamilyVideoPropertiesKHR>
11688  {
11689  std::size_t operator()( VULKAN_HPP_NAMESPACE::QueueFamilyVideoPropertiesKHR const & queueFamilyVideoPropertiesKHR ) const VULKAN_HPP_NOEXCEPT
11690  {
11691  std::size_t seed = 0;
11692  VULKAN_HPP_HASH_COMBINE( seed, queueFamilyVideoPropertiesKHR.sType );
11693  VULKAN_HPP_HASH_COMBINE( seed, queueFamilyVideoPropertiesKHR.pNext );
11694  VULKAN_HPP_HASH_COMBINE( seed, queueFamilyVideoPropertiesKHR.videoCodecOperations );
11695  return seed;
11696  }
11697  };
11698 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
11699 
11700  template <>
11701  struct hash<VULKAN_HPP_NAMESPACE::RayTracingShaderGroupCreateInfoKHR>
11702  {
11703  std::size_t operator()( VULKAN_HPP_NAMESPACE::RayTracingShaderGroupCreateInfoKHR const & rayTracingShaderGroupCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
11704  {
11705  std::size_t seed = 0;
11706  VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoKHR.sType );
11707  VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoKHR.pNext );
11708  VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoKHR.type );
11709  VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoKHR.generalShader );
11710  VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoKHR.closestHitShader );
11711  VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoKHR.anyHitShader );
11712  VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoKHR.intersectionShader );
11713  VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoKHR.pShaderGroupCaptureReplayHandle );
11714  return seed;
11715  }
11716  };
11717 
11718  template <>
11719  struct hash<VULKAN_HPP_NAMESPACE::RayTracingPipelineInterfaceCreateInfoKHR>
11720  {
11721  std::size_t
11722  operator()( VULKAN_HPP_NAMESPACE::RayTracingPipelineInterfaceCreateInfoKHR const & rayTracingPipelineInterfaceCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
11723  {
11724  std::size_t seed = 0;
11725  VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineInterfaceCreateInfoKHR.sType );
11726  VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineInterfaceCreateInfoKHR.pNext );
11727  VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineInterfaceCreateInfoKHR.maxPipelineRayPayloadSize );
11728  VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineInterfaceCreateInfoKHR.maxPipelineRayHitAttributeSize );
11729  return seed;
11730  }
11731  };
11732 
11733  template <>
11734  struct hash<VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR>
11735  {
11736  std::size_t operator()( VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR const & rayTracingPipelineCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
11737  {
11738  std::size_t seed = 0;
11739  VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.sType );
11740  VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.pNext );
11741  VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.flags );
11742  VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.stageCount );
11743  VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.pStages );
11744  VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.groupCount );
11745  VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.pGroups );
11746  VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.maxPipelineRayRecursionDepth );
11747  VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.pLibraryInfo );
11748  VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.pLibraryInterface );
11749  VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.pDynamicState );
11750  VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.layout );
11751  VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.basePipelineHandle );
11752  VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.basePipelineIndex );
11753  return seed;
11754  }
11755  };
11756 
11757  template <>
11758  struct hash<VULKAN_HPP_NAMESPACE::RayTracingShaderGroupCreateInfoNV>
11759  {
11760  std::size_t operator()( VULKAN_HPP_NAMESPACE::RayTracingShaderGroupCreateInfoNV const & rayTracingShaderGroupCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
11761  {
11762  std::size_t seed = 0;
11763  VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoNV.sType );
11764  VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoNV.pNext );
11765  VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoNV.type );
11766  VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoNV.generalShader );
11767  VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoNV.closestHitShader );
11768  VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoNV.anyHitShader );
11769  VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoNV.intersectionShader );
11770  return seed;
11771  }
11772  };
11773 
11774  template <>
11775  struct hash<VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV>
11776  {
11777  std::size_t operator()( VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV const & rayTracingPipelineCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
11778  {
11779  std::size_t seed = 0;
11780  VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.sType );
11781  VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.pNext );
11782  VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.flags );
11783  VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.stageCount );
11784  VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.pStages );
11785  VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.groupCount );
11786  VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.pGroups );
11787  VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.maxRecursionDepth );
11788  VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.layout );
11789  VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.basePipelineHandle );
11790  VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.basePipelineIndex );
11791  return seed;
11792  }
11793  };
11794 
11795  template <>
11796  struct hash<VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE>
11797  {
11798  std::size_t operator()( VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE const & refreshCycleDurationGOOGLE ) const VULKAN_HPP_NOEXCEPT
11799  {
11800  std::size_t seed = 0;
11801  VULKAN_HPP_HASH_COMBINE( seed, refreshCycleDurationGOOGLE.refreshDuration );
11802  return seed;
11803  }
11804  };
11805 
11806  template <>
11807  struct hash<VULKAN_HPP_NAMESPACE::RenderPassAttachmentBeginInfo>
11808  {
11809  std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassAttachmentBeginInfo const & renderPassAttachmentBeginInfo ) const VULKAN_HPP_NOEXCEPT
11810  {
11811  std::size_t seed = 0;
11812  VULKAN_HPP_HASH_COMBINE( seed, renderPassAttachmentBeginInfo.sType );
11813  VULKAN_HPP_HASH_COMBINE( seed, renderPassAttachmentBeginInfo.pNext );
11814  VULKAN_HPP_HASH_COMBINE( seed, renderPassAttachmentBeginInfo.attachmentCount );
11815  VULKAN_HPP_HASH_COMBINE( seed, renderPassAttachmentBeginInfo.pAttachments );
11816  return seed;
11817  }
11818  };
11819 
11820  template <>
11821  struct hash<VULKAN_HPP_NAMESPACE::RenderPassBeginInfo>
11822  {
11823  std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassBeginInfo const & renderPassBeginInfo ) const VULKAN_HPP_NOEXCEPT
11824  {
11825  std::size_t seed = 0;
11826  VULKAN_HPP_HASH_COMBINE( seed, renderPassBeginInfo.sType );
11827  VULKAN_HPP_HASH_COMBINE( seed, renderPassBeginInfo.pNext );
11828  VULKAN_HPP_HASH_COMBINE( seed, renderPassBeginInfo.renderPass );
11829  VULKAN_HPP_HASH_COMBINE( seed, renderPassBeginInfo.framebuffer );
11830  VULKAN_HPP_HASH_COMBINE( seed, renderPassBeginInfo.renderArea );
11831  VULKAN_HPP_HASH_COMBINE( seed, renderPassBeginInfo.clearValueCount );
11832  VULKAN_HPP_HASH_COMBINE( seed, renderPassBeginInfo.pClearValues );
11833  return seed;
11834  }
11835  };
11836 
11837  template <>
11838  struct hash<VULKAN_HPP_NAMESPACE::SubpassDescription>
11839  {
11840  std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassDescription const & subpassDescription ) const VULKAN_HPP_NOEXCEPT
11841  {
11842  std::size_t seed = 0;
11843  VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.flags );
11844  VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.pipelineBindPoint );
11845  VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.inputAttachmentCount );
11846  VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.pInputAttachments );
11847  VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.colorAttachmentCount );
11848  VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.pColorAttachments );
11849  VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.pResolveAttachments );
11850  VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.pDepthStencilAttachment );
11851  VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.preserveAttachmentCount );
11852  VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.pPreserveAttachments );
11853  return seed;
11854  }
11855  };
11856 
11857  template <>
11858  struct hash<VULKAN_HPP_NAMESPACE::SubpassDependency>
11859  {
11860  std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassDependency const & subpassDependency ) const VULKAN_HPP_NOEXCEPT
11861  {
11862  std::size_t seed = 0;
11863  VULKAN_HPP_HASH_COMBINE( seed, subpassDependency.srcSubpass );
11864  VULKAN_HPP_HASH_COMBINE( seed, subpassDependency.dstSubpass );
11865  VULKAN_HPP_HASH_COMBINE( seed, subpassDependency.srcStageMask );
11866  VULKAN_HPP_HASH_COMBINE( seed, subpassDependency.dstStageMask );
11867  VULKAN_HPP_HASH_COMBINE( seed, subpassDependency.srcAccessMask );
11868  VULKAN_HPP_HASH_COMBINE( seed, subpassDependency.dstAccessMask );
11869  VULKAN_HPP_HASH_COMBINE( seed, subpassDependency.dependencyFlags );
11870  return seed;
11871  }
11872  };
11873 
11874  template <>
11875  struct hash<VULKAN_HPP_NAMESPACE::RenderPassCreateInfo>
11876  {
11877  std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassCreateInfo const & renderPassCreateInfo ) const VULKAN_HPP_NOEXCEPT
11878  {
11879  std::size_t seed = 0;
11880  VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo.sType );
11881  VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo.pNext );
11882  VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo.flags );
11883  VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo.attachmentCount );
11884  VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo.pAttachments );
11885  VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo.subpassCount );
11886  VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo.pSubpasses );
11887  VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo.dependencyCount );
11888  VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo.pDependencies );
11889  return seed;
11890  }
11891  };
11892 
11893  template <>
11894  struct hash<VULKAN_HPP_NAMESPACE::SubpassDescription2>
11895  {
11896  std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassDescription2 const & subpassDescription2 ) const VULKAN_HPP_NOEXCEPT
11897  {
11898  std::size_t seed = 0;
11899  VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.sType );
11900  VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.pNext );
11901  VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.flags );
11902  VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.pipelineBindPoint );
11903  VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.viewMask );
11904  VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.inputAttachmentCount );
11905  VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.pInputAttachments );
11906  VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.colorAttachmentCount );
11907  VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.pColorAttachments );
11908  VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.pResolveAttachments );
11909  VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.pDepthStencilAttachment );
11910  VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.preserveAttachmentCount );
11911  VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.pPreserveAttachments );
11912  return seed;
11913  }
11914  };
11915 
11916  template <>
11917  struct hash<VULKAN_HPP_NAMESPACE::SubpassDependency2>
11918  {
11919  std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassDependency2 const & subpassDependency2 ) const VULKAN_HPP_NOEXCEPT
11920  {
11921  std::size_t seed = 0;
11922  VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.sType );
11923  VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.pNext );
11924  VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.srcSubpass );
11925  VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.dstSubpass );
11926  VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.srcStageMask );
11927  VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.dstStageMask );
11928  VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.srcAccessMask );
11929  VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.dstAccessMask );
11930  VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.dependencyFlags );
11931  VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.viewOffset );
11932  return seed;
11933  }
11934  };
11935 
11936  template <>
11937  struct hash<VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2>
11938  {
11939  std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 const & renderPassCreateInfo2 ) const VULKAN_HPP_NOEXCEPT
11940  {
11941  std::size_t seed = 0;
11942  VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.sType );
11943  VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.pNext );
11944  VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.flags );
11945  VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.attachmentCount );
11946  VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.pAttachments );
11947  VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.subpassCount );
11948  VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.pSubpasses );
11949  VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.dependencyCount );
11950  VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.pDependencies );
11951  VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.correlatedViewMaskCount );
11952  VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.pCorrelatedViewMasks );
11953  return seed;
11954  }
11955  };
11956 
11957  template <>
11958  struct hash<VULKAN_HPP_NAMESPACE::RenderPassCreationControlEXT>
11959  {
11960  std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassCreationControlEXT const & renderPassCreationControlEXT ) const VULKAN_HPP_NOEXCEPT
11961  {
11962  std::size_t seed = 0;
11963  VULKAN_HPP_HASH_COMBINE( seed, renderPassCreationControlEXT.sType );
11964  VULKAN_HPP_HASH_COMBINE( seed, renderPassCreationControlEXT.pNext );
11965  VULKAN_HPP_HASH_COMBINE( seed, renderPassCreationControlEXT.disallowMerging );
11966  return seed;
11967  }
11968  };
11969 
11970  template <>
11971  struct hash<VULKAN_HPP_NAMESPACE::RenderPassCreationFeedbackInfoEXT>
11972  {
11973  std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassCreationFeedbackInfoEXT const & renderPassCreationFeedbackInfoEXT ) const VULKAN_HPP_NOEXCEPT
11974  {
11975  std::size_t seed = 0;
11976  VULKAN_HPP_HASH_COMBINE( seed, renderPassCreationFeedbackInfoEXT.postMergeSubpassCount );
11977  return seed;
11978  }
11979  };
11980 
11981  template <>
11982  struct hash<VULKAN_HPP_NAMESPACE::RenderPassCreationFeedbackCreateInfoEXT>
11983  {
11984  std::size_t
11985  operator()( VULKAN_HPP_NAMESPACE::RenderPassCreationFeedbackCreateInfoEXT const & renderPassCreationFeedbackCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
11986  {
11987  std::size_t seed = 0;
11988  VULKAN_HPP_HASH_COMBINE( seed, renderPassCreationFeedbackCreateInfoEXT.sType );
11989  VULKAN_HPP_HASH_COMBINE( seed, renderPassCreationFeedbackCreateInfoEXT.pNext );
11990  VULKAN_HPP_HASH_COMBINE( seed, renderPassCreationFeedbackCreateInfoEXT.pRenderPassFeedback );
11991  return seed;
11992  }
11993  };
11994 
11995  template <>
11996  struct hash<VULKAN_HPP_NAMESPACE::RenderPassFragmentDensityMapCreateInfoEXT>
11997  {
11998  std::size_t
11999  operator()( VULKAN_HPP_NAMESPACE::RenderPassFragmentDensityMapCreateInfoEXT const & renderPassFragmentDensityMapCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
12000  {
12001  std::size_t seed = 0;
12002  VULKAN_HPP_HASH_COMBINE( seed, renderPassFragmentDensityMapCreateInfoEXT.sType );
12003  VULKAN_HPP_HASH_COMBINE( seed, renderPassFragmentDensityMapCreateInfoEXT.pNext );
12004  VULKAN_HPP_HASH_COMBINE( seed, renderPassFragmentDensityMapCreateInfoEXT.fragmentDensityMapAttachment );
12005  return seed;
12006  }
12007  };
12008 
12009  template <>
12010  struct hash<VULKAN_HPP_NAMESPACE::RenderPassInputAttachmentAspectCreateInfo>
12011  {
12012  std::size_t
12013  operator()( VULKAN_HPP_NAMESPACE::RenderPassInputAttachmentAspectCreateInfo const & renderPassInputAttachmentAspectCreateInfo ) const VULKAN_HPP_NOEXCEPT
12014  {
12015  std::size_t seed = 0;
12016  VULKAN_HPP_HASH_COMBINE( seed, renderPassInputAttachmentAspectCreateInfo.sType );
12017  VULKAN_HPP_HASH_COMBINE( seed, renderPassInputAttachmentAspectCreateInfo.pNext );
12018  VULKAN_HPP_HASH_COMBINE( seed, renderPassInputAttachmentAspectCreateInfo.aspectReferenceCount );
12019  VULKAN_HPP_HASH_COMBINE( seed, renderPassInputAttachmentAspectCreateInfo.pAspectReferences );
12020  return seed;
12021  }
12022  };
12023 
12024  template <>
12025  struct hash<VULKAN_HPP_NAMESPACE::RenderPassMultiviewCreateInfo>
12026  {
12027  std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassMultiviewCreateInfo const & renderPassMultiviewCreateInfo ) const VULKAN_HPP_NOEXCEPT
12028  {
12029  std::size_t seed = 0;
12030  VULKAN_HPP_HASH_COMBINE( seed, renderPassMultiviewCreateInfo.sType );
12031  VULKAN_HPP_HASH_COMBINE( seed, renderPassMultiviewCreateInfo.pNext );
12032  VULKAN_HPP_HASH_COMBINE( seed, renderPassMultiviewCreateInfo.subpassCount );
12033  VULKAN_HPP_HASH_COMBINE( seed, renderPassMultiviewCreateInfo.pViewMasks );
12034  VULKAN_HPP_HASH_COMBINE( seed, renderPassMultiviewCreateInfo.dependencyCount );
12035  VULKAN_HPP_HASH_COMBINE( seed, renderPassMultiviewCreateInfo.pViewOffsets );
12036  VULKAN_HPP_HASH_COMBINE( seed, renderPassMultiviewCreateInfo.correlationMaskCount );
12037  VULKAN_HPP_HASH_COMBINE( seed, renderPassMultiviewCreateInfo.pCorrelationMasks );
12038  return seed;
12039  }
12040  };
12041 
12042  template <>
12043  struct hash<VULKAN_HPP_NAMESPACE::SubpassSampleLocationsEXT>
12044  {
12045  std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassSampleLocationsEXT const & subpassSampleLocationsEXT ) const VULKAN_HPP_NOEXCEPT
12046  {
12047  std::size_t seed = 0;
12048  VULKAN_HPP_HASH_COMBINE( seed, subpassSampleLocationsEXT.subpassIndex );
12049  VULKAN_HPP_HASH_COMBINE( seed, subpassSampleLocationsEXT.sampleLocationsInfo );
12050  return seed;
12051  }
12052  };
12053 
12054  template <>
12055  struct hash<VULKAN_HPP_NAMESPACE::RenderPassSampleLocationsBeginInfoEXT>
12056  {
12057  std::size_t
12058  operator()( VULKAN_HPP_NAMESPACE::RenderPassSampleLocationsBeginInfoEXT const & renderPassSampleLocationsBeginInfoEXT ) const VULKAN_HPP_NOEXCEPT
12059  {
12060  std::size_t seed = 0;
12061  VULKAN_HPP_HASH_COMBINE( seed, renderPassSampleLocationsBeginInfoEXT.sType );
12062  VULKAN_HPP_HASH_COMBINE( seed, renderPassSampleLocationsBeginInfoEXT.pNext );
12063  VULKAN_HPP_HASH_COMBINE( seed, renderPassSampleLocationsBeginInfoEXT.attachmentInitialSampleLocationsCount );
12064  VULKAN_HPP_HASH_COMBINE( seed, renderPassSampleLocationsBeginInfoEXT.pAttachmentInitialSampleLocations );
12065  VULKAN_HPP_HASH_COMBINE( seed, renderPassSampleLocationsBeginInfoEXT.postSubpassSampleLocationsCount );
12066  VULKAN_HPP_HASH_COMBINE( seed, renderPassSampleLocationsBeginInfoEXT.pPostSubpassSampleLocations );
12067  return seed;
12068  }
12069  };
12070 
12071  template <>
12072  struct hash<VULKAN_HPP_NAMESPACE::RenderPassSubpassFeedbackInfoEXT>
12073  {
12074  std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassSubpassFeedbackInfoEXT const & renderPassSubpassFeedbackInfoEXT ) const VULKAN_HPP_NOEXCEPT
12075  {
12076  std::size_t seed = 0;
12077  VULKAN_HPP_HASH_COMBINE( seed, renderPassSubpassFeedbackInfoEXT.subpassMergeStatus );
12078  for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i )
12079  {
12080  VULKAN_HPP_HASH_COMBINE( seed, renderPassSubpassFeedbackInfoEXT.description[i] );
12081  }
12082  VULKAN_HPP_HASH_COMBINE( seed, renderPassSubpassFeedbackInfoEXT.postMergeIndex );
12083  return seed;
12084  }
12085  };
12086 
12087  template <>
12088  struct hash<VULKAN_HPP_NAMESPACE::RenderPassSubpassFeedbackCreateInfoEXT>
12089  {
12090  std::size_t
12091  operator()( VULKAN_HPP_NAMESPACE::RenderPassSubpassFeedbackCreateInfoEXT const & renderPassSubpassFeedbackCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
12092  {
12093  std::size_t seed = 0;
12094  VULKAN_HPP_HASH_COMBINE( seed, renderPassSubpassFeedbackCreateInfoEXT.sType );
12095  VULKAN_HPP_HASH_COMBINE( seed, renderPassSubpassFeedbackCreateInfoEXT.pNext );
12096  VULKAN_HPP_HASH_COMBINE( seed, renderPassSubpassFeedbackCreateInfoEXT.pSubpassFeedback );
12097  return seed;
12098  }
12099  };
12100 
12101  template <>
12102  struct hash<VULKAN_HPP_NAMESPACE::RenderPassTransformBeginInfoQCOM>
12103  {
12104  std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassTransformBeginInfoQCOM const & renderPassTransformBeginInfoQCOM ) const VULKAN_HPP_NOEXCEPT
12105  {
12106  std::size_t seed = 0;
12107  VULKAN_HPP_HASH_COMBINE( seed, renderPassTransformBeginInfoQCOM.sType );
12108  VULKAN_HPP_HASH_COMBINE( seed, renderPassTransformBeginInfoQCOM.pNext );
12109  VULKAN_HPP_HASH_COMBINE( seed, renderPassTransformBeginInfoQCOM.transform );
12110  return seed;
12111  }
12112  };
12113 
12114  template <>
12115  struct hash<VULKAN_HPP_NAMESPACE::RenderingFragmentDensityMapAttachmentInfoEXT>
12116  {
12117  std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderingFragmentDensityMapAttachmentInfoEXT const & renderingFragmentDensityMapAttachmentInfoEXT ) const
12118  VULKAN_HPP_NOEXCEPT
12119  {
12120  std::size_t seed = 0;
12121  VULKAN_HPP_HASH_COMBINE( seed, renderingFragmentDensityMapAttachmentInfoEXT.sType );
12122  VULKAN_HPP_HASH_COMBINE( seed, renderingFragmentDensityMapAttachmentInfoEXT.pNext );
12123  VULKAN_HPP_HASH_COMBINE( seed, renderingFragmentDensityMapAttachmentInfoEXT.imageView );
12124  VULKAN_HPP_HASH_COMBINE( seed, renderingFragmentDensityMapAttachmentInfoEXT.imageLayout );
12125  return seed;
12126  }
12127  };
12128 
12129  template <>
12130  struct hash<VULKAN_HPP_NAMESPACE::RenderingFragmentShadingRateAttachmentInfoKHR>
12131  {
12132  std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderingFragmentShadingRateAttachmentInfoKHR const & renderingFragmentShadingRateAttachmentInfoKHR ) const
12133  VULKAN_HPP_NOEXCEPT
12134  {
12135  std::size_t seed = 0;
12136  VULKAN_HPP_HASH_COMBINE( seed, renderingFragmentShadingRateAttachmentInfoKHR.sType );
12137  VULKAN_HPP_HASH_COMBINE( seed, renderingFragmentShadingRateAttachmentInfoKHR.pNext );
12138  VULKAN_HPP_HASH_COMBINE( seed, renderingFragmentShadingRateAttachmentInfoKHR.imageView );
12139  VULKAN_HPP_HASH_COMBINE( seed, renderingFragmentShadingRateAttachmentInfoKHR.imageLayout );
12140  VULKAN_HPP_HASH_COMBINE( seed, renderingFragmentShadingRateAttachmentInfoKHR.shadingRateAttachmentTexelSize );
12141  return seed;
12142  }
12143  };
12144 
12145  template <>
12146  struct hash<VULKAN_HPP_NAMESPACE::RenderingInfo>
12147  {
12148  std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderingInfo const & renderingInfo ) const VULKAN_HPP_NOEXCEPT
12149  {
12150  std::size_t seed = 0;
12151  VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.sType );
12152  VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.pNext );
12153  VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.flags );
12154  VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.renderArea );
12155  VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.layerCount );
12156  VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.viewMask );
12157  VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.colorAttachmentCount );
12158  VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.pColorAttachments );
12159  VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.pDepthAttachment );
12160  VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.pStencilAttachment );
12161  return seed;
12162  }
12163  };
12164 
12165  template <>
12166  struct hash<VULKAN_HPP_NAMESPACE::ResolveImageInfo2>
12167  {
12168  std::size_t operator()( VULKAN_HPP_NAMESPACE::ResolveImageInfo2 const & resolveImageInfo2 ) const VULKAN_HPP_NOEXCEPT
12169  {
12170  std::size_t seed = 0;
12171  VULKAN_HPP_HASH_COMBINE( seed, resolveImageInfo2.sType );
12172  VULKAN_HPP_HASH_COMBINE( seed, resolveImageInfo2.pNext );
12173  VULKAN_HPP_HASH_COMBINE( seed, resolveImageInfo2.srcImage );
12174  VULKAN_HPP_HASH_COMBINE( seed, resolveImageInfo2.srcImageLayout );
12175  VULKAN_HPP_HASH_COMBINE( seed, resolveImageInfo2.dstImage );
12176  VULKAN_HPP_HASH_COMBINE( seed, resolveImageInfo2.dstImageLayout );
12177  VULKAN_HPP_HASH_COMBINE( seed, resolveImageInfo2.regionCount );
12178  VULKAN_HPP_HASH_COMBINE( seed, resolveImageInfo2.pRegions );
12179  return seed;
12180  }
12181  };
12182 
12183  template <>
12184  struct hash<VULKAN_HPP_NAMESPACE::SamplerBorderColorComponentMappingCreateInfoEXT>
12185  {
12186  std::size_t operator()(
12187  VULKAN_HPP_NAMESPACE::SamplerBorderColorComponentMappingCreateInfoEXT const & samplerBorderColorComponentMappingCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
12188  {
12189  std::size_t seed = 0;
12190  VULKAN_HPP_HASH_COMBINE( seed, samplerBorderColorComponentMappingCreateInfoEXT.sType );
12191  VULKAN_HPP_HASH_COMBINE( seed, samplerBorderColorComponentMappingCreateInfoEXT.pNext );
12192  VULKAN_HPP_HASH_COMBINE( seed, samplerBorderColorComponentMappingCreateInfoEXT.components );
12193  VULKAN_HPP_HASH_COMBINE( seed, samplerBorderColorComponentMappingCreateInfoEXT.srgb );
12194  return seed;
12195  }
12196  };
12197 
12198  template <>
12199  struct hash<VULKAN_HPP_NAMESPACE::SamplerCaptureDescriptorDataInfoEXT>
12200  {
12201  std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerCaptureDescriptorDataInfoEXT const & samplerCaptureDescriptorDataInfoEXT ) const VULKAN_HPP_NOEXCEPT
12202  {
12203  std::size_t seed = 0;
12204  VULKAN_HPP_HASH_COMBINE( seed, samplerCaptureDescriptorDataInfoEXT.sType );
12205  VULKAN_HPP_HASH_COMBINE( seed, samplerCaptureDescriptorDataInfoEXT.pNext );
12206  VULKAN_HPP_HASH_COMBINE( seed, samplerCaptureDescriptorDataInfoEXT.sampler );
12207  return seed;
12208  }
12209  };
12210 
12211  template <>
12212  struct hash<VULKAN_HPP_NAMESPACE::SamplerCreateInfo>
12213  {
12214  std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerCreateInfo const & samplerCreateInfo ) const VULKAN_HPP_NOEXCEPT
12215  {
12216  std::size_t seed = 0;
12217  VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.sType );
12218  VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.pNext );
12219  VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.flags );
12220  VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.magFilter );
12221  VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.minFilter );
12222  VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.mipmapMode );
12223  VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.addressModeU );
12224  VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.addressModeV );
12225  VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.addressModeW );
12226  VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.mipLodBias );
12227  VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.anisotropyEnable );
12228  VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.maxAnisotropy );
12229  VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.compareEnable );
12230  VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.compareOp );
12231  VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.minLod );
12232  VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.maxLod );
12233  VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.borderColor );
12234  VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.unnormalizedCoordinates );
12235  return seed;
12236  }
12237  };
12238 
12239  template <>
12240  struct hash<VULKAN_HPP_NAMESPACE::SamplerReductionModeCreateInfo>
12241  {
12242  std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerReductionModeCreateInfo const & samplerReductionModeCreateInfo ) const VULKAN_HPP_NOEXCEPT
12243  {
12244  std::size_t seed = 0;
12245  VULKAN_HPP_HASH_COMBINE( seed, samplerReductionModeCreateInfo.sType );
12246  VULKAN_HPP_HASH_COMBINE( seed, samplerReductionModeCreateInfo.pNext );
12247  VULKAN_HPP_HASH_COMBINE( seed, samplerReductionModeCreateInfo.reductionMode );
12248  return seed;
12249  }
12250  };
12251 
12252  template <>
12253  struct hash<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo>
12254  {
12255  std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo const & samplerYcbcrConversionCreateInfo ) const VULKAN_HPP_NOEXCEPT
12256  {
12257  std::size_t seed = 0;
12258  VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.sType );
12259  VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.pNext );
12260  VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.format );
12261  VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.ycbcrModel );
12262  VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.ycbcrRange );
12263  VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.components );
12264  VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.xChromaOffset );
12265  VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.yChromaOffset );
12266  VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.chromaFilter );
12267  VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.forceExplicitReconstruction );
12268  return seed;
12269  }
12270  };
12271 
12272  template <>
12273  struct hash<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionImageFormatProperties>
12274  {
12275  std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionImageFormatProperties const & samplerYcbcrConversionImageFormatProperties ) const
12276  VULKAN_HPP_NOEXCEPT
12277  {
12278  std::size_t seed = 0;
12279  VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionImageFormatProperties.sType );
12280  VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionImageFormatProperties.pNext );
12281  VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionImageFormatProperties.combinedImageSamplerDescriptorCount );
12282  return seed;
12283  }
12284  };
12285 
12286  template <>
12287  struct hash<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionInfo>
12288  {
12289  std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionInfo const & samplerYcbcrConversionInfo ) const VULKAN_HPP_NOEXCEPT
12290  {
12291  std::size_t seed = 0;
12292  VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionInfo.sType );
12293  VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionInfo.pNext );
12294  VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionInfo.conversion );
12295  return seed;
12296  }
12297  };
12298 
12299 # if defined( VK_USE_PLATFORM_SCREEN_QNX )
12300  template <>
12301  struct hash<VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX>
12302  {
12303  std::size_t operator()( VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX const & screenSurfaceCreateInfoQNX ) const VULKAN_HPP_NOEXCEPT
12304  {
12305  std::size_t seed = 0;
12306  VULKAN_HPP_HASH_COMBINE( seed, screenSurfaceCreateInfoQNX.sType );
12307  VULKAN_HPP_HASH_COMBINE( seed, screenSurfaceCreateInfoQNX.pNext );
12308  VULKAN_HPP_HASH_COMBINE( seed, screenSurfaceCreateInfoQNX.flags );
12309  VULKAN_HPP_HASH_COMBINE( seed, screenSurfaceCreateInfoQNX.context );
12310  VULKAN_HPP_HASH_COMBINE( seed, screenSurfaceCreateInfoQNX.window );
12311  return seed;
12312  }
12313  };
12314 # endif /*VK_USE_PLATFORM_SCREEN_QNX*/
12315 
12316  template <>
12317  struct hash<VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo>
12318  {
12319  std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo const & semaphoreCreateInfo ) const VULKAN_HPP_NOEXCEPT
12320  {
12321  std::size_t seed = 0;
12322  VULKAN_HPP_HASH_COMBINE( seed, semaphoreCreateInfo.sType );
12323  VULKAN_HPP_HASH_COMBINE( seed, semaphoreCreateInfo.pNext );
12324  VULKAN_HPP_HASH_COMBINE( seed, semaphoreCreateInfo.flags );
12325  return seed;
12326  }
12327  };
12328 
12329  template <>
12330  struct hash<VULKAN_HPP_NAMESPACE::SemaphoreGetFdInfoKHR>
12331  {
12332  std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreGetFdInfoKHR const & semaphoreGetFdInfoKHR ) const VULKAN_HPP_NOEXCEPT
12333  {
12334  std::size_t seed = 0;
12335  VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetFdInfoKHR.sType );
12336  VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetFdInfoKHR.pNext );
12337  VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetFdInfoKHR.semaphore );
12338  VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetFdInfoKHR.handleType );
12339  return seed;
12340  }
12341  };
12342 
12343 # if defined( VK_USE_PLATFORM_WIN32_KHR )
12344  template <>
12345  struct hash<VULKAN_HPP_NAMESPACE::SemaphoreGetWin32HandleInfoKHR>
12346  {
12347  std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreGetWin32HandleInfoKHR const & semaphoreGetWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT
12348  {
12349  std::size_t seed = 0;
12350  VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetWin32HandleInfoKHR.sType );
12351  VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetWin32HandleInfoKHR.pNext );
12352  VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetWin32HandleInfoKHR.semaphore );
12353  VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetWin32HandleInfoKHR.handleType );
12354  return seed;
12355  }
12356  };
12357 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
12358 
12359 # if defined( VK_USE_PLATFORM_FUCHSIA )
12360  template <>
12361  struct hash<VULKAN_HPP_NAMESPACE::SemaphoreGetZirconHandleInfoFUCHSIA>
12362  {
12363  std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreGetZirconHandleInfoFUCHSIA const & semaphoreGetZirconHandleInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT
12364  {
12365  std::size_t seed = 0;
12366  VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetZirconHandleInfoFUCHSIA.sType );
12367  VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetZirconHandleInfoFUCHSIA.pNext );
12368  VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetZirconHandleInfoFUCHSIA.semaphore );
12369  VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetZirconHandleInfoFUCHSIA.handleType );
12370  return seed;
12371  }
12372  };
12373 # endif /*VK_USE_PLATFORM_FUCHSIA*/
12374 
12375  template <>
12376  struct hash<VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo>
12377  {
12378  std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo const & semaphoreSignalInfo ) const VULKAN_HPP_NOEXCEPT
12379  {
12380  std::size_t seed = 0;
12381  VULKAN_HPP_HASH_COMBINE( seed, semaphoreSignalInfo.sType );
12382  VULKAN_HPP_HASH_COMBINE( seed, semaphoreSignalInfo.pNext );
12383  VULKAN_HPP_HASH_COMBINE( seed, semaphoreSignalInfo.semaphore );
12384  VULKAN_HPP_HASH_COMBINE( seed, semaphoreSignalInfo.value );
12385  return seed;
12386  }
12387  };
12388 
12389  template <>
12390  struct hash<VULKAN_HPP_NAMESPACE::SemaphoreSubmitInfo>
12391  {
12392  std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreSubmitInfo const & semaphoreSubmitInfo ) const VULKAN_HPP_NOEXCEPT
12393  {
12394  std::size_t seed = 0;
12395  VULKAN_HPP_HASH_COMBINE( seed, semaphoreSubmitInfo.sType );
12396  VULKAN_HPP_HASH_COMBINE( seed, semaphoreSubmitInfo.pNext );
12397  VULKAN_HPP_HASH_COMBINE( seed, semaphoreSubmitInfo.semaphore );
12398  VULKAN_HPP_HASH_COMBINE( seed, semaphoreSubmitInfo.value );
12399  VULKAN_HPP_HASH_COMBINE( seed, semaphoreSubmitInfo.stageMask );
12400  VULKAN_HPP_HASH_COMBINE( seed, semaphoreSubmitInfo.deviceIndex );
12401  return seed;
12402  }
12403  };
12404 
12405  template <>
12406  struct hash<VULKAN_HPP_NAMESPACE::SemaphoreTypeCreateInfo>
12407  {
12408  std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreTypeCreateInfo const & semaphoreTypeCreateInfo ) const VULKAN_HPP_NOEXCEPT
12409  {
12410  std::size_t seed = 0;
12411  VULKAN_HPP_HASH_COMBINE( seed, semaphoreTypeCreateInfo.sType );
12412  VULKAN_HPP_HASH_COMBINE( seed, semaphoreTypeCreateInfo.pNext );
12413  VULKAN_HPP_HASH_COMBINE( seed, semaphoreTypeCreateInfo.semaphoreType );
12414  VULKAN_HPP_HASH_COMBINE( seed, semaphoreTypeCreateInfo.initialValue );
12415  return seed;
12416  }
12417  };
12418 
12419  template <>
12420  struct hash<VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo>
12421  {
12422  std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo const & semaphoreWaitInfo ) const VULKAN_HPP_NOEXCEPT
12423  {
12424  std::size_t seed = 0;
12425  VULKAN_HPP_HASH_COMBINE( seed, semaphoreWaitInfo.sType );
12426  VULKAN_HPP_HASH_COMBINE( seed, semaphoreWaitInfo.pNext );
12427  VULKAN_HPP_HASH_COMBINE( seed, semaphoreWaitInfo.flags );
12428  VULKAN_HPP_HASH_COMBINE( seed, semaphoreWaitInfo.semaphoreCount );
12429  VULKAN_HPP_HASH_COMBINE( seed, semaphoreWaitInfo.pSemaphores );
12430  VULKAN_HPP_HASH_COMBINE( seed, semaphoreWaitInfo.pValues );
12431  return seed;
12432  }
12433  };
12434 
12435  template <>
12436  struct hash<VULKAN_HPP_NAMESPACE::SetStateFlagsIndirectCommandNV>
12437  {
12438  std::size_t operator()( VULKAN_HPP_NAMESPACE::SetStateFlagsIndirectCommandNV const & setStateFlagsIndirectCommandNV ) const VULKAN_HPP_NOEXCEPT
12439  {
12440  std::size_t seed = 0;
12441  VULKAN_HPP_HASH_COMBINE( seed, setStateFlagsIndirectCommandNV.data );
12442  return seed;
12443  }
12444  };
12445 
12446  template <>
12447  struct hash<VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo>
12448  {
12449  std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo const & shaderModuleCreateInfo ) const VULKAN_HPP_NOEXCEPT
12450  {
12451  std::size_t seed = 0;
12452  VULKAN_HPP_HASH_COMBINE( seed, shaderModuleCreateInfo.sType );
12453  VULKAN_HPP_HASH_COMBINE( seed, shaderModuleCreateInfo.pNext );
12454  VULKAN_HPP_HASH_COMBINE( seed, shaderModuleCreateInfo.flags );
12455  VULKAN_HPP_HASH_COMBINE( seed, shaderModuleCreateInfo.codeSize );
12456  VULKAN_HPP_HASH_COMBINE( seed, shaderModuleCreateInfo.pCode );
12457  return seed;
12458  }
12459  };
12460 
12461  template <>
12462  struct hash<VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT>
12463  {
12464  std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT const & shaderModuleIdentifierEXT ) const VULKAN_HPP_NOEXCEPT
12465  {
12466  std::size_t seed = 0;
12467  VULKAN_HPP_HASH_COMBINE( seed, shaderModuleIdentifierEXT.sType );
12468  VULKAN_HPP_HASH_COMBINE( seed, shaderModuleIdentifierEXT.pNext );
12469  VULKAN_HPP_HASH_COMBINE( seed, shaderModuleIdentifierEXT.identifierSize );
12470  for ( size_t i = 0; i < VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT; ++i )
12471  {
12472  VULKAN_HPP_HASH_COMBINE( seed, shaderModuleIdentifierEXT.identifier[i] );
12473  }
12474  return seed;
12475  }
12476  };
12477 
12478  template <>
12479  struct hash<VULKAN_HPP_NAMESPACE::ShaderModuleValidationCacheCreateInfoEXT>
12480  {
12481  std::size_t
12482  operator()( VULKAN_HPP_NAMESPACE::ShaderModuleValidationCacheCreateInfoEXT const & shaderModuleValidationCacheCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
12483  {
12484  std::size_t seed = 0;
12485  VULKAN_HPP_HASH_COMBINE( seed, shaderModuleValidationCacheCreateInfoEXT.sType );
12486  VULKAN_HPP_HASH_COMBINE( seed, shaderModuleValidationCacheCreateInfoEXT.pNext );
12487  VULKAN_HPP_HASH_COMBINE( seed, shaderModuleValidationCacheCreateInfoEXT.validationCache );
12488  return seed;
12489  }
12490  };
12491 
12492  template <>
12493  struct hash<VULKAN_HPP_NAMESPACE::ShaderResourceUsageAMD>
12494  {
12495  std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderResourceUsageAMD const & shaderResourceUsageAMD ) const VULKAN_HPP_NOEXCEPT
12496  {
12497  std::size_t seed = 0;
12498  VULKAN_HPP_HASH_COMBINE( seed, shaderResourceUsageAMD.numUsedVgprs );
12499  VULKAN_HPP_HASH_COMBINE( seed, shaderResourceUsageAMD.numUsedSgprs );
12500  VULKAN_HPP_HASH_COMBINE( seed, shaderResourceUsageAMD.ldsSizePerLocalWorkGroup );
12501  VULKAN_HPP_HASH_COMBINE( seed, shaderResourceUsageAMD.ldsUsageSizeInBytes );
12502  VULKAN_HPP_HASH_COMBINE( seed, shaderResourceUsageAMD.scratchMemUsageInBytes );
12503  return seed;
12504  }
12505  };
12506 
12507  template <>
12508  struct hash<VULKAN_HPP_NAMESPACE::ShaderStatisticsInfoAMD>
12509  {
12510  std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderStatisticsInfoAMD const & shaderStatisticsInfoAMD ) const VULKAN_HPP_NOEXCEPT
12511  {
12512  std::size_t seed = 0;
12513  VULKAN_HPP_HASH_COMBINE( seed, shaderStatisticsInfoAMD.shaderStageMask );
12514  VULKAN_HPP_HASH_COMBINE( seed, shaderStatisticsInfoAMD.resourceUsage );
12515  VULKAN_HPP_HASH_COMBINE( seed, shaderStatisticsInfoAMD.numPhysicalVgprs );
12516  VULKAN_HPP_HASH_COMBINE( seed, shaderStatisticsInfoAMD.numPhysicalSgprs );
12517  VULKAN_HPP_HASH_COMBINE( seed, shaderStatisticsInfoAMD.numAvailableVgprs );
12518  VULKAN_HPP_HASH_COMBINE( seed, shaderStatisticsInfoAMD.numAvailableSgprs );
12519  for ( size_t i = 0; i < 3; ++i )
12520  {
12521  VULKAN_HPP_HASH_COMBINE( seed, shaderStatisticsInfoAMD.computeWorkGroupSize[i] );
12522  }
12523  return seed;
12524  }
12525  };
12526 
12527  template <>
12528  struct hash<VULKAN_HPP_NAMESPACE::SharedPresentSurfaceCapabilitiesKHR>
12529  {
12530  std::size_t operator()( VULKAN_HPP_NAMESPACE::SharedPresentSurfaceCapabilitiesKHR const & sharedPresentSurfaceCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT
12531  {
12532  std::size_t seed = 0;
12533  VULKAN_HPP_HASH_COMBINE( seed, sharedPresentSurfaceCapabilitiesKHR.sType );
12534  VULKAN_HPP_HASH_COMBINE( seed, sharedPresentSurfaceCapabilitiesKHR.pNext );
12535  VULKAN_HPP_HASH_COMBINE( seed, sharedPresentSurfaceCapabilitiesKHR.sharedPresentSupportedUsageFlags );
12536  return seed;
12537  }
12538  };
12539 
12540  template <>
12541  struct hash<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties>
12542  {
12543  std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageFormatProperties const & sparseImageFormatProperties ) const VULKAN_HPP_NOEXCEPT
12544  {
12545  std::size_t seed = 0;
12546  VULKAN_HPP_HASH_COMBINE( seed, sparseImageFormatProperties.aspectMask );
12547  VULKAN_HPP_HASH_COMBINE( seed, sparseImageFormatProperties.imageGranularity );
12548  VULKAN_HPP_HASH_COMBINE( seed, sparseImageFormatProperties.flags );
12549  return seed;
12550  }
12551  };
12552 
12553  template <>
12554  struct hash<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>
12555  {
12556  std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2 const & sparseImageFormatProperties2 ) const VULKAN_HPP_NOEXCEPT
12557  {
12558  std::size_t seed = 0;
12559  VULKAN_HPP_HASH_COMBINE( seed, sparseImageFormatProperties2.sType );
12560  VULKAN_HPP_HASH_COMBINE( seed, sparseImageFormatProperties2.pNext );
12561  VULKAN_HPP_HASH_COMBINE( seed, sparseImageFormatProperties2.properties );
12562  return seed;
12563  }
12564  };
12565 
12566  template <>
12567  struct hash<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements>
12568  {
12569  std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements const & sparseImageMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
12570  {
12571  std::size_t seed = 0;
12572  VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryRequirements.formatProperties );
12573  VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryRequirements.imageMipTailFirstLod );
12574  VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryRequirements.imageMipTailSize );
12575  VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryRequirements.imageMipTailOffset );
12576  VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryRequirements.imageMipTailStride );
12577  return seed;
12578  }
12579  };
12580 
12581  template <>
12582  struct hash<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>
12583  {
12584  std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 const & sparseImageMemoryRequirements2 ) const VULKAN_HPP_NOEXCEPT
12585  {
12586  std::size_t seed = 0;
12587  VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryRequirements2.sType );
12588  VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryRequirements2.pNext );
12589  VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryRequirements2.memoryRequirements );
12590  return seed;
12591  }
12592  };
12593 
12594 # if defined( VK_USE_PLATFORM_GGP )
12595  template <>
12596  struct hash<VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP>
12597  {
12598  std::size_t operator()( VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP const & streamDescriptorSurfaceCreateInfoGGP ) const VULKAN_HPP_NOEXCEPT
12599  {
12600  std::size_t seed = 0;
12601  VULKAN_HPP_HASH_COMBINE( seed, streamDescriptorSurfaceCreateInfoGGP.sType );
12602  VULKAN_HPP_HASH_COMBINE( seed, streamDescriptorSurfaceCreateInfoGGP.pNext );
12603  VULKAN_HPP_HASH_COMBINE( seed, streamDescriptorSurfaceCreateInfoGGP.flags );
12604  VULKAN_HPP_HASH_COMBINE( seed, streamDescriptorSurfaceCreateInfoGGP.streamDescriptor );
12605  return seed;
12606  }
12607  };
12608 # endif /*VK_USE_PLATFORM_GGP*/
12609 
12610  template <>
12611  struct hash<VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR>
12612  {
12613  std::size_t operator()( VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR const & stridedDeviceAddressRegionKHR ) const VULKAN_HPP_NOEXCEPT
12614  {
12615  std::size_t seed = 0;
12616  VULKAN_HPP_HASH_COMBINE( seed, stridedDeviceAddressRegionKHR.deviceAddress );
12617  VULKAN_HPP_HASH_COMBINE( seed, stridedDeviceAddressRegionKHR.stride );
12618  VULKAN_HPP_HASH_COMBINE( seed, stridedDeviceAddressRegionKHR.size );
12619  return seed;
12620  }
12621  };
12622 
12623  template <>
12624  struct hash<VULKAN_HPP_NAMESPACE::SubmitInfo>
12625  {
12626  std::size_t operator()( VULKAN_HPP_NAMESPACE::SubmitInfo const & submitInfo ) const VULKAN_HPP_NOEXCEPT
12627  {
12628  std::size_t seed = 0;
12629  VULKAN_HPP_HASH_COMBINE( seed, submitInfo.sType );
12630  VULKAN_HPP_HASH_COMBINE( seed, submitInfo.pNext );
12631  VULKAN_HPP_HASH_COMBINE( seed, submitInfo.waitSemaphoreCount );
12632  VULKAN_HPP_HASH_COMBINE( seed, submitInfo.pWaitSemaphores );
12633  VULKAN_HPP_HASH_COMBINE( seed, submitInfo.pWaitDstStageMask );
12634  VULKAN_HPP_HASH_COMBINE( seed, submitInfo.commandBufferCount );
12635  VULKAN_HPP_HASH_COMBINE( seed, submitInfo.pCommandBuffers );
12636  VULKAN_HPP_HASH_COMBINE( seed, submitInfo.signalSemaphoreCount );
12637  VULKAN_HPP_HASH_COMBINE( seed, submitInfo.pSignalSemaphores );
12638  return seed;
12639  }
12640  };
12641 
12642  template <>
12643  struct hash<VULKAN_HPP_NAMESPACE::SubmitInfo2>
12644  {
12645  std::size_t operator()( VULKAN_HPP_NAMESPACE::SubmitInfo2 const & submitInfo2 ) const VULKAN_HPP_NOEXCEPT
12646  {
12647  std::size_t seed = 0;
12648  VULKAN_HPP_HASH_COMBINE( seed, submitInfo2.sType );
12649  VULKAN_HPP_HASH_COMBINE( seed, submitInfo2.pNext );
12650  VULKAN_HPP_HASH_COMBINE( seed, submitInfo2.flags );
12651  VULKAN_HPP_HASH_COMBINE( seed, submitInfo2.waitSemaphoreInfoCount );
12652  VULKAN_HPP_HASH_COMBINE( seed, submitInfo2.pWaitSemaphoreInfos );
12653  VULKAN_HPP_HASH_COMBINE( seed, submitInfo2.commandBufferInfoCount );
12654  VULKAN_HPP_HASH_COMBINE( seed, submitInfo2.pCommandBufferInfos );
12655  VULKAN_HPP_HASH_COMBINE( seed, submitInfo2.signalSemaphoreInfoCount );
12656  VULKAN_HPP_HASH_COMBINE( seed, submitInfo2.pSignalSemaphoreInfos );
12657  return seed;
12658  }
12659  };
12660 
12661  template <>
12662  struct hash<VULKAN_HPP_NAMESPACE::SubpassBeginInfo>
12663  {
12664  std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassBeginInfo const & subpassBeginInfo ) const VULKAN_HPP_NOEXCEPT
12665  {
12666  std::size_t seed = 0;
12667  VULKAN_HPP_HASH_COMBINE( seed, subpassBeginInfo.sType );
12668  VULKAN_HPP_HASH_COMBINE( seed, subpassBeginInfo.pNext );
12669  VULKAN_HPP_HASH_COMBINE( seed, subpassBeginInfo.contents );
12670  return seed;
12671  }
12672  };
12673 
12674  template <>
12675  struct hash<VULKAN_HPP_NAMESPACE::SubpassDescriptionDepthStencilResolve>
12676  {
12677  std::size_t
12678  operator()( VULKAN_HPP_NAMESPACE::SubpassDescriptionDepthStencilResolve const & subpassDescriptionDepthStencilResolve ) const VULKAN_HPP_NOEXCEPT
12679  {
12680  std::size_t seed = 0;
12681  VULKAN_HPP_HASH_COMBINE( seed, subpassDescriptionDepthStencilResolve.sType );
12682  VULKAN_HPP_HASH_COMBINE( seed, subpassDescriptionDepthStencilResolve.pNext );
12683  VULKAN_HPP_HASH_COMBINE( seed, subpassDescriptionDepthStencilResolve.depthResolveMode );
12684  VULKAN_HPP_HASH_COMBINE( seed, subpassDescriptionDepthStencilResolve.stencilResolveMode );
12685  VULKAN_HPP_HASH_COMBINE( seed, subpassDescriptionDepthStencilResolve.pDepthStencilResolveAttachment );
12686  return seed;
12687  }
12688  };
12689 
12690  template <>
12691  struct hash<VULKAN_HPP_NAMESPACE::SubpassEndInfo>
12692  {
12693  std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassEndInfo const & subpassEndInfo ) const VULKAN_HPP_NOEXCEPT
12694  {
12695  std::size_t seed = 0;
12696  VULKAN_HPP_HASH_COMBINE( seed, subpassEndInfo.sType );
12697  VULKAN_HPP_HASH_COMBINE( seed, subpassEndInfo.pNext );
12698  return seed;
12699  }
12700  };
12701 
12702  template <>
12703  struct hash<VULKAN_HPP_NAMESPACE::SubpassFragmentDensityMapOffsetEndInfoQCOM>
12704  {
12705  std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassFragmentDensityMapOffsetEndInfoQCOM const & subpassFragmentDensityMapOffsetEndInfoQCOM ) const
12706  VULKAN_HPP_NOEXCEPT
12707  {
12708  std::size_t seed = 0;
12709  VULKAN_HPP_HASH_COMBINE( seed, subpassFragmentDensityMapOffsetEndInfoQCOM.sType );
12710  VULKAN_HPP_HASH_COMBINE( seed, subpassFragmentDensityMapOffsetEndInfoQCOM.pNext );
12711  VULKAN_HPP_HASH_COMBINE( seed, subpassFragmentDensityMapOffsetEndInfoQCOM.fragmentDensityOffsetCount );
12712  VULKAN_HPP_HASH_COMBINE( seed, subpassFragmentDensityMapOffsetEndInfoQCOM.pFragmentDensityOffsets );
12713  return seed;
12714  }
12715  };
12716 
12717  template <>
12718  struct hash<VULKAN_HPP_NAMESPACE::SubpassResolvePerformanceQueryEXT>
12719  {
12720  std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassResolvePerformanceQueryEXT const & subpassResolvePerformanceQueryEXT ) const VULKAN_HPP_NOEXCEPT
12721  {
12722  std::size_t seed = 0;
12723  VULKAN_HPP_HASH_COMBINE( seed, subpassResolvePerformanceQueryEXT.sType );
12724  VULKAN_HPP_HASH_COMBINE( seed, subpassResolvePerformanceQueryEXT.pNext );
12725  VULKAN_HPP_HASH_COMBINE( seed, subpassResolvePerformanceQueryEXT.optimal );
12726  return seed;
12727  }
12728  };
12729 
12730  template <>
12731  struct hash<VULKAN_HPP_NAMESPACE::SubpassShadingPipelineCreateInfoHUAWEI>
12732  {
12733  std::size_t
12734  operator()( VULKAN_HPP_NAMESPACE::SubpassShadingPipelineCreateInfoHUAWEI const & subpassShadingPipelineCreateInfoHUAWEI ) const VULKAN_HPP_NOEXCEPT
12735  {
12736  std::size_t seed = 0;
12737  VULKAN_HPP_HASH_COMBINE( seed, subpassShadingPipelineCreateInfoHUAWEI.sType );
12738  VULKAN_HPP_HASH_COMBINE( seed, subpassShadingPipelineCreateInfoHUAWEI.pNext );
12739  VULKAN_HPP_HASH_COMBINE( seed, subpassShadingPipelineCreateInfoHUAWEI.renderPass );
12740  VULKAN_HPP_HASH_COMBINE( seed, subpassShadingPipelineCreateInfoHUAWEI.subpass );
12741  return seed;
12742  }
12743  };
12744 
12745  template <>
12746  struct hash<VULKAN_HPP_NAMESPACE::SubresourceLayout2EXT>
12747  {
12748  std::size_t operator()( VULKAN_HPP_NAMESPACE::SubresourceLayout2EXT const & subresourceLayout2EXT ) const VULKAN_HPP_NOEXCEPT
12749  {
12750  std::size_t seed = 0;
12751  VULKAN_HPP_HASH_COMBINE( seed, subresourceLayout2EXT.sType );
12752  VULKAN_HPP_HASH_COMBINE( seed, subresourceLayout2EXT.pNext );
12753  VULKAN_HPP_HASH_COMBINE( seed, subresourceLayout2EXT.subresourceLayout );
12754  return seed;
12755  }
12756  };
12757 
12758  template <>
12759  struct hash<VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT>
12760  {
12761  std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT const & surfaceCapabilities2EXT ) const VULKAN_HPP_NOEXCEPT
12762  {
12763  std::size_t seed = 0;
12764  VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.sType );
12765  VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.pNext );
12766  VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.minImageCount );
12767  VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.maxImageCount );
12768  VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.currentExtent );
12769  VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.minImageExtent );
12770  VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.maxImageExtent );
12771  VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.maxImageArrayLayers );
12772  VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.supportedTransforms );
12773  VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.currentTransform );
12774  VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.supportedCompositeAlpha );
12775  VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.supportedUsageFlags );
12776  VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.supportedSurfaceCounters );
12777  return seed;
12778  }
12779  };
12780 
12781  template <>
12782  struct hash<VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR>
12783  {
12784  std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR const & surfaceCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT
12785  {
12786  std::size_t seed = 0;
12787  VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.minImageCount );
12788  VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.maxImageCount );
12789  VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.currentExtent );
12790  VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.minImageExtent );
12791  VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.maxImageExtent );
12792  VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.maxImageArrayLayers );
12793  VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.supportedTransforms );
12794  VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.currentTransform );
12795  VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.supportedCompositeAlpha );
12796  VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.supportedUsageFlags );
12797  return seed;
12798  }
12799  };
12800 
12801  template <>
12802  struct hash<VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR>
12803  {
12804  std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR const & surfaceCapabilities2KHR ) const VULKAN_HPP_NOEXCEPT
12805  {
12806  std::size_t seed = 0;
12807  VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2KHR.sType );
12808  VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2KHR.pNext );
12809  VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2KHR.surfaceCapabilities );
12810  return seed;
12811  }
12812  };
12813 
12814 # if defined( VK_USE_PLATFORM_WIN32_KHR )
12815  template <>
12816  struct hash<VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesFullScreenExclusiveEXT>
12817  {
12818  std::size_t
12819  operator()( VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesFullScreenExclusiveEXT const & surfaceCapabilitiesFullScreenExclusiveEXT ) const VULKAN_HPP_NOEXCEPT
12820  {
12821  std::size_t seed = 0;
12822  VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesFullScreenExclusiveEXT.sType );
12823  VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesFullScreenExclusiveEXT.pNext );
12824  VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesFullScreenExclusiveEXT.fullScreenExclusiveSupported );
12825  return seed;
12826  }
12827  };
12828 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
12829 
12830  template <>
12831  struct hash<VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesPresentBarrierNV>
12832  {
12833  std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesPresentBarrierNV const & surfaceCapabilitiesPresentBarrierNV ) const VULKAN_HPP_NOEXCEPT
12834  {
12835  std::size_t seed = 0;
12836  VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesPresentBarrierNV.sType );
12837  VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesPresentBarrierNV.pNext );
12838  VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesPresentBarrierNV.presentBarrierSupported );
12839  return seed;
12840  }
12841  };
12842 
12843  template <>
12844  struct hash<VULKAN_HPP_NAMESPACE::SurfaceFormatKHR>
12845  {
12846  std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceFormatKHR const & surfaceFormatKHR ) const VULKAN_HPP_NOEXCEPT
12847  {
12848  std::size_t seed = 0;
12849  VULKAN_HPP_HASH_COMBINE( seed, surfaceFormatKHR.format );
12850  VULKAN_HPP_HASH_COMBINE( seed, surfaceFormatKHR.colorSpace );
12851  return seed;
12852  }
12853  };
12854 
12855  template <>
12856  struct hash<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR>
12857  {
12858  std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR const & surfaceFormat2KHR ) const VULKAN_HPP_NOEXCEPT
12859  {
12860  std::size_t seed = 0;
12861  VULKAN_HPP_HASH_COMBINE( seed, surfaceFormat2KHR.sType );
12862  VULKAN_HPP_HASH_COMBINE( seed, surfaceFormat2KHR.pNext );
12863  VULKAN_HPP_HASH_COMBINE( seed, surfaceFormat2KHR.surfaceFormat );
12864  return seed;
12865  }
12866  };
12867 
12868 # if defined( VK_USE_PLATFORM_WIN32_KHR )
12869  template <>
12870  struct hash<VULKAN_HPP_NAMESPACE::SurfaceFullScreenExclusiveInfoEXT>
12871  {
12872  std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceFullScreenExclusiveInfoEXT const & surfaceFullScreenExclusiveInfoEXT ) const VULKAN_HPP_NOEXCEPT
12873  {
12874  std::size_t seed = 0;
12875  VULKAN_HPP_HASH_COMBINE( seed, surfaceFullScreenExclusiveInfoEXT.sType );
12876  VULKAN_HPP_HASH_COMBINE( seed, surfaceFullScreenExclusiveInfoEXT.pNext );
12877  VULKAN_HPP_HASH_COMBINE( seed, surfaceFullScreenExclusiveInfoEXT.fullScreenExclusive );
12878  return seed;
12879  }
12880  };
12881 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
12882 
12883 # if defined( VK_USE_PLATFORM_WIN32_KHR )
12884  template <>
12885  struct hash<VULKAN_HPP_NAMESPACE::SurfaceFullScreenExclusiveWin32InfoEXT>
12886  {
12887  std::size_t
12888  operator()( VULKAN_HPP_NAMESPACE::SurfaceFullScreenExclusiveWin32InfoEXT const & surfaceFullScreenExclusiveWin32InfoEXT ) const VULKAN_HPP_NOEXCEPT
12889  {
12890  std::size_t seed = 0;
12891  VULKAN_HPP_HASH_COMBINE( seed, surfaceFullScreenExclusiveWin32InfoEXT.sType );
12892  VULKAN_HPP_HASH_COMBINE( seed, surfaceFullScreenExclusiveWin32InfoEXT.pNext );
12893  VULKAN_HPP_HASH_COMBINE( seed, surfaceFullScreenExclusiveWin32InfoEXT.hmonitor );
12894  return seed;
12895  }
12896  };
12897 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
12898 
12899  template <>
12900  struct hash<VULKAN_HPP_NAMESPACE::SurfaceProtectedCapabilitiesKHR>
12901  {
12902  std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceProtectedCapabilitiesKHR const & surfaceProtectedCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT
12903  {
12904  std::size_t seed = 0;
12905  VULKAN_HPP_HASH_COMBINE( seed, surfaceProtectedCapabilitiesKHR.sType );
12906  VULKAN_HPP_HASH_COMBINE( seed, surfaceProtectedCapabilitiesKHR.pNext );
12907  VULKAN_HPP_HASH_COMBINE( seed, surfaceProtectedCapabilitiesKHR.supportsProtected );
12908  return seed;
12909  }
12910  };
12911 
12912  template <>
12913  struct hash<VULKAN_HPP_NAMESPACE::SwapchainCounterCreateInfoEXT>
12914  {
12915  std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainCounterCreateInfoEXT const & swapchainCounterCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
12916  {
12917  std::size_t seed = 0;
12918  VULKAN_HPP_HASH_COMBINE( seed, swapchainCounterCreateInfoEXT.sType );
12919  VULKAN_HPP_HASH_COMBINE( seed, swapchainCounterCreateInfoEXT.pNext );
12920  VULKAN_HPP_HASH_COMBINE( seed, swapchainCounterCreateInfoEXT.surfaceCounters );
12921  return seed;
12922  }
12923  };
12924 
12925  template <>
12926  struct hash<VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR>
12927  {
12928  std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR const & swapchainCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
12929  {
12930  std::size_t seed = 0;
12931  VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.sType );
12932  VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.pNext );
12933  VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.flags );
12934  VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.surface );
12935  VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.minImageCount );
12936  VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.imageFormat );
12937  VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.imageColorSpace );
12938  VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.imageExtent );
12939  VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.imageArrayLayers );
12940  VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.imageUsage );
12941  VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.imageSharingMode );
12942  VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.queueFamilyIndexCount );
12943  VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.pQueueFamilyIndices );
12944  VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.preTransform );
12945  VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.compositeAlpha );
12946  VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.presentMode );
12947  VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.clipped );
12948  VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.oldSwapchain );
12949  return seed;
12950  }
12951  };
12952 
12953  template <>
12954  struct hash<VULKAN_HPP_NAMESPACE::SwapchainDisplayNativeHdrCreateInfoAMD>
12955  {
12956  std::size_t
12957  operator()( VULKAN_HPP_NAMESPACE::SwapchainDisplayNativeHdrCreateInfoAMD const & swapchainDisplayNativeHdrCreateInfoAMD ) const VULKAN_HPP_NOEXCEPT
12958  {
12959  std::size_t seed = 0;
12960  VULKAN_HPP_HASH_COMBINE( seed, swapchainDisplayNativeHdrCreateInfoAMD.sType );
12961  VULKAN_HPP_HASH_COMBINE( seed, swapchainDisplayNativeHdrCreateInfoAMD.pNext );
12962  VULKAN_HPP_HASH_COMBINE( seed, swapchainDisplayNativeHdrCreateInfoAMD.localDimmingEnable );
12963  return seed;
12964  }
12965  };
12966 
12967  template <>
12968  struct hash<VULKAN_HPP_NAMESPACE::SwapchainPresentBarrierCreateInfoNV>
12969  {
12970  std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainPresentBarrierCreateInfoNV const & swapchainPresentBarrierCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
12971  {
12972  std::size_t seed = 0;
12973  VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentBarrierCreateInfoNV.sType );
12974  VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentBarrierCreateInfoNV.pNext );
12975  VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentBarrierCreateInfoNV.presentBarrierEnable );
12976  return seed;
12977  }
12978  };
12979 
12980  template <>
12981  struct hash<VULKAN_HPP_NAMESPACE::TextureLODGatherFormatPropertiesAMD>
12982  {
12983  std::size_t operator()( VULKAN_HPP_NAMESPACE::TextureLODGatherFormatPropertiesAMD const & textureLODGatherFormatPropertiesAMD ) const VULKAN_HPP_NOEXCEPT
12984  {
12985  std::size_t seed = 0;
12986  VULKAN_HPP_HASH_COMBINE( seed, textureLODGatherFormatPropertiesAMD.sType );
12987  VULKAN_HPP_HASH_COMBINE( seed, textureLODGatherFormatPropertiesAMD.pNext );
12988  VULKAN_HPP_HASH_COMBINE( seed, textureLODGatherFormatPropertiesAMD.supportsTextureGatherLODBiasAMD );
12989  return seed;
12990  }
12991  };
12992 
12993  template <>
12994  struct hash<VULKAN_HPP_NAMESPACE::TilePropertiesQCOM>
12995  {
12996  std::size_t operator()( VULKAN_HPP_NAMESPACE::TilePropertiesQCOM const & tilePropertiesQCOM ) const VULKAN_HPP_NOEXCEPT
12997  {
12998  std::size_t seed = 0;
12999  VULKAN_HPP_HASH_COMBINE( seed, tilePropertiesQCOM.sType );
13000  VULKAN_HPP_HASH_COMBINE( seed, tilePropertiesQCOM.pNext );
13001  VULKAN_HPP_HASH_COMBINE( seed, tilePropertiesQCOM.tileSize );
13002  VULKAN_HPP_HASH_COMBINE( seed, tilePropertiesQCOM.apronSize );
13003  VULKAN_HPP_HASH_COMBINE( seed, tilePropertiesQCOM.origin );
13004  return seed;
13005  }
13006  };
13007 
13008  template <>
13009  struct hash<VULKAN_HPP_NAMESPACE::TimelineSemaphoreSubmitInfo>
13010  {
13011  std::size_t operator()( VULKAN_HPP_NAMESPACE::TimelineSemaphoreSubmitInfo const & timelineSemaphoreSubmitInfo ) const VULKAN_HPP_NOEXCEPT
13012  {
13013  std::size_t seed = 0;
13014  VULKAN_HPP_HASH_COMBINE( seed, timelineSemaphoreSubmitInfo.sType );
13015  VULKAN_HPP_HASH_COMBINE( seed, timelineSemaphoreSubmitInfo.pNext );
13016  VULKAN_HPP_HASH_COMBINE( seed, timelineSemaphoreSubmitInfo.waitSemaphoreValueCount );
13017  VULKAN_HPP_HASH_COMBINE( seed, timelineSemaphoreSubmitInfo.pWaitSemaphoreValues );
13018  VULKAN_HPP_HASH_COMBINE( seed, timelineSemaphoreSubmitInfo.signalSemaphoreValueCount );
13019  VULKAN_HPP_HASH_COMBINE( seed, timelineSemaphoreSubmitInfo.pSignalSemaphoreValues );
13020  return seed;
13021  }
13022  };
13023 
13024  template <>
13025  struct hash<VULKAN_HPP_NAMESPACE::TraceRaysIndirectCommand2KHR>
13026  {
13027  std::size_t operator()( VULKAN_HPP_NAMESPACE::TraceRaysIndirectCommand2KHR const & traceRaysIndirectCommand2KHR ) const VULKAN_HPP_NOEXCEPT
13028  {
13029  std::size_t seed = 0;
13030  VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.raygenShaderRecordAddress );
13031  VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.raygenShaderRecordSize );
13032  VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.missShaderBindingTableAddress );
13033  VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.missShaderBindingTableSize );
13034  VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.missShaderBindingTableStride );
13035  VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.hitShaderBindingTableAddress );
13036  VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.hitShaderBindingTableSize );
13037  VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.hitShaderBindingTableStride );
13038  VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.callableShaderBindingTableAddress );
13039  VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.callableShaderBindingTableSize );
13040  VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.callableShaderBindingTableStride );
13041  VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.width );
13042  VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.height );
13043  VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.depth );
13044  return seed;
13045  }
13046  };
13047 
13048  template <>
13049  struct hash<VULKAN_HPP_NAMESPACE::TraceRaysIndirectCommandKHR>
13050  {
13051  std::size_t operator()( VULKAN_HPP_NAMESPACE::TraceRaysIndirectCommandKHR const & traceRaysIndirectCommandKHR ) const VULKAN_HPP_NOEXCEPT
13052  {
13053  std::size_t seed = 0;
13054  VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommandKHR.width );
13055  VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommandKHR.height );
13056  VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommandKHR.depth );
13057  return seed;
13058  }
13059  };
13060 
13061  template <>
13062  struct hash<VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT>
13063  {
13064  std::size_t operator()( VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT const & validationCacheCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
13065  {
13066  std::size_t seed = 0;
13067  VULKAN_HPP_HASH_COMBINE( seed, validationCacheCreateInfoEXT.sType );
13068  VULKAN_HPP_HASH_COMBINE( seed, validationCacheCreateInfoEXT.pNext );
13069  VULKAN_HPP_HASH_COMBINE( seed, validationCacheCreateInfoEXT.flags );
13070  VULKAN_HPP_HASH_COMBINE( seed, validationCacheCreateInfoEXT.initialDataSize );
13071  VULKAN_HPP_HASH_COMBINE( seed, validationCacheCreateInfoEXT.pInitialData );
13072  return seed;
13073  }
13074  };
13075 
13076  template <>
13077  struct hash<VULKAN_HPP_NAMESPACE::ValidationFeaturesEXT>
13078  {
13079  std::size_t operator()( VULKAN_HPP_NAMESPACE::ValidationFeaturesEXT const & validationFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
13080  {
13081  std::size_t seed = 0;
13082  VULKAN_HPP_HASH_COMBINE( seed, validationFeaturesEXT.sType );
13083  VULKAN_HPP_HASH_COMBINE( seed, validationFeaturesEXT.pNext );
13084  VULKAN_HPP_HASH_COMBINE( seed, validationFeaturesEXT.enabledValidationFeatureCount );
13085  VULKAN_HPP_HASH_COMBINE( seed, validationFeaturesEXT.pEnabledValidationFeatures );
13086  VULKAN_HPP_HASH_COMBINE( seed, validationFeaturesEXT.disabledValidationFeatureCount );
13087  VULKAN_HPP_HASH_COMBINE( seed, validationFeaturesEXT.pDisabledValidationFeatures );
13088  return seed;
13089  }
13090  };
13091 
13092  template <>
13093  struct hash<VULKAN_HPP_NAMESPACE::ValidationFlagsEXT>
13094  {
13095  std::size_t operator()( VULKAN_HPP_NAMESPACE::ValidationFlagsEXT const & validationFlagsEXT ) const VULKAN_HPP_NOEXCEPT
13096  {
13097  std::size_t seed = 0;
13098  VULKAN_HPP_HASH_COMBINE( seed, validationFlagsEXT.sType );
13099  VULKAN_HPP_HASH_COMBINE( seed, validationFlagsEXT.pNext );
13100  VULKAN_HPP_HASH_COMBINE( seed, validationFlagsEXT.disabledValidationCheckCount );
13101  VULKAN_HPP_HASH_COMBINE( seed, validationFlagsEXT.pDisabledValidationChecks );
13102  return seed;
13103  }
13104  };
13105 
13106  template <>
13107  struct hash<VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT>
13108  {
13109  std::size_t operator()( VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT const & vertexInputAttributeDescription2EXT ) const VULKAN_HPP_NOEXCEPT
13110  {
13111  std::size_t seed = 0;
13112  VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription2EXT.sType );
13113  VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription2EXT.pNext );
13114  VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription2EXT.location );
13115  VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription2EXT.binding );
13116  VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription2EXT.format );
13117  VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription2EXT.offset );
13118  return seed;
13119  }
13120  };
13121 
13122  template <>
13123  struct hash<VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT>
13124  {
13125  std::size_t operator()( VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT const & vertexInputBindingDescription2EXT ) const VULKAN_HPP_NOEXCEPT
13126  {
13127  std::size_t seed = 0;
13128  VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDescription2EXT.sType );
13129  VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDescription2EXT.pNext );
13130  VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDescription2EXT.binding );
13131  VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDescription2EXT.stride );
13132  VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDescription2EXT.inputRate );
13133  VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDescription2EXT.divisor );
13134  return seed;
13135  }
13136  };
13137 
13138 # if defined( VK_USE_PLATFORM_VI_NN )
13139  template <>
13140  struct hash<VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN>
13141  {
13142  std::size_t operator()( VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN const & viSurfaceCreateInfoNN ) const VULKAN_HPP_NOEXCEPT
13143  {
13144  std::size_t seed = 0;
13145  VULKAN_HPP_HASH_COMBINE( seed, viSurfaceCreateInfoNN.sType );
13146  VULKAN_HPP_HASH_COMBINE( seed, viSurfaceCreateInfoNN.pNext );
13147  VULKAN_HPP_HASH_COMBINE( seed, viSurfaceCreateInfoNN.flags );
13148  VULKAN_HPP_HASH_COMBINE( seed, viSurfaceCreateInfoNN.window );
13149  return seed;
13150  }
13151  };
13152 # endif /*VK_USE_PLATFORM_VI_NN*/
13153 
13154 # if defined( VK_ENABLE_BETA_EXTENSIONS )
13155  template <>
13156  struct hash<VULKAN_HPP_NAMESPACE::VideoPictureResourceInfoKHR>
13157  {
13158  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoPictureResourceInfoKHR const & videoPictureResourceInfoKHR ) const VULKAN_HPP_NOEXCEPT
13159  {
13160  std::size_t seed = 0;
13161  VULKAN_HPP_HASH_COMBINE( seed, videoPictureResourceInfoKHR.sType );
13162  VULKAN_HPP_HASH_COMBINE( seed, videoPictureResourceInfoKHR.pNext );
13163  VULKAN_HPP_HASH_COMBINE( seed, videoPictureResourceInfoKHR.codedOffset );
13164  VULKAN_HPP_HASH_COMBINE( seed, videoPictureResourceInfoKHR.codedExtent );
13165  VULKAN_HPP_HASH_COMBINE( seed, videoPictureResourceInfoKHR.baseArrayLayer );
13166  VULKAN_HPP_HASH_COMBINE( seed, videoPictureResourceInfoKHR.imageViewBinding );
13167  return seed;
13168  }
13169  };
13170 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
13171 
13172 # if defined( VK_ENABLE_BETA_EXTENSIONS )
13173  template <>
13174  struct hash<VULKAN_HPP_NAMESPACE::VideoReferenceSlotInfoKHR>
13175  {
13176  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoReferenceSlotInfoKHR const & videoReferenceSlotInfoKHR ) const VULKAN_HPP_NOEXCEPT
13177  {
13178  std::size_t seed = 0;
13179  VULKAN_HPP_HASH_COMBINE( seed, videoReferenceSlotInfoKHR.sType );
13180  VULKAN_HPP_HASH_COMBINE( seed, videoReferenceSlotInfoKHR.pNext );
13181  VULKAN_HPP_HASH_COMBINE( seed, videoReferenceSlotInfoKHR.slotIndex );
13182  VULKAN_HPP_HASH_COMBINE( seed, videoReferenceSlotInfoKHR.pPictureResource );
13183  return seed;
13184  }
13185  };
13186 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
13187 
13188 # if defined( VK_ENABLE_BETA_EXTENSIONS )
13189  template <>
13190  struct hash<VULKAN_HPP_NAMESPACE::VideoBeginCodingInfoKHR>
13191  {
13192  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoBeginCodingInfoKHR const & videoBeginCodingInfoKHR ) const VULKAN_HPP_NOEXCEPT
13193  {
13194  std::size_t seed = 0;
13195  VULKAN_HPP_HASH_COMBINE( seed, videoBeginCodingInfoKHR.sType );
13196  VULKAN_HPP_HASH_COMBINE( seed, videoBeginCodingInfoKHR.pNext );
13197  VULKAN_HPP_HASH_COMBINE( seed, videoBeginCodingInfoKHR.flags );
13198  VULKAN_HPP_HASH_COMBINE( seed, videoBeginCodingInfoKHR.videoSession );
13199  VULKAN_HPP_HASH_COMBINE( seed, videoBeginCodingInfoKHR.videoSessionParameters );
13200  VULKAN_HPP_HASH_COMBINE( seed, videoBeginCodingInfoKHR.referenceSlotCount );
13201  VULKAN_HPP_HASH_COMBINE( seed, videoBeginCodingInfoKHR.pReferenceSlots );
13202  return seed;
13203  }
13204  };
13205 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
13206 
13207 # if defined( VK_ENABLE_BETA_EXTENSIONS )
13208  template <>
13209  struct hash<VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR>
13210  {
13211  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR const & videoCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT
13212  {
13213  std::size_t seed = 0;
13214  VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.sType );
13215  VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.pNext );
13216  VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.flags );
13217  VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.minBitstreamBufferOffsetAlignment );
13218  VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.minBitstreamBufferSizeAlignment );
13219  VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.pictureAccessGranularity );
13220  VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.minCodedExtent );
13221  VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.maxCodedExtent );
13222  VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.maxDpbSlots );
13223  VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.maxActiveReferencePictures );
13224  VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.stdHeaderVersion );
13225  return seed;
13226  }
13227  };
13228 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
13229 
13230 # if defined( VK_ENABLE_BETA_EXTENSIONS )
13231  template <>
13232  struct hash<VULKAN_HPP_NAMESPACE::VideoCodingControlInfoKHR>
13233  {
13234  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoCodingControlInfoKHR const & videoCodingControlInfoKHR ) const VULKAN_HPP_NOEXCEPT
13235  {
13236  std::size_t seed = 0;
13237  VULKAN_HPP_HASH_COMBINE( seed, videoCodingControlInfoKHR.sType );
13238  VULKAN_HPP_HASH_COMBINE( seed, videoCodingControlInfoKHR.pNext );
13239  VULKAN_HPP_HASH_COMBINE( seed, videoCodingControlInfoKHR.flags );
13240  return seed;
13241  }
13242  };
13243 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
13244 
13245 # if defined( VK_ENABLE_BETA_EXTENSIONS )
13246  template <>
13247  struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeCapabilitiesKHR>
13248  {
13249  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeCapabilitiesKHR const & videoDecodeCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT
13250  {
13251  std::size_t seed = 0;
13252  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeCapabilitiesKHR.sType );
13253  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeCapabilitiesKHR.pNext );
13254  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeCapabilitiesKHR.flags );
13255  return seed;
13256  }
13257  };
13258 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
13259 
13260 # if defined( VK_ENABLE_BETA_EXTENSIONS )
13261  template <>
13262  struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH264CapabilitiesEXT>
13263  {
13264  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264CapabilitiesEXT const & videoDecodeH264CapabilitiesEXT ) const VULKAN_HPP_NOEXCEPT
13265  {
13266  std::size_t seed = 0;
13267  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264CapabilitiesEXT.sType );
13268  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264CapabilitiesEXT.pNext );
13269  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264CapabilitiesEXT.maxLevelIdc );
13270  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264CapabilitiesEXT.fieldOffsetGranularity );
13271  return seed;
13272  }
13273  };
13274 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
13275 
13276 # if defined( VK_ENABLE_BETA_EXTENSIONS )
13277  template <>
13278  struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH264DpbSlotInfoEXT>
13279  {
13280  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264DpbSlotInfoEXT const & videoDecodeH264DpbSlotInfoEXT ) const VULKAN_HPP_NOEXCEPT
13281  {
13282  std::size_t seed = 0;
13283  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264DpbSlotInfoEXT.sType );
13284  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264DpbSlotInfoEXT.pNext );
13285  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264DpbSlotInfoEXT.pStdReferenceInfo );
13286  return seed;
13287  }
13288  };
13289 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
13290 
13291 # if defined( VK_ENABLE_BETA_EXTENSIONS )
13292  template <>
13293  struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH264PictureInfoEXT>
13294  {
13295  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264PictureInfoEXT const & videoDecodeH264PictureInfoEXT ) const VULKAN_HPP_NOEXCEPT
13296  {
13297  std::size_t seed = 0;
13298  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264PictureInfoEXT.sType );
13299  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264PictureInfoEXT.pNext );
13300  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264PictureInfoEXT.pStdPictureInfo );
13301  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264PictureInfoEXT.sliceCount );
13302  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264PictureInfoEXT.pSliceOffsets );
13303  return seed;
13304  }
13305  };
13306 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
13307 
13308 # if defined( VK_ENABLE_BETA_EXTENSIONS )
13309  template <>
13310  struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH264ProfileInfoEXT>
13311  {
13312  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264ProfileInfoEXT const & videoDecodeH264ProfileInfoEXT ) const VULKAN_HPP_NOEXCEPT
13313  {
13314  std::size_t seed = 0;
13315  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264ProfileInfoEXT.sType );
13316  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264ProfileInfoEXT.pNext );
13317  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264ProfileInfoEXT.stdProfileIdc );
13318  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264ProfileInfoEXT.pictureLayout );
13319  return seed;
13320  }
13321  };
13322 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
13323 
13324 # if defined( VK_ENABLE_BETA_EXTENSIONS )
13325  template <>
13326  struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH264SessionParametersAddInfoEXT>
13327  {
13328  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264SessionParametersAddInfoEXT const & videoDecodeH264SessionParametersAddInfoEXT ) const
13329  VULKAN_HPP_NOEXCEPT
13330  {
13331  std::size_t seed = 0;
13332  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersAddInfoEXT.sType );
13333  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersAddInfoEXT.pNext );
13334  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersAddInfoEXT.stdSPSCount );
13335  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersAddInfoEXT.pStdSPSs );
13336  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersAddInfoEXT.stdPPSCount );
13337  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersAddInfoEXT.pStdPPSs );
13338  return seed;
13339  }
13340  };
13341 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
13342 
13343 # if defined( VK_ENABLE_BETA_EXTENSIONS )
13344  template <>
13345  struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH264SessionParametersCreateInfoEXT>
13346  {
13347  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264SessionParametersCreateInfoEXT const & videoDecodeH264SessionParametersCreateInfoEXT ) const
13348  VULKAN_HPP_NOEXCEPT
13349  {
13350  std::size_t seed = 0;
13351  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersCreateInfoEXT.sType );
13352  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersCreateInfoEXT.pNext );
13353  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersCreateInfoEXT.maxStdSPSCount );
13354  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersCreateInfoEXT.maxStdPPSCount );
13355  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersCreateInfoEXT.pParametersAddInfo );
13356  return seed;
13357  }
13358  };
13359 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
13360 
13361 # if defined( VK_ENABLE_BETA_EXTENSIONS )
13362  template <>
13363  struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH265CapabilitiesEXT>
13364  {
13365  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265CapabilitiesEXT const & videoDecodeH265CapabilitiesEXT ) const VULKAN_HPP_NOEXCEPT
13366  {
13367  std::size_t seed = 0;
13368  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265CapabilitiesEXT.sType );
13369  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265CapabilitiesEXT.pNext );
13370  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265CapabilitiesEXT.maxLevelIdc );
13371  return seed;
13372  }
13373  };
13374 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
13375 
13376 # if defined( VK_ENABLE_BETA_EXTENSIONS )
13377  template <>
13378  struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH265DpbSlotInfoEXT>
13379  {
13380  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265DpbSlotInfoEXT const & videoDecodeH265DpbSlotInfoEXT ) const VULKAN_HPP_NOEXCEPT
13381  {
13382  std::size_t seed = 0;
13383  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265DpbSlotInfoEXT.sType );
13384  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265DpbSlotInfoEXT.pNext );
13385  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265DpbSlotInfoEXT.pStdReferenceInfo );
13386  return seed;
13387  }
13388  };
13389 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
13390 
13391 # if defined( VK_ENABLE_BETA_EXTENSIONS )
13392  template <>
13393  struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH265PictureInfoEXT>
13394  {
13395  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265PictureInfoEXT const & videoDecodeH265PictureInfoEXT ) const VULKAN_HPP_NOEXCEPT
13396  {
13397  std::size_t seed = 0;
13398  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265PictureInfoEXT.sType );
13399  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265PictureInfoEXT.pNext );
13400  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265PictureInfoEXT.pStdPictureInfo );
13401  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265PictureInfoEXT.sliceSegmentCount );
13402  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265PictureInfoEXT.pSliceSegmentOffsets );
13403  return seed;
13404  }
13405  };
13406 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
13407 
13408 # if defined( VK_ENABLE_BETA_EXTENSIONS )
13409  template <>
13410  struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH265ProfileInfoEXT>
13411  {
13412  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265ProfileInfoEXT const & videoDecodeH265ProfileInfoEXT ) const VULKAN_HPP_NOEXCEPT
13413  {
13414  std::size_t seed = 0;
13415  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265ProfileInfoEXT.sType );
13416  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265ProfileInfoEXT.pNext );
13417  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265ProfileInfoEXT.stdProfileIdc );
13418  return seed;
13419  }
13420  };
13421 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
13422 
13423 # if defined( VK_ENABLE_BETA_EXTENSIONS )
13424  template <>
13425  struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH265SessionParametersAddInfoEXT>
13426  {
13427  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265SessionParametersAddInfoEXT const & videoDecodeH265SessionParametersAddInfoEXT ) const
13428  VULKAN_HPP_NOEXCEPT
13429  {
13430  std::size_t seed = 0;
13431  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersAddInfoEXT.sType );
13432  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersAddInfoEXT.pNext );
13433  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersAddInfoEXT.stdVPSCount );
13434  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersAddInfoEXT.pStdVPSs );
13435  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersAddInfoEXT.stdSPSCount );
13436  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersAddInfoEXT.pStdSPSs );
13437  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersAddInfoEXT.stdPPSCount );
13438  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersAddInfoEXT.pStdPPSs );
13439  return seed;
13440  }
13441  };
13442 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
13443 
13444 # if defined( VK_ENABLE_BETA_EXTENSIONS )
13445  template <>
13446  struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH265SessionParametersCreateInfoEXT>
13447  {
13448  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265SessionParametersCreateInfoEXT const & videoDecodeH265SessionParametersCreateInfoEXT ) const
13449  VULKAN_HPP_NOEXCEPT
13450  {
13451  std::size_t seed = 0;
13452  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersCreateInfoEXT.sType );
13453  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersCreateInfoEXT.pNext );
13454  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersCreateInfoEXT.maxStdVPSCount );
13455  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersCreateInfoEXT.maxStdSPSCount );
13456  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersCreateInfoEXT.maxStdPPSCount );
13457  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersCreateInfoEXT.pParametersAddInfo );
13458  return seed;
13459  }
13460  };
13461 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
13462 
13463 # if defined( VK_ENABLE_BETA_EXTENSIONS )
13464  template <>
13465  struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR>
13466  {
13467  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR const & videoDecodeInfoKHR ) const VULKAN_HPP_NOEXCEPT
13468  {
13469  std::size_t seed = 0;
13470  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.sType );
13471  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.pNext );
13472  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.flags );
13473  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.srcBuffer );
13474  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.srcBufferOffset );
13475  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.srcBufferRange );
13476  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.dstPictureResource );
13477  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.pSetupReferenceSlot );
13478  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.referenceSlotCount );
13479  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.pReferenceSlots );
13480  return seed;
13481  }
13482  };
13483 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
13484 
13485 # if defined( VK_ENABLE_BETA_EXTENSIONS )
13486  template <>
13487  struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeUsageInfoKHR>
13488  {
13489  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeUsageInfoKHR const & videoDecodeUsageInfoKHR ) const VULKAN_HPP_NOEXCEPT
13490  {
13491  std::size_t seed = 0;
13492  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeUsageInfoKHR.sType );
13493  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeUsageInfoKHR.pNext );
13494  VULKAN_HPP_HASH_COMBINE( seed, videoDecodeUsageInfoKHR.videoUsageHints );
13495  return seed;
13496  }
13497  };
13498 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
13499 
13500 # if defined( VK_ENABLE_BETA_EXTENSIONS )
13501  template <>
13502  struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeCapabilitiesKHR>
13503  {
13504  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeCapabilitiesKHR const & videoEncodeCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT
13505  {
13506  std::size_t seed = 0;
13507  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.sType );
13508  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.pNext );
13509  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.flags );
13510  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.rateControlModes );
13511  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.rateControlLayerCount );
13512  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.qualityLevelCount );
13513  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.inputImageDataFillAlignment );
13514  return seed;
13515  }
13516  };
13517 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
13518 
13519 # if defined( VK_ENABLE_BETA_EXTENSIONS )
13520  template <>
13521  struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilitiesEXT>
13522  {
13523  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilitiesEXT const & videoEncodeH264CapabilitiesEXT ) const VULKAN_HPP_NOEXCEPT
13524  {
13525  std::size_t seed = 0;
13526  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesEXT.sType );
13527  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesEXT.pNext );
13528  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesEXT.flags );
13529  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesEXT.inputModeFlags );
13530  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesEXT.outputModeFlags );
13531  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesEXT.maxPPictureL0ReferenceCount );
13532  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesEXT.maxBPictureL0ReferenceCount );
13533  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesEXT.maxL1ReferenceCount );
13534  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesEXT.motionVectorsOverPicBoundariesFlag );
13535  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesEXT.maxBytesPerPicDenom );
13536  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesEXT.maxBitsPerMbDenom );
13537  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesEXT.log2MaxMvLengthHorizontal );
13538  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesEXT.log2MaxMvLengthVertical );
13539  return seed;
13540  }
13541  };
13542 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
13543 
13544 # if defined( VK_ENABLE_BETA_EXTENSIONS )
13545  template <>
13546  struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoEXT>
13547  {
13548  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoEXT const & videoEncodeH264DpbSlotInfoEXT ) const VULKAN_HPP_NOEXCEPT
13549  {
13550  std::size_t seed = 0;
13551  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264DpbSlotInfoEXT.sType );
13552  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264DpbSlotInfoEXT.pNext );
13553  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264DpbSlotInfoEXT.slotIndex );
13554  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264DpbSlotInfoEXT.pStdReferenceInfo );
13555  return seed;
13556  }
13557  };
13558 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
13559 
13560 # if defined( VK_ENABLE_BETA_EXTENSIONS )
13561  template <>
13562  struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264EmitPictureParametersInfoEXT>
13563  {
13564  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264EmitPictureParametersInfoEXT const & videoEncodeH264EmitPictureParametersInfoEXT ) const
13565  VULKAN_HPP_NOEXCEPT
13566  {
13567  std::size_t seed = 0;
13568  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264EmitPictureParametersInfoEXT.sType );
13569  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264EmitPictureParametersInfoEXT.pNext );
13570  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264EmitPictureParametersInfoEXT.spsId );
13571  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264EmitPictureParametersInfoEXT.emitSpsEnable );
13572  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264EmitPictureParametersInfoEXT.ppsIdEntryCount );
13573  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264EmitPictureParametersInfoEXT.ppsIdEntries );
13574  return seed;
13575  }
13576  };
13577 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
13578 
13579 # if defined( VK_ENABLE_BETA_EXTENSIONS )
13580  template <>
13581  struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264FrameSizeEXT>
13582  {
13583  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264FrameSizeEXT const & videoEncodeH264FrameSizeEXT ) const VULKAN_HPP_NOEXCEPT
13584  {
13585  std::size_t seed = 0;
13586  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264FrameSizeEXT.frameISize );
13587  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264FrameSizeEXT.framePSize );
13588  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264FrameSizeEXT.frameBSize );
13589  return seed;
13590  }
13591  };
13592 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
13593 
13594 # if defined( VK_ENABLE_BETA_EXTENSIONS )
13595  template <>
13596  struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264ReferenceListsInfoEXT>
13597  {
13598  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264ReferenceListsInfoEXT const & videoEncodeH264ReferenceListsInfoEXT ) const VULKAN_HPP_NOEXCEPT
13599  {
13600  std::size_t seed = 0;
13601  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264ReferenceListsInfoEXT.sType );
13602  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264ReferenceListsInfoEXT.pNext );
13603  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264ReferenceListsInfoEXT.referenceList0EntryCount );
13604  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264ReferenceListsInfoEXT.pReferenceList0Entries );
13605  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264ReferenceListsInfoEXT.referenceList1EntryCount );
13606  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264ReferenceListsInfoEXT.pReferenceList1Entries );
13607  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264ReferenceListsInfoEXT.pMemMgmtCtrlOperations );
13608  return seed;
13609  }
13610  };
13611 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
13612 
13613 # if defined( VK_ENABLE_BETA_EXTENSIONS )
13614  template <>
13615  struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264NaluSliceInfoEXT>
13616  {
13617  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264NaluSliceInfoEXT const & videoEncodeH264NaluSliceInfoEXT ) const VULKAN_HPP_NOEXCEPT
13618  {
13619  std::size_t seed = 0;
13620  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264NaluSliceInfoEXT.sType );
13621  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264NaluSliceInfoEXT.pNext );
13622  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264NaluSliceInfoEXT.mbCount );
13623  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264NaluSliceInfoEXT.pReferenceFinalLists );
13624  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264NaluSliceInfoEXT.pSliceHeaderStd );
13625  return seed;
13626  }
13627  };
13628 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
13629 
13630 # if defined( VK_ENABLE_BETA_EXTENSIONS )
13631  template <>
13632  struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264ProfileInfoEXT>
13633  {
13634  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264ProfileInfoEXT const & videoEncodeH264ProfileInfoEXT ) const VULKAN_HPP_NOEXCEPT
13635  {
13636  std::size_t seed = 0;
13637  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264ProfileInfoEXT.sType );
13638  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264ProfileInfoEXT.pNext );
13639  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264ProfileInfoEXT.stdProfileIdc );
13640  return seed;
13641  }
13642  };
13643 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
13644 
13645 # if defined( VK_ENABLE_BETA_EXTENSIONS )
13646  template <>
13647  struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264QpEXT>
13648  {
13649  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264QpEXT const & videoEncodeH264QpEXT ) const VULKAN_HPP_NOEXCEPT
13650  {
13651  std::size_t seed = 0;
13652  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QpEXT.qpI );
13653  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QpEXT.qpP );
13654  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QpEXT.qpB );
13655  return seed;
13656  }
13657  };
13658 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
13659 
13660 # if defined( VK_ENABLE_BETA_EXTENSIONS )
13661  template <>
13662  struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlInfoEXT>
13663  {
13664  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlInfoEXT const & videoEncodeH264RateControlInfoEXT ) const VULKAN_HPP_NOEXCEPT
13665  {
13666  std::size_t seed = 0;
13667  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlInfoEXT.sType );
13668  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlInfoEXT.pNext );
13669  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlInfoEXT.gopFrameCount );
13670  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlInfoEXT.idrPeriod );
13671  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlInfoEXT.consecutiveBFrameCount );
13672  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlInfoEXT.rateControlStructure );
13673  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlInfoEXT.temporalLayerCount );
13674  return seed;
13675  }
13676  };
13677 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
13678 
13679 # if defined( VK_ENABLE_BETA_EXTENSIONS )
13680  template <>
13681  struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlLayerInfoEXT>
13682  {
13683  std::size_t
13684  operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlLayerInfoEXT const & videoEncodeH264RateControlLayerInfoEXT ) const VULKAN_HPP_NOEXCEPT
13685  {
13686  std::size_t seed = 0;
13687  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoEXT.sType );
13688  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoEXT.pNext );
13689  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoEXT.temporalLayerId );
13690  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoEXT.useInitialRcQp );
13691  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoEXT.initialRcQp );
13692  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoEXT.useMinQp );
13693  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoEXT.minQp );
13694  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoEXT.useMaxQp );
13695  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoEXT.maxQp );
13696  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoEXT.useMaxFrameSize );
13697  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoEXT.maxFrameSize );
13698  return seed;
13699  }
13700  };
13701 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
13702 
13703 # if defined( VK_ENABLE_BETA_EXTENSIONS )
13704  template <>
13705  struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersAddInfoEXT>
13706  {
13707  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersAddInfoEXT const & videoEncodeH264SessionParametersAddInfoEXT ) const
13708  VULKAN_HPP_NOEXCEPT
13709  {
13710  std::size_t seed = 0;
13711  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersAddInfoEXT.sType );
13712  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersAddInfoEXT.pNext );
13713  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersAddInfoEXT.stdSPSCount );
13714  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersAddInfoEXT.pStdSPSs );
13715  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersAddInfoEXT.stdPPSCount );
13716  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersAddInfoEXT.pStdPPSs );
13717  return seed;
13718  }
13719  };
13720 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
13721 
13722 # if defined( VK_ENABLE_BETA_EXTENSIONS )
13723  template <>
13724  struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersCreateInfoEXT>
13725  {
13726  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersCreateInfoEXT const & videoEncodeH264SessionParametersCreateInfoEXT ) const
13727  VULKAN_HPP_NOEXCEPT
13728  {
13729  std::size_t seed = 0;
13730  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersCreateInfoEXT.sType );
13731  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersCreateInfoEXT.pNext );
13732  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersCreateInfoEXT.maxStdSPSCount );
13733  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersCreateInfoEXT.maxStdPPSCount );
13734  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersCreateInfoEXT.pParametersAddInfo );
13735  return seed;
13736  }
13737  };
13738 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
13739 
13740 # if defined( VK_ENABLE_BETA_EXTENSIONS )
13741  template <>
13742  struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264VclFrameInfoEXT>
13743  {
13744  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264VclFrameInfoEXT const & videoEncodeH264VclFrameInfoEXT ) const VULKAN_HPP_NOEXCEPT
13745  {
13746  std::size_t seed = 0;
13747  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264VclFrameInfoEXT.sType );
13748  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264VclFrameInfoEXT.pNext );
13749  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264VclFrameInfoEXT.pReferenceFinalLists );
13750  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264VclFrameInfoEXT.naluSliceEntryCount );
13751  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264VclFrameInfoEXT.pNaluSliceEntries );
13752  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264VclFrameInfoEXT.pCurrentPictureInfo );
13753  return seed;
13754  }
13755  };
13756 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
13757 
13758 # if defined( VK_ENABLE_BETA_EXTENSIONS )
13759  template <>
13760  struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265CapabilitiesEXT>
13761  {
13762  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265CapabilitiesEXT const & videoEncodeH265CapabilitiesEXT ) const VULKAN_HPP_NOEXCEPT
13763  {
13764  std::size_t seed = 0;
13765  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.sType );
13766  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.pNext );
13767  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.flags );
13768  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.inputModeFlags );
13769  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.outputModeFlags );
13770  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.ctbSizes );
13771  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.transformBlockSizes );
13772  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.maxPPictureL0ReferenceCount );
13773  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.maxBPictureL0ReferenceCount );
13774  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.maxL1ReferenceCount );
13775  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.maxSubLayersCount );
13776  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.minLog2MinLumaCodingBlockSizeMinus3 );
13777  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.maxLog2MinLumaCodingBlockSizeMinus3 );
13778  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.minLog2MinLumaTransformBlockSizeMinus2 );
13779  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.maxLog2MinLumaTransformBlockSizeMinus2 );
13780  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.minMaxTransformHierarchyDepthInter );
13781  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.maxMaxTransformHierarchyDepthInter );
13782  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.minMaxTransformHierarchyDepthIntra );
13783  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.maxMaxTransformHierarchyDepthIntra );
13784  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.maxDiffCuQpDeltaDepth );
13785  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.minMaxNumMergeCand );
13786  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.maxMaxNumMergeCand );
13787  return seed;
13788  }
13789  };
13790 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
13791 
13792 # if defined( VK_ENABLE_BETA_EXTENSIONS )
13793  template <>
13794  struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265DpbSlotInfoEXT>
13795  {
13796  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265DpbSlotInfoEXT const & videoEncodeH265DpbSlotInfoEXT ) const VULKAN_HPP_NOEXCEPT
13797  {
13798  std::size_t seed = 0;
13799  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265DpbSlotInfoEXT.sType );
13800  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265DpbSlotInfoEXT.pNext );
13801  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265DpbSlotInfoEXT.slotIndex );
13802  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265DpbSlotInfoEXT.pStdReferenceInfo );
13803  return seed;
13804  }
13805  };
13806 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
13807 
13808 # if defined( VK_ENABLE_BETA_EXTENSIONS )
13809  template <>
13810  struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265EmitPictureParametersInfoEXT>
13811  {
13812  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265EmitPictureParametersInfoEXT const & videoEncodeH265EmitPictureParametersInfoEXT ) const
13813  VULKAN_HPP_NOEXCEPT
13814  {
13815  std::size_t seed = 0;
13816  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265EmitPictureParametersInfoEXT.sType );
13817  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265EmitPictureParametersInfoEXT.pNext );
13818  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265EmitPictureParametersInfoEXT.vpsId );
13819  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265EmitPictureParametersInfoEXT.spsId );
13820  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265EmitPictureParametersInfoEXT.emitVpsEnable );
13821  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265EmitPictureParametersInfoEXT.emitSpsEnable );
13822  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265EmitPictureParametersInfoEXT.ppsIdEntryCount );
13823  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265EmitPictureParametersInfoEXT.ppsIdEntries );
13824  return seed;
13825  }
13826  };
13827 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
13828 
13829 # if defined( VK_ENABLE_BETA_EXTENSIONS )
13830  template <>
13831  struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265FrameSizeEXT>
13832  {
13833  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265FrameSizeEXT const & videoEncodeH265FrameSizeEXT ) const VULKAN_HPP_NOEXCEPT
13834  {
13835  std::size_t seed = 0;
13836  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265FrameSizeEXT.frameISize );
13837  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265FrameSizeEXT.framePSize );
13838  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265FrameSizeEXT.frameBSize );
13839  return seed;
13840  }
13841  };
13842 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
13843 
13844 # if defined( VK_ENABLE_BETA_EXTENSIONS )
13845  template <>
13846  struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265ReferenceListsInfoEXT>
13847  {
13848  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265ReferenceListsInfoEXT const & videoEncodeH265ReferenceListsInfoEXT ) const VULKAN_HPP_NOEXCEPT
13849  {
13850  std::size_t seed = 0;
13851  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265ReferenceListsInfoEXT.sType );
13852  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265ReferenceListsInfoEXT.pNext );
13853  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265ReferenceListsInfoEXT.referenceList0EntryCount );
13854  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265ReferenceListsInfoEXT.pReferenceList0Entries );
13855  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265ReferenceListsInfoEXT.referenceList1EntryCount );
13856  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265ReferenceListsInfoEXT.pReferenceList1Entries );
13857  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265ReferenceListsInfoEXT.pReferenceModifications );
13858  return seed;
13859  }
13860  };
13861 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
13862 
13863 # if defined( VK_ENABLE_BETA_EXTENSIONS )
13864  template <>
13865  struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceSegmentInfoEXT>
13866  {
13867  std::size_t
13868  operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceSegmentInfoEXT const & videoEncodeH265NaluSliceSegmentInfoEXT ) const VULKAN_HPP_NOEXCEPT
13869  {
13870  std::size_t seed = 0;
13871  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265NaluSliceSegmentInfoEXT.sType );
13872  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265NaluSliceSegmentInfoEXT.pNext );
13873  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265NaluSliceSegmentInfoEXT.ctbCount );
13874  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265NaluSliceSegmentInfoEXT.pReferenceFinalLists );
13875  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265NaluSliceSegmentInfoEXT.pSliceSegmentHeaderStd );
13876  return seed;
13877  }
13878  };
13879 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
13880 
13881 # if defined( VK_ENABLE_BETA_EXTENSIONS )
13882  template <>
13883  struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265ProfileInfoEXT>
13884  {
13885  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265ProfileInfoEXT const & videoEncodeH265ProfileInfoEXT ) const VULKAN_HPP_NOEXCEPT
13886  {
13887  std::size_t seed = 0;
13888  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265ProfileInfoEXT.sType );
13889  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265ProfileInfoEXT.pNext );
13890  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265ProfileInfoEXT.stdProfileIdc );
13891  return seed;
13892  }
13893  };
13894 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
13895 
13896 # if defined( VK_ENABLE_BETA_EXTENSIONS )
13897  template <>
13898  struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265QpEXT>
13899  {
13900  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265QpEXT const & videoEncodeH265QpEXT ) const VULKAN_HPP_NOEXCEPT
13901  {
13902  std::size_t seed = 0;
13903  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QpEXT.qpI );
13904  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QpEXT.qpP );
13905  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QpEXT.qpB );
13906  return seed;
13907  }
13908  };
13909 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
13910 
13911 # if defined( VK_ENABLE_BETA_EXTENSIONS )
13912  template <>
13913  struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlInfoEXT>
13914  {
13915  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlInfoEXT const & videoEncodeH265RateControlInfoEXT ) const VULKAN_HPP_NOEXCEPT
13916  {
13917  std::size_t seed = 0;
13918  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlInfoEXT.sType );
13919  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlInfoEXT.pNext );
13920  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlInfoEXT.gopFrameCount );
13921  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlInfoEXT.idrPeriod );
13922  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlInfoEXT.consecutiveBFrameCount );
13923  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlInfoEXT.rateControlStructure );
13924  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlInfoEXT.subLayerCount );
13925  return seed;
13926  }
13927  };
13928 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
13929 
13930 # if defined( VK_ENABLE_BETA_EXTENSIONS )
13931  template <>
13932  struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlLayerInfoEXT>
13933  {
13934  std::size_t
13935  operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlLayerInfoEXT const & videoEncodeH265RateControlLayerInfoEXT ) const VULKAN_HPP_NOEXCEPT
13936  {
13937  std::size_t seed = 0;
13938  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoEXT.sType );
13939  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoEXT.pNext );
13940  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoEXT.temporalId );
13941  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoEXT.useInitialRcQp );
13942  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoEXT.initialRcQp );
13943  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoEXT.useMinQp );
13944  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoEXT.minQp );
13945  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoEXT.useMaxQp );
13946  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoEXT.maxQp );
13947  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoEXT.useMaxFrameSize );
13948  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoEXT.maxFrameSize );
13949  return seed;
13950  }
13951  };
13952 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
13953 
13954 # if defined( VK_ENABLE_BETA_EXTENSIONS )
13955  template <>
13956  struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersAddInfoEXT>
13957  {
13958  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersAddInfoEXT const & videoEncodeH265SessionParametersAddInfoEXT ) const
13959  VULKAN_HPP_NOEXCEPT
13960  {
13961  std::size_t seed = 0;
13962  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersAddInfoEXT.sType );
13963  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersAddInfoEXT.pNext );
13964  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersAddInfoEXT.stdVPSCount );
13965  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersAddInfoEXT.pStdVPSs );
13966  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersAddInfoEXT.stdSPSCount );
13967  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersAddInfoEXT.pStdSPSs );
13968  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersAddInfoEXT.stdPPSCount );
13969  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersAddInfoEXT.pStdPPSs );
13970  return seed;
13971  }
13972  };
13973 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
13974 
13975 # if defined( VK_ENABLE_BETA_EXTENSIONS )
13976  template <>
13977  struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersCreateInfoEXT>
13978  {
13979  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersCreateInfoEXT const & videoEncodeH265SessionParametersCreateInfoEXT ) const
13980  VULKAN_HPP_NOEXCEPT
13981  {
13982  std::size_t seed = 0;
13983  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersCreateInfoEXT.sType );
13984  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersCreateInfoEXT.pNext );
13985  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersCreateInfoEXT.maxStdVPSCount );
13986  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersCreateInfoEXT.maxStdSPSCount );
13987  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersCreateInfoEXT.maxStdPPSCount );
13988  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersCreateInfoEXT.pParametersAddInfo );
13989  return seed;
13990  }
13991  };
13992 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
13993 
13994 # if defined( VK_ENABLE_BETA_EXTENSIONS )
13995  template <>
13996  struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265VclFrameInfoEXT>
13997  {
13998  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265VclFrameInfoEXT const & videoEncodeH265VclFrameInfoEXT ) const VULKAN_HPP_NOEXCEPT
13999  {
14000  std::size_t seed = 0;
14001  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265VclFrameInfoEXT.sType );
14002  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265VclFrameInfoEXT.pNext );
14003  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265VclFrameInfoEXT.pReferenceFinalLists );
14004  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265VclFrameInfoEXT.naluSliceSegmentEntryCount );
14005  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265VclFrameInfoEXT.pNaluSliceSegmentEntries );
14006  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265VclFrameInfoEXT.pCurrentPictureInfo );
14007  return seed;
14008  }
14009  };
14010 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
14011 
14012 # if defined( VK_ENABLE_BETA_EXTENSIONS )
14013  template <>
14014  struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeInfoKHR>
14015  {
14016  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeInfoKHR const & videoEncodeInfoKHR ) const VULKAN_HPP_NOEXCEPT
14017  {
14018  std::size_t seed = 0;
14019  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.sType );
14020  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.pNext );
14021  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.flags );
14022  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.qualityLevel );
14023  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.dstBitstreamBuffer );
14024  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.dstBitstreamBufferOffset );
14025  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.dstBitstreamBufferMaxRange );
14026  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.srcPictureResource );
14027  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.pSetupReferenceSlot );
14028  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.referenceSlotCount );
14029  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.pReferenceSlots );
14030  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.precedingExternallyEncodedBytes );
14031  return seed;
14032  }
14033  };
14034 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
14035 
14036 # if defined( VK_ENABLE_BETA_EXTENSIONS )
14037  template <>
14038  struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeRateControlLayerInfoKHR>
14039  {
14040  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeRateControlLayerInfoKHR const & videoEncodeRateControlLayerInfoKHR ) const VULKAN_HPP_NOEXCEPT
14041  {
14042  std::size_t seed = 0;
14043  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlLayerInfoKHR.sType );
14044  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlLayerInfoKHR.pNext );
14045  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlLayerInfoKHR.averageBitrate );
14046  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlLayerInfoKHR.maxBitrate );
14047  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlLayerInfoKHR.frameRateNumerator );
14048  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlLayerInfoKHR.frameRateDenominator );
14049  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlLayerInfoKHR.virtualBufferSizeInMs );
14050  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlLayerInfoKHR.initialVirtualBufferSizeInMs );
14051  return seed;
14052  }
14053  };
14054 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
14055 
14056 # if defined( VK_ENABLE_BETA_EXTENSIONS )
14057  template <>
14058  struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeRateControlInfoKHR>
14059  {
14060  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeRateControlInfoKHR const & videoEncodeRateControlInfoKHR ) const VULKAN_HPP_NOEXCEPT
14061  {
14062  std::size_t seed = 0;
14063  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlInfoKHR.sType );
14064  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlInfoKHR.pNext );
14065  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlInfoKHR.flags );
14066  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlInfoKHR.rateControlMode );
14067  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlInfoKHR.layerCount );
14068  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlInfoKHR.pLayerConfigs );
14069  return seed;
14070  }
14071  };
14072 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
14073 
14074 # if defined( VK_ENABLE_BETA_EXTENSIONS )
14075  template <>
14076  struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeUsageInfoKHR>
14077  {
14078  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeUsageInfoKHR const & videoEncodeUsageInfoKHR ) const VULKAN_HPP_NOEXCEPT
14079  {
14080  std::size_t seed = 0;
14081  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeUsageInfoKHR.sType );
14082  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeUsageInfoKHR.pNext );
14083  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeUsageInfoKHR.videoUsageHints );
14084  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeUsageInfoKHR.videoContentHints );
14085  VULKAN_HPP_HASH_COMBINE( seed, videoEncodeUsageInfoKHR.tuningMode );
14086  return seed;
14087  }
14088  };
14089 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
14090 
14091 # if defined( VK_ENABLE_BETA_EXTENSIONS )
14092  template <>
14093  struct hash<VULKAN_HPP_NAMESPACE::VideoEndCodingInfoKHR>
14094  {
14095  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEndCodingInfoKHR const & videoEndCodingInfoKHR ) const VULKAN_HPP_NOEXCEPT
14096  {
14097  std::size_t seed = 0;
14098  VULKAN_HPP_HASH_COMBINE( seed, videoEndCodingInfoKHR.sType );
14099  VULKAN_HPP_HASH_COMBINE( seed, videoEndCodingInfoKHR.pNext );
14100  VULKAN_HPP_HASH_COMBINE( seed, videoEndCodingInfoKHR.flags );
14101  return seed;
14102  }
14103  };
14104 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
14105 
14106 # if defined( VK_ENABLE_BETA_EXTENSIONS )
14107  template <>
14108  struct hash<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR>
14109  {
14110  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR const & videoFormatPropertiesKHR ) const VULKAN_HPP_NOEXCEPT
14111  {
14112  std::size_t seed = 0;
14113  VULKAN_HPP_HASH_COMBINE( seed, videoFormatPropertiesKHR.sType );
14114  VULKAN_HPP_HASH_COMBINE( seed, videoFormatPropertiesKHR.pNext );
14115  VULKAN_HPP_HASH_COMBINE( seed, videoFormatPropertiesKHR.format );
14116  VULKAN_HPP_HASH_COMBINE( seed, videoFormatPropertiesKHR.componentMapping );
14117  VULKAN_HPP_HASH_COMBINE( seed, videoFormatPropertiesKHR.imageCreateFlags );
14118  VULKAN_HPP_HASH_COMBINE( seed, videoFormatPropertiesKHR.imageType );
14119  VULKAN_HPP_HASH_COMBINE( seed, videoFormatPropertiesKHR.imageTiling );
14120  VULKAN_HPP_HASH_COMBINE( seed, videoFormatPropertiesKHR.imageUsageFlags );
14121  return seed;
14122  }
14123  };
14124 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
14125 
14126 # if defined( VK_ENABLE_BETA_EXTENSIONS )
14127  template <>
14128  struct hash<VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR>
14129  {
14130  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR const & videoProfileInfoKHR ) const VULKAN_HPP_NOEXCEPT
14131  {
14132  std::size_t seed = 0;
14133  VULKAN_HPP_HASH_COMBINE( seed, videoProfileInfoKHR.sType );
14134  VULKAN_HPP_HASH_COMBINE( seed, videoProfileInfoKHR.pNext );
14135  VULKAN_HPP_HASH_COMBINE( seed, videoProfileInfoKHR.videoCodecOperation );
14136  VULKAN_HPP_HASH_COMBINE( seed, videoProfileInfoKHR.chromaSubsampling );
14137  VULKAN_HPP_HASH_COMBINE( seed, videoProfileInfoKHR.lumaBitDepth );
14138  VULKAN_HPP_HASH_COMBINE( seed, videoProfileInfoKHR.chromaBitDepth );
14139  return seed;
14140  }
14141  };
14142 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
14143 
14144 # if defined( VK_ENABLE_BETA_EXTENSIONS )
14145  template <>
14146  struct hash<VULKAN_HPP_NAMESPACE::VideoProfileListInfoKHR>
14147  {
14148  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoProfileListInfoKHR const & videoProfileListInfoKHR ) const VULKAN_HPP_NOEXCEPT
14149  {
14150  std::size_t seed = 0;
14151  VULKAN_HPP_HASH_COMBINE( seed, videoProfileListInfoKHR.sType );
14152  VULKAN_HPP_HASH_COMBINE( seed, videoProfileListInfoKHR.pNext );
14153  VULKAN_HPP_HASH_COMBINE( seed, videoProfileListInfoKHR.profileCount );
14154  VULKAN_HPP_HASH_COMBINE( seed, videoProfileListInfoKHR.pProfiles );
14155  return seed;
14156  }
14157  };
14158 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
14159 
14160 # if defined( VK_ENABLE_BETA_EXTENSIONS )
14161  template <>
14162  struct hash<VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR>
14163  {
14164  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR const & videoSessionCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
14165  {
14166  std::size_t seed = 0;
14167  VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.sType );
14168  VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.pNext );
14169  VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.queueFamilyIndex );
14170  VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.flags );
14171  VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.pVideoProfile );
14172  VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.pictureFormat );
14173  VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.maxCodedExtent );
14174  VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.referencePictureFormat );
14175  VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.maxDpbSlots );
14176  VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.maxActiveReferencePictures );
14177  VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.pStdHeaderVersion );
14178  return seed;
14179  }
14180  };
14181 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
14182 
14183 # if defined( VK_ENABLE_BETA_EXTENSIONS )
14184  template <>
14185  struct hash<VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR>
14186  {
14187  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR const & videoSessionMemoryRequirementsKHR ) const VULKAN_HPP_NOEXCEPT
14188  {
14189  std::size_t seed = 0;
14190  VULKAN_HPP_HASH_COMBINE( seed, videoSessionMemoryRequirementsKHR.sType );
14191  VULKAN_HPP_HASH_COMBINE( seed, videoSessionMemoryRequirementsKHR.pNext );
14192  VULKAN_HPP_HASH_COMBINE( seed, videoSessionMemoryRequirementsKHR.memoryBindIndex );
14193  VULKAN_HPP_HASH_COMBINE( seed, videoSessionMemoryRequirementsKHR.memoryRequirements );
14194  return seed;
14195  }
14196  };
14197 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
14198 
14199 # if defined( VK_ENABLE_BETA_EXTENSIONS )
14200  template <>
14201  struct hash<VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR>
14202  {
14203  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR const & videoSessionParametersCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
14204  {
14205  std::size_t seed = 0;
14206  VULKAN_HPP_HASH_COMBINE( seed, videoSessionParametersCreateInfoKHR.sType );
14207  VULKAN_HPP_HASH_COMBINE( seed, videoSessionParametersCreateInfoKHR.pNext );
14208  VULKAN_HPP_HASH_COMBINE( seed, videoSessionParametersCreateInfoKHR.flags );
14209  VULKAN_HPP_HASH_COMBINE( seed, videoSessionParametersCreateInfoKHR.videoSessionParametersTemplate );
14210  VULKAN_HPP_HASH_COMBINE( seed, videoSessionParametersCreateInfoKHR.videoSession );
14211  return seed;
14212  }
14213  };
14214 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
14215 
14216 # if defined( VK_ENABLE_BETA_EXTENSIONS )
14217  template <>
14218  struct hash<VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR>
14219  {
14220  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR const & videoSessionParametersUpdateInfoKHR ) const VULKAN_HPP_NOEXCEPT
14221  {
14222  std::size_t seed = 0;
14223  VULKAN_HPP_HASH_COMBINE( seed, videoSessionParametersUpdateInfoKHR.sType );
14224  VULKAN_HPP_HASH_COMBINE( seed, videoSessionParametersUpdateInfoKHR.pNext );
14225  VULKAN_HPP_HASH_COMBINE( seed, videoSessionParametersUpdateInfoKHR.updateSequenceCount );
14226  return seed;
14227  }
14228  };
14229 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
14230 
14231 # if defined( VK_USE_PLATFORM_WAYLAND_KHR )
14232  template <>
14233  struct hash<VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR>
14234  {
14235  std::size_t operator()( VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR const & waylandSurfaceCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
14236  {
14237  std::size_t seed = 0;
14238  VULKAN_HPP_HASH_COMBINE( seed, waylandSurfaceCreateInfoKHR.sType );
14239  VULKAN_HPP_HASH_COMBINE( seed, waylandSurfaceCreateInfoKHR.pNext );
14240  VULKAN_HPP_HASH_COMBINE( seed, waylandSurfaceCreateInfoKHR.flags );
14241  VULKAN_HPP_HASH_COMBINE( seed, waylandSurfaceCreateInfoKHR.display );
14242  VULKAN_HPP_HASH_COMBINE( seed, waylandSurfaceCreateInfoKHR.surface );
14243  return seed;
14244  }
14245  };
14246 # endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
14247 
14248 # if defined( VK_USE_PLATFORM_WIN32_KHR )
14249  template <>
14250  struct hash<VULKAN_HPP_NAMESPACE::Win32KeyedMutexAcquireReleaseInfoKHR>
14251  {
14252  std::size_t operator()( VULKAN_HPP_NAMESPACE::Win32KeyedMutexAcquireReleaseInfoKHR const & win32KeyedMutexAcquireReleaseInfoKHR ) const VULKAN_HPP_NOEXCEPT
14253  {
14254  std::size_t seed = 0;
14255  VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoKHR.sType );
14256  VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoKHR.pNext );
14257  VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoKHR.acquireCount );
14258  VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoKHR.pAcquireSyncs );
14259  VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoKHR.pAcquireKeys );
14260  VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoKHR.pAcquireTimeouts );
14261  VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoKHR.releaseCount );
14262  VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoKHR.pReleaseSyncs );
14263  VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoKHR.pReleaseKeys );
14264  return seed;
14265  }
14266  };
14267 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
14268 
14269 # if defined( VK_USE_PLATFORM_WIN32_KHR )
14270  template <>
14271  struct hash<VULKAN_HPP_NAMESPACE::Win32KeyedMutexAcquireReleaseInfoNV>
14272  {
14273  std::size_t operator()( VULKAN_HPP_NAMESPACE::Win32KeyedMutexAcquireReleaseInfoNV const & win32KeyedMutexAcquireReleaseInfoNV ) const VULKAN_HPP_NOEXCEPT
14274  {
14275  std::size_t seed = 0;
14276  VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoNV.sType );
14277  VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoNV.pNext );
14278  VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoNV.acquireCount );
14279  VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoNV.pAcquireSyncs );
14280  VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoNV.pAcquireKeys );
14281  VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoNV.pAcquireTimeoutMilliseconds );
14282  VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoNV.releaseCount );
14283  VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoNV.pReleaseSyncs );
14284  VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoNV.pReleaseKeys );
14285  return seed;
14286  }
14287  };
14288 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
14289 
14290 # if defined( VK_USE_PLATFORM_WIN32_KHR )
14291  template <>
14292  struct hash<VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR>
14293  {
14294  std::size_t operator()( VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR const & win32SurfaceCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
14295  {
14296  std::size_t seed = 0;
14297  VULKAN_HPP_HASH_COMBINE( seed, win32SurfaceCreateInfoKHR.sType );
14298  VULKAN_HPP_HASH_COMBINE( seed, win32SurfaceCreateInfoKHR.pNext );
14299  VULKAN_HPP_HASH_COMBINE( seed, win32SurfaceCreateInfoKHR.flags );
14300  VULKAN_HPP_HASH_COMBINE( seed, win32SurfaceCreateInfoKHR.hinstance );
14301  VULKAN_HPP_HASH_COMBINE( seed, win32SurfaceCreateInfoKHR.hwnd );
14302  return seed;
14303  }
14304  };
14305 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
14306 
14307  template <>
14308  struct hash<VULKAN_HPP_NAMESPACE::WriteDescriptorSet>
14309  {
14310  std::size_t operator()( VULKAN_HPP_NAMESPACE::WriteDescriptorSet const & writeDescriptorSet ) const VULKAN_HPP_NOEXCEPT
14311  {
14312  std::size_t seed = 0;
14313  VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.sType );
14314  VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.pNext );
14315  VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.dstSet );
14316  VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.dstBinding );
14317  VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.dstArrayElement );
14318  VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.descriptorCount );
14319  VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.descriptorType );
14320  VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.pImageInfo );
14321  VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.pBufferInfo );
14322  VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.pTexelBufferView );
14323  return seed;
14324  }
14325  };
14326 
14327  template <>
14328  struct hash<VULKAN_HPP_NAMESPACE::WriteDescriptorSetAccelerationStructureKHR>
14329  {
14330  std::size_t operator()( VULKAN_HPP_NAMESPACE::WriteDescriptorSetAccelerationStructureKHR const & writeDescriptorSetAccelerationStructureKHR ) const
14331  VULKAN_HPP_NOEXCEPT
14332  {
14333  std::size_t seed = 0;
14334  VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetAccelerationStructureKHR.sType );
14335  VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetAccelerationStructureKHR.pNext );
14336  VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetAccelerationStructureKHR.accelerationStructureCount );
14337  VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetAccelerationStructureKHR.pAccelerationStructures );
14338  return seed;
14339  }
14340  };
14341 
14342  template <>
14343  struct hash<VULKAN_HPP_NAMESPACE::WriteDescriptorSetAccelerationStructureNV>
14344  {
14345  std::size_t
14346  operator()( VULKAN_HPP_NAMESPACE::WriteDescriptorSetAccelerationStructureNV const & writeDescriptorSetAccelerationStructureNV ) const VULKAN_HPP_NOEXCEPT
14347  {
14348  std::size_t seed = 0;
14349  VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetAccelerationStructureNV.sType );
14350  VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetAccelerationStructureNV.pNext );
14351  VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetAccelerationStructureNV.accelerationStructureCount );
14352  VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetAccelerationStructureNV.pAccelerationStructures );
14353  return seed;
14354  }
14355  };
14356 
14357  template <>
14358  struct hash<VULKAN_HPP_NAMESPACE::WriteDescriptorSetInlineUniformBlock>
14359  {
14360  std::size_t operator()( VULKAN_HPP_NAMESPACE::WriteDescriptorSetInlineUniformBlock const & writeDescriptorSetInlineUniformBlock ) const VULKAN_HPP_NOEXCEPT
14361  {
14362  std::size_t seed = 0;
14363  VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetInlineUniformBlock.sType );
14364  VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetInlineUniformBlock.pNext );
14365  VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetInlineUniformBlock.dataSize );
14366  VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetInlineUniformBlock.pData );
14367  return seed;
14368  }
14369  };
14370 
14371 # if defined( VK_USE_PLATFORM_XCB_KHR )
14372  template <>
14373  struct hash<VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR>
14374  {
14375  std::size_t operator()( VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR const & xcbSurfaceCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
14376  {
14377  std::size_t seed = 0;
14378  VULKAN_HPP_HASH_COMBINE( seed, xcbSurfaceCreateInfoKHR.sType );
14379  VULKAN_HPP_HASH_COMBINE( seed, xcbSurfaceCreateInfoKHR.pNext );
14380  VULKAN_HPP_HASH_COMBINE( seed, xcbSurfaceCreateInfoKHR.flags );
14381  VULKAN_HPP_HASH_COMBINE( seed, xcbSurfaceCreateInfoKHR.connection );
14382  VULKAN_HPP_HASH_COMBINE( seed, xcbSurfaceCreateInfoKHR.window );
14383  return seed;
14384  }
14385  };
14386 # endif /*VK_USE_PLATFORM_XCB_KHR*/
14387 
14388 # if defined( VK_USE_PLATFORM_XLIB_KHR )
14389  template <>
14390  struct hash<VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR>
14391  {
14392  std::size_t operator()( VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR const & xlibSurfaceCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
14393  {
14394  std::size_t seed = 0;
14395  VULKAN_HPP_HASH_COMBINE( seed, xlibSurfaceCreateInfoKHR.sType );
14396  VULKAN_HPP_HASH_COMBINE( seed, xlibSurfaceCreateInfoKHR.pNext );
14397  VULKAN_HPP_HASH_COMBINE( seed, xlibSurfaceCreateInfoKHR.flags );
14398  VULKAN_HPP_HASH_COMBINE( seed, xlibSurfaceCreateInfoKHR.dpy );
14399  VULKAN_HPP_HASH_COMBINE( seed, xlibSurfaceCreateInfoKHR.window );
14400  return seed;
14401  }
14402  };
14403 # endif /*VK_USE_PLATFORM_XLIB_KHR*/
14404 
14405 #endif // 14 <= VULKAN_HPP_CPP_VERSION
14406 
14407 } // namespace std
14408 #endif
VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT
Definition: vulkan_structs.hpp:45858
VULKAN_HPP_NAMESPACE::DisplayModeParametersKHR
Definition: vulkan_structs.hpp:27806
VULKAN_HPP_NAMESPACE::ImagePlaneMemoryRequirementsInfo
Definition: vulkan_structs.hpp:39965
VULKAN_HPP_NAMESPACE::SwapchainCounterCreateInfoEXT
Definition: vulkan_structs.hpp:95442
VULKAN_HPP_NAMESPACE::PhysicalDeviceTransformFeedbackFeaturesEXT
Definition: vulkan_structs.hpp:74282
VULKAN_HPP_NAMESPACE::MappedMemoryRange
Definition: vulkan_structs.hpp:44537
VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR
Definition: vulkan_structs.hpp:28903
VULKAN_HPP_NAMESPACE::PhysicalDeviceImage2DViewOf3DFeaturesEXT
Definition: vulkan_structs.hpp:59235
VULKAN_HPP_NAMESPACE::EventCreateInfo
Definition: vulkan_structs.hpp:30021
VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationFeaturesEXT
Definition: vulkan_structs.hpp:61721
VULKAN_HPP_NAMESPACE::PipelineCoverageReductionStateCreateInfoNV
Definition: vulkan_structs.hpp:78566
VULKAN_HPP_NAMESPACE::MicromapCreateInfoEXT
Definition: vulkan_structs.hpp:46995
VULKAN_HPP_NAMESPACE::DisplayProperties2KHR
Definition: vulkan_structs.hpp:29015
VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupExtendedTypesFeatures
Definition: vulkan_structs.hpp:72171
VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR
Definition: vulkan_structs.hpp:25573
VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPipelineFeaturesKHR
Definition: vulkan_structs.hpp:68369
VULKAN_HPP_NAMESPACE::BufferMemoryBarrier2
Definition: vulkan_structs.hpp:11727
VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClipEnableFeaturesEXT
Definition: vulkan_structs.hpp:53006
VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderModuleIdentifierFeaturesEXT
Definition: vulkan_structs.hpp:71804
VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceQueryPropertiesKHR
Definition: vulkan_structs.hpp:65126
VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR
Definition: vulkan_structs.hpp:79402
VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan11Properties
Definition: vulkan_structs.hpp:75367
VULKAN_HPP_NAMESPACE::Device
Definition: vulkan_handles.hpp:7729
VULKAN_HPP_NAMESPACE::FenceGetFdInfoKHR
Definition: vulkan_structs.hpp:33006
flags
GLbitfield flags
Definition: glcorearb.h:1596
VULKAN_HPP_NAMESPACE::PhysicalDeviceVariablePointersFeatures
Definition: vulkan_structs.hpp:74630
std::hash< VULKAN_HPP_NAMESPACE::ValidationCacheEXT >::operator()
std::size_t operator()(VULKAN_HPP_NAMESPACE::ValidationCacheEXT const &validationCacheEXT) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:412
VULKAN_HPP_NAMESPACE::PipelineLibraryCreateInfoKHR
Definition: vulkan_structs.hpp:80246
VULKAN_HPP_NAMESPACE::AttachmentReferenceStencilLayout
Definition: vulkan_structs.hpp:5864
VULKAN_HPP_NAMESPACE::AttachmentReference
Definition: vulkan_structs.hpp:5657
VULKAN_HPP_NAMESPACE::Framebuffer
Definition: vulkan_handles.hpp:6463
VULKAN_HPP_NAMESPACE::PushConstantRange
Definition: vulkan_structs.hpp:79977
VULKAN_HPP_NAMESPACE::PipelineColorBlendAdvancedStateCreateInfoEXT
Definition: vulkan_structs.hpp:78046
VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT
Definition: vulkan_structs.hpp:6275
VULKAN_HPP_NAMESPACE::ImageMemoryBarrier
Definition: vulkan_structs.hpp:39579
VULKAN_HPP_NAMESPACE::PhysicalDeviceTexelBufferAlignmentProperties
Definition: vulkan_structs.hpp:73693
VULKAN_HPP_NAMESPACE::IndirectCommandsStreamNV
Definition: vulkan_structs.hpp:34286
VULKAN_HPP_NAMESPACE::DevicePrivateDataCreateInfo
Definition: vulkan_structs.hpp:26939
VULKAN_HPP_NAMESPACE::Buffer
Definition: vulkan_handles.hpp:2327
VULKAN_HPP_NAMESPACE::PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT
Definition: vulkan_structs.hpp:58827
VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBindingFlagsCreateInfo
Definition: vulkan_structs.hpp:21968
VULKAN_HPP_NAMESPACE::DeviceGroupCommandBufferBeginInfo
Definition: vulkan_structs.hpp:25349
VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL
Definition: vulkan_structs.hpp:48854
VULKAN_HPP_NAMESPACE::PhysicalDeviceCoverageReductionModeFeaturesNV
Definition: vulkan_structs.hpp:52418
VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferPropertiesEXT
Definition: vulkan_structs.hpp:53425
std::hash< VULKAN_HPP_NAMESPACE::QueryPool >::operator()
std::size_t operator()(VULKAN_HPP_NAMESPACE::QueryPool const &queryPool) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:109
VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfoEXT
Definition: vulkan_structs.hpp:15108
VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR
Definition: vulkan_structs.hpp:65310
VULKAN_HPP_NAMESPACE::PhysicalDeviceSampleLocationsPropertiesEXT
Definition: vulkan_structs.hpp:69084
VULKAN_HPP_NAMESPACE::PhysicalDeviceLegacyDitheringFeaturesEXT
Definition: vulkan_structs.hpp:60968
VULKAN_HPP_NAMESPACE::ImageSubresource
Definition: vulkan_structs.hpp:8259
VULKAN_HPP_NAMESPACE::SubpassFragmentDensityMapOffsetEndInfoQCOM
Definition: vulkan_structs.hpp:94075
VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo
Definition: vulkan_structs.hpp:11194
std::hash< VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT >::operator()
std::size_t operator()(VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT const &debugReportCallbackEXT) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:337
VULKAN_HPP_NAMESPACE::AccelerationStructureSRTMotionInstanceNV
Definition: vulkan_structs.hpp:3236
VULKAN_HPP_NOEXCEPT
#define VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:200
VULKAN_HPP_NAMESPACE::RenderPassCreateInfo
Definition: vulkan_structs.hpp:87118
VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInfoNV
Definition: vulkan_structs.hpp:2899
VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesListEXT
Definition: vulkan_structs.hpp:29923
VULKAN_HPP_NAMESPACE::GraphicsShaderGroupCreateInfoNV
Definition: vulkan_structs.hpp:37219
VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCoreBuiltinsPropertiesARM
Definition: vulkan_structs.hpp:70380
std::hash< VULKAN_HPP_NAMESPACE::Queue >::operator()
std::size_t operator()(VULKAN_HPP_NAMESPACE::Queue const &queue) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:64
VULKAN_HPP_NAMESPACE::DeviceFaultVendorBinaryHeaderVersionOneEXT
Definition: vulkan_structs.hpp:25077
VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderBarycentricFeaturesKHR
Definition: vulkan_structs.hpp:57695
VULKAN_HPP_NAMESPACE::BindImageMemorySwapchainInfoKHR
Definition: vulkan_structs.hpp:7539
VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState3FeaturesEXT
Definition: vulkan_structs.hpp:55411
VULKAN_HPP_NAMESPACE::CopyMemoryToImageIndirectCommandNV
Definition: vulkan_structs.hpp:16970
VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupSizeControlFeatures
Definition: vulkan_structs.hpp:72912
VULKAN_HPP_NAMESPACE::TilePropertiesQCOM
Definition: vulkan_structs.hpp:96139
VULKAN_HPP_NAMESPACE::PerformanceStreamMarkerInfoINTEL
Definition: vulkan_structs.hpp:49538
VULKAN_HPP_NAMESPACE::FramebufferCreateInfo
Definition: vulkan_structs.hpp:33996
VULKAN_HPP_NAMESPACE::ImageViewASTCDecodeModeEXT
Definition: vulkan_structs.hpp:40705
VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV
Definition: vulkan_structs.hpp:43747
VULKAN_HPP_NAMESPACE::Pipeline
Definition: vulkan_handles.hpp:2667
VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatInfoNV
Definition: vulkan_structs.hpp:48291
VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo
Definition: vulkan_structs.hpp:22095
VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties
Definition: vulkan_structs.hpp:58939
VULKAN_HPP_NAMESPACE::ShaderModuleValidationCacheCreateInfoEXT
Definition: vulkan_structs.hpp:92419
VULKAN_HPP_NAMESPACE::BindShaderGroupIndirectCommandNV
Definition: vulkan_structs.hpp:7840
VULKAN_HPP_NAMESPACE::SubresourceLayout
Definition: vulkan_structs.hpp:38902
VULKAN_HPP_NAMESPACE::ColorBlendEquationEXT
Definition: vulkan_structs.hpp:13207
VULKAN_HPP_NAMESPACE::ExternalMemoryImageCreateInfo
Definition: vulkan_structs.hpp:32621
VULKAN_HPP_NAMESPACE::ImageViewMinLodCreateInfoEXT
Definition: vulkan_structs.hpp:41256
VULKAN_HPP_NAMESPACE::PhysicalDeviceSeparateDepthStencilLayoutsFeatures
Definition: vulkan_structs.hpp:69479
VULKAN_HPP_NAMESPACE::PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT
Definition: vulkan_structs.hpp:59441
VULKAN_HPP_NAMESPACE::BindImageMemoryDeviceGroupInfo
Definition: vulkan_structs.hpp:7255
VULKAN_HPP_NAMESPACE::BindSparseInfo
Definition: vulkan_structs.hpp:8780
VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderDemoteToHelperInvocationFeatures
Definition: vulkan_structs.hpp:70716
VULKAN_HPP_NAMESPACE::FormatProperties2
Definition: vulkan_structs.hpp:33387
VULKAN_HPP_NAMESPACE::DescriptorSetLayoutHostMappingInfoVALVE
Definition: vulkan_structs.hpp:22235
VULKAN_HPP_NAMESPACE::PhysicalDevicePipelinePropertiesFeaturesEXT
Definition: vulkan_structs.hpp:65410
VULKAN_HPP_NAMESPACE::PhysicalDeviceDrmPropertiesEXT
Definition: vulkan_structs.hpp:54984
VULKAN_HPP_NAMESPACE::MultisampledRenderToSingleSampledInfoEXT
Definition: vulkan_structs.hpp:47593
VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo
Definition: vulkan_structs.hpp:91949
VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryBudgetPropertiesEXT
Definition: vulkan_structs.hpp:62326
VULKAN_HPP_NAMESPACE::PhysicalDeviceOpacityMicromapPropertiesEXT
Definition: vulkan_structs.hpp:64503
VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT
Definition: vulkan_structs.hpp:97322
VULKAN_HPP_NAMESPACE::QueryPool
Definition: vulkan_handles.hpp:2242
VULKAN_HPP_NAMESPACE::ShaderResourceUsageAMD
Definition: vulkan_structs.hpp:92517
VULKAN_HPP_NAMESPACE::ViewportSwizzleNV
Definition: vulkan_structs.hpp:82832
VULKAN_HPP_NAMESPACE::PhysicalDeviceSynchronization2Features
Definition: vulkan_structs.hpp:73496
VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties
Definition: vulkan_structs.hpp:32818
VULKAN_HPP_NAMESPACE::PhysicalDeviceImageRobustnessFeatures
Definition: vulkan_structs.hpp:60061
VULKAN_HPP_NAMESPACE::MemoryHeap
Definition: vulkan_structs.hpp:45789
VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL
Definition: vulkan_structs.hpp:71704
VULKAN_HPP_NAMESPACE::BindIndexBufferIndirectCommandNV
Definition: vulkan_structs.hpp:7743
VULKAN_HPP_NAMESPACE::Semaphore
Definition: vulkan_handles.hpp:1990
VULKAN_HPP_NAMESPACE::SubpassSampleLocationsEXT
Definition: vulkan_structs.hpp:88734
VULKAN_HPP_NAMESPACE::PresentRegionsKHR
Definition: vulkan_structs.hpp:83944
VULKAN_HPP_NAMESPACE::PipelineViewportShadingRateImageStateCreateInfoNV
Definition: vulkan_structs.hpp:82685
VULKAN_HPP_NAMESPACE::RenderPassSubpassFeedbackCreateInfoEXT
Definition: vulkan_structs.hpp:89073
VULKAN_HPP_NAMESPACE::DeviceQueueInfo2
Definition: vulkan_structs.hpp:27136
VULKAN_HPP_NAMESPACE::PipelineVertexInputDivisorStateCreateInfoEXT
Definition: vulkan_structs.hpp:82066
std::hash< VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate >::operator()
std::size_t operator()(VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate const &descriptorUpdateTemplate) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:273
VULKAN_HPP_NAMESPACE::DeviceGroupSwapchainCreateInfoKHR
Definition: vulkan_structs.hpp:26148
VULKAN_HPP_NAMESPACE::Extent3D
Definition: vulkan_structs.hpp:8444
VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSMBuiltinsPropertiesNV
Definition: vulkan_structs.hpp:72086
VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthStencilResolveProperties
Definition: vulkan_structs.hpp:53103
VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryDecompressionFeaturesNV
Definition: vulkan_structs.hpp:62415
VULKAN_HPP_NAMESPACE::QueueFamilyCheckpointProperties2NV
Definition: vulkan_structs.hpp:84833
VULKAN_HPP_NAMESPACE::SemaphoreTypeCreateInfo
Definition: vulkan_structs.hpp:91842
VULKAN_HPP_NAMESPACE::Extent2D
Definition: vulkan_structs.hpp:6109
VULKAN_HPP_NAMESPACE::ComponentMapping
Definition: vulkan_structs.hpp:4402
VULKAN_HPP_NAMESPACE::AttachmentDescription2
Definition: vulkan_structs.hpp:5363
VULKAN_HPP_NAMESPACE::MemoryType
Definition: vulkan_structs.hpp:46288
VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT
Definition: vulkan_structs.hpp:27709
VULKAN_HPP_NAMESPACE::PhysicalDeviceImageDrmFormatModifierInfoEXT
Definition: vulkan_structs.hpp:59543
VULKAN_HPP_NAMESPACE::PhysicalDeviceOpacityMicromapFeaturesEXT
Definition: vulkan_structs.hpp:64381
VULKAN_HPP_NAMESPACE::PipelineVertexInputStateCreateInfo
Definition: vulkan_structs.hpp:34990
VULKAN_HPP_NAMESPACE::RenderPassSubpassFeedbackInfoEXT
Definition: vulkan_structs.hpp:88995
VULKAN_HPP_NAMESPACE::DeferredOperationKHR
Definition: vulkan_handles.hpp:5693
VULKAN_HPP_NAMESPACE::PhysicalDeviceExclusiveScissorFeaturesNV
Definition: vulkan_structs.hpp:55189
VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR
Definition: vulkan_structs.hpp:28532
VULKAN_HPP_NAMESPACE::PhysicalDevicePointClippingProperties
Definition: vulkan_structs.hpp:65813
VULKAN_HPP_NAMESPACE::FormatProperties
Definition: vulkan_structs.hpp:33311
VK_MAX_PHYSICAL_DEVICE_NAME_SIZE
#define VK_MAX_PHYSICAL_DEVICE_NAME_SIZE
Definition: vulkan_core.h:133
VULKAN_HPP_NAMESPACE::DeviceGroupDeviceCreateInfo
Definition: vulkan_structs.hpp:25446
VULKAN_HPP_NAMESPACE::ExportMemoryAllocateInfo
Definition: vulkan_structs.hpp:30329
VULKAN_HPP_NAMESPACE::ImageCompressionPropertiesEXT
Definition: vulkan_structs.hpp:38352
VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCoreProperties2AMD
Definition: vulkan_structs.hpp:70471
VULKAN_HPP_NAMESPACE::MultiDrawIndexedInfoEXT
Definition: vulkan_structs.hpp:47334
VULKAN_HPP_NAMESPACE::SurfaceKHR
Definition: vulkan_handles.hpp:1565
VULKAN_HPP_NAMESPACE::DrmFormatModifierProperties2EXT
Definition: vulkan_structs.hpp:29671
VULKAN_HPP_NAMESPACE::DescriptorSetLayout
Definition: vulkan_handles.hpp:6375
VULKAN_HPP_NAMESPACE::SemaphoreGetFdInfoKHR
Definition: vulkan_structs.hpp:91271
VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT
Definition: vulkan_structs.hpp:12243
VULKAN_HPP_NAMESPACE::ImageBlit2
Definition: vulkan_structs.hpp:9387
VULKAN_HPP_NAMESPACE::SurfaceFormatKHR
Definition: vulkan_structs.hpp:94996
VULKAN_HPP_NAMESPACE::PhysicalDeviceTimelineSemaphoreFeatures
Definition: vulkan_structs.hpp:73996
VULKAN_HPP_NAMESPACE::RenderPassTransformBeginInfoQCOM
Definition: vulkan_structs.hpp:89171
VULKAN_HPP_NAMESPACE::MemoryAllocateInfo
Definition: vulkan_structs.hpp:44760
VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderImageAtomicInt64FeaturesEXT
Definition: vulkan_structs.hpp:71125
VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateFeaturesKHR
Definition: vulkan_structs.hpp:58234
VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE
Definition: vulkan_structs.hpp:54272
VULKAN_HPP_NAMESPACE::PhysicalDeviceRayQueryFeaturesKHR
Definition: vulkan_structs.hpp:67866
VULKAN_HPP_NAMESPACE::ImageResolve2
Definition: vulkan_structs.hpp:40180
VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiDrawPropertiesEXT
Definition: vulkan_structs.hpp:63603
VULKAN_HPP_NAMESPACE::CommandBufferInheritanceRenderingInfo
Definition: vulkan_structs.hpp:13932
VULKAN_HPP_NAMESPACE::Rect2D
Definition: vulkan_structs.hpp:7172
VULKAN_HPP_NAMESPACE::MemoryGetRemoteAddressInfoNV
Definition: vulkan_structs.hpp:45452
VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT
Definition: vulkan_structs.hpp:92330
std::hash< VULKAN_HPP_NAMESPACE::Framebuffer >::operator()
std::size_t operator()(VULKAN_HPP_NAMESPACE::Framebuffer const &framebuffer) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:226
VULKAN_HPP_NAMESPACE::PipelineRasterizationConservativeStateCreateInfoEXT
Definition: vulkan_structs.hpp:80467
VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance4Properties
Definition: vulkan_structs.hpp:62242
VULKAN_HPP_NAMESPACE::FilterCubicImageViewImageFormatPropertiesEXT
Definition: vulkan_structs.hpp:33225
VK_MAX_DRIVER_INFO_SIZE
#define VK_MAX_DRIVER_INFO_SIZE
Definition: vulkan_core.h:5714
VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE
Definition: vulkan_structs.hpp:48771
VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderBarycentricPropertiesKHR
Definition: vulkan_structs.hpp:57796
VULKAN_HPP_NAMESPACE::PipelineDynamicStateCreateInfo
Definition: vulkan_structs.hpp:36641
VULKAN_HPP_NAMESPACE::PipelineInputAssemblyStateCreateInfo
Definition: vulkan_structs.hpp:35174
VK_MAX_DRIVER_NAME_SIZE
#define VK_MAX_DRIVER_NAME_SIZE
Definition: vulkan_core.h:5713
VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV
Definition: vulkan_structs.hpp:2786
std::hash< VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT >::operator()
std::size_t operator()(VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT const &debugUtilsMessengerEXT) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:390
VULKAN_HPP_NAMESPACE::DrawMeshTasksIndirectCommandEXT
Definition: vulkan_structs.hpp:29490
VULKAN_HPP_NAMESPACE::DescriptorPool
Definition: vulkan_handles.hpp:6290
VULKAN_HPP_NAMESPACE::ExternalMemoryImageCreateInfoNV
Definition: vulkan_structs.hpp:32720
VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2
Definition: vulkan_structs.hpp:67095
VULKAN_HPP_NAMESPACE::DeviceFaultAddressInfoEXT
Definition: vulkan_structs.hpp:24641
VULKAN_HPP_NAMESPACE::RenderPassCreationFeedbackCreateInfoEXT
Definition: vulkan_structs.hpp:88211
VULKAN_HPP_NAMESPACE::PresentIdKHR
Definition: vulkan_structs.hpp:83412
VULKAN_HPP_NAMESPACE::PhysicalDeviceIDProperties
Definition: vulkan_structs.hpp:59132
VULKAN_HPP_NAMESPACE::MemoryBarrier
Definition: vulkan_structs.hpp:44863
VULKAN_HPP_NAMESPACE::DeviceAddressBindingCallbackDataEXT
Definition: vulkan_structs.hpp:22975
VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo
Definition: vulkan_structs.hpp:56226
std::hash< VULKAN_HPP_NAMESPACE::PrivateDataSlot >::operator()
std::size_t operator()(VULKAN_HPP_NAMESPACE::PrivateDataSlot const &privateDataSlot) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:284
VULKAN_HPP_NAMESPACE::AccelerationStructureInstanceKHR
Definition: vulkan_structs.hpp:2509
VULKAN_HPP_NAMESPACE::DeviceGroupBindSparseInfo
Definition: vulkan_structs.hpp:25242
VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingMaintenance1FeaturesKHR
Definition: vulkan_structs.hpp:68150
VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties
Definition: vulkan_structs.hpp:62698
VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV
Definition: vulkan_structs.hpp:86143
VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo
Definition: vulkan_structs.hpp:13336
VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements
Definition: vulkan_structs.hpp:23107
VULKAN_HPP_NAMESPACE::GeometryDataNV
Definition: vulkan_structs.hpp:1781
VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderDrawParametersFeatures
Definition: vulkan_structs.hpp:70817
image
GLenum GLenum GLsizei void * image
Definition: glad.h:5132
VULKAN_HPP_NAMESPACE::PhysicalDeviceTransformFeedbackPropertiesEXT
Definition: vulkan_structs.hpp:74389
VULKAN_HPP_NAMESPACE::Event
Definition: vulkan_handles.hpp:3096
VULKAN_HPP_NAMESPACE::ImportSemaphoreFdInfoKHR
Definition: vulkan_structs.hpp:43022
VULKAN_HPP_NAMESPACE::PipelineTessellationStateCreateInfo
Definition: vulkan_structs.hpp:35297
VULKAN_HPP_NAMESPACE::PhysicalDevice16BitStorageFeatures
Definition: vulkan_structs.hpp:49775
VULKAN_HPP_NAMESPACE::MemoryDedicatedRequirements
Definition: vulkan_structs.hpp:45076
VULKAN_HPP_NAMESPACE::RenderPassSampleLocationsBeginInfoEXT
Definition: vulkan_structs.hpp:88822
VULKAN_HPP_NAMESPACE::PhysicalDeviceCornerSampledImageFeaturesNV
Definition: vulkan_structs.hpp:52320
VULKAN_HPP_NAMESPACE::ImageFormatProperties2
Definition: vulkan_structs.hpp:39495
VULKAN_HPP_NAMESPACE::PipelineViewportExclusiveScissorStateCreateInfoNV
Definition: vulkan_structs.hpp:82449
VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance4Features
Definition: vulkan_structs.hpp:62145
VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT
Definition: vulkan_handles.hpp:1650
VULKAN_HPP_NAMESPACE::QueueFamilyCheckpointPropertiesNV
Definition: vulkan_structs.hpp:84916
VULKAN_HPP_NAMESPACE::MemoryAllocateFlagsInfo
Definition: vulkan_structs.hpp:44653
std::hash< VULKAN_HPP_NAMESPACE::Semaphore >::operator()
std::size_t operator()(VULKAN_HPP_NAMESPACE::Semaphore const &semaphore) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:91
VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2
Definition: vulkan_structs.hpp:92855
VULKAN_HPP_NAMESPACE::PhysicalDeviceMutableDescriptorTypeFeaturesEXT
Definition: vulkan_structs.hpp:64183
std::hash< VULKAN_HPP_NAMESPACE::ShaderModule >::operator()
std::size_t operator()(VULKAN_HPP_NAMESPACE::ShaderModule const &shaderModule) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:154
VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState2FeaturesEXT
Definition: vulkan_structs.hpp:55286
sampler
GLuint sampler
Definition: glcorearb.h:1656
VULKAN_HPP_NAMESPACE::PhysicalDeviceFaultFeaturesEXT
Definition: vulkan_structs.hpp:56708
VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR
Definition: vulkan_structs.hpp:95067
VULKAN_HPP_NAMESPACE::AccelerationStructureNV
Definition: vulkan_handles.hpp:2837
VULKAN_HPP_NAMESPACE::PipelineCompilerControlCreateInfoAMD
Definition: vulkan_structs.hpp:78295
Image
Definition: Image.h:45
VULKAN_HPP_NAMESPACE::PhysicalDeviceProvokingVertexFeaturesEXT
Definition: vulkan_structs.hpp:67359
VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesList2EXT
Definition: vulkan_structs.hpp:29825
VULKAN_HPP_NAMESPACE::DescriptorImageInfo
Definition: vulkan_structs.hpp:20938
VULKAN_HPP_NAMESPACE::PhysicalDeviceFloatControlsProperties
Definition: vulkan_structs.hpp:56913
VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineRobustnessFeaturesEXT
Definition: vulkan_structs.hpp:65607
VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassShadingPropertiesHUAWEI
Definition: vulkan_structs.hpp:73317
VULKAN_HPP_NAMESPACE::ImageSwapchainCreateInfoKHR
Definition: vulkan_structs.hpp:40609
VULKAN_HPP_NAMESPACE::BufferMemoryBarrier
Definition: vulkan_structs.hpp:11567
VULKAN_HPP_NAMESPACE::PhysicalDeviceShadingRateImageFeaturesNV
Definition: vulkan_structs.hpp:72474
VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR
Definition: vulkan_structs.hpp:2256
VULKAN_HPP_NAMESPACE::SparseImageMemoryBind
Definition: vulkan_structs.hpp:8537
buffer
GLuint buffer
Definition: glcorearb.h:660
VULKAN_HPP_NAMESPACE::QueueFamilyProperties2
Definition: vulkan_structs.hpp:85207
VULKAN_HPP_NAMESPACE::ImageViewSampleWeightCreateInfoQCOM
Definition: vulkan_structs.hpp:41352
VULKAN_HPP_NAMESPACE::ImageSubresourceLayers
Definition: vulkan_structs.hpp:9282
VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT
Definition: vulkan_structs.hpp:18604
VULKAN_HPP_NAMESPACE::PrivateDataSlot
Definition: vulkan_handles.hpp:6630
VULKAN_HPP_NAMESPACE::SurfaceProtectedCapabilitiesKHR
Definition: vulkan_structs.hpp:95345
std::hash< VULKAN_HPP_NAMESPACE::AccelerationStructureKHR >::operator()
std::size_t operator()(VULKAN_HPP_NAMESPACE::AccelerationStructureKHR const &accelerationStructureKHR) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:401
VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo
Definition: vulkan_structs.hpp:84465
VULKAN_HPP_NAMESPACE::ExternalFenceProperties
Definition: vulkan_structs.hpp:32074
VULKAN_HPP_NAMESPACE::SpecializationInfo
Definition: vulkan_structs.hpp:14678
VULKAN_HPP_NAMESPACE::PhysicalDeviceTextureCompressionASTCHDRFeatures
Definition: vulkan_structs.hpp:73799
VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClipControlFeaturesEXT
Definition: vulkan_structs.hpp:52908
VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapFeaturesEXT
Definition: vulkan_structs.hpp:57291
VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsFeaturesNV
Definition: vulkan_structs.hpp:54372
VULKAN_HPP_NAMESPACE::PresentInfoKHR
Definition: vulkan_structs.hpp:83529
VULKAN_HPP_NAMESPACE::BindVertexBufferIndirectCommandNV
Definition: vulkan_structs.hpp:9054
VULKAN_HPP_NAMESPACE::BindImagePlaneMemoryInfo
Definition: vulkan_structs.hpp:7645
VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorPropertiesEXT
Definition: vulkan_structs.hpp:74851
VULKAN_HPP_NAMESPACE::ImageCopy2
Definition: vulkan_structs.hpp:16290
VULKAN_HPP_NAMESPACE::SwapchainDisplayNativeHdrCreateInfoAMD
Definition: vulkan_structs.hpp:95860
std::hash< VULKAN_HPP_NAMESPACE::SurfaceKHR >::operator()
std::size_t operator()(VULKAN_HPP_NAMESPACE::SurfaceKHR const &surfaceKHR) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:295
VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2
Definition: vulkan_structs.hpp:40318
VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixPropertiesNV
Definition: vulkan_structs.hpp:52057
VULKAN_HPP_NAMESPACE::SparseMemoryBind
Definition: vulkan_structs.hpp:7915
VULKAN_HPP_NAMESPACE::ResolveImageInfo2
Definition: vulkan_structs.hpp:89856
VULKAN_HPP_NAMESPACE::PhysicalDeviceDiagnosticsConfigFeaturesNV
Definition: vulkan_structs.hpp:54705
VULKAN_HPP_NAMESPACE::PipelineViewportStateCreateInfo
Definition: vulkan_structs.hpp:35407
VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateEntry
Definition: vulkan_structs.hpp:22636
VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo
Definition: vulkan_structs.hpp:21330
VULKAN_HPP_NAMESPACE::ColorBlendAdvancedEXT
Definition: vulkan_structs.hpp:13088
VULKAN_HPP_NAMESPACE::DispatchIndirectCommand
Definition: vulkan_structs.hpp:27615
VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderFeaturesNV
Definition: vulkan_structs.hpp:67962
VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV
Definition: vulkan_structs.hpp:82577
VULKAN_HPP_NAMESPACE::PipelineLayout
Definition: vulkan_handles.hpp:2412
VULKAN_HPP_NAMESPACE::PipelineSampleLocationsStateCreateInfoEXT
Definition: vulkan_structs.hpp:81557
VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport
Definition: vulkan_structs.hpp:22340
VULKAN_HPP_NAMESPACE::MemoryGetFdInfoKHR
Definition: vulkan_structs.hpp:45345
VULKAN_HPP_NAMESPACE::BindBufferMemoryDeviceGroupInfo
Definition: vulkan_structs.hpp:6845
VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo
Definition: vulkan_structs.hpp:77785
VULKAN_HPP_NAMESPACE::RenderingFragmentDensityMapAttachmentInfoEXT
Definition: vulkan_structs.hpp:89421
event
struct _cl_event * event
Definition: glcorearb.h:2961
VULKAN_HPP_NAMESPACE::MutableDescriptorTypeListEXT
Definition: vulkan_structs.hpp:47814
VULKAN_HPP_NAMESPACE::PipelineFragmentShadingRateEnumStateCreateInfoNV
Definition: vulkan_structs.hpp:79643
VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT
#define VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT
Definition: vulkan_core.h:15566
VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV
Definition: vulkan_structs.hpp:6678
VULKAN_HPP_NAMESPACE::SamplerCaptureDescriptorDataInfoEXT
Definition: vulkan_structs.hpp:90143
VULKAN_HPP_NAMESPACE::MemoryPriorityAllocateInfoEXT
Definition: vulkan_structs.hpp:46037
VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM
Definition: vulkan_structs.hpp:57515
VULKAN_HPP_NAMESPACE::ClearDepthStencilValue
Definition: vulkan_structs.hpp:12566
VULKAN_HPP_NAMESPACE::ExportSemaphoreCreateInfo
Definition: vulkan_structs.hpp:31622
VULKAN_HPP_NAMESPACE::Queue
Definition: vulkan_handles.hpp:7225
VULKAN_HPP_NAMESPACE::SparseBufferMemoryBindInfo
Definition: vulkan_structs.hpp:8031
VULKAN_HPP_NAMESPACE::DisplayPlaneInfo2KHR
Definition: vulkan_structs.hpp:28427
VULKAN_HPP_NAMESPACE::DescriptorSetVariableDescriptorCountLayoutSupport
Definition: vulkan_structs.hpp:22550
VULKAN_HPP_NAMESPACE::PhysicalDeviceRGBA10X6FormatsFeaturesEXT
Definition: vulkan_structs.hpp:67637
VULKAN_HPP_NAMESPACE::PhysicalDeviceDiscardRectanglePropertiesEXT
Definition: vulkan_structs.hpp:54803
VULKAN_HPP_NAMESPACE::Flags
Definition: vulkan.hpp:384
VULKAN_HPP_NAMESPACE::DescriptorBufferInfo
Definition: vulkan_structs.hpp:20842
VULKAN_HPP_NAMESPACE::CommandBuffer
Definition: vulkan_handles.hpp:3348
VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorIndexingFeatures
Definition: vulkan_structs.hpp:53702
VULKAN_HPP_NAMESPACE::PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT
Definition: vulkan_structs.hpp:64917
VULKAN_HPP_NAMESPACE::SubpassDescription2
Definition: vulkan_structs.hpp:87327
VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionInfo
Definition: vulkan_structs.hpp:90957
VULKAN_HPP_NAMESPACE::PhysicalDeviceBufferDeviceAddressFeatures
Definition: vulkan_structs.hpp:51146
VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT
Definition: vulkan_structs.hpp:96758
VULKAN_HPP_NAMESPACE::MutableDescriptorTypeCreateInfoEXT
Definition: vulkan_structs.hpp:47920
VULKAN_HPP_NAMESPACE::DeviceMemoryOverallocationCreateInfoAMD
Definition: vulkan_structs.hpp:26729
VULKAN_HPP_NAMESPACE::PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV
Definition: vulkan_structs.hpp:52709
VK_MAX_DEVICE_GROUP_SIZE
#define VK_MAX_DEVICE_GROUP_SIZE
Definition: vulkan_core.h:4850
VK_MAX_DESCRIPTION_SIZE
#define VK_MAX_DESCRIPTION_SIZE
Definition: vulkan_core.h:136
VULKAN_HPP_NAMESPACE::AmigoProfilingSubmitInfoSEC
Definition: vulkan_structs.hpp:4296
VULKAN_HPP_NAMESPACE::SubpassDescription
Definition: vulkan_structs.hpp:86727
VULKAN_HPP_NAMESPACE::DirectDriverLoadingInfoLUNARG
Definition: vulkan_structs.hpp:27253
VULKAN_HPP_NAMESPACE::PhysicalDeviceLinearColorAttachmentFeaturesNV
Definition: vulkan_structs.hpp:61958
std::hash< VULKAN_HPP_NAMESPACE::Image >::operator()
std::size_t operator()(VULKAN_HPP_NAMESPACE::Image const &image) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:136
VULKAN_HPP_NAMESPACE::AccelerationStructureMatrixMotionInstanceNV
Definition: vulkan_structs.hpp:2641
VULKAN_HPP_NAMESPACE::CuModuleNVX
Definition: vulkan_handles.hpp:6205
VULKAN_HPP_NAMESPACE::OpaqueCaptureDescriptorDataCreateInfoEXT
Definition: vulkan_structs.hpp:48055
VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion
Definition: vulkan_handles.hpp:6880
VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryDecompressionPropertiesNV
Definition: vulkan_structs.hpp:62513
VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixFeaturesNV
Definition: vulkan_structs.hpp:51948
VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL
Definition: vulkan_structs.hpp:49226
VULKAN_HPP_NAMESPACE::PhysicalDeviceConservativeRasterizationPropertiesEXT
Definition: vulkan_structs.hpp:51812
VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceMemoryReportFeaturesEXT
Definition: vulkan_structs.hpp:54607
VULKAN_HPP_NAMESPACE::PhysicalDeviceConditionalRenderingFeaturesEXT
Definition: vulkan_structs.hpp:51702
VULKAN_HPP_NAMESPACE::DrawIndexedIndirectCommand
Definition: vulkan_structs.hpp:29270
std::hash< VULKAN_HPP_NAMESPACE::CuModuleNVX >::operator()
std::size_t operator()(VULKAN_HPP_NAMESPACE::CuModuleNVX const &cuModuleNVX) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:370
VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState3PropertiesEXT
Definition: vulkan_structs.hpp:55906
VULKAN_HPP_NAMESPACE::AttachmentDescription
Definition: vulkan_structs.hpp:5202
VULKAN_HPP_NAMESPACE::PipelineTessellationDomainOriginStateCreateInfo
Definition: vulkan_structs.hpp:81879
VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesEXT
Definition: vulkan_structs.hpp:29748
VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2
Definition: vulkan_structs.hpp:93027
VULKAN_HPP_NAMESPACE::AccelerationStructureVersionInfoKHR
Definition: vulkan_structs.hpp:3830
framebuffer
GLuint framebuffer
Definition: glcorearb.h:1287
VULKAN_HPP_NAMESPACE::BufferView
Definition: vulkan_handles.hpp:5865
VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessingPropertiesQCOM
Definition: vulkan_structs.hpp:59962
VULKAN_HPP_NAMESPACE::PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT
Definition: vulkan_structs.hpp:66564
VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorFeaturesEXT
Definition: vulkan_structs.hpp:74741
VULKAN_HPP_NAMESPACE::Offset2D
Definition: vulkan_structs.hpp:7089
VULKAN_HPP_NAMESPACE::BufferCopy
Definition: vulkan_structs.hpp:10887
VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerDotProductFeatures
Definition: vulkan_structs.hpp:71332
VULKAN_HPP_NAMESPACE::DeviceGroupPresentInfoKHR
Definition: vulkan_structs.hpp:25662
VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM
Definition: vulkan_structs.hpp:63995
VULKAN_HPP_NAMESPACE::DescriptorSet
Definition: vulkan_handles.hpp:2497
VULKAN_HPP_NAMESPACE::BaseInStructure
Definition: vulkan_structs.hpp:6522
buffer
Definition: core.h:760
VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkanMemoryModelFeatures
Definition: vulkan_structs.hpp:77217
VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSMBuiltinsFeaturesNV
Definition: vulkan_structs.hpp:71989
VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassShadingFeaturesHUAWEI
Definition: vulkan_structs.hpp:73220
VULKAN_HPP_NAMESPACE::ShaderStatisticsInfoAMD
Definition: vulkan_structs.hpp:92600
VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderPropertiesNV
Definition: vulkan_structs.hpp:68062
VULKAN_HPP_NAMESPACE::Offset3D
Definition: vulkan_structs.hpp:8351
VULKAN_HPP_NAMESPACE::RectLayerKHR
Definition: vulkan_structs.hpp:83750
VULKAN_HPP_NAMESPACE::GeometryAABBNV
Definition: vulkan_structs.hpp:1654
VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingMotionBlurFeaturesNV
Definition: vulkan_structs.hpp:68260
VULKAN_HPP_NAMESPACE::ImageViewCaptureDescriptorDataInfoEXT
Definition: vulkan_structs.hpp:40889
VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR
Definition: vulkan_structs.hpp:79287
VULKAN_HPP_NAMESPACE::DirectDriverLoadingListLUNARG
Definition: vulkan_structs.hpp:27358
VULKAN_HPP_NAMESPACE::ImageCopy
Definition: vulkan_structs.hpp:38786
VULKAN_HPP_NAMESPACE::BufferImageCopy
Definition: vulkan_structs.hpp:11292
VULKAN_HPP_NAMESPACE::PhysicalDeviceSamplerYcbcrConversionFeatures
Definition: vulkan_structs.hpp:69281
VULKAN_HPP_NAMESPACE::DisplayPowerInfoEXT
Definition: vulkan_structs.hpp:28688
VULKAN_HPP_NAMESPACE::DependencyInfo
Definition: vulkan_structs.hpp:20297
VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo
Definition: vulkan_structs.hpp:80069
VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewFeatures
Definition: vulkan_structs.hpp:63787
VULKAN_HPP_NAMESPACE::PhysicalDeviceImageViewMinLodFeaturesEXT
Definition: vulkan_structs.hpp:60258
VULKAN_HPP_NAMESPACE::MicromapBuildSizesInfoEXT
Definition: vulkan_structs.hpp:46875
VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessingFeaturesQCOM
Definition: vulkan_structs.hpp:59839
VULKAN_HPP_NAMESPACE::PhysicalDeviceGlobalPriorityQueryFeaturesKHR
Definition: vulkan_structs.hpp:58629
VULKAN_HPP_NAMESPACE::PhysicalDeviceTexelBufferAlignmentFeaturesEXT
Definition: vulkan_structs.hpp:73594
VULKAN_HPP_NAMESPACE::PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR
Definition: vulkan_structs.hpp:77342
VULKAN_HPP_NAMESPACE::CoarseSampleLocationNV
Definition: vulkan_structs.hpp:12861
VULKAN_HPP_NAMESPACE::SubmitInfo
Definition: vulkan_structs.hpp:93328
VULKAN_HPP_NAMESPACE::SamplerCreateInfo
Definition: vulkan_structs.hpp:90239
VULKAN_HPP_NAMESPACE::BufferCopy2
Definition: vulkan_structs.hpp:10980
VULKAN_HPP_NAMESPACE::PipelineDiscardRectangleStateCreateInfoEXT
Definition: vulkan_structs.hpp:79023
VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription
Definition: vulkan_structs.hpp:34885
VULKAN_HPP_NAMESPACE::PresentRegionKHR
Definition: vulkan_structs.hpp:83844
VULKAN_HPP_NAMESPACE::QueryPoolPerformanceCreateInfoKHR
Definition: vulkan_structs.hpp:84595
VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements
Definition: vulkan_structs.hpp:92939
VULKAN_HPP_NAMESPACE::PipelineColorBlendAttachmentState
Definition: vulkan_structs.hpp:36304
VULKAN_HPP_NAMESPACE::PhysicalDeviceProtectedMemoryProperties
Definition: vulkan_structs.hpp:67276
VULKAN_HPP_NAMESPACE::QueueFamilyProperties
Definition: vulkan_structs.hpp:85127
VULKAN_HPP_NAMESPACE
#define VULKAN_HPP_NAMESPACE
Definition: vulkan.hpp:229
VULKAN_HPP_NAMESPACE::SubresourceLayout2EXT
Definition: vulkan_structs.hpp:94372
VULKAN_HPP_NAMESPACE::DeviceDiagnosticsConfigCreateInfoNV
Definition: vulkan_structs.hpp:24450
VULKAN_HPP_NAMESPACE::ImageViewUsageCreateInfo
Definition: vulkan_structs.hpp:41472
VULKAN_HPP_NAMESPACE::PhysicalDeviceAccelerationStructurePropertiesKHR
Definition: vulkan_structs.hpp:50395
VULKAN_HPP_NAMESPACE::PhysicalDeviceProtectedMemoryFeatures
Definition: vulkan_structs.hpp:67179
VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectPropertiesNV
Definition: vulkan_structs.hpp:52237
VULKAN_HPP_NAMESPACE::DisplayKHR
Definition: vulkan_handles.hpp:1820
VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferFeaturesEXT
Definition: vulkan_structs.hpp:53289
VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL
Definition: vulkan_handles.hpp:2160
VULKAN_HPP_NAMESPACE::AttachmentDescriptionStencilLayout
Definition: vulkan_structs.hpp:5545
VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcrImageArraysFeaturesEXT
Definition: vulkan_structs.hpp:77586
VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT
Definition: vulkan_structs.hpp:19261
VULKAN_HPP_NAMESPACE::PhysicalDeviceAmigoProfilingFeaturesSEC
Definition: vulkan_structs.hpp:50623
VULKAN_HPP_NAMESPACE::ExternalMemoryProperties
Definition: vulkan_structs.hpp:31910
VULKAN_HPP_NAMESPACE::ImageViewCreateInfo
Definition: vulkan_structs.hpp:40986
VULKAN_HPP_NAMESPACE::PipelineViewportSwizzleStateCreateInfoNV
Definition: vulkan_structs.hpp:82938
VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectFeaturesNV
Definition: vulkan_structs.hpp:52140
VULKAN_HPP_NAMESPACE::PhysicalDevicePrivateDataFeatures
Definition: vulkan_structs.hpp:66801
std::hash< VULKAN_HPP_NAMESPACE::MicromapEXT >::operator()
std::size_t operator()(VULKAN_HPP_NAMESPACE::MicromapEXT const &micromapEXT) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:480
VULKAN_HPP_NAMESPACE::SwapchainKHR
Definition: vulkan_handles.hpp:1905
VULKAN_HPP_NAMESPACE::ValidationFlagsEXT
Definition: vulkan_structs.hpp:97067
VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryPriorityFeaturesEXT
Definition: vulkan_structs.hpp:62601
VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2
Definition: vulkan_structs.hpp:15867
VULKAN_HPP_NAMESPACE::PhysicalDeviceComputeShaderDerivativesFeaturesNV
Definition: vulkan_structs.hpp:51592
VULKAN_HPP_NAMESPACE::GraphicsPipelineShaderGroupsCreateInfoNV
Definition: vulkan_structs.hpp:37376
VULKAN_HPP_NAMESPACE::RenderPass
Definition: vulkan_handles.hpp:6710
VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan12Features
Definition: vulkan_structs.hpp:75532
VULKAN_HPP_NAMESPACE::AttachmentSampleLocationsEXT
Definition: vulkan_structs.hpp:6434
VULKAN_HPP_NAMESPACE::RenderPassAttachmentBeginInfo
Definition: vulkan_structs.hpp:86437
VULKAN_HPP_NAMESPACE::PipelineCoverageToColorStateCreateInfoNV
Definition: vulkan_structs.hpp:78678
VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT
Definition: vulkan_structs.hpp:39288
VULKAN_HPP_NAMESPACE::MicromapEXT
Definition: vulkan_handles.hpp:3269
VULKAN_HPP_NAMESPACE::ImportFenceFdInfoKHR
Definition: vulkan_structs.hpp:41667
VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderPropertiesNV
Definition: vulkan_structs.hpp:63353
VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo
Definition: vulkan_structs.hpp:56608
VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryHostPropertiesEXT
Definition: vulkan_structs.hpp:56426
VULKAN_HPP_NAMESPACE::PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT
Definition: vulkan_structs.hpp:63685
VULKAN_HPP_NAMESPACE::MultiDrawInfoEXT
Definition: vulkan_structs.hpp:47428
VULKAN_HPP_NAMESPACE::CheckpointDataNV
Definition: vulkan_structs.hpp:12422
VULKAN_HPP_NAMESPACE::InputAttachmentAspectReference
Definition: vulkan_structs.hpp:44034
VULKAN_HPP_NAMESPACE::PipelineRasterizationLineStateCreateInfoEXT
Definition: vulkan_structs.hpp:80706
VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCoreBuiltinsFeaturesARM
Definition: vulkan_structs.hpp:70282
VULKAN_HPP_NAMESPACE::PhysicalDeviceASTCDecodeFeaturesEXT
Definition: vulkan_structs.hpp:50141
VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderImageFootprintFeaturesNV
Definition: vulkan_structs.hpp:71235
VULKAN_HPP_NAMESPACE::CopyMemoryIndirectCommandNV
Definition: vulkan_structs.hpp:16770
VULKAN_HPP_NAMESPACE::SubpassResolvePerformanceQueryEXT
Definition: vulkan_structs.hpp:94204
VULKAN_HPP_NAMESPACE::DisplayPresentInfoKHR
Definition: vulkan_structs.hpp:28784
std::hash< VULKAN_HPP_NAMESPACE::Fence >::operator()
std::size_t operator()(VULKAN_HPP_NAMESPACE::Fence const &fence) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:82
VULKAN_HPP_NAMESPACE::CopyImageInfo2
Definition: vulkan_structs.hpp:16428
VULKAN_HPP_NAMESPACE::WriteDescriptorSetAccelerationStructureNV
Definition: vulkan_structs.hpp:106721
VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR
Definition: vulkan_structs.hpp:29098
VULKAN_HPP_NAMESPACE::PhysicalDevicePushDescriptorPropertiesKHR
Definition: vulkan_structs.hpp:67555
VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPipelinePropertiesKHR
Definition: vulkan_structs.hpp:68523
VULKAN_HPP_NAMESPACE::BufferViewCreateInfo
Definition: vulkan_structs.hpp:12103
VULKAN_HPP_NAMESPACE::FormatProperties3
Definition: vulkan_structs.hpp:33467
VULKAN_HPP_NAMESPACE::PhysicalDeviceInlineUniformBlockFeatures
Definition: vulkan_structs.hpp:60649
VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClampZeroOneFeaturesEXT
Definition: vulkan_structs.hpp:52810
VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT
Definition: vulkan_structs.hpp:18326
VULKAN_HPP_NAMESPACE::PipelineViewportWScalingStateCreateInfoNV
Definition: vulkan_structs.hpp:83163
VULKAN_HPP_NAMESPACE::PhysicalDeviceBufferDeviceAddressFeaturesEXT
Definition: vulkan_structs.hpp:51271
VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR
Definition: vulkan_structs.hpp:85722
VULKAN_HPP_NAMESPACE::ApplicationInfo
Definition: vulkan_structs.hpp:5047
std::hash< VULKAN_HPP_NAMESPACE::Event >::operator()
std::size_t operator()(VULKAN_HPP_NAMESPACE::Event const &event) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:100
VULKAN_HPP_NAMESPACE::CopyBufferInfo2
Definition: vulkan_structs.hpp:15720
VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT
Definition: vulkan_structs.hpp:53203
VULKAN_HPP_NAMESPACE::BufferCaptureDescriptorDataInfoEXT
Definition: vulkan_structs.hpp:9703
VULKAN_HPP_NAMESPACE::PhysicalDeviceDriverProperties
Definition: vulkan_structs.hpp:54885
VULKAN_HPP_NAMESPACE::HdrMetadataEXT
Definition: vulkan_structs.hpp:37624
VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo
Definition: vulkan_structs.hpp:56104
VULKAN_HPP_NAMESPACE::DescriptorPoolSize
Definition: vulkan_structs.hpp:21246
VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingFeatures
Definition: vulkan_structs.hpp:55091
VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR
Definition: vulkan_structs.hpp:3926
VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomBorderColorFeaturesEXT
Definition: vulkan_structs.hpp:52517
VULKAN_HPP_NAMESPACE::PhysicalDeviceIndexTypeUint8FeaturesEXT
Definition: vulkan_structs.hpp:60453
VULKAN_HPP_NAMESPACE::PipelineRobustnessCreateInfoEXT
Definition: vulkan_structs.hpp:81423
VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV
Definition: vulkan_structs.hpp:34373
std::hash< VULKAN_HPP_NAMESPACE::DisplayKHR >::operator()
std::size_t operator()(VULKAN_HPP_NAMESPACE::DisplayKHR const &displayKHR) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:317
VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexInputDynamicStateFeaturesEXT
Definition: vulkan_structs.hpp:74935
VULKAN_HPP_NAMESPACE::DisplayNativeHdrSurfaceCapabilitiesAMD
Definition: vulkan_structs.hpp:28157
std::hash< VULKAN_HPP_NAMESPACE::CommandBuffer >::operator()
std::size_t operator()(VULKAN_HPP_NAMESPACE::CommandBuffer const &commandBuffer) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:253
VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineCreationCacheControlFeatures
Definition: vulkan_structs.hpp:65209
VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2PropertiesEXT
Definition: vulkan_structs.hpp:68997
VULKAN_HPP_NAMESPACE::PipelineRasterizationStateCreateInfo
Definition: vulkan_structs.hpp:35582
queue
*get result *(waiting if necessary)*A common idiom is to fire a bunch of sub tasks at the queue
Definition: thread.h:623
VULKAN_HPP_NAMESPACE::PipelineCacheHeaderVersionOne
Definition: vulkan_structs.hpp:77925
VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierListCreateInfoEXT
Definition: vulkan_structs.hpp:39163
VULKAN_HPP_NAMESPACE::StencilOpState
Definition: vulkan_structs.hpp:35963
VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan13Properties
Definition: vulkan_structs.hpp:76860
VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo
Definition: vulkan_structs.hpp:90697
VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupProperties
Definition: vulkan_structs.hpp:72814
VULKAN_HPP_NAMESPACE::ProtectedSubmitInfo
Definition: vulkan_structs.hpp:84370
VULKAN_HPP_NAMESPACE::OpticalFlowExecuteInfoNV
Definition: vulkan_structs.hpp:48153
VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2FeaturesEXT
Definition: vulkan_structs.hpp:68876
VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan11Features
Definition: vulkan_structs.hpp:75133
VULKAN_HPP_NAMESPACE::DedicatedAllocationMemoryAllocateInfoNV
Definition: vulkan_structs.hpp:19744
VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicInt64Features
Definition: vulkan_structs.hpp:70064
VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM
Definition: vulkan_structs.hpp:57415
VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineProtectedAccessFeaturesEXT
Definition: vulkan_structs.hpp:65508
VULKAN_HPP_NAMESPACE::ImageSubresourceRange
Definition: vulkan_structs.hpp:19978
VULKAN_HPP_NAMESPACE::PhysicalDevicePresentWaitFeaturesKHR
Definition: vulkan_structs.hpp:66468
VULKAN_HPP_NAMESPACE::PhysicalDeviceUniformBufferStandardLayoutFeatures
Definition: vulkan_structs.hpp:74529
VULKAN_HPP_NAMESPACE::DescriptorAddressInfoEXT
Definition: vulkan_structs.hpp:20515
std::hash< VULKAN_HPP_NAMESPACE::DeferredOperationKHR >::operator()
std::size_t operator()(VULKAN_HPP_NAMESPACE::DeferredOperationKHR const &deferredOperationKHR) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:445
VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderPropertiesEXT
Definition: vulkan_structs.hpp:63115
VULKAN_HPP_NAMESPACE::DeviceFaultInfoEXT
Definition: vulkan_structs.hpp:24950
VULKAN_HPP_NAMESPACE::PhysicalDevice4444FormatsFeaturesEXT
Definition: vulkan_structs.hpp:49911
VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT
Definition: vulkan_structs.hpp:19123
VULKAN_HPP_NAMESPACE::RenderPassCreationControlEXT
Definition: vulkan_structs.hpp:88045
VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT
Definition: vulkan_structs.hpp:37802
VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiDrawFeaturesEXT
Definition: vulkan_structs.hpp:63507
VULKAN_HPP_NAMESPACE::WriteDescriptorSetInlineUniformBlock
Definition: vulkan_structs.hpp:106852
VULKAN_HPP_NAMESPACE::LayerProperties
Definition: vulkan_structs.hpp:44348
VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderTerminateInvocationFeatures
Definition: vulkan_structs.hpp:72374
VULKAN_HPP_NAMESPACE::QueueFamilyGlobalPriorityPropertiesKHR
Definition: vulkan_structs.hpp:84999
VULKAN_HPP_NAMESPACE::ImageMemoryBarrier2
Definition: vulkan_structs.hpp:20093
VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance3Properties
Definition: vulkan_structs.hpp:62057
VULKAN_HPP_NAMESPACE::DescriptorSetBindingReferenceVALVE
Definition: vulkan_structs.hpp:21718
VULKAN_HPP_NAMESPACE::ExternalBufferProperties
Definition: vulkan_structs.hpp:31990
VULKAN_HPP_NAMESPACE::AabbPositionsKHR
Definition: vulkan_structs.hpp:19
VULKAN_HPP_NAMESPACE::SubpassShadingPipelineCreateInfoHUAWEI
Definition: vulkan_structs.hpp:94286
VULKAN_HPP_NAMESPACE::FramebufferAttachmentsCreateInfo
Definition: vulkan_structs.hpp:33862
std::hash< VULKAN_HPP_NAMESPACE::ImageView >::operator()
std::size_t operator()(VULKAN_HPP_NAMESPACE::ImageView const &imageView) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:145
VULKAN_HPP_NAMESPACE::ExtensionProperties
Definition: vulkan_structs.hpp:31838
VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures
Definition: vulkan_structs.hpp:23358
VULKAN_HPP_NAMESPACE::SRTDataNV
Definition: vulkan_structs.hpp:3009
std::hash< VULKAN_HPP_NAMESPACE::PipelineLayout >::operator()
std::size_t operator()(VULKAN_HPP_NAMESPACE::PipelineLayout const &pipelineLayout) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:181
VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR
Definition: vulkan_structs.hpp:95540
VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo
Definition: vulkan_structs.hpp:14968
VULKAN_HPP_NAMESPACE::PhysicalDeviceInlineUniformBlockProperties
Definition: vulkan_structs.hpp:60759
VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2
Definition: vulkan_structs.hpp:39748
VULKAN_HPP_NAMESPACE::VertexInputBindingDivisorDescriptionEXT
Definition: vulkan_structs.hpp:81980
VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2
Definition: vulkan_structs.hpp:16603
VULKAN_HPP_NAMESPACE::Image
Definition: vulkan_handles.hpp:2752
VULKAN_HPP_NAMESPACE::GeometryNV
Definition: vulkan_structs.hpp:1865
VULKAN_HPP_NAMESPACE::ShaderModule
Definition: vulkan_handles.hpp:6969
VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapPropertiesEXT
Definition: vulkan_structs.hpp:57600
VULKAN_HPP_NAMESPACE::SubpassBeginInfo
Definition: vulkan_structs.hpp:93772
VULKAN_HPP_NAMESPACE::ExportMemoryAllocateInfoNV
Definition: vulkan_structs.hpp:30427
VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX
Definition: vulkan_structs.hpp:40802
VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR
Definition: vulkan_structs.hpp:72272
VULKAN_HPP_NAMESPACE::SpecializationMapEntry
Definition: vulkan_structs.hpp:14584
VULKAN_HPP_NAMESPACE::PipelinePropertiesIdentifierEXT
Definition: vulkan_structs.hpp:80370
VULKAN_HPP_NAMESPACE::QueryPoolPerformanceQueryCreateInfoINTEL
Definition: vulkan_structs.hpp:84733
VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR
Definition: vulkan_structs.hpp:45164
std::hash< VULKAN_HPP_NAMESPACE::CuFunctionNVX >::operator()
std::size_t operator()(VULKAN_HPP_NAMESPACE::CuFunctionNVX const &cuFunctionNVX) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:379
VULKAN_HPP_NAMESPACE::PipelineMultisampleStateCreateInfo
Definition: vulkan_structs.hpp:35798
VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalImageFormatInfo
Definition: vulkan_structs.hpp:56326
VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesPresentBarrierNV
Definition: vulkan_structs.hpp:94898
VULKAN_HPP_NAMESPACE::BlitImageInfo2
Definition: vulkan_structs.hpp:9515
VULKAN_HPP_NAMESPACE::PhysicalDeviceBlendOperationAdvancedPropertiesEXT
Definition: vulkan_structs.hpp:50919
VULKAN_HPP_NAMESPACE::DeviceQueueGlobalPriorityCreateInfoKHR
Definition: vulkan_structs.hpp:27036
std::hash< VULKAN_HPP_NAMESPACE::CommandPool >::operator()
std::size_t operator()(VULKAN_HPP_NAMESPACE::CommandPool const &commandPool) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:244
VULKAN_HPP_NAMESPACE::MicromapUsageEXT
Definition: vulkan_structs.hpp:3529
VULKAN_HPP_NAMESPACE::PipelineColorWriteCreateInfoEXT
Definition: vulkan_structs.hpp:78170
VULKAN_HPP_NAMESPACE::PhysicalDeviceLimits
Definition: vulkan_structs.hpp:61065
VULKAN_HPP_NAMESPACE::ImageCaptureDescriptorDataInfoEXT
Definition: vulkan_structs.hpp:38113
VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo
Definition: vulkan_structs.hpp:91176
VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMap2FeaturesEXT
Definition: vulkan_structs.hpp:57093
VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomBorderColorPropertiesEXT
Definition: vulkan_structs.hpp:52626
VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo
Definition: vulkan_structs.hpp:14812
VULKAN_HPP_NAMESPACE::PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT
Definition: vulkan_structs.hpp:67735
VULKAN_HPP_NAMESPACE::DeviceFaultVendorInfoEXT
Definition: vulkan_structs.hpp:24854
VULKAN_HPP_NAMESPACE::DrawMeshTasksIndirectCommandNV
Definition: vulkan_structs.hpp:29585
VULKAN_HPP_NAMESPACE::BufferDeviceAddressCreateInfoEXT
Definition: vulkan_structs.hpp:11097
VULKAN_HPP_NAMESPACE::SparseImageFormatProperties
Definition: vulkan_structs.hpp:92779
VULKAN_HPP_NAMESPACE::SamplerReductionModeCreateInfo
Definition: vulkan_structs.hpp:90598
VK_MAX_GLOBAL_PRIORITY_SIZE_KHR
#define VK_MAX_GLOBAL_PRIORITY_SIZE_KHR
Definition: vulkan_core.h:9052
VULKAN_HPP_NAMESPACE::PhysicalDevice
Definition: vulkan_handles.hpp:12399
std::hash< VULKAN_HPP_NAMESPACE::Flags< BitType > >::operator()
std::size_t operator()(VULKAN_HPP_NAMESPACE::Flags< BitType > const &flags) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:22
VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT
Definition: vulkan_structs.hpp:18489
VULKAN_HPP_NAMESPACE::PerformanceQuerySubmitInfoKHR
Definition: vulkan_structs.hpp:49442
VULKAN_HPP_NAMESPACE::ExternalImageFormatProperties
Definition: vulkan_structs.hpp:32267
VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo
Definition: vulkan_structs.hpp:14478
VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2
Definition: vulkan_structs.hpp:62782
VULKAN_HPP_NAMESPACE::Viewport
Definition: vulkan_structs.hpp:14131
VULKAN_HPP_NAMESPACE::DescriptorBufferBindingPushDescriptorBufferHandleEXT
Definition: vulkan_structs.hpp:20743
VULKAN_HPP_NAMESPACE::PhysicalDeviceAddressBindingReportFeaturesEXT
Definition: vulkan_structs.hpp:50524
VULKAN_HPP_NAMESPACE::TraceRaysIndirectCommandKHR
Definition: vulkan_structs.hpp:96659
VULKAN_HPP_NAMESPACE::PhysicalDeviceTimelineSemaphoreProperties
Definition: vulkan_structs.hpp:74095
VULKAN_HPP_NAMESPACE::PhysicalDeviceBorderColorSwizzleFeaturesEXT
Definition: vulkan_structs.hpp:51037
VULKAN_HPP_NAMESPACE::PipelineViewportDepthClipControlCreateInfoEXT
Definition: vulkan_structs.hpp:82350
VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerDotProductProperties
Definition: vulkan_structs.hpp:71432
SOP_VisibilityEnums::Viewport
Viewport
Definition: SOP_Visibility.proto.h:35
VULKAN_HPP_NAMESPACE::PresentTimeGOOGLE
Definition: vulkan_structs.hpp:84065
VULKAN_HPP_NAMESPACE::ExternalMemoryBufferCreateInfo
Definition: vulkan_structs.hpp:32522
VULKAN_HPP_NAMESPACE::PhysicalDeviceNonSeamlessCubeMapFeaturesEXT
Definition: vulkan_structs.hpp:64283
std::hash< VULKAN_HPP_NAMESPACE::SwapchainKHR >::operator()
std::size_t operator()(VULKAN_HPP_NAMESPACE::SwapchainKHR const &swapchainKHR) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:306
VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderInterlockFeaturesEXT
Definition: vulkan_structs.hpp:57883
VULKAN_HPP_NAMESPACE::AccelerationStructureKHR
Definition: vulkan_handles.hpp:3181
VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierExplicitCreateInfoEXT
Definition: vulkan_structs.hpp:39018
VULKAN_HPP_NAMESPACE::DeviceMemory
Definition: vulkan_handles.hpp:5527
VULKAN_HPP_NAMESPACE::DeviceCreateInfo
Definition: vulkan_structs.hpp:24068
VULKAN_HPP_NAMESPACE::VertexInputBindingDescription
Definition: vulkan_structs.hpp:34788
VULKAN_HPP_NAMESPACE::RenderPassBeginInfo
Definition: vulkan_structs.hpp:86562
std::hash< VULKAN_HPP_NAMESPACE::Buffer >::operator()
std::size_t operator()(VULKAN_HPP_NAMESPACE::Buffer const &buffer) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:118
VULKAN_HPP_NAMESPACE::SamplerBorderColorComponentMappingCreateInfoEXT
Definition: vulkan_structs.hpp:90032
VULKAN_HPP_NAMESPACE::Instance
Definition: vulkan_handles.hpp:13780
VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR
Definition: vulkan_structs.hpp:946
VULKAN_HPP_NAMESPACE::CommandBufferInheritanceConditionalRenderingInfoEXT
Definition: vulkan_structs.hpp:13718
j
GLint j
Definition: glad.h:2733
VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR
Definition: vulkan_structs.hpp:79181
VULKAN_HPP_NAMESPACE::DecompressMemoryRegionNV
Definition: vulkan_structs.hpp:19428
VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT
Definition: vulkan_structs.hpp:77487
VK_MAX_EXTENSION_NAME_SIZE
#define VK_MAX_EXTENSION_NAME_SIZE
Definition: vulkan_core.h:135
VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR
Definition: vulkan_structs.hpp:28001
VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderFeaturesNV
Definition: vulkan_structs.hpp:63009
VULKAN_HPP_NAMESPACE::AttachmentReference2
Definition: vulkan_structs.hpp:5743
VULKAN_HPP_NAMESPACE::ImageView
Definition: vulkan_handles.hpp:2582
VULKAN_HPP_NAMESPACE::ImageBlit
Definition: vulkan_structs.hpp:38007
std::hash< VULKAN_HPP_NAMESPACE::Instance >::operator()
std::size_t operator()(VULKAN_HPP_NAMESPACE::Instance const &instance) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:37
VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan12Properties
Definition: vulkan_structs.hpp:76207
VULKAN_HPP_NAMESPACE::CommandBufferSubmitInfo
Definition: vulkan_structs.hpp:14371
VULKAN_HPP_NAMESPACE::BufferImageCopy2
Definition: vulkan_structs.hpp:11418
VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR
Definition: vulkan_structs.hpp:15497
VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2
Definition: vulkan_structs.hpp:59698
VULKAN_HPP_NAMESPACE::ValidationCacheEXT
Definition: vulkan_handles.hpp:7054
VULKAN_HPP_NAMESPACE::SubpassDependency
Definition: vulkan_structs.hpp:86981
VULKAN_HPP_NAMESPACE::PhysicalDevicePresentBarrierFeaturesNV
Definition: vulkan_structs.hpp:66275
std::hash< VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV >::operator()
std::size_t operator()(VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV const &indirectCommandsLayoutNV) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:456
VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements
Definition: vulkan_structs.hpp:26520
VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicStateFeaturesEXT
Definition: vulkan_structs.hpp:56005
VULKAN_HPP_NAMESPACE::PipelineRepresentativeFragmentTestStateCreateInfoNV
Definition: vulkan_structs.hpp:81323
VULKAN_HPP_NAMESPACE::GraphicsPipelineLibraryCreateInfoEXT
Definition: vulkan_structs.hpp:37122
VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutTokenNV
Definition: vulkan_structs.hpp:43444
VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo
Definition: vulkan_structs.hpp:92193
VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR
Definition: vulkan_structs.hpp:28240
VULKAN_HPP_NAMESPACE::TraceRaysIndirectCommand2KHR
Definition: vulkan_structs.hpp:96420
VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR
Definition: vulkan_structs.hpp:73400
VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD
Definition: vulkan_structs.hpp:70916
VULKAN_HPP_NAMESPACE::PipelineDepthStencilStateCreateInfo
Definition: vulkan_structs.hpp:36099
VULKAN_HPP_NAMESPACE::ValidationFeaturesEXT
Definition: vulkan_structs.hpp:96898
VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT
Definition: vulkan_structs.hpp:47511
VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR
Definition: vulkan_structs.hpp:58357
VULKAN_HPP_NAMESPACE::MemoryBarrier2
Definition: vulkan_structs.hpp:19850
VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV
Definition: vulkan_structs.hpp:15327
VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineRobustnessPropertiesEXT
Definition: vulkan_structs.hpp:65705
VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT
Definition: vulkan_structs.hpp:24547
VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo
Definition: vulkan_structs.hpp:36780
VULKAN_HPP_NAMESPACE::CheckpointData2NV
Definition: vulkan_structs.hpp:12340
VK_UUID_SIZE
#define VK_UUID_SIZE
Definition: vulkan_core.h:134
VULKAN_HPP_NAMESPACE::PhysicalDeviceBlendOperationAdvancedFeaturesEXT
Definition: vulkan_structs.hpp:50820
VULKAN_HPP_NAMESPACE::PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT
Definition: vulkan_structs.hpp:58728
VULKAN_HPP_NAMESPACE::MemoryDedicatedAllocateInfo
Definition: vulkan_structs.hpp:44969
std::hash< VULKAN_HPP_NAMESPACE::DescriptorSetLayout >::operator()
std::size_t operator()(VULKAN_HPP_NAMESPACE::DescriptorSetLayout const &descriptorSetLayout) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:217
VULKAN_HPP_NAMESPACE::PipelineShaderStageRequiredSubgroupSizeCreateInfo
Definition: vulkan_structs.hpp:81794
VULKAN_HPP_NAMESPACE::RenderingInfo
Definition: vulkan_structs.hpp:89654
std::hash< VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion >::operator()
std::size_t operator()(VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion const &samplerYcbcrConversion) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:264
VULKAN_HPP_NAMESPACE::AccelerationStructureCaptureDescriptorDataInfoEXT
Definition: vulkan_structs.hpp:1175
VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX
Definition: vulkan_structs.hpp:63910
std::hash< VULKAN_HPP_NAMESPACE::BufferView >::operator()
std::size_t operator()(VULKAN_HPP_NAMESPACE::BufferView const &bufferView) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:127
VULKAN_HPP_NAMESPACE::CommandBufferInheritanceViewportScissorInfoNV
Definition: vulkan_structs.hpp:14248
VULKAN_HPP_NAMESPACE::DedicatedAllocationImageCreateInfoNV
Definition: vulkan_structs.hpp:19646
VULKAN_HPP_NAMESPACE::PerformanceCounterKHR
Definition: vulkan_structs.hpp:49053
VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2
Definition: vulkan_structs.hpp:11909
VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT
Definition: vulkan_structs.hpp:97192
VULKAN_HPP_NAMESPACE::PhysicalDeviceImagelessFramebufferFeatures
Definition: vulkan_structs.hpp:60354
VULKAN_HPP_NAMESPACE::DeviceGroupRenderPassBeginInfo
Definition: vulkan_structs.hpp:25801
VULKAN_HPP_NAMESPACE::PhysicalDeviceAccelerationStructureFeaturesKHR
Definition: vulkan_structs.hpp:50239
VULKAN_HPP_NAMESPACE::PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT
Definition: vulkan_structs.hpp:66675
VULKAN_HPP_NAMESPACE::SubpassDependency2
Definition: vulkan_structs.hpp:87622
VULKAN_HPP_NAMESPACE::PhysicalDeviceRepresentativeFragmentTestFeaturesNV
Definition: vulkan_structs.hpp:68776
VULKAN_HPP_NAMESPACE::RenderPassMultiviewCreateInfo
Definition: vulkan_structs.hpp:88538
VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPropertiesNV
Definition: vulkan_structs.hpp:68650
VULKAN_HPP_NAMESPACE::PhysicalDeviceCoherentMemoryFeaturesAMD
Definition: vulkan_structs.hpp:51396
VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV
Definition: vulkan_handles.hpp:2925
VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreatePrivateDataInfoNV
Definition: vulkan_structs.hpp:48656
VULKAN_HPP_NAMESPACE::DeviceGroupSubmitInfo
Definition: vulkan_structs.hpp:25942
VULKAN_HPP_NAMESPACE::CommandBufferInheritanceRenderPassTransformInfoQCOM
Definition: vulkan_structs.hpp:13818
VULKAN_HPP_NAMESPACE::WriteDescriptorSetAccelerationStructureKHR
Definition: vulkan_structs.hpp:106590
VK_MAX_MEMORY_HEAPS
#define VK_MAX_MEMORY_HEAPS
Definition: vulkan_core.h:137
VULKAN_HPP_NAMESPACE::RenderPassCreationFeedbackInfoEXT
Definition: vulkan_structs.hpp:88141
VULKAN_HPP_NAMESPACE::PhysicalDevice8BitStorageFeatures
Definition: vulkan_structs.hpp:50017
VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo
Definition: vulkan_structs.hpp:84272
VULKAN_HPP_NAMESPACE::RenderPassInputAttachmentAspectCreateInfo
Definition: vulkan_structs.hpp:88407
VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2
Definition: vulkan_structs.hpp:56816
VULKAN_HPP_NAMESPACE::SetStateFlagsIndirectCommandNV
Definition: vulkan_structs.hpp:92118
VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo
Definition: vulkan_structs.hpp:22761
std::hash< VULKAN_HPP_NAMESPACE::AccelerationStructureNV >::operator()
std::size_t operator()(VULKAN_HPP_NAMESPACE::AccelerationStructureNV const &accelerationStructureNV) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:423
VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT
Definition: vulkan_structs.hpp:18716
VULKAN_HPP_NAMESPACE::PipelineCoverageModulationStateCreateInfoNV
Definition: vulkan_structs.hpp:78393
std::hash< VULKAN_HPP_NAMESPACE::Device >::operator()
std::size_t operator()(VULKAN_HPP_NAMESPACE::Device const &device) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:55
VULKAN_HPP_NAMESPACE::PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures
Definition: vulkan_structs.hpp:77684
std::hash< VULKAN_HPP_NAMESPACE::DeviceMemory >::operator()
std::size_t operator()(VULKAN_HPP_NAMESPACE::DeviceMemory const &deviceMemory) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:73
VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackCreateInfo
Definition: vulkan_structs.hpp:78874
VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX
Definition: vulkan_structs.hpp:41136
VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR
Definition: vulkan_structs.hpp:4066
VULKAN_HPP_NAMESPACE::PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT
Definition: vulkan_structs.hpp:50720
VULKAN_HPP_NAMESPACE::PipelineCreationFeedback
Definition: vulkan_structs.hpp:78800
VULKAN_HPP_NAMESPACE::PhysicalDevicePCIBusInfoPropertiesEXT
Definition: vulkan_structs.hpp:64827
VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV
Definition: vulkan_structs.hpp:34655
VULKAN_HPP_NAMESPACE::MemoryRequirements2
Definition: vulkan_structs.hpp:46206
VULKAN_HPP_NAMESPACE::PhysicalDeviceInheritedViewportScissorFeaturesNV
Definition: vulkan_structs.hpp:60550
VULKAN_HPP_NAMESPACE::SubmitInfo2
Definition: vulkan_structs.hpp:93554
VULKAN_HPP_NAMESPACE::BaseOutStructure
Definition: vulkan_structs.hpp:6600
VULKAN_HPP_NAMESPACE::TextureLODGatherFormatPropertiesAMD
Definition: vulkan_structs.hpp:96056
VULKAN_HPP_NAMESPACE::PhysicalDeviceScalarBlockLayoutFeatures
Definition: vulkan_structs.hpp:69380
VULKAN_HPP_NAMESPACE::ImageStencilUsageCreateInfo
Definition: vulkan_structs.hpp:40415
VULKAN_HPP_NAMESPACE::PhysicalDevicePresentIdFeaturesKHR
Definition: vulkan_structs.hpp:66372
VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRatePropertiesKHR
Definition: vulkan_structs.hpp:58444
VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX
Definition: vulkan_structs.hpp:17534
std::hash< VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV >::operator()
std::size_t operator()(VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV const &opticalFlowSessionNV) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:491
VULKAN_HPP_NAMESPACE::WriteDescriptorSet
Definition: vulkan_structs.hpp:106359
VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan13Features
Definition: vulkan_structs.hpp:76590
VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo
Definition: vulkan_structs.hpp:26631
VULKAN_HPP_NAMESPACE::RenderingFragmentShadingRateAttachmentInfoKHR
Definition: vulkan_structs.hpp:89531
VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataEXT
Definition: vulkan_structs.hpp:18844
VULKAN_HPP_NAMESPACE::PhysicalDeviceImageCompressionControlFeaturesEXT
Definition: vulkan_structs.hpp:59342
VULKAN_HPP_NAMESPACE::PerformanceOverrideInfoINTEL
Definition: vulkan_structs.hpp:49322
VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT
Definition: vulkan_structs.hpp:18194
VULKAN_HPP_NAMESPACE::PhysicalDeviceSamplerFilterMinmaxProperties
Definition: vulkan_structs.hpp:69193
VULKAN_HPP_NAMESPACE::PhysicalDeviceOpticalFlowFeaturesNV
Definition: vulkan_structs.hpp:64590
VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE
Definition: vulkan_structs.hpp:86370
VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR
Definition: vulkan_structs.hpp:94596
VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate
Definition: vulkan_handles.hpp:3007
VULKAN_HPP_NAMESPACE::SubpassEndInfo
Definition: vulkan_structs.hpp:93992
VULKAN_HPP_NAMESPACE::ImageCreateInfo
Definition: vulkan_structs.hpp:26245
VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV
Definition: vulkan_structs.hpp:32438
VULKAN_HPP_NAMESPACE::MemoryOpaqueCaptureAddressAllocateInfo
Definition: vulkan_structs.hpp:45940
VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorIndexingProperties
Definition: vulkan_structs.hpp:54053
VULKAN_HPP_NAMESPACE::PhysicalDeviceHostQueryResetFeatures
Definition: vulkan_structs.hpp:59035
VULKAN_HPP_NAMESPACE::PhysicalDeviceTilePropertiesFeaturesQCOM
Definition: vulkan_structs.hpp:73899
VULKAN_HPP_NAMESPACE::Sampler
Definition: vulkan_handles.hpp:6795
VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR
Definition: vulkan_structs.hpp:94715
VULKAN_HPP_NAMESPACE::AttachmentSampleCountInfoAMD
Definition: vulkan_structs.hpp:5962
VULKAN_HPP_NAMESPACE::DescriptorSetVariableDescriptorCountAllocateInfo
Definition: vulkan_structs.hpp:22423
VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR
Definition: vulkan_structs.hpp:48955
VULKAN_HPP_NAMESPACE::ImportMemoryHostPointerInfoEXT
Definition: vulkan_structs.hpp:42157
VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties
Definition: vulkan_structs.hpp:66991
VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMap2PropertiesEXT
Definition: vulkan_structs.hpp:57191
VULKAN_HPP_NAMESPACE::DrawIndirectCommand
Definition: vulkan_structs.hpp:29385
VULKAN_HPP_NAMESPACE::PhysicalDeviceOpticalFlowPropertiesNV
Definition: vulkan_structs.hpp:64686
VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderClockFeaturesKHR
Definition: vulkan_structs.hpp:70174
VULKAN_HPP_NAMESPACE::GeometryTrianglesNV
Definition: vulkan_structs.hpp:1441
VULKAN_HPP_NAMESPACE::DedicatedAllocationBufferCreateInfoNV
Definition: vulkan_structs.hpp:19548
VULKAN_HPP_NAMESPACE::MicromapVersionInfoEXT
Definition: vulkan_structs.hpp:47238
VULKAN_HPP_NAMESPACE::DeviceMemoryReportCallbackDataEXT
Definition: vulkan_structs.hpp:26828
VULKAN_HPP_NAMESPACE::ConformanceVersion
Definition: vulkan_structs.hpp:15227
VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV
Definition: vulkan_handles.hpp:6548
VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT
Definition: vulkan_structs.hpp:18079
VULKAN_HPP_NAMESPACE::ImageFormatListCreateInfo
Definition: vulkan_structs.hpp:39370
std::hash< VULKAN_HPP_NAMESPACE::DescriptorSet >::operator()
std::size_t operator()(VULKAN_HPP_NAMESPACE::DescriptorSet const &descriptorSet) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:208
VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo
Definition: vulkan_structs.hpp:13608
VULKAN_HPP_NAMESPACE::ViewportWScalingNV
Definition: vulkan_structs.hpp:83080
VULKAN_HPP_NAMESPACE::CommandPool
Definition: vulkan_handles.hpp:5950
VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseProperties
Definition: vulkan_structs.hpp:66898
VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties
Definition: vulkan_structs.hpp:74179
VULKAN_HPP_NAMESPACE::ImageSubresource2EXT
Definition: vulkan_structs.hpp:40513
VULKAN_HPP_NAMESPACE::MemoryRequirements
Definition: vulkan_structs.hpp:46133
VULKAN_HPP_NAMESPACE::InstanceCreateInfo
Definition: vulkan_structs.hpp:44131
VULKAN_HPP_NAMESPACE::XYColorEXT
Definition: vulkan_structs.hpp:37541
VULKAN_HPP_NAMESPACE::RenderPassFragmentDensityMapCreateInfoEXT
Definition: vulkan_structs.hpp:88309
VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCorePropertiesAMD
Definition: vulkan_structs.hpp:70558
VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV
Definition: vulkan_structs.hpp:34187
VULKAN_HPP_NAMESPACE::CuFunctionNVX
Definition: vulkan_handles.hpp:6120
VULKAN_HPP_NAMESPACE::DeviceDeviceMemoryReportCreateInfoEXT
Definition: vulkan_structs.hpp:24333
VULKAN_HPP_NAMESPACE::PipelineRasterizationStateStreamCreateInfoEXT
Definition: vulkan_structs.hpp:81042
VULKAN_HPP_NAMESPACE::ExportFenceCreateInfo
Definition: vulkan_structs.hpp:30114
VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderFeaturesEXT
Definition: vulkan_structs.hpp:62866
VULKAN_HPP_NAMESPACE::PipelineCache
Definition: vulkan_handles.hpp:6035
VULKAN_HPP_NAMESPACE::SubpassDescriptionDepthStencilResolve
Definition: vulkan_structs.hpp:93867
VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassMergeFeedbackFeaturesEXT
Definition: vulkan_structs.hpp:73121
std::hash< VULKAN_HPP_NAMESPACE::RenderPass >::operator()
std::size_t operator()(VULKAN_HPP_NAMESPACE::RenderPass const &renderPass) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:235
VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFloat16Int8Features
Definition: vulkan_structs.hpp:71017
VULKAN_HPP_NAMESPACE::RayTracingShaderGroupCreateInfoKHR
Definition: vulkan_structs.hpp:85461
VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT
Definition: vulkan_structs.hpp:94454
VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo
Definition: vulkan_structs.hpp:21579
VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT
Definition: vulkan_handles.hpp:1738
VULKAN_HPP_NAMESPACE::PipelineInfoKHR
Definition: vulkan_structs.hpp:79883
VULKAN_HPP_NAMESPACE::SharedPresentSurfaceCapabilitiesKHR
Definition: vulkan_structs.hpp:92696
VULKAN_HPP_NAMESPACE::SampleLocationEXT
Definition: vulkan_structs.hpp:6192
VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX
Definition: vulkan_structs.hpp:17420
VK_LUID_SIZE
#define VK_LUID_SIZE
Definition: vulkan_core.h:4851
VULKAN_HPP_NAMESPACE::BindImageMemoryInfo
Definition: vulkan_structs.hpp:7420
VULKAN_HPP_NAMESPACE::PipelineColorBlendStateCreateInfo
Definition: vulkan_structs.hpp:36460
std::hash< VULKAN_HPP_NAMESPACE::Sampler >::operator()
std::size_t operator()(VULKAN_HPP_NAMESPACE::Sampler const &sampler) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:190
VULKAN_HPP_NAMESPACE::ClearRect
Definition: vulkan_structs.hpp:12770
VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreateInfoNV
Definition: vulkan_structs.hpp:48471
VULKAN_HPP_NAMESPACE::DescriptorBufferBindingInfoEXT
Definition: vulkan_structs.hpp:20634
VULKAN_HPP_NAMESPACE::TimelineSemaphoreSubmitInfo
Definition: vulkan_structs.hpp:96255
VULKAN_HPP_NAMESPACE::PipelineShaderStageModuleIdentifierCreateInfoEXT
Definition: vulkan_structs.hpp:81669
VULKAN_HPP_NAMESPACE::Fence
Definition: vulkan_handles.hpp:2075
VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo
Definition: vulkan_structs.hpp:6969
VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR
Definition: vulkan_structs.hpp:28605
VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsPropertiesNV
Definition: vulkan_structs.hpp:54471
VULKAN_HPP_NAMESPACE::BufferCreateInfo
Definition: vulkan_structs.hpp:10589
type
type
Definition: core.h:1059
VULKAN_HPP_NAMESPACE::BufferOpaqueCaptureAddressCreateInfo
Definition: vulkan_structs.hpp:12006
VULKAN_HPP_NAMESPACE::PipelineFragmentShadingRateStateCreateInfoKHR
Definition: vulkan_structs.hpp:79769
VULKAN_HPP_NAMESPACE::PipelineRasterizationProvokingVertexStateCreateInfoEXT
Definition: vulkan_structs.hpp:80840
VULKAN_HPP_NAMESPACE::FramebufferAttachmentImageInfo
Definition: vulkan_structs.hpp:33671
VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR
Definition: vulkan_structs.hpp:28344
VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV
Definition: vulkan_structs.hpp:12955
VULKAN_HPP_NAMESPACE::CommandBufferInheritanceInfo
Definition: vulkan_structs.hpp:13456
VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX
Definition: vulkan_structs.hpp:17791
VULKAN_HPP_NAMESPACE::PhysicalDeviceShadingRateImagePropertiesNV
Definition: vulkan_structs.hpp:72582
VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloat2FeaturesEXT
Definition: vulkan_structs.hpp:69580
VULKAN_HPP_NAMESPACE::SemaphoreSubmitInfo
Definition: vulkan_structs.hpp:91712
VULKAN_HPP_NAMESPACE::ImportMemoryFdInfoKHR
Definition: vulkan_structs.hpp:42050
VULKAN_HPP_NAMESPACE::PipelineRasterizationStateRasterizationOrderAMD
Definition: vulkan_structs.hpp:80942
VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationPropertiesEXT
Definition: vulkan_structs.hpp:61876
VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2
Definition: vulkan_structs.hpp:72672
VULKAN_HPP_NAMESPACE::ImageResolve
Definition: vulkan_structs.hpp:40064
VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV
Definition: vulkan_structs.hpp:48388
std::hash< VULKAN_HPP_NAMESPACE::Pipeline >::operator()
std::size_t operator()(VULKAN_HPP_NAMESPACE::Pipeline const &pipeline) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:172
VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT
Definition: vulkan_structs.hpp:17201
VULKAN_HPP_NAMESPACE::ImageFormatProperties
Definition: vulkan_structs.hpp:32351
VULKAN_HPP_NAMESPACE::MicromapTriangleEXT
Definition: vulkan_structs.hpp:47145
VULKAN_HPP_NAMESPACE::FragmentShadingRateAttachmentInfoKHR
Definition: vulkan_structs.hpp:33559
VULKAN_HPP_NAMESPACE::TransformMatrixKHR
Definition: vulkan_structs.hpp:2436
VULKAN_HPP_NAMESPACE::InitializePerformanceApiInfoINTEL
Definition: vulkan_structs.hpp:43938
VULKAN_HPP_NAMESPACE::SwapchainPresentBarrierCreateInfoNV
Definition: vulkan_structs.hpp:95958
VULKAN_HPP_NAMESPACE::RayTracingShaderGroupCreateInfoNV
Definition: vulkan_structs.hpp:86002
VULKAN_HPP_NAMESPACE::AllocationCallbacks
Definition: vulkan_structs.hpp:4172
VULKAN_HPP_NAMESPACE::SparseImageOpaqueMemoryBindInfo
Definition: vulkan_structs.hpp:8145
VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR
Definition: vulkan_structs.hpp:1289
VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR
Definition: vulkan_structs.hpp:28074
std::hash< VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL >::operator()
std::size_t operator()(VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL const &performanceConfigurationINTEL) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:434
VULKAN_HPP_NAMESPACE::PipelineRasterizationDepthClipStateCreateInfoEXT
Definition: vulkan_structs.hpp:80594
VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderModuleIdentifierPropertiesEXT
Definition: vulkan_structs.hpp:71903
VULKAN_HPP_NAMESPACE::PipelineViewportCoarseSampleOrderStateCreateInfoNV
Definition: vulkan_structs.hpp:82201
std::hash< VULKAN_HPP_NAMESPACE::PipelineCache >::operator()
std::size_t operator()(VULKAN_HPP_NAMESPACE::PipelineCache const &pipelineCache) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:163
std::hash< VULKAN_HPP_NAMESPACE::PhysicalDevice >::operator()
std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDevice const &physicalDevice) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:46
VULKAN_HPP_NAMESPACE::CopyDescriptorSet
Definition: vulkan_structs.hpp:16132
VULKAN_HPP_NAMESPACE::PhysicalDeviceColorWriteEnableFeaturesEXT
Definition: vulkan_structs.hpp:51494
VULKAN_HPP_NAMESPACE::PhysicalDeviceProvokingVertexPropertiesEXT
Definition: vulkan_structs.hpp:67468
VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo
Definition: vulkan_structs.hpp:91607
VULKAN_HPP_NAMESPACE::PhysicalDeviceInvocationMaskFeaturesHUAWEI
Definition: vulkan_structs.hpp:60871
VULKAN_HPP_NAMESPACE::RayTracingPipelineInterfaceCreateInfoKHR
Definition: vulkan_structs.hpp:85614
VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2
Definition: vulkan_structs.hpp:87791
VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR
Definition: vulkan_structs.hpp:93232
VULKAN_HPP_NAMESPACE::CopyCommandTransformInfoQCOM
Definition: vulkan_structs.hpp:16034
VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR
Definition: vulkan_structs.hpp:1052
VULKAN_HPP_NAMESPACE::DisplayModeKHR
Definition: vulkan_handles.hpp:12304
VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV
Definition: vulkan_structs.hpp:1981
VULKAN_HPP_NAMESPACE::PipelineRenderingCreateInfo
Definition: vulkan_structs.hpp:81153
VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionImageFormatProperties
Definition: vulkan_structs.hpp:90873
VULKAN_HPP_NAMESPACE::DeviceQueueCreateInfo
Definition: vulkan_structs.hpp:23205
VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryRDMAFeaturesNV
Definition: vulkan_structs.hpp:56510
VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceQueryFeaturesKHR
Definition: vulkan_structs.hpp:65017
VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateEnumsFeaturesNV
Definition: vulkan_structs.hpp:58008
VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR
Definition: vulkan_structs.hpp:27892
VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateEnumsPropertiesNV
Definition: vulkan_structs.hpp:58133
VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV
Definition: vulkan_structs.hpp:2147
VULKAN_HPP_NAMESPACE::MultiviewPerViewAttributesInfoNVX
Definition: vulkan_structs.hpp:47706
VULKAN_HPP_NAMESPACE::DescriptorPoolInlineUniformBlockCreateInfo
Definition: vulkan_structs.hpp:21480
VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupSizeControlProperties
Definition: vulkan_structs.hpp:73022
std::hash< VULKAN_HPP_NAMESPACE::DescriptorPool >::operator()
std::size_t operator()(VULKAN_HPP_NAMESPACE::DescriptorPool const &descriptorPool) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:199
VULKAN_HPP_NAMESPACE::FenceCreateInfo
Definition: vulkan_structs.hpp:32913
VULKAN_HPP_NAMESPACE::PresentTimesInfoGOOGLE
Definition: vulkan_structs.hpp:84148
VULKAN_HPP_NAMESPACE::ImageCompressionControlEXT
Definition: vulkan_structs.hpp:38209
VK_MAX_MEMORY_TYPES
#define VK_MAX_MEMORY_TYPES
Definition: vulkan_core.h:132
VULKAN_HPP_NAMESPACE::DeviceFaultCountsEXT
Definition: vulkan_structs.hpp:24738
VULKAN_HPP_NAMESPACE::SparseImageMemoryBindInfo
Definition: vulkan_structs.hpp:8666
std::hash< VULKAN_HPP_NAMESPACE::DisplayModeKHR >::operator()
std::size_t operator()(VULKAN_HPP_NAMESPACE::DisplayModeKHR const &displayModeKHR) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_hash.hpp:326
VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBinding
Definition: vulkan_structs.hpp:21825
VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewProperties
Definition: vulkan_structs.hpp:64095
VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloatFeaturesEXT
Definition: vulkan_structs.hpp:69824
VULKAN_HPP_NAMESPACE::PhysicalDeviceImageViewImageFormatInfoEXT
Definition: vulkan_structs.hpp:60159