Mercurial > games > semicongine

comparison fuhtark_test/Vulkan-Headers-1.4.334/include/vulkan/vulkan_hash.hpp @ 1501:f40d9d814c08 default tip main

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
did: correct vulkan-api generator
author sam <sam@basx.dev>
date Wed, 26 Nov 2025 23:34:29 +0700
parents
children
comparison
equal deleted inserted replaced
1500:91c8c3b7cbf0 1501:f40d9d814c08
1 // Copyright 2015-2025 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::QueryPool>
99 {
100 std::size_t operator()( VULKAN_HPP_NAMESPACE::QueryPool const & queryPool ) const VULKAN_HPP_NOEXCEPT
101 {
102 return std::hash<VkQueryPool>{}( static_cast<VkQueryPool>( queryPool ) );
103 }
104 };
105
106 template <>
107 struct hash<VULKAN_HPP_NAMESPACE::Buffer>
108 {
109 std::size_t operator()( VULKAN_HPP_NAMESPACE::Buffer const & buffer ) const VULKAN_HPP_NOEXCEPT
110 {
111 return std::hash<VkBuffer>{}( static_cast<VkBuffer>( buffer ) );
112 }
113 };
114
115 template <>
116 struct hash<VULKAN_HPP_NAMESPACE::Image>
117 {
118 std::size_t operator()( VULKAN_HPP_NAMESPACE::Image const & image ) const VULKAN_HPP_NOEXCEPT
119 {
120 return std::hash<VkImage>{}( static_cast<VkImage>( image ) );
121 }
122 };
123
124 template <>
125 struct hash<VULKAN_HPP_NAMESPACE::ImageView>
126 {
127 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageView const & imageView ) const VULKAN_HPP_NOEXCEPT
128 {
129 return std::hash<VkImageView>{}( static_cast<VkImageView>( imageView ) );
130 }
131 };
132
133 template <>
134 struct hash<VULKAN_HPP_NAMESPACE::CommandPool>
135 {
136 std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandPool const & commandPool ) const VULKAN_HPP_NOEXCEPT
137 {
138 return std::hash<VkCommandPool>{}( static_cast<VkCommandPool>( commandPool ) );
139 }
140 };
141
142 template <>
143 struct hash<VULKAN_HPP_NAMESPACE::CommandBuffer>
144 {
145 std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBuffer const & commandBuffer ) const VULKAN_HPP_NOEXCEPT
146 {
147 return std::hash<VkCommandBuffer>{}( static_cast<VkCommandBuffer>( commandBuffer ) );
148 }
149 };
150
151 template <>
152 struct hash<VULKAN_HPP_NAMESPACE::Event>
153 {
154 std::size_t operator()( VULKAN_HPP_NAMESPACE::Event const & event ) const VULKAN_HPP_NOEXCEPT
155 {
156 return std::hash<VkEvent>{}( static_cast<VkEvent>( event ) );
157 }
158 };
159
160 template <>
161 struct hash<VULKAN_HPP_NAMESPACE::BufferView>
162 {
163 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferView const & bufferView ) const VULKAN_HPP_NOEXCEPT
164 {
165 return std::hash<VkBufferView>{}( static_cast<VkBufferView>( bufferView ) );
166 }
167 };
168
169 template <>
170 struct hash<VULKAN_HPP_NAMESPACE::ShaderModule>
171 {
172 std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderModule const & shaderModule ) const VULKAN_HPP_NOEXCEPT
173 {
174 return std::hash<VkShaderModule>{}( static_cast<VkShaderModule>( shaderModule ) );
175 }
176 };
177
178 template <>
179 struct hash<VULKAN_HPP_NAMESPACE::PipelineCache>
180 {
181 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCache const & pipelineCache ) const VULKAN_HPP_NOEXCEPT
182 {
183 return std::hash<VkPipelineCache>{}( static_cast<VkPipelineCache>( pipelineCache ) );
184 }
185 };
186
187 template <>
188 struct hash<VULKAN_HPP_NAMESPACE::Pipeline>
189 {
190 std::size_t operator()( VULKAN_HPP_NAMESPACE::Pipeline const & pipeline ) const VULKAN_HPP_NOEXCEPT
191 {
192 return std::hash<VkPipeline>{}( static_cast<VkPipeline>( pipeline ) );
193 }
194 };
195
196 template <>
197 struct hash<VULKAN_HPP_NAMESPACE::PipelineLayout>
198 {
199 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineLayout const & pipelineLayout ) const VULKAN_HPP_NOEXCEPT
200 {
201 return std::hash<VkPipelineLayout>{}( static_cast<VkPipelineLayout>( pipelineLayout ) );
202 }
203 };
204
205 template <>
206 struct hash<VULKAN_HPP_NAMESPACE::Sampler>
207 {
208 std::size_t operator()( VULKAN_HPP_NAMESPACE::Sampler const & sampler ) const VULKAN_HPP_NOEXCEPT
209 {
210 return std::hash<VkSampler>{}( static_cast<VkSampler>( sampler ) );
211 }
212 };
213
214 template <>
215 struct hash<VULKAN_HPP_NAMESPACE::DescriptorPool>
216 {
217 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorPool const & descriptorPool ) const VULKAN_HPP_NOEXCEPT
218 {
219 return std::hash<VkDescriptorPool>{}( static_cast<VkDescriptorPool>( descriptorPool ) );
220 }
221 };
222
223 template <>
224 struct hash<VULKAN_HPP_NAMESPACE::DescriptorSet>
225 {
226 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSet const & descriptorSet ) const VULKAN_HPP_NOEXCEPT
227 {
228 return std::hash<VkDescriptorSet>{}( static_cast<VkDescriptorSet>( descriptorSet ) );
229 }
230 };
231
232 template <>
233 struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetLayout>
234 {
235 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetLayout const & descriptorSetLayout ) const VULKAN_HPP_NOEXCEPT
236 {
237 return std::hash<VkDescriptorSetLayout>{}( static_cast<VkDescriptorSetLayout>( descriptorSetLayout ) );
238 }
239 };
240
241 template <>
242 struct hash<VULKAN_HPP_NAMESPACE::Framebuffer>
243 {
244 std::size_t operator()( VULKAN_HPP_NAMESPACE::Framebuffer const & framebuffer ) const VULKAN_HPP_NOEXCEPT
245 {
246 return std::hash<VkFramebuffer>{}( static_cast<VkFramebuffer>( framebuffer ) );
247 }
248 };
249
250 template <>
251 struct hash<VULKAN_HPP_NAMESPACE::RenderPass>
252 {
253 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPass const & renderPass ) const VULKAN_HPP_NOEXCEPT
254 {
255 return std::hash<VkRenderPass>{}( static_cast<VkRenderPass>( renderPass ) );
256 }
257 };
258
259 //=== VK_VERSION_1_1 ===
260
261 template <>
262 struct hash<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate>
263 {
264 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate const & descriptorUpdateTemplate ) const VULKAN_HPP_NOEXCEPT
265 {
266 return std::hash<VkDescriptorUpdateTemplate>{}( static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ) );
267 }
268 };
269
270 template <>
271 struct hash<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion>
272 {
273 std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion const & samplerYcbcrConversion ) const VULKAN_HPP_NOEXCEPT
274 {
275 return std::hash<VkSamplerYcbcrConversion>{}( static_cast<VkSamplerYcbcrConversion>( samplerYcbcrConversion ) );
276 }
277 };
278
279 //=== VK_VERSION_1_3 ===
280
281 template <>
282 struct hash<VULKAN_HPP_NAMESPACE::PrivateDataSlot>
283 {
284 std::size_t operator()( VULKAN_HPP_NAMESPACE::PrivateDataSlot const & privateDataSlot ) const VULKAN_HPP_NOEXCEPT
285 {
286 return std::hash<VkPrivateDataSlot>{}( static_cast<VkPrivateDataSlot>( privateDataSlot ) );
287 }
288 };
289
290 //=== VK_KHR_surface ===
291
292 template <>
293 struct hash<VULKAN_HPP_NAMESPACE::SurfaceKHR>
294 {
295 std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceKHR const & surfaceKHR ) const VULKAN_HPP_NOEXCEPT
296 {
297 return std::hash<VkSurfaceKHR>{}( static_cast<VkSurfaceKHR>( surfaceKHR ) );
298 }
299 };
300
301 //=== VK_KHR_swapchain ===
302
303 template <>
304 struct hash<VULKAN_HPP_NAMESPACE::SwapchainKHR>
305 {
306 std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainKHR const & swapchainKHR ) const VULKAN_HPP_NOEXCEPT
307 {
308 return std::hash<VkSwapchainKHR>{}( static_cast<VkSwapchainKHR>( swapchainKHR ) );
309 }
310 };
311
312 //=== VK_KHR_display ===
313
314 template <>
315 struct hash<VULKAN_HPP_NAMESPACE::DisplayKHR>
316 {
317 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayKHR const & displayKHR ) const VULKAN_HPP_NOEXCEPT
318 {
319 return std::hash<VkDisplayKHR>{}( static_cast<VkDisplayKHR>( displayKHR ) );
320 }
321 };
322
323 template <>
324 struct hash<VULKAN_HPP_NAMESPACE::DisplayModeKHR>
325 {
326 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayModeKHR const & displayModeKHR ) const VULKAN_HPP_NOEXCEPT
327 {
328 return std::hash<VkDisplayModeKHR>{}( static_cast<VkDisplayModeKHR>( displayModeKHR ) );
329 }
330 };
331
332 //=== VK_EXT_debug_report ===
333
334 template <>
335 struct hash<VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT>
336 {
337 std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT const & debugReportCallbackEXT ) const VULKAN_HPP_NOEXCEPT
338 {
339 return std::hash<VkDebugReportCallbackEXT>{}( static_cast<VkDebugReportCallbackEXT>( debugReportCallbackEXT ) );
340 }
341 };
342
343 //=== VK_KHR_video_queue ===
344
345 template <>
346 struct hash<VULKAN_HPP_NAMESPACE::VideoSessionKHR>
347 {
348 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoSessionKHR const & videoSessionKHR ) const VULKAN_HPP_NOEXCEPT
349 {
350 return std::hash<VkVideoSessionKHR>{}( static_cast<VkVideoSessionKHR>( videoSessionKHR ) );
351 }
352 };
353
354 template <>
355 struct hash<VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR>
356 {
357 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR const & videoSessionParametersKHR ) const VULKAN_HPP_NOEXCEPT
358 {
359 return std::hash<VkVideoSessionParametersKHR>{}( static_cast<VkVideoSessionParametersKHR>( videoSessionParametersKHR ) );
360 }
361 };
362
363 //=== VK_NVX_binary_import ===
364
365 template <>
366 struct hash<VULKAN_HPP_NAMESPACE::CuModuleNVX>
367 {
368 std::size_t operator()( VULKAN_HPP_NAMESPACE::CuModuleNVX const & cuModuleNVX ) const VULKAN_HPP_NOEXCEPT
369 {
370 return std::hash<VkCuModuleNVX>{}( static_cast<VkCuModuleNVX>( cuModuleNVX ) );
371 }
372 };
373
374 template <>
375 struct hash<VULKAN_HPP_NAMESPACE::CuFunctionNVX>
376 {
377 std::size_t operator()( VULKAN_HPP_NAMESPACE::CuFunctionNVX const & cuFunctionNVX ) const VULKAN_HPP_NOEXCEPT
378 {
379 return std::hash<VkCuFunctionNVX>{}( static_cast<VkCuFunctionNVX>( cuFunctionNVX ) );
380 }
381 };
382
383 //=== VK_EXT_debug_utils ===
384
385 template <>
386 struct hash<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT>
387 {
388 std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT const & debugUtilsMessengerEXT ) const VULKAN_HPP_NOEXCEPT
389 {
390 return std::hash<VkDebugUtilsMessengerEXT>{}( static_cast<VkDebugUtilsMessengerEXT>( debugUtilsMessengerEXT ) );
391 }
392 };
393
394 //=== VK_KHR_acceleration_structure ===
395
396 template <>
397 struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureKHR>
398 {
399 std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR const & accelerationStructureKHR ) const VULKAN_HPP_NOEXCEPT
400 {
401 return std::hash<VkAccelerationStructureKHR>{}( static_cast<VkAccelerationStructureKHR>( accelerationStructureKHR ) );
402 }
403 };
404
405 //=== VK_EXT_validation_cache ===
406
407 template <>
408 struct hash<VULKAN_HPP_NAMESPACE::ValidationCacheEXT>
409 {
410 std::size_t operator()( VULKAN_HPP_NAMESPACE::ValidationCacheEXT const & validationCacheEXT ) const VULKAN_HPP_NOEXCEPT
411 {
412 return std::hash<VkValidationCacheEXT>{}( static_cast<VkValidationCacheEXT>( validationCacheEXT ) );
413 }
414 };
415
416 //=== VK_NV_ray_tracing ===
417
418 template <>
419 struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureNV>
420 {
421 std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureNV const & accelerationStructureNV ) const VULKAN_HPP_NOEXCEPT
422 {
423 return std::hash<VkAccelerationStructureNV>{}( static_cast<VkAccelerationStructureNV>( accelerationStructureNV ) );
424 }
425 };
426
427 //=== VK_INTEL_performance_query ===
428
429 template <>
430 struct hash<VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL>
431 {
432 std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL const & performanceConfigurationINTEL ) const VULKAN_HPP_NOEXCEPT
433 {
434 return std::hash<VkPerformanceConfigurationINTEL>{}( static_cast<VkPerformanceConfigurationINTEL>( performanceConfigurationINTEL ) );
435 }
436 };
437
438 //=== VK_KHR_deferred_host_operations ===
439
440 template <>
441 struct hash<VULKAN_HPP_NAMESPACE::DeferredOperationKHR>
442 {
443 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeferredOperationKHR const & deferredOperationKHR ) const VULKAN_HPP_NOEXCEPT
444 {
445 return std::hash<VkDeferredOperationKHR>{}( static_cast<VkDeferredOperationKHR>( deferredOperationKHR ) );
446 }
447 };
448
449 //=== VK_NV_device_generated_commands ===
450
451 template <>
452 struct hash<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV>
453 {
454 std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV const & indirectCommandsLayoutNV ) const VULKAN_HPP_NOEXCEPT
455 {
456 return std::hash<VkIndirectCommandsLayoutNV>{}( static_cast<VkIndirectCommandsLayoutNV>( indirectCommandsLayoutNV ) );
457 }
458 };
459
460 #if defined( VK_ENABLE_BETA_EXTENSIONS )
461 //=== VK_NV_cuda_kernel_launch ===
462
463 template <>
464 struct hash<VULKAN_HPP_NAMESPACE::CudaModuleNV>
465 {
466 std::size_t operator()( VULKAN_HPP_NAMESPACE::CudaModuleNV const & cudaModuleNV ) const VULKAN_HPP_NOEXCEPT
467 {
468 return std::hash<VkCudaModuleNV>{}( static_cast<VkCudaModuleNV>( cudaModuleNV ) );
469 }
470 };
471
472 template <>
473 struct hash<VULKAN_HPP_NAMESPACE::CudaFunctionNV>
474 {
475 std::size_t operator()( VULKAN_HPP_NAMESPACE::CudaFunctionNV const & cudaFunctionNV ) const VULKAN_HPP_NOEXCEPT
476 {
477 return std::hash<VkCudaFunctionNV>{}( static_cast<VkCudaFunctionNV>( cudaFunctionNV ) );
478 }
479 };
480 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
481
482 #if defined( VK_USE_PLATFORM_FUCHSIA )
483 //=== VK_FUCHSIA_buffer_collection ===
484
485 template <>
486 struct hash<VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA>
487 {
488 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA const & bufferCollectionFUCHSIA ) const VULKAN_HPP_NOEXCEPT
489 {
490 return std::hash<VkBufferCollectionFUCHSIA>{}( static_cast<VkBufferCollectionFUCHSIA>( bufferCollectionFUCHSIA ) );
491 }
492 };
493 #endif /*VK_USE_PLATFORM_FUCHSIA*/
494
495 //=== VK_EXT_opacity_micromap ===
496
497 template <>
498 struct hash<VULKAN_HPP_NAMESPACE::MicromapEXT>
499 {
500 std::size_t operator()( VULKAN_HPP_NAMESPACE::MicromapEXT const & micromapEXT ) const VULKAN_HPP_NOEXCEPT
501 {
502 return std::hash<VkMicromapEXT>{}( static_cast<VkMicromapEXT>( micromapEXT ) );
503 }
504 };
505
506 //=== VK_ARM_tensors ===
507
508 template <>
509 struct hash<VULKAN_HPP_NAMESPACE::TensorARM>
510 {
511 std::size_t operator()( VULKAN_HPP_NAMESPACE::TensorARM const & tensorARM ) const VULKAN_HPP_NOEXCEPT
512 {
513 return std::hash<VkTensorARM>{}( static_cast<VkTensorARM>( tensorARM ) );
514 }
515 };
516
517 template <>
518 struct hash<VULKAN_HPP_NAMESPACE::TensorViewARM>
519 {
520 std::size_t operator()( VULKAN_HPP_NAMESPACE::TensorViewARM const & tensorViewARM ) const VULKAN_HPP_NOEXCEPT
521 {
522 return std::hash<VkTensorViewARM>{}( static_cast<VkTensorViewARM>( tensorViewARM ) );
523 }
524 };
525
526 //=== VK_NV_optical_flow ===
527
528 template <>
529 struct hash<VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV>
530 {
531 std::size_t operator()( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV const & opticalFlowSessionNV ) const VULKAN_HPP_NOEXCEPT
532 {
533 return std::hash<VkOpticalFlowSessionNV>{}( static_cast<VkOpticalFlowSessionNV>( opticalFlowSessionNV ) );
534 }
535 };
536
537 //=== VK_EXT_shader_object ===
538
539 template <>
540 struct hash<VULKAN_HPP_NAMESPACE::ShaderEXT>
541 {
542 std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderEXT const & shaderEXT ) const VULKAN_HPP_NOEXCEPT
543 {
544 return std::hash<VkShaderEXT>{}( static_cast<VkShaderEXT>( shaderEXT ) );
545 }
546 };
547
548 //=== VK_KHR_pipeline_binary ===
549
550 template <>
551 struct hash<VULKAN_HPP_NAMESPACE::PipelineBinaryKHR>
552 {
553 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineBinaryKHR const & pipelineBinaryKHR ) const VULKAN_HPP_NOEXCEPT
554 {
555 return std::hash<VkPipelineBinaryKHR>{}( static_cast<VkPipelineBinaryKHR>( pipelineBinaryKHR ) );
556 }
557 };
558
559 //=== VK_ARM_data_graph ===
560
561 template <>
562 struct hash<VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionARM>
563 {
564 std::size_t operator()( VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionARM const & dataGraphPipelineSessionARM ) const VULKAN_HPP_NOEXCEPT
565 {
566 return std::hash<VkDataGraphPipelineSessionARM>{}( static_cast<VkDataGraphPipelineSessionARM>( dataGraphPipelineSessionARM ) );
567 }
568 };
569
570 //=== VK_NV_external_compute_queue ===
571
572 template <>
573 struct hash<VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV>
574 {
575 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV const & externalComputeQueueNV ) const VULKAN_HPP_NOEXCEPT
576 {
577 return std::hash<VkExternalComputeQueueNV>{}( static_cast<VkExternalComputeQueueNV>( externalComputeQueueNV ) );
578 }
579 };
580
581 //=== VK_EXT_device_generated_commands ===
582
583 template <>
584 struct hash<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutEXT>
585 {
586 std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutEXT const & indirectCommandsLayoutEXT ) const VULKAN_HPP_NOEXCEPT
587 {
588 return std::hash<VkIndirectCommandsLayoutEXT>{}( static_cast<VkIndirectCommandsLayoutEXT>( indirectCommandsLayoutEXT ) );
589 }
590 };
591
592 template <>
593 struct hash<VULKAN_HPP_NAMESPACE::IndirectExecutionSetEXT>
594 {
595 std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectExecutionSetEXT const & indirectExecutionSetEXT ) const VULKAN_HPP_NOEXCEPT
596 {
597 return std::hash<VkIndirectExecutionSetEXT>{}( static_cast<VkIndirectExecutionSetEXT>( indirectExecutionSetEXT ) );
598 }
599 };
600
601 #if 14 <= VULKAN_HPP_CPP_VERSION
602 //======================================
603 //=== HASH structures for structures ===
604 //======================================
605
606 # if !defined( VULKAN_HPP_HASH_COMBINE )
607 # define VULKAN_HPP_HASH_COMBINE( seed, value ) \
608 seed ^= std::hash<std::decay<decltype( value )>::type>{}( value ) + 0x9e3779b9 + ( seed << 6 ) + ( seed >> 2 )
609 # endif
610
611 template <>
612 struct hash<VULKAN_HPP_NAMESPACE::AabbPositionsKHR>
613 {
614 std::size_t operator()( VULKAN_HPP_NAMESPACE::AabbPositionsKHR const & aabbPositionsKHR ) const VULKAN_HPP_NOEXCEPT
615 {
616 std::size_t seed = 0;
617 VULKAN_HPP_HASH_COMBINE( seed, aabbPositionsKHR.minX );
618 VULKAN_HPP_HASH_COMBINE( seed, aabbPositionsKHR.minY );
619 VULKAN_HPP_HASH_COMBINE( seed, aabbPositionsKHR.minZ );
620 VULKAN_HPP_HASH_COMBINE( seed, aabbPositionsKHR.maxX );
621 VULKAN_HPP_HASH_COMBINE( seed, aabbPositionsKHR.maxY );
622 VULKAN_HPP_HASH_COMBINE( seed, aabbPositionsKHR.maxZ );
623 return seed;
624 }
625 };
626
627 template <>
628 struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR>
629 {
630 std::size_t
631 operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR const & accelerationStructureBuildRangeInfoKHR ) const VULKAN_HPP_NOEXCEPT
632 {
633 std::size_t seed = 0;
634 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildRangeInfoKHR.primitiveCount );
635 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildRangeInfoKHR.primitiveOffset );
636 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildRangeInfoKHR.firstVertex );
637 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildRangeInfoKHR.transformOffset );
638 return seed;
639 }
640 };
641
642 template <>
643 struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR>
644 {
645 std::size_t
646 operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR const & accelerationStructureBuildSizesInfoKHR ) const VULKAN_HPP_NOEXCEPT
647 {
648 std::size_t seed = 0;
649 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildSizesInfoKHR.sType );
650 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildSizesInfoKHR.pNext );
651 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildSizesInfoKHR.accelerationStructureSize );
652 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildSizesInfoKHR.updateScratchSize );
653 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildSizesInfoKHR.buildScratchSize );
654 return seed;
655 }
656 };
657
658 template <>
659 struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureCaptureDescriptorDataInfoEXT>
660 {
661 std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureCaptureDescriptorDataInfoEXT const & accelerationStructureCaptureDescriptorDataInfoEXT )
662 const VULKAN_HPP_NOEXCEPT
663 {
664 std::size_t seed = 0;
665 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCaptureDescriptorDataInfoEXT.sType );
666 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCaptureDescriptorDataInfoEXT.pNext );
667 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCaptureDescriptorDataInfoEXT.accelerationStructure );
668 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCaptureDescriptorDataInfoEXT.accelerationStructureNV );
669 return seed;
670 }
671 };
672
673 template <>
674 struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR>
675 {
676 std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR const & accelerationStructureCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
677 {
678 std::size_t seed = 0;
679 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoKHR.sType );
680 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoKHR.pNext );
681 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoKHR.createFlags );
682 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoKHR.buffer );
683 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoKHR.offset );
684 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoKHR.size );
685 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoKHR.type );
686 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoKHR.deviceAddress );
687 return seed;
688 }
689 };
690
691 template <>
692 struct hash<VULKAN_HPP_NAMESPACE::GeometryTrianglesNV>
693 {
694 std::size_t operator()( VULKAN_HPP_NAMESPACE::GeometryTrianglesNV const & geometryTrianglesNV ) const VULKAN_HPP_NOEXCEPT
695 {
696 std::size_t seed = 0;
697 VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.sType );
698 VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.pNext );
699 VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.vertexData );
700 VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.vertexOffset );
701 VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.vertexCount );
702 VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.vertexStride );
703 VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.vertexFormat );
704 VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.indexData );
705 VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.indexOffset );
706 VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.indexCount );
707 VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.indexType );
708 VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.transformData );
709 VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.transformOffset );
710 return seed;
711 }
712 };
713
714 template <>
715 struct hash<VULKAN_HPP_NAMESPACE::GeometryAABBNV>
716 {
717 std::size_t operator()( VULKAN_HPP_NAMESPACE::GeometryAABBNV const & geometryAABBNV ) const VULKAN_HPP_NOEXCEPT
718 {
719 std::size_t seed = 0;
720 VULKAN_HPP_HASH_COMBINE( seed, geometryAABBNV.sType );
721 VULKAN_HPP_HASH_COMBINE( seed, geometryAABBNV.pNext );
722 VULKAN_HPP_HASH_COMBINE( seed, geometryAABBNV.aabbData );
723 VULKAN_HPP_HASH_COMBINE( seed, geometryAABBNV.numAABBs );
724 VULKAN_HPP_HASH_COMBINE( seed, geometryAABBNV.stride );
725 VULKAN_HPP_HASH_COMBINE( seed, geometryAABBNV.offset );
726 return seed;
727 }
728 };
729
730 template <>
731 struct hash<VULKAN_HPP_NAMESPACE::GeometryDataNV>
732 {
733 std::size_t operator()( VULKAN_HPP_NAMESPACE::GeometryDataNV const & geometryDataNV ) const VULKAN_HPP_NOEXCEPT
734 {
735 std::size_t seed = 0;
736 VULKAN_HPP_HASH_COMBINE( seed, geometryDataNV.triangles );
737 VULKAN_HPP_HASH_COMBINE( seed, geometryDataNV.aabbs );
738 return seed;
739 }
740 };
741
742 template <>
743 struct hash<VULKAN_HPP_NAMESPACE::GeometryNV>
744 {
745 std::size_t operator()( VULKAN_HPP_NAMESPACE::GeometryNV const & geometryNV ) const VULKAN_HPP_NOEXCEPT
746 {
747 std::size_t seed = 0;
748 VULKAN_HPP_HASH_COMBINE( seed, geometryNV.sType );
749 VULKAN_HPP_HASH_COMBINE( seed, geometryNV.pNext );
750 VULKAN_HPP_HASH_COMBINE( seed, geometryNV.geometryType );
751 VULKAN_HPP_HASH_COMBINE( seed, geometryNV.geometry );
752 VULKAN_HPP_HASH_COMBINE( seed, geometryNV.flags );
753 return seed;
754 }
755 };
756
757 template <>
758 struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV>
759 {
760 std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV const & accelerationStructureInfoNV ) const VULKAN_HPP_NOEXCEPT
761 {
762 std::size_t seed = 0;
763 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInfoNV.sType );
764 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInfoNV.pNext );
765 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInfoNV.type );
766 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInfoNV.flags );
767 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInfoNV.instanceCount );
768 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInfoNV.geometryCount );
769 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInfoNV.pGeometries );
770 return seed;
771 }
772 };
773
774 template <>
775 struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV>
776 {
777 std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV const & accelerationStructureCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
778 {
779 std::size_t seed = 0;
780 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoNV.sType );
781 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoNV.pNext );
782 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoNV.compactedSize );
783 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoNV.info );
784 return seed;
785 }
786 };
787
788 template <>
789 struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR>
790 {
791 std::size_t
792 operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR const & accelerationStructureDeviceAddressInfoKHR ) const VULKAN_HPP_NOEXCEPT
793 {
794 std::size_t seed = 0;
795 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureDeviceAddressInfoKHR.sType );
796 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureDeviceAddressInfoKHR.pNext );
797 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureDeviceAddressInfoKHR.accelerationStructure );
798 return seed;
799 }
800 };
801
802 template <>
803 struct hash<VULKAN_HPP_NAMESPACE::TransformMatrixKHR>
804 {
805 std::size_t operator()( VULKAN_HPP_NAMESPACE::TransformMatrixKHR const & transformMatrixKHR ) const VULKAN_HPP_NOEXCEPT
806 {
807 std::size_t seed = 0;
808 for ( size_t i = 0; i < 3; ++i )
809 {
810 for ( size_t j = 0; j < 4; ++j )
811 {
812 VULKAN_HPP_HASH_COMBINE( seed, transformMatrixKHR.matrix[i][j] );
813 }
814 }
815 return seed;
816 }
817 };
818
819 template <>
820 struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureInstanceKHR>
821 {
822 std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureInstanceKHR const & accelerationStructureInstanceKHR ) const VULKAN_HPP_NOEXCEPT
823 {
824 std::size_t seed = 0;
825 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInstanceKHR.transform );
826 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInstanceKHR.instanceCustomIndex );
827 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInstanceKHR.mask );
828 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInstanceKHR.instanceShaderBindingTableRecordOffset );
829 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInstanceKHR.flags );
830 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInstanceKHR.accelerationStructureReference );
831 return seed;
832 }
833 };
834
835 template <>
836 struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureMatrixMotionInstanceNV>
837 {
838 std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureMatrixMotionInstanceNV const & accelerationStructureMatrixMotionInstanceNV ) const
839 VULKAN_HPP_NOEXCEPT
840 {
841 std::size_t seed = 0;
842 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMatrixMotionInstanceNV.transformT0 );
843 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMatrixMotionInstanceNV.transformT1 );
844 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMatrixMotionInstanceNV.instanceCustomIndex );
845 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMatrixMotionInstanceNV.mask );
846 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMatrixMotionInstanceNV.instanceShaderBindingTableRecordOffset );
847 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMatrixMotionInstanceNV.flags );
848 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMatrixMotionInstanceNV.accelerationStructureReference );
849 return seed;
850 }
851 };
852
853 template <>
854 struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV>
855 {
856 std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV const & accelerationStructureMemoryRequirementsInfoNV ) const
857 VULKAN_HPP_NOEXCEPT
858 {
859 std::size_t seed = 0;
860 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMemoryRequirementsInfoNV.sType );
861 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMemoryRequirementsInfoNV.pNext );
862 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMemoryRequirementsInfoNV.type );
863 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMemoryRequirementsInfoNV.accelerationStructure );
864 return seed;
865 }
866 };
867
868 template <>
869 struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInfoNV>
870 {
871 std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInfoNV const & accelerationStructureMotionInfoNV ) const VULKAN_HPP_NOEXCEPT
872 {
873 std::size_t seed = 0;
874 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMotionInfoNV.sType );
875 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMotionInfoNV.pNext );
876 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMotionInfoNV.maxInstances );
877 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMotionInfoNV.flags );
878 return seed;
879 }
880 };
881
882 template <>
883 struct hash<VULKAN_HPP_NAMESPACE::SRTDataNV>
884 {
885 std::size_t operator()( VULKAN_HPP_NAMESPACE::SRTDataNV const & sRTDataNV ) const VULKAN_HPP_NOEXCEPT
886 {
887 std::size_t seed = 0;
888 VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.sx );
889 VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.a );
890 VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.b );
891 VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.pvx );
892 VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.sy );
893 VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.c );
894 VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.pvy );
895 VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.sz );
896 VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.pvz );
897 VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.qx );
898 VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.qy );
899 VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.qz );
900 VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.qw );
901 VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.tx );
902 VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.ty );
903 VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.tz );
904 return seed;
905 }
906 };
907
908 template <>
909 struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureSRTMotionInstanceNV>
910 {
911 std::size_t
912 operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureSRTMotionInstanceNV const & accelerationStructureSRTMotionInstanceNV ) const VULKAN_HPP_NOEXCEPT
913 {
914 std::size_t seed = 0;
915 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureSRTMotionInstanceNV.transformT0 );
916 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureSRTMotionInstanceNV.transformT1 );
917 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureSRTMotionInstanceNV.instanceCustomIndex );
918 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureSRTMotionInstanceNV.mask );
919 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureSRTMotionInstanceNV.instanceShaderBindingTableRecordOffset );
920 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureSRTMotionInstanceNV.flags );
921 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureSRTMotionInstanceNV.accelerationStructureReference );
922 return seed;
923 }
924 };
925
926 template <>
927 struct hash<VULKAN_HPP_NAMESPACE::MicromapUsageEXT>
928 {
929 std::size_t operator()( VULKAN_HPP_NAMESPACE::MicromapUsageEXT const & micromapUsageEXT ) const VULKAN_HPP_NOEXCEPT
930 {
931 std::size_t seed = 0;
932 VULKAN_HPP_HASH_COMBINE( seed, micromapUsageEXT.count );
933 VULKAN_HPP_HASH_COMBINE( seed, micromapUsageEXT.subdivisionLevel );
934 VULKAN_HPP_HASH_COMBINE( seed, micromapUsageEXT.format );
935 return seed;
936 }
937 };
938
939 template <>
940 struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureVersionInfoKHR>
941 {
942 std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureVersionInfoKHR const & accelerationStructureVersionInfoKHR ) const VULKAN_HPP_NOEXCEPT
943 {
944 std::size_t seed = 0;
945 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureVersionInfoKHR.sType );
946 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureVersionInfoKHR.pNext );
947 VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureVersionInfoKHR.pVersionData );
948 return seed;
949 }
950 };
951
952 template <>
953 struct hash<VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR>
954 {
955 std::size_t operator()( VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR const & acquireNextImageInfoKHR ) const VULKAN_HPP_NOEXCEPT
956 {
957 std::size_t seed = 0;
958 VULKAN_HPP_HASH_COMBINE( seed, acquireNextImageInfoKHR.sType );
959 VULKAN_HPP_HASH_COMBINE( seed, acquireNextImageInfoKHR.pNext );
960 VULKAN_HPP_HASH_COMBINE( seed, acquireNextImageInfoKHR.swapchain );
961 VULKAN_HPP_HASH_COMBINE( seed, acquireNextImageInfoKHR.timeout );
962 VULKAN_HPP_HASH_COMBINE( seed, acquireNextImageInfoKHR.semaphore );
963 VULKAN_HPP_HASH_COMBINE( seed, acquireNextImageInfoKHR.fence );
964 VULKAN_HPP_HASH_COMBINE( seed, acquireNextImageInfoKHR.deviceMask );
965 return seed;
966 }
967 };
968
969 template <>
970 struct hash<VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR>
971 {
972 std::size_t operator()( VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR const & acquireProfilingLockInfoKHR ) const VULKAN_HPP_NOEXCEPT
973 {
974 std::size_t seed = 0;
975 VULKAN_HPP_HASH_COMBINE( seed, acquireProfilingLockInfoKHR.sType );
976 VULKAN_HPP_HASH_COMBINE( seed, acquireProfilingLockInfoKHR.pNext );
977 VULKAN_HPP_HASH_COMBINE( seed, acquireProfilingLockInfoKHR.flags );
978 VULKAN_HPP_HASH_COMBINE( seed, acquireProfilingLockInfoKHR.timeout );
979 return seed;
980 }
981 };
982
983 template <>
984 struct hash<VULKAN_HPP_NAMESPACE::AllocationCallbacks>
985 {
986 std::size_t operator()( VULKAN_HPP_NAMESPACE::AllocationCallbacks const & allocationCallbacks ) const VULKAN_HPP_NOEXCEPT
987 {
988 std::size_t seed = 0;
989 VULKAN_HPP_HASH_COMBINE( seed, allocationCallbacks.pUserData );
990 VULKAN_HPP_HASH_COMBINE( seed, allocationCallbacks.pfnAllocation );
991 VULKAN_HPP_HASH_COMBINE( seed, allocationCallbacks.pfnReallocation );
992 VULKAN_HPP_HASH_COMBINE( seed, allocationCallbacks.pfnFree );
993 VULKAN_HPP_HASH_COMBINE( seed, allocationCallbacks.pfnInternalAllocation );
994 VULKAN_HPP_HASH_COMBINE( seed, allocationCallbacks.pfnInternalFree );
995 return seed;
996 }
997 };
998
999 template <>
1000 struct hash<VULKAN_HPP_NAMESPACE::AmigoProfilingSubmitInfoSEC>
1001 {
1002 std::size_t operator()( VULKAN_HPP_NAMESPACE::AmigoProfilingSubmitInfoSEC const & amigoProfilingSubmitInfoSEC ) const VULKAN_HPP_NOEXCEPT
1003 {
1004 std::size_t seed = 0;
1005 VULKAN_HPP_HASH_COMBINE( seed, amigoProfilingSubmitInfoSEC.sType );
1006 VULKAN_HPP_HASH_COMBINE( seed, amigoProfilingSubmitInfoSEC.pNext );
1007 VULKAN_HPP_HASH_COMBINE( seed, amigoProfilingSubmitInfoSEC.firstDrawTimestamp );
1008 VULKAN_HPP_HASH_COMBINE( seed, amigoProfilingSubmitInfoSEC.swapBufferTimestamp );
1009 return seed;
1010 }
1011 };
1012
1013 template <>
1014 struct hash<VULKAN_HPP_NAMESPACE::ComponentMapping>
1015 {
1016 std::size_t operator()( VULKAN_HPP_NAMESPACE::ComponentMapping const & componentMapping ) const VULKAN_HPP_NOEXCEPT
1017 {
1018 std::size_t seed = 0;
1019 VULKAN_HPP_HASH_COMBINE( seed, componentMapping.r );
1020 VULKAN_HPP_HASH_COMBINE( seed, componentMapping.g );
1021 VULKAN_HPP_HASH_COMBINE( seed, componentMapping.b );
1022 VULKAN_HPP_HASH_COMBINE( seed, componentMapping.a );
1023 return seed;
1024 }
1025 };
1026
1027 # if defined( VK_USE_PLATFORM_ANDROID_KHR )
1028 template <>
1029 struct hash<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatProperties2ANDROID>
1030 {
1031 std::size_t operator()( VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatProperties2ANDROID const & androidHardwareBufferFormatProperties2ANDROID ) const
1032 VULKAN_HPP_NOEXCEPT
1033 {
1034 std::size_t seed = 0;
1035 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.sType );
1036 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.pNext );
1037 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.format );
1038 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.externalFormat );
1039 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.formatFeatures );
1040 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.samplerYcbcrConversionComponents );
1041 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.suggestedYcbcrModel );
1042 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.suggestedYcbcrRange );
1043 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.suggestedXChromaOffset );
1044 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.suggestedYChromaOffset );
1045 return seed;
1046 }
1047 };
1048 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/
1049
1050 # if defined( VK_USE_PLATFORM_ANDROID_KHR )
1051 template <>
1052 struct hash<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatPropertiesANDROID>
1053 {
1054 std::size_t operator()( VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatPropertiesANDROID const & androidHardwareBufferFormatPropertiesANDROID ) const
1055 VULKAN_HPP_NOEXCEPT
1056 {
1057 std::size_t seed = 0;
1058 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.sType );
1059 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.pNext );
1060 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.format );
1061 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.externalFormat );
1062 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.formatFeatures );
1063 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.samplerYcbcrConversionComponents );
1064 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.suggestedYcbcrModel );
1065 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.suggestedYcbcrRange );
1066 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.suggestedXChromaOffset );
1067 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.suggestedYChromaOffset );
1068 return seed;
1069 }
1070 };
1071 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/
1072
1073 # if defined( VK_USE_PLATFORM_ANDROID_KHR )
1074 template <>
1075 struct hash<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatResolvePropertiesANDROID>
1076 {
1077 std::size_t
1078 operator()( VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatResolvePropertiesANDROID const & androidHardwareBufferFormatResolvePropertiesANDROID ) const
1079 VULKAN_HPP_NOEXCEPT
1080 {
1081 std::size_t seed = 0;
1082 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatResolvePropertiesANDROID.sType );
1083 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatResolvePropertiesANDROID.pNext );
1084 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatResolvePropertiesANDROID.colorAttachmentFormat );
1085 return seed;
1086 }
1087 };
1088 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/
1089
1090 # if defined( VK_USE_PLATFORM_ANDROID_KHR )
1091 template <>
1092 struct hash<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID>
1093 {
1094 std::size_t
1095 operator()( VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID const & androidHardwareBufferPropertiesANDROID ) const VULKAN_HPP_NOEXCEPT
1096 {
1097 std::size_t seed = 0;
1098 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferPropertiesANDROID.sType );
1099 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferPropertiesANDROID.pNext );
1100 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferPropertiesANDROID.allocationSize );
1101 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferPropertiesANDROID.memoryTypeBits );
1102 return seed;
1103 }
1104 };
1105 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/
1106
1107 # if defined( VK_USE_PLATFORM_ANDROID_KHR )
1108 template <>
1109 struct hash<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferUsageANDROID>
1110 {
1111 std::size_t operator()( VULKAN_HPP_NAMESPACE::AndroidHardwareBufferUsageANDROID const & androidHardwareBufferUsageANDROID ) const VULKAN_HPP_NOEXCEPT
1112 {
1113 std::size_t seed = 0;
1114 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferUsageANDROID.sType );
1115 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferUsageANDROID.pNext );
1116 VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferUsageANDROID.androidHardwareBufferUsage );
1117 return seed;
1118 }
1119 };
1120 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/
1121
1122 # if defined( VK_USE_PLATFORM_ANDROID_KHR )
1123 template <>
1124 struct hash<VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR>
1125 {
1126 std::size_t operator()( VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR const & androidSurfaceCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
1127 {
1128 std::size_t seed = 0;
1129 VULKAN_HPP_HASH_COMBINE( seed, androidSurfaceCreateInfoKHR.sType );
1130 VULKAN_HPP_HASH_COMBINE( seed, androidSurfaceCreateInfoKHR.pNext );
1131 VULKAN_HPP_HASH_COMBINE( seed, androidSurfaceCreateInfoKHR.flags );
1132 VULKAN_HPP_HASH_COMBINE( seed, androidSurfaceCreateInfoKHR.window );
1133 return seed;
1134 }
1135 };
1136 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/
1137
1138 template <>
1139 struct hash<VULKAN_HPP_NAMESPACE::AntiLagPresentationInfoAMD>
1140 {
1141 std::size_t operator()( VULKAN_HPP_NAMESPACE::AntiLagPresentationInfoAMD const & antiLagPresentationInfoAMD ) const VULKAN_HPP_NOEXCEPT
1142 {
1143 std::size_t seed = 0;
1144 VULKAN_HPP_HASH_COMBINE( seed, antiLagPresentationInfoAMD.sType );
1145 VULKAN_HPP_HASH_COMBINE( seed, antiLagPresentationInfoAMD.pNext );
1146 VULKAN_HPP_HASH_COMBINE( seed, antiLagPresentationInfoAMD.stage );
1147 VULKAN_HPP_HASH_COMBINE( seed, antiLagPresentationInfoAMD.frameIndex );
1148 return seed;
1149 }
1150 };
1151
1152 template <>
1153 struct hash<VULKAN_HPP_NAMESPACE::AntiLagDataAMD>
1154 {
1155 std::size_t operator()( VULKAN_HPP_NAMESPACE::AntiLagDataAMD const & antiLagDataAMD ) const VULKAN_HPP_NOEXCEPT
1156 {
1157 std::size_t seed = 0;
1158 VULKAN_HPP_HASH_COMBINE( seed, antiLagDataAMD.sType );
1159 VULKAN_HPP_HASH_COMBINE( seed, antiLagDataAMD.pNext );
1160 VULKAN_HPP_HASH_COMBINE( seed, antiLagDataAMD.mode );
1161 VULKAN_HPP_HASH_COMBINE( seed, antiLagDataAMD.maxFPS );
1162 VULKAN_HPP_HASH_COMBINE( seed, antiLagDataAMD.pPresentationInfo );
1163 return seed;
1164 }
1165 };
1166
1167 template <>
1168 struct hash<VULKAN_HPP_NAMESPACE::ApplicationInfo>
1169 {
1170 std::size_t operator()( VULKAN_HPP_NAMESPACE::ApplicationInfo const & applicationInfo ) const VULKAN_HPP_NOEXCEPT
1171 {
1172 std::size_t seed = 0;
1173 VULKAN_HPP_HASH_COMBINE( seed, applicationInfo.sType );
1174 VULKAN_HPP_HASH_COMBINE( seed, applicationInfo.pNext );
1175 for ( const char * p = applicationInfo.pApplicationName; *p != '\0'; ++p )
1176 {
1177 VULKAN_HPP_HASH_COMBINE( seed, *p );
1178 }
1179 VULKAN_HPP_HASH_COMBINE( seed, applicationInfo.applicationVersion );
1180 for ( const char * p = applicationInfo.pEngineName; *p != '\0'; ++p )
1181 {
1182 VULKAN_HPP_HASH_COMBINE( seed, *p );
1183 }
1184 VULKAN_HPP_HASH_COMBINE( seed, applicationInfo.engineVersion );
1185 VULKAN_HPP_HASH_COMBINE( seed, applicationInfo.apiVersion );
1186 return seed;
1187 }
1188 };
1189
1190 template <>
1191 struct hash<VULKAN_HPP_NAMESPACE::AttachmentDescription>
1192 {
1193 std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentDescription const & attachmentDescription ) const VULKAN_HPP_NOEXCEPT
1194 {
1195 std::size_t seed = 0;
1196 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.flags );
1197 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.format );
1198 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.samples );
1199 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.loadOp );
1200 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.storeOp );
1201 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.stencilLoadOp );
1202 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.stencilStoreOp );
1203 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.initialLayout );
1204 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.finalLayout );
1205 return seed;
1206 }
1207 };
1208
1209 template <>
1210 struct hash<VULKAN_HPP_NAMESPACE::AttachmentDescription2>
1211 {
1212 std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentDescription2 const & attachmentDescription2 ) const VULKAN_HPP_NOEXCEPT
1213 {
1214 std::size_t seed = 0;
1215 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.sType );
1216 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.pNext );
1217 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.flags );
1218 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.format );
1219 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.samples );
1220 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.loadOp );
1221 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.storeOp );
1222 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.stencilLoadOp );
1223 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.stencilStoreOp );
1224 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.initialLayout );
1225 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.finalLayout );
1226 return seed;
1227 }
1228 };
1229
1230 template <>
1231 struct hash<VULKAN_HPP_NAMESPACE::AttachmentDescriptionStencilLayout>
1232 {
1233 std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentDescriptionStencilLayout const & attachmentDescriptionStencilLayout ) const VULKAN_HPP_NOEXCEPT
1234 {
1235 std::size_t seed = 0;
1236 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescriptionStencilLayout.sType );
1237 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescriptionStencilLayout.pNext );
1238 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescriptionStencilLayout.stencilInitialLayout );
1239 VULKAN_HPP_HASH_COMBINE( seed, attachmentDescriptionStencilLayout.stencilFinalLayout );
1240 return seed;
1241 }
1242 };
1243
1244 template <>
1245 struct hash<VULKAN_HPP_NAMESPACE::AttachmentFeedbackLoopInfoEXT>
1246 {
1247 std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentFeedbackLoopInfoEXT const & attachmentFeedbackLoopInfoEXT ) const VULKAN_HPP_NOEXCEPT
1248 {
1249 std::size_t seed = 0;
1250 VULKAN_HPP_HASH_COMBINE( seed, attachmentFeedbackLoopInfoEXT.sType );
1251 VULKAN_HPP_HASH_COMBINE( seed, attachmentFeedbackLoopInfoEXT.pNext );
1252 VULKAN_HPP_HASH_COMBINE( seed, attachmentFeedbackLoopInfoEXT.feedbackLoopEnable );
1253 return seed;
1254 }
1255 };
1256
1257 template <>
1258 struct hash<VULKAN_HPP_NAMESPACE::AttachmentReference>
1259 {
1260 std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentReference const & attachmentReference ) const VULKAN_HPP_NOEXCEPT
1261 {
1262 std::size_t seed = 0;
1263 VULKAN_HPP_HASH_COMBINE( seed, attachmentReference.attachment );
1264 VULKAN_HPP_HASH_COMBINE( seed, attachmentReference.layout );
1265 return seed;
1266 }
1267 };
1268
1269 template <>
1270 struct hash<VULKAN_HPP_NAMESPACE::AttachmentReference2>
1271 {
1272 std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentReference2 const & attachmentReference2 ) const VULKAN_HPP_NOEXCEPT
1273 {
1274 std::size_t seed = 0;
1275 VULKAN_HPP_HASH_COMBINE( seed, attachmentReference2.sType );
1276 VULKAN_HPP_HASH_COMBINE( seed, attachmentReference2.pNext );
1277 VULKAN_HPP_HASH_COMBINE( seed, attachmentReference2.attachment );
1278 VULKAN_HPP_HASH_COMBINE( seed, attachmentReference2.layout );
1279 VULKAN_HPP_HASH_COMBINE( seed, attachmentReference2.aspectMask );
1280 return seed;
1281 }
1282 };
1283
1284 template <>
1285 struct hash<VULKAN_HPP_NAMESPACE::AttachmentReferenceStencilLayout>
1286 {
1287 std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentReferenceStencilLayout const & attachmentReferenceStencilLayout ) const VULKAN_HPP_NOEXCEPT
1288 {
1289 std::size_t seed = 0;
1290 VULKAN_HPP_HASH_COMBINE( seed, attachmentReferenceStencilLayout.sType );
1291 VULKAN_HPP_HASH_COMBINE( seed, attachmentReferenceStencilLayout.pNext );
1292 VULKAN_HPP_HASH_COMBINE( seed, attachmentReferenceStencilLayout.stencilLayout );
1293 return seed;
1294 }
1295 };
1296
1297 template <>
1298 struct hash<VULKAN_HPP_NAMESPACE::AttachmentSampleCountInfoAMD>
1299 {
1300 std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentSampleCountInfoAMD const & attachmentSampleCountInfoAMD ) const VULKAN_HPP_NOEXCEPT
1301 {
1302 std::size_t seed = 0;
1303 VULKAN_HPP_HASH_COMBINE( seed, attachmentSampleCountInfoAMD.sType );
1304 VULKAN_HPP_HASH_COMBINE( seed, attachmentSampleCountInfoAMD.pNext );
1305 VULKAN_HPP_HASH_COMBINE( seed, attachmentSampleCountInfoAMD.colorAttachmentCount );
1306 VULKAN_HPP_HASH_COMBINE( seed, attachmentSampleCountInfoAMD.pColorAttachmentSamples );
1307 VULKAN_HPP_HASH_COMBINE( seed, attachmentSampleCountInfoAMD.depthStencilAttachmentSamples );
1308 return seed;
1309 }
1310 };
1311
1312 template <>
1313 struct hash<VULKAN_HPP_NAMESPACE::Extent2D>
1314 {
1315 std::size_t operator()( VULKAN_HPP_NAMESPACE::Extent2D const & extent2D ) const VULKAN_HPP_NOEXCEPT
1316 {
1317 std::size_t seed = 0;
1318 VULKAN_HPP_HASH_COMBINE( seed, extent2D.width );
1319 VULKAN_HPP_HASH_COMBINE( seed, extent2D.height );
1320 return seed;
1321 }
1322 };
1323
1324 template <>
1325 struct hash<VULKAN_HPP_NAMESPACE::SampleLocationEXT>
1326 {
1327 std::size_t operator()( VULKAN_HPP_NAMESPACE::SampleLocationEXT const & sampleLocationEXT ) const VULKAN_HPP_NOEXCEPT
1328 {
1329 std::size_t seed = 0;
1330 VULKAN_HPP_HASH_COMBINE( seed, sampleLocationEXT.x );
1331 VULKAN_HPP_HASH_COMBINE( seed, sampleLocationEXT.y );
1332 return seed;
1333 }
1334 };
1335
1336 template <>
1337 struct hash<VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT>
1338 {
1339 std::size_t operator()( VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT const & sampleLocationsInfoEXT ) const VULKAN_HPP_NOEXCEPT
1340 {
1341 std::size_t seed = 0;
1342 VULKAN_HPP_HASH_COMBINE( seed, sampleLocationsInfoEXT.sType );
1343 VULKAN_HPP_HASH_COMBINE( seed, sampleLocationsInfoEXT.pNext );
1344 VULKAN_HPP_HASH_COMBINE( seed, sampleLocationsInfoEXT.sampleLocationsPerPixel );
1345 VULKAN_HPP_HASH_COMBINE( seed, sampleLocationsInfoEXT.sampleLocationGridSize );
1346 VULKAN_HPP_HASH_COMBINE( seed, sampleLocationsInfoEXT.sampleLocationsCount );
1347 VULKAN_HPP_HASH_COMBINE( seed, sampleLocationsInfoEXT.pSampleLocations );
1348 return seed;
1349 }
1350 };
1351
1352 template <>
1353 struct hash<VULKAN_HPP_NAMESPACE::AttachmentSampleLocationsEXT>
1354 {
1355 std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentSampleLocationsEXT const & attachmentSampleLocationsEXT ) const VULKAN_HPP_NOEXCEPT
1356 {
1357 std::size_t seed = 0;
1358 VULKAN_HPP_HASH_COMBINE( seed, attachmentSampleLocationsEXT.attachmentIndex );
1359 VULKAN_HPP_HASH_COMBINE( seed, attachmentSampleLocationsEXT.sampleLocationsInfo );
1360 return seed;
1361 }
1362 };
1363
1364 template <>
1365 struct hash<VULKAN_HPP_NAMESPACE::BaseInStructure>
1366 {
1367 std::size_t operator()( VULKAN_HPP_NAMESPACE::BaseInStructure const & baseInStructure ) const VULKAN_HPP_NOEXCEPT
1368 {
1369 std::size_t seed = 0;
1370 VULKAN_HPP_HASH_COMBINE( seed, baseInStructure.sType );
1371 VULKAN_HPP_HASH_COMBINE( seed, baseInStructure.pNext );
1372 return seed;
1373 }
1374 };
1375
1376 template <>
1377 struct hash<VULKAN_HPP_NAMESPACE::BaseOutStructure>
1378 {
1379 std::size_t operator()( VULKAN_HPP_NAMESPACE::BaseOutStructure const & baseOutStructure ) const VULKAN_HPP_NOEXCEPT
1380 {
1381 std::size_t seed = 0;
1382 VULKAN_HPP_HASH_COMBINE( seed, baseOutStructure.sType );
1383 VULKAN_HPP_HASH_COMBINE( seed, baseOutStructure.pNext );
1384 return seed;
1385 }
1386 };
1387
1388 template <>
1389 struct hash<VULKAN_HPP_NAMESPACE::BeginCustomResolveInfoEXT>
1390 {
1391 std::size_t operator()( VULKAN_HPP_NAMESPACE::BeginCustomResolveInfoEXT const & beginCustomResolveInfoEXT ) const VULKAN_HPP_NOEXCEPT
1392 {
1393 std::size_t seed = 0;
1394 VULKAN_HPP_HASH_COMBINE( seed, beginCustomResolveInfoEXT.sType );
1395 VULKAN_HPP_HASH_COMBINE( seed, beginCustomResolveInfoEXT.pNext );
1396 return seed;
1397 }
1398 };
1399
1400 template <>
1401 struct hash<VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV>
1402 {
1403 std::size_t
1404 operator()( VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV const & bindAccelerationStructureMemoryInfoNV ) const VULKAN_HPP_NOEXCEPT
1405 {
1406 std::size_t seed = 0;
1407 VULKAN_HPP_HASH_COMBINE( seed, bindAccelerationStructureMemoryInfoNV.sType );
1408 VULKAN_HPP_HASH_COMBINE( seed, bindAccelerationStructureMemoryInfoNV.pNext );
1409 VULKAN_HPP_HASH_COMBINE( seed, bindAccelerationStructureMemoryInfoNV.accelerationStructure );
1410 VULKAN_HPP_HASH_COMBINE( seed, bindAccelerationStructureMemoryInfoNV.memory );
1411 VULKAN_HPP_HASH_COMBINE( seed, bindAccelerationStructureMemoryInfoNV.memoryOffset );
1412 VULKAN_HPP_HASH_COMBINE( seed, bindAccelerationStructureMemoryInfoNV.deviceIndexCount );
1413 VULKAN_HPP_HASH_COMBINE( seed, bindAccelerationStructureMemoryInfoNV.pDeviceIndices );
1414 return seed;
1415 }
1416 };
1417
1418 template <>
1419 struct hash<VULKAN_HPP_NAMESPACE::BindBufferMemoryDeviceGroupInfo>
1420 {
1421 std::size_t operator()( VULKAN_HPP_NAMESPACE::BindBufferMemoryDeviceGroupInfo const & bindBufferMemoryDeviceGroupInfo ) const VULKAN_HPP_NOEXCEPT
1422 {
1423 std::size_t seed = 0;
1424 VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryDeviceGroupInfo.sType );
1425 VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryDeviceGroupInfo.pNext );
1426 VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryDeviceGroupInfo.deviceIndexCount );
1427 VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryDeviceGroupInfo.pDeviceIndices );
1428 return seed;
1429 }
1430 };
1431
1432 template <>
1433 struct hash<VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo>
1434 {
1435 std::size_t operator()( VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo const & bindBufferMemoryInfo ) const VULKAN_HPP_NOEXCEPT
1436 {
1437 std::size_t seed = 0;
1438 VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryInfo.sType );
1439 VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryInfo.pNext );
1440 VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryInfo.buffer );
1441 VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryInfo.memory );
1442 VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryInfo.memoryOffset );
1443 return seed;
1444 }
1445 };
1446
1447 template <>
1448 struct hash<VULKAN_HPP_NAMESPACE::BindDataGraphPipelineSessionMemoryInfoARM>
1449 {
1450 std::size_t
1451 operator()( VULKAN_HPP_NAMESPACE::BindDataGraphPipelineSessionMemoryInfoARM const & bindDataGraphPipelineSessionMemoryInfoARM ) const VULKAN_HPP_NOEXCEPT
1452 {
1453 std::size_t seed = 0;
1454 VULKAN_HPP_HASH_COMBINE( seed, bindDataGraphPipelineSessionMemoryInfoARM.sType );
1455 VULKAN_HPP_HASH_COMBINE( seed, bindDataGraphPipelineSessionMemoryInfoARM.pNext );
1456 VULKAN_HPP_HASH_COMBINE( seed, bindDataGraphPipelineSessionMemoryInfoARM.session );
1457 VULKAN_HPP_HASH_COMBINE( seed, bindDataGraphPipelineSessionMemoryInfoARM.bindPoint );
1458 VULKAN_HPP_HASH_COMBINE( seed, bindDataGraphPipelineSessionMemoryInfoARM.objectIndex );
1459 VULKAN_HPP_HASH_COMBINE( seed, bindDataGraphPipelineSessionMemoryInfoARM.memory );
1460 VULKAN_HPP_HASH_COMBINE( seed, bindDataGraphPipelineSessionMemoryInfoARM.memoryOffset );
1461 return seed;
1462 }
1463 };
1464
1465 template <>
1466 struct hash<VULKAN_HPP_NAMESPACE::BindDescriptorBufferEmbeddedSamplersInfoEXT>
1467 {
1468 std::size_t operator()( VULKAN_HPP_NAMESPACE::BindDescriptorBufferEmbeddedSamplersInfoEXT const & bindDescriptorBufferEmbeddedSamplersInfoEXT ) const
1469 VULKAN_HPP_NOEXCEPT
1470 {
1471 std::size_t seed = 0;
1472 VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorBufferEmbeddedSamplersInfoEXT.sType );
1473 VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorBufferEmbeddedSamplersInfoEXT.pNext );
1474 VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorBufferEmbeddedSamplersInfoEXT.stageFlags );
1475 VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorBufferEmbeddedSamplersInfoEXT.layout );
1476 VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorBufferEmbeddedSamplersInfoEXT.set );
1477 return seed;
1478 }
1479 };
1480
1481 template <>
1482 struct hash<VULKAN_HPP_NAMESPACE::BindDescriptorSetsInfo>
1483 {
1484 std::size_t operator()( VULKAN_HPP_NAMESPACE::BindDescriptorSetsInfo const & bindDescriptorSetsInfo ) const VULKAN_HPP_NOEXCEPT
1485 {
1486 std::size_t seed = 0;
1487 VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorSetsInfo.sType );
1488 VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorSetsInfo.pNext );
1489 VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorSetsInfo.stageFlags );
1490 VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorSetsInfo.layout );
1491 VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorSetsInfo.firstSet );
1492 VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorSetsInfo.descriptorSetCount );
1493 VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorSetsInfo.pDescriptorSets );
1494 VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorSetsInfo.dynamicOffsetCount );
1495 VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorSetsInfo.pDynamicOffsets );
1496 return seed;
1497 }
1498 };
1499
1500 template <>
1501 struct hash<VULKAN_HPP_NAMESPACE::Offset2D>
1502 {
1503 std::size_t operator()( VULKAN_HPP_NAMESPACE::Offset2D const & offset2D ) const VULKAN_HPP_NOEXCEPT
1504 {
1505 std::size_t seed = 0;
1506 VULKAN_HPP_HASH_COMBINE( seed, offset2D.x );
1507 VULKAN_HPP_HASH_COMBINE( seed, offset2D.y );
1508 return seed;
1509 }
1510 };
1511
1512 template <>
1513 struct hash<VULKAN_HPP_NAMESPACE::Rect2D>
1514 {
1515 std::size_t operator()( VULKAN_HPP_NAMESPACE::Rect2D const & rect2D ) const VULKAN_HPP_NOEXCEPT
1516 {
1517 std::size_t seed = 0;
1518 VULKAN_HPP_HASH_COMBINE( seed, rect2D.offset );
1519 VULKAN_HPP_HASH_COMBINE( seed, rect2D.extent );
1520 return seed;
1521 }
1522 };
1523
1524 template <>
1525 struct hash<VULKAN_HPP_NAMESPACE::BindImageMemoryDeviceGroupInfo>
1526 {
1527 std::size_t operator()( VULKAN_HPP_NAMESPACE::BindImageMemoryDeviceGroupInfo const & bindImageMemoryDeviceGroupInfo ) const VULKAN_HPP_NOEXCEPT
1528 {
1529 std::size_t seed = 0;
1530 VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryDeviceGroupInfo.sType );
1531 VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryDeviceGroupInfo.pNext );
1532 VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryDeviceGroupInfo.deviceIndexCount );
1533 VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryDeviceGroupInfo.pDeviceIndices );
1534 VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryDeviceGroupInfo.splitInstanceBindRegionCount );
1535 VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryDeviceGroupInfo.pSplitInstanceBindRegions );
1536 return seed;
1537 }
1538 };
1539
1540 template <>
1541 struct hash<VULKAN_HPP_NAMESPACE::BindImageMemoryInfo>
1542 {
1543 std::size_t operator()( VULKAN_HPP_NAMESPACE::BindImageMemoryInfo const & bindImageMemoryInfo ) const VULKAN_HPP_NOEXCEPT
1544 {
1545 std::size_t seed = 0;
1546 VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryInfo.sType );
1547 VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryInfo.pNext );
1548 VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryInfo.image );
1549 VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryInfo.memory );
1550 VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryInfo.memoryOffset );
1551 return seed;
1552 }
1553 };
1554
1555 template <>
1556 struct hash<VULKAN_HPP_NAMESPACE::BindImageMemorySwapchainInfoKHR>
1557 {
1558 std::size_t operator()( VULKAN_HPP_NAMESPACE::BindImageMemorySwapchainInfoKHR const & bindImageMemorySwapchainInfoKHR ) const VULKAN_HPP_NOEXCEPT
1559 {
1560 std::size_t seed = 0;
1561 VULKAN_HPP_HASH_COMBINE( seed, bindImageMemorySwapchainInfoKHR.sType );
1562 VULKAN_HPP_HASH_COMBINE( seed, bindImageMemorySwapchainInfoKHR.pNext );
1563 VULKAN_HPP_HASH_COMBINE( seed, bindImageMemorySwapchainInfoKHR.swapchain );
1564 VULKAN_HPP_HASH_COMBINE( seed, bindImageMemorySwapchainInfoKHR.imageIndex );
1565 return seed;
1566 }
1567 };
1568
1569 template <>
1570 struct hash<VULKAN_HPP_NAMESPACE::BindImagePlaneMemoryInfo>
1571 {
1572 std::size_t operator()( VULKAN_HPP_NAMESPACE::BindImagePlaneMemoryInfo const & bindImagePlaneMemoryInfo ) const VULKAN_HPP_NOEXCEPT
1573 {
1574 std::size_t seed = 0;
1575 VULKAN_HPP_HASH_COMBINE( seed, bindImagePlaneMemoryInfo.sType );
1576 VULKAN_HPP_HASH_COMBINE( seed, bindImagePlaneMemoryInfo.pNext );
1577 VULKAN_HPP_HASH_COMBINE( seed, bindImagePlaneMemoryInfo.planeAspect );
1578 return seed;
1579 }
1580 };
1581
1582 template <>
1583 struct hash<VULKAN_HPP_NAMESPACE::BindIndexBufferIndirectCommandEXT>
1584 {
1585 std::size_t operator()( VULKAN_HPP_NAMESPACE::BindIndexBufferIndirectCommandEXT const & bindIndexBufferIndirectCommandEXT ) const VULKAN_HPP_NOEXCEPT
1586 {
1587 std::size_t seed = 0;
1588 VULKAN_HPP_HASH_COMBINE( seed, bindIndexBufferIndirectCommandEXT.bufferAddress );
1589 VULKAN_HPP_HASH_COMBINE( seed, bindIndexBufferIndirectCommandEXT.size );
1590 VULKAN_HPP_HASH_COMBINE( seed, bindIndexBufferIndirectCommandEXT.indexType );
1591 return seed;
1592 }
1593 };
1594
1595 template <>
1596 struct hash<VULKAN_HPP_NAMESPACE::BindIndexBufferIndirectCommandNV>
1597 {
1598 std::size_t operator()( VULKAN_HPP_NAMESPACE::BindIndexBufferIndirectCommandNV const & bindIndexBufferIndirectCommandNV ) const VULKAN_HPP_NOEXCEPT
1599 {
1600 std::size_t seed = 0;
1601 VULKAN_HPP_HASH_COMBINE( seed, bindIndexBufferIndirectCommandNV.bufferAddress );
1602 VULKAN_HPP_HASH_COMBINE( seed, bindIndexBufferIndirectCommandNV.size );
1603 VULKAN_HPP_HASH_COMBINE( seed, bindIndexBufferIndirectCommandNV.indexType );
1604 return seed;
1605 }
1606 };
1607
1608 template <>
1609 struct hash<VULKAN_HPP_NAMESPACE::BindMemoryStatus>
1610 {
1611 std::size_t operator()( VULKAN_HPP_NAMESPACE::BindMemoryStatus const & bindMemoryStatus ) const VULKAN_HPP_NOEXCEPT
1612 {
1613 std::size_t seed = 0;
1614 VULKAN_HPP_HASH_COMBINE( seed, bindMemoryStatus.sType );
1615 VULKAN_HPP_HASH_COMBINE( seed, bindMemoryStatus.pNext );
1616 VULKAN_HPP_HASH_COMBINE( seed, bindMemoryStatus.pResult );
1617 return seed;
1618 }
1619 };
1620
1621 template <>
1622 struct hash<VULKAN_HPP_NAMESPACE::BindPipelineIndirectCommandNV>
1623 {
1624 std::size_t operator()( VULKAN_HPP_NAMESPACE::BindPipelineIndirectCommandNV const & bindPipelineIndirectCommandNV ) const VULKAN_HPP_NOEXCEPT
1625 {
1626 std::size_t seed = 0;
1627 VULKAN_HPP_HASH_COMBINE( seed, bindPipelineIndirectCommandNV.pipelineAddress );
1628 return seed;
1629 }
1630 };
1631
1632 template <>
1633 struct hash<VULKAN_HPP_NAMESPACE::BindShaderGroupIndirectCommandNV>
1634 {
1635 std::size_t operator()( VULKAN_HPP_NAMESPACE::BindShaderGroupIndirectCommandNV const & bindShaderGroupIndirectCommandNV ) const VULKAN_HPP_NOEXCEPT
1636 {
1637 std::size_t seed = 0;
1638 VULKAN_HPP_HASH_COMBINE( seed, bindShaderGroupIndirectCommandNV.groupIndex );
1639 return seed;
1640 }
1641 };
1642
1643 template <>
1644 struct hash<VULKAN_HPP_NAMESPACE::SparseMemoryBind>
1645 {
1646 std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseMemoryBind const & sparseMemoryBind ) const VULKAN_HPP_NOEXCEPT
1647 {
1648 std::size_t seed = 0;
1649 VULKAN_HPP_HASH_COMBINE( seed, sparseMemoryBind.resourceOffset );
1650 VULKAN_HPP_HASH_COMBINE( seed, sparseMemoryBind.size );
1651 VULKAN_HPP_HASH_COMBINE( seed, sparseMemoryBind.memory );
1652 VULKAN_HPP_HASH_COMBINE( seed, sparseMemoryBind.memoryOffset );
1653 VULKAN_HPP_HASH_COMBINE( seed, sparseMemoryBind.flags );
1654 return seed;
1655 }
1656 };
1657
1658 template <>
1659 struct hash<VULKAN_HPP_NAMESPACE::SparseBufferMemoryBindInfo>
1660 {
1661 std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseBufferMemoryBindInfo const & sparseBufferMemoryBindInfo ) const VULKAN_HPP_NOEXCEPT
1662 {
1663 std::size_t seed = 0;
1664 VULKAN_HPP_HASH_COMBINE( seed, sparseBufferMemoryBindInfo.buffer );
1665 VULKAN_HPP_HASH_COMBINE( seed, sparseBufferMemoryBindInfo.bindCount );
1666 VULKAN_HPP_HASH_COMBINE( seed, sparseBufferMemoryBindInfo.pBinds );
1667 return seed;
1668 }
1669 };
1670
1671 template <>
1672 struct hash<VULKAN_HPP_NAMESPACE::SparseImageOpaqueMemoryBindInfo>
1673 {
1674 std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageOpaqueMemoryBindInfo const & sparseImageOpaqueMemoryBindInfo ) const VULKAN_HPP_NOEXCEPT
1675 {
1676 std::size_t seed = 0;
1677 VULKAN_HPP_HASH_COMBINE( seed, sparseImageOpaqueMemoryBindInfo.image );
1678 VULKAN_HPP_HASH_COMBINE( seed, sparseImageOpaqueMemoryBindInfo.bindCount );
1679 VULKAN_HPP_HASH_COMBINE( seed, sparseImageOpaqueMemoryBindInfo.pBinds );
1680 return seed;
1681 }
1682 };
1683
1684 template <>
1685 struct hash<VULKAN_HPP_NAMESPACE::ImageSubresource>
1686 {
1687 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageSubresource const & imageSubresource ) const VULKAN_HPP_NOEXCEPT
1688 {
1689 std::size_t seed = 0;
1690 VULKAN_HPP_HASH_COMBINE( seed, imageSubresource.aspectMask );
1691 VULKAN_HPP_HASH_COMBINE( seed, imageSubresource.mipLevel );
1692 VULKAN_HPP_HASH_COMBINE( seed, imageSubresource.arrayLayer );
1693 return seed;
1694 }
1695 };
1696
1697 template <>
1698 struct hash<VULKAN_HPP_NAMESPACE::Offset3D>
1699 {
1700 std::size_t operator()( VULKAN_HPP_NAMESPACE::Offset3D const & offset3D ) const VULKAN_HPP_NOEXCEPT
1701 {
1702 std::size_t seed = 0;
1703 VULKAN_HPP_HASH_COMBINE( seed, offset3D.x );
1704 VULKAN_HPP_HASH_COMBINE( seed, offset3D.y );
1705 VULKAN_HPP_HASH_COMBINE( seed, offset3D.z );
1706 return seed;
1707 }
1708 };
1709
1710 template <>
1711 struct hash<VULKAN_HPP_NAMESPACE::Extent3D>
1712 {
1713 std::size_t operator()( VULKAN_HPP_NAMESPACE::Extent3D const & extent3D ) const VULKAN_HPP_NOEXCEPT
1714 {
1715 std::size_t seed = 0;
1716 VULKAN_HPP_HASH_COMBINE( seed, extent3D.width );
1717 VULKAN_HPP_HASH_COMBINE( seed, extent3D.height );
1718 VULKAN_HPP_HASH_COMBINE( seed, extent3D.depth );
1719 return seed;
1720 }
1721 };
1722
1723 template <>
1724 struct hash<VULKAN_HPP_NAMESPACE::SparseImageMemoryBind>
1725 {
1726 std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageMemoryBind const & sparseImageMemoryBind ) const VULKAN_HPP_NOEXCEPT
1727 {
1728 std::size_t seed = 0;
1729 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBind.subresource );
1730 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBind.offset );
1731 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBind.extent );
1732 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBind.memory );
1733 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBind.memoryOffset );
1734 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBind.flags );
1735 return seed;
1736 }
1737 };
1738
1739 template <>
1740 struct hash<VULKAN_HPP_NAMESPACE::SparseImageMemoryBindInfo>
1741 {
1742 std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageMemoryBindInfo const & sparseImageMemoryBindInfo ) const VULKAN_HPP_NOEXCEPT
1743 {
1744 std::size_t seed = 0;
1745 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBindInfo.image );
1746 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBindInfo.bindCount );
1747 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBindInfo.pBinds );
1748 return seed;
1749 }
1750 };
1751
1752 template <>
1753 struct hash<VULKAN_HPP_NAMESPACE::BindSparseInfo>
1754 {
1755 std::size_t operator()( VULKAN_HPP_NAMESPACE::BindSparseInfo const & bindSparseInfo ) const VULKAN_HPP_NOEXCEPT
1756 {
1757 std::size_t seed = 0;
1758 VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.sType );
1759 VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.pNext );
1760 VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.waitSemaphoreCount );
1761 VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.pWaitSemaphores );
1762 VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.bufferBindCount );
1763 VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.pBufferBinds );
1764 VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.imageOpaqueBindCount );
1765 VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.pImageOpaqueBinds );
1766 VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.imageBindCount );
1767 VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.pImageBinds );
1768 VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.signalSemaphoreCount );
1769 VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.pSignalSemaphores );
1770 return seed;
1771 }
1772 };
1773
1774 template <>
1775 struct hash<VULKAN_HPP_NAMESPACE::BindTensorMemoryInfoARM>
1776 {
1777 std::size_t operator()( VULKAN_HPP_NAMESPACE::BindTensorMemoryInfoARM const & bindTensorMemoryInfoARM ) const VULKAN_HPP_NOEXCEPT
1778 {
1779 std::size_t seed = 0;
1780 VULKAN_HPP_HASH_COMBINE( seed, bindTensorMemoryInfoARM.sType );
1781 VULKAN_HPP_HASH_COMBINE( seed, bindTensorMemoryInfoARM.pNext );
1782 VULKAN_HPP_HASH_COMBINE( seed, bindTensorMemoryInfoARM.tensor );
1783 VULKAN_HPP_HASH_COMBINE( seed, bindTensorMemoryInfoARM.memory );
1784 VULKAN_HPP_HASH_COMBINE( seed, bindTensorMemoryInfoARM.memoryOffset );
1785 return seed;
1786 }
1787 };
1788
1789 template <>
1790 struct hash<VULKAN_HPP_NAMESPACE::BindVertexBufferIndirectCommandEXT>
1791 {
1792 std::size_t operator()( VULKAN_HPP_NAMESPACE::BindVertexBufferIndirectCommandEXT const & bindVertexBufferIndirectCommandEXT ) const VULKAN_HPP_NOEXCEPT
1793 {
1794 std::size_t seed = 0;
1795 VULKAN_HPP_HASH_COMBINE( seed, bindVertexBufferIndirectCommandEXT.bufferAddress );
1796 VULKAN_HPP_HASH_COMBINE( seed, bindVertexBufferIndirectCommandEXT.size );
1797 VULKAN_HPP_HASH_COMBINE( seed, bindVertexBufferIndirectCommandEXT.stride );
1798 return seed;
1799 }
1800 };
1801
1802 template <>
1803 struct hash<VULKAN_HPP_NAMESPACE::BindVertexBufferIndirectCommandNV>
1804 {
1805 std::size_t operator()( VULKAN_HPP_NAMESPACE::BindVertexBufferIndirectCommandNV const & bindVertexBufferIndirectCommandNV ) const VULKAN_HPP_NOEXCEPT
1806 {
1807 std::size_t seed = 0;
1808 VULKAN_HPP_HASH_COMBINE( seed, bindVertexBufferIndirectCommandNV.bufferAddress );
1809 VULKAN_HPP_HASH_COMBINE( seed, bindVertexBufferIndirectCommandNV.size );
1810 VULKAN_HPP_HASH_COMBINE( seed, bindVertexBufferIndirectCommandNV.stride );
1811 return seed;
1812 }
1813 };
1814
1815 template <>
1816 struct hash<VULKAN_HPP_NAMESPACE::BindVideoSessionMemoryInfoKHR>
1817 {
1818 std::size_t operator()( VULKAN_HPP_NAMESPACE::BindVideoSessionMemoryInfoKHR const & bindVideoSessionMemoryInfoKHR ) const VULKAN_HPP_NOEXCEPT
1819 {
1820 std::size_t seed = 0;
1821 VULKAN_HPP_HASH_COMBINE( seed, bindVideoSessionMemoryInfoKHR.sType );
1822 VULKAN_HPP_HASH_COMBINE( seed, bindVideoSessionMemoryInfoKHR.pNext );
1823 VULKAN_HPP_HASH_COMBINE( seed, bindVideoSessionMemoryInfoKHR.memoryBindIndex );
1824 VULKAN_HPP_HASH_COMBINE( seed, bindVideoSessionMemoryInfoKHR.memory );
1825 VULKAN_HPP_HASH_COMBINE( seed, bindVideoSessionMemoryInfoKHR.memoryOffset );
1826 VULKAN_HPP_HASH_COMBINE( seed, bindVideoSessionMemoryInfoKHR.memorySize );
1827 return seed;
1828 }
1829 };
1830
1831 template <>
1832 struct hash<VULKAN_HPP_NAMESPACE::BlitImageCubicWeightsInfoQCOM>
1833 {
1834 std::size_t operator()( VULKAN_HPP_NAMESPACE::BlitImageCubicWeightsInfoQCOM const & blitImageCubicWeightsInfoQCOM ) const VULKAN_HPP_NOEXCEPT
1835 {
1836 std::size_t seed = 0;
1837 VULKAN_HPP_HASH_COMBINE( seed, blitImageCubicWeightsInfoQCOM.sType );
1838 VULKAN_HPP_HASH_COMBINE( seed, blitImageCubicWeightsInfoQCOM.pNext );
1839 VULKAN_HPP_HASH_COMBINE( seed, blitImageCubicWeightsInfoQCOM.cubicWeights );
1840 return seed;
1841 }
1842 };
1843
1844 template <>
1845 struct hash<VULKAN_HPP_NAMESPACE::ImageSubresourceLayers>
1846 {
1847 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const & imageSubresourceLayers ) const VULKAN_HPP_NOEXCEPT
1848 {
1849 std::size_t seed = 0;
1850 VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceLayers.aspectMask );
1851 VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceLayers.mipLevel );
1852 VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceLayers.baseArrayLayer );
1853 VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceLayers.layerCount );
1854 return seed;
1855 }
1856 };
1857
1858 template <>
1859 struct hash<VULKAN_HPP_NAMESPACE::ImageBlit2>
1860 {
1861 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageBlit2 const & imageBlit2 ) const VULKAN_HPP_NOEXCEPT
1862 {
1863 std::size_t seed = 0;
1864 VULKAN_HPP_HASH_COMBINE( seed, imageBlit2.sType );
1865 VULKAN_HPP_HASH_COMBINE( seed, imageBlit2.pNext );
1866 VULKAN_HPP_HASH_COMBINE( seed, imageBlit2.srcSubresource );
1867 for ( size_t i = 0; i < 2; ++i )
1868 {
1869 VULKAN_HPP_HASH_COMBINE( seed, imageBlit2.srcOffsets[i] );
1870 }
1871 VULKAN_HPP_HASH_COMBINE( seed, imageBlit2.dstSubresource );
1872 for ( size_t i = 0; i < 2; ++i )
1873 {
1874 VULKAN_HPP_HASH_COMBINE( seed, imageBlit2.dstOffsets[i] );
1875 }
1876 return seed;
1877 }
1878 };
1879
1880 template <>
1881 struct hash<VULKAN_HPP_NAMESPACE::BlitImageInfo2>
1882 {
1883 std::size_t operator()( VULKAN_HPP_NAMESPACE::BlitImageInfo2 const & blitImageInfo2 ) const VULKAN_HPP_NOEXCEPT
1884 {
1885 std::size_t seed = 0;
1886 VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.sType );
1887 VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.pNext );
1888 VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.srcImage );
1889 VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.srcImageLayout );
1890 VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.dstImage );
1891 VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.dstImageLayout );
1892 VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.regionCount );
1893 VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.pRegions );
1894 VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.filter );
1895 return seed;
1896 }
1897 };
1898
1899 template <>
1900 struct hash<VULKAN_HPP_NAMESPACE::BufferCaptureDescriptorDataInfoEXT>
1901 {
1902 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCaptureDescriptorDataInfoEXT const & bufferCaptureDescriptorDataInfoEXT ) const VULKAN_HPP_NOEXCEPT
1903 {
1904 std::size_t seed = 0;
1905 VULKAN_HPP_HASH_COMBINE( seed, bufferCaptureDescriptorDataInfoEXT.sType );
1906 VULKAN_HPP_HASH_COMBINE( seed, bufferCaptureDescriptorDataInfoEXT.pNext );
1907 VULKAN_HPP_HASH_COMBINE( seed, bufferCaptureDescriptorDataInfoEXT.buffer );
1908 return seed;
1909 }
1910 };
1911
1912 # if defined( VK_USE_PLATFORM_FUCHSIA )
1913 template <>
1914 struct hash<VULKAN_HPP_NAMESPACE::BufferCollectionBufferCreateInfoFUCHSIA>
1915 {
1916 std::size_t
1917 operator()( VULKAN_HPP_NAMESPACE::BufferCollectionBufferCreateInfoFUCHSIA const & bufferCollectionBufferCreateInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT
1918 {
1919 std::size_t seed = 0;
1920 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionBufferCreateInfoFUCHSIA.sType );
1921 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionBufferCreateInfoFUCHSIA.pNext );
1922 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionBufferCreateInfoFUCHSIA.collection );
1923 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionBufferCreateInfoFUCHSIA.index );
1924 return seed;
1925 }
1926 };
1927 # endif /*VK_USE_PLATFORM_FUCHSIA*/
1928
1929 # if defined( VK_USE_PLATFORM_FUCHSIA )
1930 template <>
1931 struct hash<VULKAN_HPP_NAMESPACE::BufferCollectionConstraintsInfoFUCHSIA>
1932 {
1933 std::size_t
1934 operator()( VULKAN_HPP_NAMESPACE::BufferCollectionConstraintsInfoFUCHSIA const & bufferCollectionConstraintsInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT
1935 {
1936 std::size_t seed = 0;
1937 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionConstraintsInfoFUCHSIA.sType );
1938 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionConstraintsInfoFUCHSIA.pNext );
1939 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionConstraintsInfoFUCHSIA.minBufferCount );
1940 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionConstraintsInfoFUCHSIA.maxBufferCount );
1941 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionConstraintsInfoFUCHSIA.minBufferCountForCamping );
1942 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionConstraintsInfoFUCHSIA.minBufferCountForDedicatedSlack );
1943 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionConstraintsInfoFUCHSIA.minBufferCountForSharedSlack );
1944 return seed;
1945 }
1946 };
1947 # endif /*VK_USE_PLATFORM_FUCHSIA*/
1948
1949 # if defined( VK_USE_PLATFORM_FUCHSIA )
1950 template <>
1951 struct hash<VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA>
1952 {
1953 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA const & bufferCollectionCreateInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT
1954 {
1955 std::size_t seed = 0;
1956 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionCreateInfoFUCHSIA.sType );
1957 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionCreateInfoFUCHSIA.pNext );
1958 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionCreateInfoFUCHSIA.collectionToken );
1959 return seed;
1960 }
1961 };
1962 # endif /*VK_USE_PLATFORM_FUCHSIA*/
1963
1964 # if defined( VK_USE_PLATFORM_FUCHSIA )
1965 template <>
1966 struct hash<VULKAN_HPP_NAMESPACE::BufferCollectionImageCreateInfoFUCHSIA>
1967 {
1968 std::size_t
1969 operator()( VULKAN_HPP_NAMESPACE::BufferCollectionImageCreateInfoFUCHSIA const & bufferCollectionImageCreateInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT
1970 {
1971 std::size_t seed = 0;
1972 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionImageCreateInfoFUCHSIA.sType );
1973 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionImageCreateInfoFUCHSIA.pNext );
1974 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionImageCreateInfoFUCHSIA.collection );
1975 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionImageCreateInfoFUCHSIA.index );
1976 return seed;
1977 }
1978 };
1979 # endif /*VK_USE_PLATFORM_FUCHSIA*/
1980
1981 # if defined( VK_USE_PLATFORM_FUCHSIA )
1982 template <>
1983 struct hash<VULKAN_HPP_NAMESPACE::SysmemColorSpaceFUCHSIA>
1984 {
1985 std::size_t operator()( VULKAN_HPP_NAMESPACE::SysmemColorSpaceFUCHSIA const & sysmemColorSpaceFUCHSIA ) const VULKAN_HPP_NOEXCEPT
1986 {
1987 std::size_t seed = 0;
1988 VULKAN_HPP_HASH_COMBINE( seed, sysmemColorSpaceFUCHSIA.sType );
1989 VULKAN_HPP_HASH_COMBINE( seed, sysmemColorSpaceFUCHSIA.pNext );
1990 VULKAN_HPP_HASH_COMBINE( seed, sysmemColorSpaceFUCHSIA.colorSpace );
1991 return seed;
1992 }
1993 };
1994 # endif /*VK_USE_PLATFORM_FUCHSIA*/
1995
1996 # if defined( VK_USE_PLATFORM_FUCHSIA )
1997 template <>
1998 struct hash<VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA>
1999 {
2000 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA const & bufferCollectionPropertiesFUCHSIA ) const VULKAN_HPP_NOEXCEPT
2001 {
2002 std::size_t seed = 0;
2003 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.sType );
2004 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.pNext );
2005 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.memoryTypeBits );
2006 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.bufferCount );
2007 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.createInfoIndex );
2008 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.sysmemPixelFormat );
2009 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.formatFeatures );
2010 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.sysmemColorSpaceIndex );
2011 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.samplerYcbcrConversionComponents );
2012 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.suggestedYcbcrModel );
2013 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.suggestedYcbcrRange );
2014 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.suggestedXChromaOffset );
2015 VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.suggestedYChromaOffset );
2016 return seed;
2017 }
2018 };
2019 # endif /*VK_USE_PLATFORM_FUCHSIA*/
2020
2021 template <>
2022 struct hash<VULKAN_HPP_NAMESPACE::BufferCreateInfo>
2023 {
2024 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCreateInfo const & bufferCreateInfo ) const VULKAN_HPP_NOEXCEPT
2025 {
2026 std::size_t seed = 0;
2027 VULKAN_HPP_HASH_COMBINE( seed, bufferCreateInfo.sType );
2028 VULKAN_HPP_HASH_COMBINE( seed, bufferCreateInfo.pNext );
2029 VULKAN_HPP_HASH_COMBINE( seed, bufferCreateInfo.flags );
2030 VULKAN_HPP_HASH_COMBINE( seed, bufferCreateInfo.size );
2031 VULKAN_HPP_HASH_COMBINE( seed, bufferCreateInfo.usage );
2032 VULKAN_HPP_HASH_COMBINE( seed, bufferCreateInfo.sharingMode );
2033 VULKAN_HPP_HASH_COMBINE( seed, bufferCreateInfo.queueFamilyIndexCount );
2034 VULKAN_HPP_HASH_COMBINE( seed, bufferCreateInfo.pQueueFamilyIndices );
2035 return seed;
2036 }
2037 };
2038
2039 # if defined( VK_USE_PLATFORM_FUCHSIA )
2040 template <>
2041 struct hash<VULKAN_HPP_NAMESPACE::BufferConstraintsInfoFUCHSIA>
2042 {
2043 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferConstraintsInfoFUCHSIA const & bufferConstraintsInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT
2044 {
2045 std::size_t seed = 0;
2046 VULKAN_HPP_HASH_COMBINE( seed, bufferConstraintsInfoFUCHSIA.sType );
2047 VULKAN_HPP_HASH_COMBINE( seed, bufferConstraintsInfoFUCHSIA.pNext );
2048 VULKAN_HPP_HASH_COMBINE( seed, bufferConstraintsInfoFUCHSIA.createInfo );
2049 VULKAN_HPP_HASH_COMBINE( seed, bufferConstraintsInfoFUCHSIA.requiredFormatFeatures );
2050 VULKAN_HPP_HASH_COMBINE( seed, bufferConstraintsInfoFUCHSIA.bufferCollectionConstraints );
2051 return seed;
2052 }
2053 };
2054 # endif /*VK_USE_PLATFORM_FUCHSIA*/
2055
2056 template <>
2057 struct hash<VULKAN_HPP_NAMESPACE::BufferCopy>
2058 {
2059 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCopy const & bufferCopy ) const VULKAN_HPP_NOEXCEPT
2060 {
2061 std::size_t seed = 0;
2062 VULKAN_HPP_HASH_COMBINE( seed, bufferCopy.srcOffset );
2063 VULKAN_HPP_HASH_COMBINE( seed, bufferCopy.dstOffset );
2064 VULKAN_HPP_HASH_COMBINE( seed, bufferCopy.size );
2065 return seed;
2066 }
2067 };
2068
2069 template <>
2070 struct hash<VULKAN_HPP_NAMESPACE::BufferCopy2>
2071 {
2072 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCopy2 const & bufferCopy2 ) const VULKAN_HPP_NOEXCEPT
2073 {
2074 std::size_t seed = 0;
2075 VULKAN_HPP_HASH_COMBINE( seed, bufferCopy2.sType );
2076 VULKAN_HPP_HASH_COMBINE( seed, bufferCopy2.pNext );
2077 VULKAN_HPP_HASH_COMBINE( seed, bufferCopy2.srcOffset );
2078 VULKAN_HPP_HASH_COMBINE( seed, bufferCopy2.dstOffset );
2079 VULKAN_HPP_HASH_COMBINE( seed, bufferCopy2.size );
2080 return seed;
2081 }
2082 };
2083
2084 template <>
2085 struct hash<VULKAN_HPP_NAMESPACE::BufferDeviceAddressCreateInfoEXT>
2086 {
2087 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferDeviceAddressCreateInfoEXT const & bufferDeviceAddressCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
2088 {
2089 std::size_t seed = 0;
2090 VULKAN_HPP_HASH_COMBINE( seed, bufferDeviceAddressCreateInfoEXT.sType );
2091 VULKAN_HPP_HASH_COMBINE( seed, bufferDeviceAddressCreateInfoEXT.pNext );
2092 VULKAN_HPP_HASH_COMBINE( seed, bufferDeviceAddressCreateInfoEXT.deviceAddress );
2093 return seed;
2094 }
2095 };
2096
2097 template <>
2098 struct hash<VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo>
2099 {
2100 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo const & bufferDeviceAddressInfo ) const VULKAN_HPP_NOEXCEPT
2101 {
2102 std::size_t seed = 0;
2103 VULKAN_HPP_HASH_COMBINE( seed, bufferDeviceAddressInfo.sType );
2104 VULKAN_HPP_HASH_COMBINE( seed, bufferDeviceAddressInfo.pNext );
2105 VULKAN_HPP_HASH_COMBINE( seed, bufferDeviceAddressInfo.buffer );
2106 return seed;
2107 }
2108 };
2109
2110 template <>
2111 struct hash<VULKAN_HPP_NAMESPACE::BufferImageCopy>
2112 {
2113 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferImageCopy const & bufferImageCopy ) const VULKAN_HPP_NOEXCEPT
2114 {
2115 std::size_t seed = 0;
2116 VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy.bufferOffset );
2117 VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy.bufferRowLength );
2118 VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy.bufferImageHeight );
2119 VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy.imageSubresource );
2120 VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy.imageOffset );
2121 VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy.imageExtent );
2122 return seed;
2123 }
2124 };
2125
2126 template <>
2127 struct hash<VULKAN_HPP_NAMESPACE::BufferImageCopy2>
2128 {
2129 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferImageCopy2 const & bufferImageCopy2 ) const VULKAN_HPP_NOEXCEPT
2130 {
2131 std::size_t seed = 0;
2132 VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy2.sType );
2133 VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy2.pNext );
2134 VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy2.bufferOffset );
2135 VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy2.bufferRowLength );
2136 VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy2.bufferImageHeight );
2137 VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy2.imageSubresource );
2138 VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy2.imageOffset );
2139 VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy2.imageExtent );
2140 return seed;
2141 }
2142 };
2143
2144 template <>
2145 struct hash<VULKAN_HPP_NAMESPACE::BufferMemoryBarrier>
2146 {
2147 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferMemoryBarrier const & bufferMemoryBarrier ) const VULKAN_HPP_NOEXCEPT
2148 {
2149 std::size_t seed = 0;
2150 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.sType );
2151 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.pNext );
2152 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.srcAccessMask );
2153 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.dstAccessMask );
2154 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.srcQueueFamilyIndex );
2155 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.dstQueueFamilyIndex );
2156 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.buffer );
2157 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.offset );
2158 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.size );
2159 return seed;
2160 }
2161 };
2162
2163 template <>
2164 struct hash<VULKAN_HPP_NAMESPACE::BufferMemoryBarrier2>
2165 {
2166 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferMemoryBarrier2 const & bufferMemoryBarrier2 ) const VULKAN_HPP_NOEXCEPT
2167 {
2168 std::size_t seed = 0;
2169 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.sType );
2170 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.pNext );
2171 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.srcStageMask );
2172 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.srcAccessMask );
2173 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.dstStageMask );
2174 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.dstAccessMask );
2175 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.srcQueueFamilyIndex );
2176 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.dstQueueFamilyIndex );
2177 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.buffer );
2178 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.offset );
2179 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.size );
2180 return seed;
2181 }
2182 };
2183
2184 template <>
2185 struct hash<VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2>
2186 {
2187 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 const & bufferMemoryRequirementsInfo2 ) const VULKAN_HPP_NOEXCEPT
2188 {
2189 std::size_t seed = 0;
2190 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryRequirementsInfo2.sType );
2191 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryRequirementsInfo2.pNext );
2192 VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryRequirementsInfo2.buffer );
2193 return seed;
2194 }
2195 };
2196
2197 template <>
2198 struct hash<VULKAN_HPP_NAMESPACE::BufferOpaqueCaptureAddressCreateInfo>
2199 {
2200 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferOpaqueCaptureAddressCreateInfo const & bufferOpaqueCaptureAddressCreateInfo ) const VULKAN_HPP_NOEXCEPT
2201 {
2202 std::size_t seed = 0;
2203 VULKAN_HPP_HASH_COMBINE( seed, bufferOpaqueCaptureAddressCreateInfo.sType );
2204 VULKAN_HPP_HASH_COMBINE( seed, bufferOpaqueCaptureAddressCreateInfo.pNext );
2205 VULKAN_HPP_HASH_COMBINE( seed, bufferOpaqueCaptureAddressCreateInfo.opaqueCaptureAddress );
2206 return seed;
2207 }
2208 };
2209
2210 template <>
2211 struct hash<VULKAN_HPP_NAMESPACE::BufferUsageFlags2CreateInfo>
2212 {
2213 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferUsageFlags2CreateInfo const & bufferUsageFlags2CreateInfo ) const VULKAN_HPP_NOEXCEPT
2214 {
2215 std::size_t seed = 0;
2216 VULKAN_HPP_HASH_COMBINE( seed, bufferUsageFlags2CreateInfo.sType );
2217 VULKAN_HPP_HASH_COMBINE( seed, bufferUsageFlags2CreateInfo.pNext );
2218 VULKAN_HPP_HASH_COMBINE( seed, bufferUsageFlags2CreateInfo.usage );
2219 return seed;
2220 }
2221 };
2222
2223 template <>
2224 struct hash<VULKAN_HPP_NAMESPACE::BufferViewCreateInfo>
2225 {
2226 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferViewCreateInfo const & bufferViewCreateInfo ) const VULKAN_HPP_NOEXCEPT
2227 {
2228 std::size_t seed = 0;
2229 VULKAN_HPP_HASH_COMBINE( seed, bufferViewCreateInfo.sType );
2230 VULKAN_HPP_HASH_COMBINE( seed, bufferViewCreateInfo.pNext );
2231 VULKAN_HPP_HASH_COMBINE( seed, bufferViewCreateInfo.flags );
2232 VULKAN_HPP_HASH_COMBINE( seed, bufferViewCreateInfo.buffer );
2233 VULKAN_HPP_HASH_COMBINE( seed, bufferViewCreateInfo.format );
2234 VULKAN_HPP_HASH_COMBINE( seed, bufferViewCreateInfo.offset );
2235 VULKAN_HPP_HASH_COMBINE( seed, bufferViewCreateInfo.range );
2236 return seed;
2237 }
2238 };
2239
2240 template <>
2241 struct hash<VULKAN_HPP_NAMESPACE::StridedDeviceAddressNV>
2242 {
2243 std::size_t operator()( VULKAN_HPP_NAMESPACE::StridedDeviceAddressNV const & stridedDeviceAddressNV ) const VULKAN_HPP_NOEXCEPT
2244 {
2245 std::size_t seed = 0;
2246 VULKAN_HPP_HASH_COMBINE( seed, stridedDeviceAddressNV.startAddress );
2247 VULKAN_HPP_HASH_COMBINE( seed, stridedDeviceAddressNV.strideInBytes );
2248 return seed;
2249 }
2250 };
2251
2252 template <>
2253 struct hash<VULKAN_HPP_NAMESPACE::BuildPartitionedAccelerationStructureIndirectCommandNV>
2254 {
2255 std::size_t operator()( VULKAN_HPP_NAMESPACE::BuildPartitionedAccelerationStructureIndirectCommandNV const &
2256 buildPartitionedAccelerationStructureIndirectCommandNV ) const VULKAN_HPP_NOEXCEPT
2257 {
2258 std::size_t seed = 0;
2259 VULKAN_HPP_HASH_COMBINE( seed, buildPartitionedAccelerationStructureIndirectCommandNV.opType );
2260 VULKAN_HPP_HASH_COMBINE( seed, buildPartitionedAccelerationStructureIndirectCommandNV.argCount );
2261 VULKAN_HPP_HASH_COMBINE( seed, buildPartitionedAccelerationStructureIndirectCommandNV.argData );
2262 return seed;
2263 }
2264 };
2265
2266 template <>
2267 struct hash<VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureInstancesInputNV>
2268 {
2269 std::size_t operator()( VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureInstancesInputNV const & partitionedAccelerationStructureInstancesInputNV )
2270 const VULKAN_HPP_NOEXCEPT
2271 {
2272 std::size_t seed = 0;
2273 VULKAN_HPP_HASH_COMBINE( seed, partitionedAccelerationStructureInstancesInputNV.sType );
2274 VULKAN_HPP_HASH_COMBINE( seed, partitionedAccelerationStructureInstancesInputNV.pNext );
2275 VULKAN_HPP_HASH_COMBINE( seed, partitionedAccelerationStructureInstancesInputNV.flags );
2276 VULKAN_HPP_HASH_COMBINE( seed, partitionedAccelerationStructureInstancesInputNV.instanceCount );
2277 VULKAN_HPP_HASH_COMBINE( seed, partitionedAccelerationStructureInstancesInputNV.maxInstancePerPartitionCount );
2278 VULKAN_HPP_HASH_COMBINE( seed, partitionedAccelerationStructureInstancesInputNV.partitionCount );
2279 VULKAN_HPP_HASH_COMBINE( seed, partitionedAccelerationStructureInstancesInputNV.maxInstanceInGlobalPartitionCount );
2280 return seed;
2281 }
2282 };
2283
2284 template <>
2285 struct hash<VULKAN_HPP_NAMESPACE::BuildPartitionedAccelerationStructureInfoNV>
2286 {
2287 std::size_t operator()( VULKAN_HPP_NAMESPACE::BuildPartitionedAccelerationStructureInfoNV const & buildPartitionedAccelerationStructureInfoNV ) const
2288 VULKAN_HPP_NOEXCEPT
2289 {
2290 std::size_t seed = 0;
2291 VULKAN_HPP_HASH_COMBINE( seed, buildPartitionedAccelerationStructureInfoNV.sType );
2292 VULKAN_HPP_HASH_COMBINE( seed, buildPartitionedAccelerationStructureInfoNV.pNext );
2293 VULKAN_HPP_HASH_COMBINE( seed, buildPartitionedAccelerationStructureInfoNV.input );
2294 VULKAN_HPP_HASH_COMBINE( seed, buildPartitionedAccelerationStructureInfoNV.srcAccelerationStructureData );
2295 VULKAN_HPP_HASH_COMBINE( seed, buildPartitionedAccelerationStructureInfoNV.dstAccelerationStructureData );
2296 VULKAN_HPP_HASH_COMBINE( seed, buildPartitionedAccelerationStructureInfoNV.scratchData );
2297 VULKAN_HPP_HASH_COMBINE( seed, buildPartitionedAccelerationStructureInfoNV.srcInfos );
2298 VULKAN_HPP_HASH_COMBINE( seed, buildPartitionedAccelerationStructureInfoNV.srcInfosCount );
2299 return seed;
2300 }
2301 };
2302
2303 template <>
2304 struct hash<VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR>
2305 {
2306 std::size_t operator()( VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR const & calibratedTimestampInfoKHR ) const VULKAN_HPP_NOEXCEPT
2307 {
2308 std::size_t seed = 0;
2309 VULKAN_HPP_HASH_COMBINE( seed, calibratedTimestampInfoKHR.sType );
2310 VULKAN_HPP_HASH_COMBINE( seed, calibratedTimestampInfoKHR.pNext );
2311 VULKAN_HPP_HASH_COMBINE( seed, calibratedTimestampInfoKHR.timeDomain );
2312 return seed;
2313 }
2314 };
2315
2316 template <>
2317 struct hash<VULKAN_HPP_NAMESPACE::CheckpointData2NV>
2318 {
2319 std::size_t operator()( VULKAN_HPP_NAMESPACE::CheckpointData2NV const & checkpointData2NV ) const VULKAN_HPP_NOEXCEPT
2320 {
2321 std::size_t seed = 0;
2322 VULKAN_HPP_HASH_COMBINE( seed, checkpointData2NV.sType );
2323 VULKAN_HPP_HASH_COMBINE( seed, checkpointData2NV.pNext );
2324 VULKAN_HPP_HASH_COMBINE( seed, checkpointData2NV.stage );
2325 VULKAN_HPP_HASH_COMBINE( seed, checkpointData2NV.pCheckpointMarker );
2326 return seed;
2327 }
2328 };
2329
2330 template <>
2331 struct hash<VULKAN_HPP_NAMESPACE::CheckpointDataNV>
2332 {
2333 std::size_t operator()( VULKAN_HPP_NAMESPACE::CheckpointDataNV const & checkpointDataNV ) const VULKAN_HPP_NOEXCEPT
2334 {
2335 std::size_t seed = 0;
2336 VULKAN_HPP_HASH_COMBINE( seed, checkpointDataNV.sType );
2337 VULKAN_HPP_HASH_COMBINE( seed, checkpointDataNV.pNext );
2338 VULKAN_HPP_HASH_COMBINE( seed, checkpointDataNV.stage );
2339 VULKAN_HPP_HASH_COMBINE( seed, checkpointDataNV.pCheckpointMarker );
2340 return seed;
2341 }
2342 };
2343
2344 template <>
2345 struct hash<VULKAN_HPP_NAMESPACE::ClearDepthStencilValue>
2346 {
2347 std::size_t operator()( VULKAN_HPP_NAMESPACE::ClearDepthStencilValue const & clearDepthStencilValue ) const VULKAN_HPP_NOEXCEPT
2348 {
2349 std::size_t seed = 0;
2350 VULKAN_HPP_HASH_COMBINE( seed, clearDepthStencilValue.depth );
2351 VULKAN_HPP_HASH_COMBINE( seed, clearDepthStencilValue.stencil );
2352 return seed;
2353 }
2354 };
2355
2356 template <>
2357 struct hash<VULKAN_HPP_NAMESPACE::ClearRect>
2358 {
2359 std::size_t operator()( VULKAN_HPP_NAMESPACE::ClearRect const & clearRect ) const VULKAN_HPP_NOEXCEPT
2360 {
2361 std::size_t seed = 0;
2362 VULKAN_HPP_HASH_COMBINE( seed, clearRect.rect );
2363 VULKAN_HPP_HASH_COMBINE( seed, clearRect.baseArrayLayer );
2364 VULKAN_HPP_HASH_COMBINE( seed, clearRect.layerCount );
2365 return seed;
2366 }
2367 };
2368
2369 template <>
2370 struct hash<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureBuildClustersBottomLevelInfoNV>
2371 {
2372 std::size_t operator()( VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureBuildClustersBottomLevelInfoNV const &
2373 clusterAccelerationStructureBuildClustersBottomLevelInfoNV ) const VULKAN_HPP_NOEXCEPT
2374 {
2375 std::size_t seed = 0;
2376 VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildClustersBottomLevelInfoNV.clusterReferencesCount );
2377 VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildClustersBottomLevelInfoNV.clusterReferencesStride );
2378 VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildClustersBottomLevelInfoNV.clusterReferences );
2379 return seed;
2380 }
2381 };
2382
2383 template <>
2384 struct hash<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV>
2385 {
2386 std::size_t operator()( VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV const &
2387 clusterAccelerationStructureGeometryIndexAndGeometryFlagsNV ) const VULKAN_HPP_NOEXCEPT
2388 {
2389 std::size_t seed = 0;
2390 VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureGeometryIndexAndGeometryFlagsNV.geometryIndex );
2391 VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureGeometryIndexAndGeometryFlagsNV.reserved );
2392 VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureGeometryIndexAndGeometryFlagsNV.geometryFlags );
2393 return seed;
2394 }
2395 };
2396
2397 template <>
2398 struct hash<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureBuildTriangleClusterInfoNV>
2399 {
2400 std::size_t operator()( VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureBuildTriangleClusterInfoNV const &
2401 clusterAccelerationStructureBuildTriangleClusterInfoNV ) const VULKAN_HPP_NOEXCEPT
2402 {
2403 std::size_t seed = 0;
2404 VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterInfoNV.clusterID );
2405 VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterInfoNV.clusterFlags );
2406 VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterInfoNV.triangleCount );
2407 VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterInfoNV.vertexCount );
2408 VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterInfoNV.positionTruncateBitCount );
2409 VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterInfoNV.indexType );
2410 VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterInfoNV.opacityMicromapIndexType );
2411 VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterInfoNV.baseGeometryIndexAndGeometryFlags );
2412 VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterInfoNV.indexBufferStride );
2413 VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterInfoNV.vertexBufferStride );
2414 VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterInfoNV.geometryIndexAndFlagsBufferStride );
2415 VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterInfoNV.opacityMicromapIndexBufferStride );
2416 VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterInfoNV.indexBuffer );
2417 VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterInfoNV.vertexBuffer );
2418 VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterInfoNV.geometryIndexAndFlagsBuffer );
2419 VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterInfoNV.opacityMicromapArray );
2420 VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterInfoNV.opacityMicromapIndexBuffer );
2421 return seed;
2422 }
2423 };
2424
2425 template <>
2426 struct hash<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV>
2427 {
2428 std::size_t operator()( VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV const &
2429 clusterAccelerationStructureBuildTriangleClusterTemplateInfoNV ) const VULKAN_HPP_NOEXCEPT
2430 {
2431 std::size_t seed = 0;
2432 VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterTemplateInfoNV.clusterID );
2433 VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterTemplateInfoNV.clusterFlags );
2434 VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterTemplateInfoNV.triangleCount );
2435 VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterTemplateInfoNV.vertexCount );
2436 VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterTemplateInfoNV.positionTruncateBitCount );
2437 VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterTemplateInfoNV.indexType );
2438 VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterTemplateInfoNV.opacityMicromapIndexType );
2439 VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterTemplateInfoNV.baseGeometryIndexAndGeometryFlags );
2440 VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterTemplateInfoNV.indexBufferStride );
2441 VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterTemplateInfoNV.vertexBufferStride );
2442 VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterTemplateInfoNV.geometryIndexAndFlagsBufferStride );
2443 VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterTemplateInfoNV.opacityMicromapIndexBufferStride );
2444 VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterTemplateInfoNV.indexBuffer );
2445 VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterTemplateInfoNV.vertexBuffer );
2446 VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterTemplateInfoNV.geometryIndexAndFlagsBuffer );
2447 VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterTemplateInfoNV.opacityMicromapArray );
2448 VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterTemplateInfoNV.opacityMicromapIndexBuffer );
2449 VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterTemplateInfoNV.instantiationBoundingBoxLimit );
2450 return seed;
2451 }
2452 };
2453
2454 template <>
2455 struct hash<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureClustersBottomLevelInputNV>
2456 {
2457 std::size_t operator()( VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureClustersBottomLevelInputNV const &
2458 clusterAccelerationStructureClustersBottomLevelInputNV ) const VULKAN_HPP_NOEXCEPT
2459 {
2460 std::size_t seed = 0;
2461 VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureClustersBottomLevelInputNV.sType );
2462 VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureClustersBottomLevelInputNV.pNext );
2463 VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureClustersBottomLevelInputNV.maxTotalClusterCount );
2464 VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureClustersBottomLevelInputNV.maxClusterCountPerAccelerationStructure );
2465 return seed;
2466 }
2467 };
2468
2469 template <>
2470 struct hash<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureTriangleClusterInputNV>
2471 {
2472 std::size_t
2473 operator()( VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureTriangleClusterInputNV const & clusterAccelerationStructureTriangleClusterInputNV ) const
2474 VULKAN_HPP_NOEXCEPT
2475 {
2476 std::size_t seed = 0;
2477 VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureTriangleClusterInputNV.sType );
2478 VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureTriangleClusterInputNV.pNext );
2479 VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureTriangleClusterInputNV.vertexFormat );
2480 VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureTriangleClusterInputNV.maxGeometryIndexValue );
2481 VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureTriangleClusterInputNV.maxClusterUniqueGeometryCount );
2482 VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureTriangleClusterInputNV.maxClusterTriangleCount );
2483 VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureTriangleClusterInputNV.maxClusterVertexCount );
2484 VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureTriangleClusterInputNV.maxTotalTriangleCount );
2485 VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureTriangleClusterInputNV.maxTotalVertexCount );
2486 VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureTriangleClusterInputNV.minPositionTruncateBitCount );
2487 return seed;
2488 }
2489 };
2490
2491 template <>
2492 struct hash<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureMoveObjectsInputNV>
2493 {
2494 std::size_t operator()( VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureMoveObjectsInputNV const & clusterAccelerationStructureMoveObjectsInputNV ) const
2495 VULKAN_HPP_NOEXCEPT
2496 {
2497 std::size_t seed = 0;
2498 VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureMoveObjectsInputNV.sType );
2499 VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureMoveObjectsInputNV.pNext );
2500 VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureMoveObjectsInputNV.type );
2501 VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureMoveObjectsInputNV.noMoveOverlap );
2502 VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureMoveObjectsInputNV.maxMovedBytes );
2503 return seed;
2504 }
2505 };
2506
2507 template <>
2508 struct hash<VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR>
2509 {
2510 std::size_t operator()( VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR const & stridedDeviceAddressRegionKHR ) const VULKAN_HPP_NOEXCEPT
2511 {
2512 std::size_t seed = 0;
2513 VULKAN_HPP_HASH_COMBINE( seed, stridedDeviceAddressRegionKHR.deviceAddress );
2514 VULKAN_HPP_HASH_COMBINE( seed, stridedDeviceAddressRegionKHR.stride );
2515 VULKAN_HPP_HASH_COMBINE( seed, stridedDeviceAddressRegionKHR.size );
2516 return seed;
2517 }
2518 };
2519
2520 template <>
2521 struct hash<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureGetTemplateIndicesInfoNV>
2522 {
2523 std::size_t operator()( VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureGetTemplateIndicesInfoNV const &
2524 clusterAccelerationStructureGetTemplateIndicesInfoNV ) const VULKAN_HPP_NOEXCEPT
2525 {
2526 std::size_t seed = 0;
2527 VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureGetTemplateIndicesInfoNV.clusterTemplateAddress );
2528 return seed;
2529 }
2530 };
2531
2532 template <>
2533 struct hash<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureInstantiateClusterInfoNV>
2534 {
2535 std::size_t operator()( VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureInstantiateClusterInfoNV const &
2536 clusterAccelerationStructureInstantiateClusterInfoNV ) const VULKAN_HPP_NOEXCEPT
2537 {
2538 std::size_t seed = 0;
2539 VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureInstantiateClusterInfoNV.clusterIdOffset );
2540 VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureInstantiateClusterInfoNV.geometryIndexOffset );
2541 VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureInstantiateClusterInfoNV.reserved );
2542 VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureInstantiateClusterInfoNV.clusterTemplateAddress );
2543 VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureInstantiateClusterInfoNV.vertexBuffer );
2544 return seed;
2545 }
2546 };
2547
2548 template <>
2549 struct hash<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureMoveObjectsInfoNV>
2550 {
2551 std::size_t operator()( VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureMoveObjectsInfoNV const & clusterAccelerationStructureMoveObjectsInfoNV ) const
2552 VULKAN_HPP_NOEXCEPT
2553 {
2554 std::size_t seed = 0;
2555 VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureMoveObjectsInfoNV.srcAccelerationStructure );
2556 return seed;
2557 }
2558 };
2559
2560 template <>
2561 struct hash<VULKAN_HPP_NAMESPACE::CoarseSampleLocationNV>
2562 {
2563 std::size_t operator()( VULKAN_HPP_NAMESPACE::CoarseSampleLocationNV const & coarseSampleLocationNV ) const VULKAN_HPP_NOEXCEPT
2564 {
2565 std::size_t seed = 0;
2566 VULKAN_HPP_HASH_COMBINE( seed, coarseSampleLocationNV.pixelX );
2567 VULKAN_HPP_HASH_COMBINE( seed, coarseSampleLocationNV.pixelY );
2568 VULKAN_HPP_HASH_COMBINE( seed, coarseSampleLocationNV.sample );
2569 return seed;
2570 }
2571 };
2572
2573 template <>
2574 struct hash<VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV>
2575 {
2576 std::size_t operator()( VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV const & coarseSampleOrderCustomNV ) const VULKAN_HPP_NOEXCEPT
2577 {
2578 std::size_t seed = 0;
2579 VULKAN_HPP_HASH_COMBINE( seed, coarseSampleOrderCustomNV.shadingRate );
2580 VULKAN_HPP_HASH_COMBINE( seed, coarseSampleOrderCustomNV.sampleCount );
2581 VULKAN_HPP_HASH_COMBINE( seed, coarseSampleOrderCustomNV.sampleLocationCount );
2582 VULKAN_HPP_HASH_COMBINE( seed, coarseSampleOrderCustomNV.pSampleLocations );
2583 return seed;
2584 }
2585 };
2586
2587 template <>
2588 struct hash<VULKAN_HPP_NAMESPACE::ColorBlendAdvancedEXT>
2589 {
2590 std::size_t operator()( VULKAN_HPP_NAMESPACE::ColorBlendAdvancedEXT const & colorBlendAdvancedEXT ) const VULKAN_HPP_NOEXCEPT
2591 {
2592 std::size_t seed = 0;
2593 VULKAN_HPP_HASH_COMBINE( seed, colorBlendAdvancedEXT.advancedBlendOp );
2594 VULKAN_HPP_HASH_COMBINE( seed, colorBlendAdvancedEXT.srcPremultiplied );
2595 VULKAN_HPP_HASH_COMBINE( seed, colorBlendAdvancedEXT.dstPremultiplied );
2596 VULKAN_HPP_HASH_COMBINE( seed, colorBlendAdvancedEXT.blendOverlap );
2597 VULKAN_HPP_HASH_COMBINE( seed, colorBlendAdvancedEXT.clampResults );
2598 return seed;
2599 }
2600 };
2601
2602 template <>
2603 struct hash<VULKAN_HPP_NAMESPACE::ColorBlendEquationEXT>
2604 {
2605 std::size_t operator()( VULKAN_HPP_NAMESPACE::ColorBlendEquationEXT const & colorBlendEquationEXT ) const VULKAN_HPP_NOEXCEPT
2606 {
2607 std::size_t seed = 0;
2608 VULKAN_HPP_HASH_COMBINE( seed, colorBlendEquationEXT.srcColorBlendFactor );
2609 VULKAN_HPP_HASH_COMBINE( seed, colorBlendEquationEXT.dstColorBlendFactor );
2610 VULKAN_HPP_HASH_COMBINE( seed, colorBlendEquationEXT.colorBlendOp );
2611 VULKAN_HPP_HASH_COMBINE( seed, colorBlendEquationEXT.srcAlphaBlendFactor );
2612 VULKAN_HPP_HASH_COMBINE( seed, colorBlendEquationEXT.dstAlphaBlendFactor );
2613 VULKAN_HPP_HASH_COMBINE( seed, colorBlendEquationEXT.alphaBlendOp );
2614 return seed;
2615 }
2616 };
2617
2618 template <>
2619 struct hash<VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo>
2620 {
2621 std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo const & commandBufferAllocateInfo ) const VULKAN_HPP_NOEXCEPT
2622 {
2623 std::size_t seed = 0;
2624 VULKAN_HPP_HASH_COMBINE( seed, commandBufferAllocateInfo.sType );
2625 VULKAN_HPP_HASH_COMBINE( seed, commandBufferAllocateInfo.pNext );
2626 VULKAN_HPP_HASH_COMBINE( seed, commandBufferAllocateInfo.commandPool );
2627 VULKAN_HPP_HASH_COMBINE( seed, commandBufferAllocateInfo.level );
2628 VULKAN_HPP_HASH_COMBINE( seed, commandBufferAllocateInfo.commandBufferCount );
2629 return seed;
2630 }
2631 };
2632
2633 template <>
2634 struct hash<VULKAN_HPP_NAMESPACE::CommandBufferInheritanceInfo>
2635 {
2636 std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceInfo const & commandBufferInheritanceInfo ) const VULKAN_HPP_NOEXCEPT
2637 {
2638 std::size_t seed = 0;
2639 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceInfo.sType );
2640 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceInfo.pNext );
2641 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceInfo.renderPass );
2642 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceInfo.subpass );
2643 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceInfo.framebuffer );
2644 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceInfo.occlusionQueryEnable );
2645 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceInfo.queryFlags );
2646 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceInfo.pipelineStatistics );
2647 return seed;
2648 }
2649 };
2650
2651 template <>
2652 struct hash<VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo>
2653 {
2654 std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo const & commandBufferBeginInfo ) const VULKAN_HPP_NOEXCEPT
2655 {
2656 std::size_t seed = 0;
2657 VULKAN_HPP_HASH_COMBINE( seed, commandBufferBeginInfo.sType );
2658 VULKAN_HPP_HASH_COMBINE( seed, commandBufferBeginInfo.pNext );
2659 VULKAN_HPP_HASH_COMBINE( seed, commandBufferBeginInfo.flags );
2660 VULKAN_HPP_HASH_COMBINE( seed, commandBufferBeginInfo.pInheritanceInfo );
2661 return seed;
2662 }
2663 };
2664
2665 template <>
2666 struct hash<VULKAN_HPP_NAMESPACE::CommandBufferInheritanceConditionalRenderingInfoEXT>
2667 {
2668 std::size_t
2669 operator()( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceConditionalRenderingInfoEXT const & commandBufferInheritanceConditionalRenderingInfoEXT ) const
2670 VULKAN_HPP_NOEXCEPT
2671 {
2672 std::size_t seed = 0;
2673 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceConditionalRenderingInfoEXT.sType );
2674 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceConditionalRenderingInfoEXT.pNext );
2675 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceConditionalRenderingInfoEXT.conditionalRenderingEnable );
2676 return seed;
2677 }
2678 };
2679
2680 template <>
2681 struct hash<VULKAN_HPP_NAMESPACE::CommandBufferInheritanceRenderPassTransformInfoQCOM>
2682 {
2683 std::size_t
2684 operator()( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceRenderPassTransformInfoQCOM const & commandBufferInheritanceRenderPassTransformInfoQCOM ) const
2685 VULKAN_HPP_NOEXCEPT
2686 {
2687 std::size_t seed = 0;
2688 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderPassTransformInfoQCOM.sType );
2689 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderPassTransformInfoQCOM.pNext );
2690 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderPassTransformInfoQCOM.transform );
2691 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderPassTransformInfoQCOM.renderArea );
2692 return seed;
2693 }
2694 };
2695
2696 template <>
2697 struct hash<VULKAN_HPP_NAMESPACE::CommandBufferInheritanceRenderingInfo>
2698 {
2699 std::size_t
2700 operator()( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceRenderingInfo const & commandBufferInheritanceRenderingInfo ) const VULKAN_HPP_NOEXCEPT
2701 {
2702 std::size_t seed = 0;
2703 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.sType );
2704 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.pNext );
2705 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.flags );
2706 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.viewMask );
2707 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.colorAttachmentCount );
2708 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.pColorAttachmentFormats );
2709 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.depthAttachmentFormat );
2710 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.stencilAttachmentFormat );
2711 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.rasterizationSamples );
2712 return seed;
2713 }
2714 };
2715
2716 template <>
2717 struct hash<VULKAN_HPP_NAMESPACE::Viewport>
2718 {
2719 std::size_t operator()( VULKAN_HPP_NAMESPACE::Viewport const & viewport ) const VULKAN_HPP_NOEXCEPT
2720 {
2721 std::size_t seed = 0;
2722 VULKAN_HPP_HASH_COMBINE( seed, viewport.x );
2723 VULKAN_HPP_HASH_COMBINE( seed, viewport.y );
2724 VULKAN_HPP_HASH_COMBINE( seed, viewport.width );
2725 VULKAN_HPP_HASH_COMBINE( seed, viewport.height );
2726 VULKAN_HPP_HASH_COMBINE( seed, viewport.minDepth );
2727 VULKAN_HPP_HASH_COMBINE( seed, viewport.maxDepth );
2728 return seed;
2729 }
2730 };
2731
2732 template <>
2733 struct hash<VULKAN_HPP_NAMESPACE::CommandBufferInheritanceViewportScissorInfoNV>
2734 {
2735 std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceViewportScissorInfoNV const & commandBufferInheritanceViewportScissorInfoNV ) const
2736 VULKAN_HPP_NOEXCEPT
2737 {
2738 std::size_t seed = 0;
2739 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceViewportScissorInfoNV.sType );
2740 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceViewportScissorInfoNV.pNext );
2741 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceViewportScissorInfoNV.viewportScissor2D );
2742 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceViewportScissorInfoNV.viewportDepthCount );
2743 VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceViewportScissorInfoNV.pViewportDepths );
2744 return seed;
2745 }
2746 };
2747
2748 template <>
2749 struct hash<VULKAN_HPP_NAMESPACE::CommandBufferSubmitInfo>
2750 {
2751 std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBufferSubmitInfo const & commandBufferSubmitInfo ) const VULKAN_HPP_NOEXCEPT
2752 {
2753 std::size_t seed = 0;
2754 VULKAN_HPP_HASH_COMBINE( seed, commandBufferSubmitInfo.sType );
2755 VULKAN_HPP_HASH_COMBINE( seed, commandBufferSubmitInfo.pNext );
2756 VULKAN_HPP_HASH_COMBINE( seed, commandBufferSubmitInfo.commandBuffer );
2757 VULKAN_HPP_HASH_COMBINE( seed, commandBufferSubmitInfo.deviceMask );
2758 return seed;
2759 }
2760 };
2761
2762 template <>
2763 struct hash<VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo>
2764 {
2765 std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo const & commandPoolCreateInfo ) const VULKAN_HPP_NOEXCEPT
2766 {
2767 std::size_t seed = 0;
2768 VULKAN_HPP_HASH_COMBINE( seed, commandPoolCreateInfo.sType );
2769 VULKAN_HPP_HASH_COMBINE( seed, commandPoolCreateInfo.pNext );
2770 VULKAN_HPP_HASH_COMBINE( seed, commandPoolCreateInfo.flags );
2771 VULKAN_HPP_HASH_COMBINE( seed, commandPoolCreateInfo.queueFamilyIndex );
2772 return seed;
2773 }
2774 };
2775
2776 template <>
2777 struct hash<VULKAN_HPP_NAMESPACE::SpecializationMapEntry>
2778 {
2779 std::size_t operator()( VULKAN_HPP_NAMESPACE::SpecializationMapEntry const & specializationMapEntry ) const VULKAN_HPP_NOEXCEPT
2780 {
2781 std::size_t seed = 0;
2782 VULKAN_HPP_HASH_COMBINE( seed, specializationMapEntry.constantID );
2783 VULKAN_HPP_HASH_COMBINE( seed, specializationMapEntry.offset );
2784 VULKAN_HPP_HASH_COMBINE( seed, specializationMapEntry.size );
2785 return seed;
2786 }
2787 };
2788
2789 template <>
2790 struct hash<VULKAN_HPP_NAMESPACE::SpecializationInfo>
2791 {
2792 std::size_t operator()( VULKAN_HPP_NAMESPACE::SpecializationInfo const & specializationInfo ) const VULKAN_HPP_NOEXCEPT
2793 {
2794 std::size_t seed = 0;
2795 VULKAN_HPP_HASH_COMBINE( seed, specializationInfo.mapEntryCount );
2796 VULKAN_HPP_HASH_COMBINE( seed, specializationInfo.pMapEntries );
2797 VULKAN_HPP_HASH_COMBINE( seed, specializationInfo.dataSize );
2798 VULKAN_HPP_HASH_COMBINE( seed, specializationInfo.pData );
2799 return seed;
2800 }
2801 };
2802
2803 template <>
2804 struct hash<VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo>
2805 {
2806 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo const & pipelineShaderStageCreateInfo ) const VULKAN_HPP_NOEXCEPT
2807 {
2808 std::size_t seed = 0;
2809 VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageCreateInfo.sType );
2810 VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageCreateInfo.pNext );
2811 VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageCreateInfo.flags );
2812 VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageCreateInfo.stage );
2813 VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageCreateInfo.module );
2814 for ( const char * p = pipelineShaderStageCreateInfo.pName; *p != '\0'; ++p )
2815 {
2816 VULKAN_HPP_HASH_COMBINE( seed, *p );
2817 }
2818 VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageCreateInfo.pSpecializationInfo );
2819 return seed;
2820 }
2821 };
2822
2823 template <>
2824 struct hash<VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo>
2825 {
2826 std::size_t operator()( VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo const & computePipelineCreateInfo ) const VULKAN_HPP_NOEXCEPT
2827 {
2828 std::size_t seed = 0;
2829 VULKAN_HPP_HASH_COMBINE( seed, computePipelineCreateInfo.sType );
2830 VULKAN_HPP_HASH_COMBINE( seed, computePipelineCreateInfo.pNext );
2831 VULKAN_HPP_HASH_COMBINE( seed, computePipelineCreateInfo.flags );
2832 VULKAN_HPP_HASH_COMBINE( seed, computePipelineCreateInfo.stage );
2833 VULKAN_HPP_HASH_COMBINE( seed, computePipelineCreateInfo.layout );
2834 VULKAN_HPP_HASH_COMBINE( seed, computePipelineCreateInfo.basePipelineHandle );
2835 VULKAN_HPP_HASH_COMBINE( seed, computePipelineCreateInfo.basePipelineIndex );
2836 return seed;
2837 }
2838 };
2839
2840 template <>
2841 struct hash<VULKAN_HPP_NAMESPACE::ComputePipelineIndirectBufferInfoNV>
2842 {
2843 std::size_t operator()( VULKAN_HPP_NAMESPACE::ComputePipelineIndirectBufferInfoNV const & computePipelineIndirectBufferInfoNV ) const VULKAN_HPP_NOEXCEPT
2844 {
2845 std::size_t seed = 0;
2846 VULKAN_HPP_HASH_COMBINE( seed, computePipelineIndirectBufferInfoNV.sType );
2847 VULKAN_HPP_HASH_COMBINE( seed, computePipelineIndirectBufferInfoNV.pNext );
2848 VULKAN_HPP_HASH_COMBINE( seed, computePipelineIndirectBufferInfoNV.deviceAddress );
2849 VULKAN_HPP_HASH_COMBINE( seed, computePipelineIndirectBufferInfoNV.size );
2850 VULKAN_HPP_HASH_COMBINE( seed, computePipelineIndirectBufferInfoNV.pipelineDeviceAddressCaptureReplay );
2851 return seed;
2852 }
2853 };
2854
2855 template <>
2856 struct hash<VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfoEXT>
2857 {
2858 std::size_t operator()( VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfoEXT const & conditionalRenderingBeginInfoEXT ) const VULKAN_HPP_NOEXCEPT
2859 {
2860 std::size_t seed = 0;
2861 VULKAN_HPP_HASH_COMBINE( seed, conditionalRenderingBeginInfoEXT.sType );
2862 VULKAN_HPP_HASH_COMBINE( seed, conditionalRenderingBeginInfoEXT.pNext );
2863 VULKAN_HPP_HASH_COMBINE( seed, conditionalRenderingBeginInfoEXT.buffer );
2864 VULKAN_HPP_HASH_COMBINE( seed, conditionalRenderingBeginInfoEXT.offset );
2865 VULKAN_HPP_HASH_COMBINE( seed, conditionalRenderingBeginInfoEXT.flags );
2866 return seed;
2867 }
2868 };
2869
2870 template <>
2871 struct hash<VULKAN_HPP_NAMESPACE::ConformanceVersion>
2872 {
2873 std::size_t operator()( VULKAN_HPP_NAMESPACE::ConformanceVersion const & conformanceVersion ) const VULKAN_HPP_NOEXCEPT
2874 {
2875 std::size_t seed = 0;
2876 VULKAN_HPP_HASH_COMBINE( seed, conformanceVersion.major );
2877 VULKAN_HPP_HASH_COMBINE( seed, conformanceVersion.minor );
2878 VULKAN_HPP_HASH_COMBINE( seed, conformanceVersion.subminor );
2879 VULKAN_HPP_HASH_COMBINE( seed, conformanceVersion.patch );
2880 return seed;
2881 }
2882 };
2883
2884 template <>
2885 struct hash<VULKAN_HPP_NAMESPACE::CooperativeMatrixFlexibleDimensionsPropertiesNV>
2886 {
2887 std::size_t operator()(
2888 VULKAN_HPP_NAMESPACE::CooperativeMatrixFlexibleDimensionsPropertiesNV const & cooperativeMatrixFlexibleDimensionsPropertiesNV ) const VULKAN_HPP_NOEXCEPT
2889 {
2890 std::size_t seed = 0;
2891 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixFlexibleDimensionsPropertiesNV.sType );
2892 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixFlexibleDimensionsPropertiesNV.pNext );
2893 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixFlexibleDimensionsPropertiesNV.MGranularity );
2894 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixFlexibleDimensionsPropertiesNV.NGranularity );
2895 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixFlexibleDimensionsPropertiesNV.KGranularity );
2896 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixFlexibleDimensionsPropertiesNV.AType );
2897 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixFlexibleDimensionsPropertiesNV.BType );
2898 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixFlexibleDimensionsPropertiesNV.CType );
2899 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixFlexibleDimensionsPropertiesNV.ResultType );
2900 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixFlexibleDimensionsPropertiesNV.saturatingAccumulation );
2901 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixFlexibleDimensionsPropertiesNV.scope );
2902 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixFlexibleDimensionsPropertiesNV.workgroupInvocations );
2903 return seed;
2904 }
2905 };
2906
2907 template <>
2908 struct hash<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR>
2909 {
2910 std::size_t operator()( VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR const & cooperativeMatrixPropertiesKHR ) const VULKAN_HPP_NOEXCEPT
2911 {
2912 std::size_t seed = 0;
2913 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.sType );
2914 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.pNext );
2915 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.MSize );
2916 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.NSize );
2917 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.KSize );
2918 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.AType );
2919 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.BType );
2920 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.CType );
2921 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.ResultType );
2922 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.saturatingAccumulation );
2923 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.scope );
2924 return seed;
2925 }
2926 };
2927
2928 template <>
2929 struct hash<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV>
2930 {
2931 std::size_t operator()( VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV const & cooperativeMatrixPropertiesNV ) const VULKAN_HPP_NOEXCEPT
2932 {
2933 std::size_t seed = 0;
2934 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.sType );
2935 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.pNext );
2936 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.MSize );
2937 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.NSize );
2938 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.KSize );
2939 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.AType );
2940 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.BType );
2941 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.CType );
2942 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.DType );
2943 VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.scope );
2944 return seed;
2945 }
2946 };
2947
2948 template <>
2949 struct hash<VULKAN_HPP_NAMESPACE::CooperativeVectorPropertiesNV>
2950 {
2951 std::size_t operator()( VULKAN_HPP_NAMESPACE::CooperativeVectorPropertiesNV const & cooperativeVectorPropertiesNV ) const VULKAN_HPP_NOEXCEPT
2952 {
2953 std::size_t seed = 0;
2954 VULKAN_HPP_HASH_COMBINE( seed, cooperativeVectorPropertiesNV.sType );
2955 VULKAN_HPP_HASH_COMBINE( seed, cooperativeVectorPropertiesNV.pNext );
2956 VULKAN_HPP_HASH_COMBINE( seed, cooperativeVectorPropertiesNV.inputType );
2957 VULKAN_HPP_HASH_COMBINE( seed, cooperativeVectorPropertiesNV.inputInterpretation );
2958 VULKAN_HPP_HASH_COMBINE( seed, cooperativeVectorPropertiesNV.matrixInterpretation );
2959 VULKAN_HPP_HASH_COMBINE( seed, cooperativeVectorPropertiesNV.biasInterpretation );
2960 VULKAN_HPP_HASH_COMBINE( seed, cooperativeVectorPropertiesNV.resultType );
2961 VULKAN_HPP_HASH_COMBINE( seed, cooperativeVectorPropertiesNV.transpose );
2962 return seed;
2963 }
2964 };
2965
2966 template <>
2967 struct hash<VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR>
2968 {
2969 std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR const & copyAccelerationStructureInfoKHR ) const VULKAN_HPP_NOEXCEPT
2970 {
2971 std::size_t seed = 0;
2972 VULKAN_HPP_HASH_COMBINE( seed, copyAccelerationStructureInfoKHR.sType );
2973 VULKAN_HPP_HASH_COMBINE( seed, copyAccelerationStructureInfoKHR.pNext );
2974 VULKAN_HPP_HASH_COMBINE( seed, copyAccelerationStructureInfoKHR.src );
2975 VULKAN_HPP_HASH_COMBINE( seed, copyAccelerationStructureInfoKHR.dst );
2976 VULKAN_HPP_HASH_COMBINE( seed, copyAccelerationStructureInfoKHR.mode );
2977 return seed;
2978 }
2979 };
2980
2981 template <>
2982 struct hash<VULKAN_HPP_NAMESPACE::CopyBufferInfo2>
2983 {
2984 std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyBufferInfo2 const & copyBufferInfo2 ) const VULKAN_HPP_NOEXCEPT
2985 {
2986 std::size_t seed = 0;
2987 VULKAN_HPP_HASH_COMBINE( seed, copyBufferInfo2.sType );
2988 VULKAN_HPP_HASH_COMBINE( seed, copyBufferInfo2.pNext );
2989 VULKAN_HPP_HASH_COMBINE( seed, copyBufferInfo2.srcBuffer );
2990 VULKAN_HPP_HASH_COMBINE( seed, copyBufferInfo2.dstBuffer );
2991 VULKAN_HPP_HASH_COMBINE( seed, copyBufferInfo2.regionCount );
2992 VULKAN_HPP_HASH_COMBINE( seed, copyBufferInfo2.pRegions );
2993 return seed;
2994 }
2995 };
2996
2997 template <>
2998 struct hash<VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2>
2999 {
3000 std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 const & copyBufferToImageInfo2 ) const VULKAN_HPP_NOEXCEPT
3001 {
3002 std::size_t seed = 0;
3003 VULKAN_HPP_HASH_COMBINE( seed, copyBufferToImageInfo2.sType );
3004 VULKAN_HPP_HASH_COMBINE( seed, copyBufferToImageInfo2.pNext );
3005 VULKAN_HPP_HASH_COMBINE( seed, copyBufferToImageInfo2.srcBuffer );
3006 VULKAN_HPP_HASH_COMBINE( seed, copyBufferToImageInfo2.dstImage );
3007 VULKAN_HPP_HASH_COMBINE( seed, copyBufferToImageInfo2.dstImageLayout );
3008 VULKAN_HPP_HASH_COMBINE( seed, copyBufferToImageInfo2.regionCount );
3009 VULKAN_HPP_HASH_COMBINE( seed, copyBufferToImageInfo2.pRegions );
3010 return seed;
3011 }
3012 };
3013
3014 template <>
3015 struct hash<VULKAN_HPP_NAMESPACE::CopyCommandTransformInfoQCOM>
3016 {
3017 std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyCommandTransformInfoQCOM const & copyCommandTransformInfoQCOM ) const VULKAN_HPP_NOEXCEPT
3018 {
3019 std::size_t seed = 0;
3020 VULKAN_HPP_HASH_COMBINE( seed, copyCommandTransformInfoQCOM.sType );
3021 VULKAN_HPP_HASH_COMBINE( seed, copyCommandTransformInfoQCOM.pNext );
3022 VULKAN_HPP_HASH_COMBINE( seed, copyCommandTransformInfoQCOM.transform );
3023 return seed;
3024 }
3025 };
3026
3027 template <>
3028 struct hash<VULKAN_HPP_NAMESPACE::CopyDescriptorSet>
3029 {
3030 std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyDescriptorSet const & copyDescriptorSet ) const VULKAN_HPP_NOEXCEPT
3031 {
3032 std::size_t seed = 0;
3033 VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.sType );
3034 VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.pNext );
3035 VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.srcSet );
3036 VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.srcBinding );
3037 VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.srcArrayElement );
3038 VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.dstSet );
3039 VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.dstBinding );
3040 VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.dstArrayElement );
3041 VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.descriptorCount );
3042 return seed;
3043 }
3044 };
3045
3046 template <>
3047 struct hash<VULKAN_HPP_NAMESPACE::ImageCopy2>
3048 {
3049 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageCopy2 const & imageCopy2 ) const VULKAN_HPP_NOEXCEPT
3050 {
3051 std::size_t seed = 0;
3052 VULKAN_HPP_HASH_COMBINE( seed, imageCopy2.sType );
3053 VULKAN_HPP_HASH_COMBINE( seed, imageCopy2.pNext );
3054 VULKAN_HPP_HASH_COMBINE( seed, imageCopy2.srcSubresource );
3055 VULKAN_HPP_HASH_COMBINE( seed, imageCopy2.srcOffset );
3056 VULKAN_HPP_HASH_COMBINE( seed, imageCopy2.dstSubresource );
3057 VULKAN_HPP_HASH_COMBINE( seed, imageCopy2.dstOffset );
3058 VULKAN_HPP_HASH_COMBINE( seed, imageCopy2.extent );
3059 return seed;
3060 }
3061 };
3062
3063 template <>
3064 struct hash<VULKAN_HPP_NAMESPACE::CopyImageInfo2>
3065 {
3066 std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyImageInfo2 const & copyImageInfo2 ) const VULKAN_HPP_NOEXCEPT
3067 {
3068 std::size_t seed = 0;
3069 VULKAN_HPP_HASH_COMBINE( seed, copyImageInfo2.sType );
3070 VULKAN_HPP_HASH_COMBINE( seed, copyImageInfo2.pNext );
3071 VULKAN_HPP_HASH_COMBINE( seed, copyImageInfo2.srcImage );
3072 VULKAN_HPP_HASH_COMBINE( seed, copyImageInfo2.srcImageLayout );
3073 VULKAN_HPP_HASH_COMBINE( seed, copyImageInfo2.dstImage );
3074 VULKAN_HPP_HASH_COMBINE( seed, copyImageInfo2.dstImageLayout );
3075 VULKAN_HPP_HASH_COMBINE( seed, copyImageInfo2.regionCount );
3076 VULKAN_HPP_HASH_COMBINE( seed, copyImageInfo2.pRegions );
3077 return seed;
3078 }
3079 };
3080
3081 template <>
3082 struct hash<VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2>
3083 {
3084 std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 const & copyImageToBufferInfo2 ) const VULKAN_HPP_NOEXCEPT
3085 {
3086 std::size_t seed = 0;
3087 VULKAN_HPP_HASH_COMBINE( seed, copyImageToBufferInfo2.sType );
3088 VULKAN_HPP_HASH_COMBINE( seed, copyImageToBufferInfo2.pNext );
3089 VULKAN_HPP_HASH_COMBINE( seed, copyImageToBufferInfo2.srcImage );
3090 VULKAN_HPP_HASH_COMBINE( seed, copyImageToBufferInfo2.srcImageLayout );
3091 VULKAN_HPP_HASH_COMBINE( seed, copyImageToBufferInfo2.dstBuffer );
3092 VULKAN_HPP_HASH_COMBINE( seed, copyImageToBufferInfo2.regionCount );
3093 VULKAN_HPP_HASH_COMBINE( seed, copyImageToBufferInfo2.pRegions );
3094 return seed;
3095 }
3096 };
3097
3098 template <>
3099 struct hash<VULKAN_HPP_NAMESPACE::CopyImageToImageInfo>
3100 {
3101 std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyImageToImageInfo const & copyImageToImageInfo ) const VULKAN_HPP_NOEXCEPT
3102 {
3103 std::size_t seed = 0;
3104 VULKAN_HPP_HASH_COMBINE( seed, copyImageToImageInfo.sType );
3105 VULKAN_HPP_HASH_COMBINE( seed, copyImageToImageInfo.pNext );
3106 VULKAN_HPP_HASH_COMBINE( seed, copyImageToImageInfo.flags );
3107 VULKAN_HPP_HASH_COMBINE( seed, copyImageToImageInfo.srcImage );
3108 VULKAN_HPP_HASH_COMBINE( seed, copyImageToImageInfo.srcImageLayout );
3109 VULKAN_HPP_HASH_COMBINE( seed, copyImageToImageInfo.dstImage );
3110 VULKAN_HPP_HASH_COMBINE( seed, copyImageToImageInfo.dstImageLayout );
3111 VULKAN_HPP_HASH_COMBINE( seed, copyImageToImageInfo.regionCount );
3112 VULKAN_HPP_HASH_COMBINE( seed, copyImageToImageInfo.pRegions );
3113 return seed;
3114 }
3115 };
3116
3117 template <>
3118 struct hash<VULKAN_HPP_NAMESPACE::ImageToMemoryCopy>
3119 {
3120 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageToMemoryCopy const & imageToMemoryCopy ) const VULKAN_HPP_NOEXCEPT
3121 {
3122 std::size_t seed = 0;
3123 VULKAN_HPP_HASH_COMBINE( seed, imageToMemoryCopy.sType );
3124 VULKAN_HPP_HASH_COMBINE( seed, imageToMemoryCopy.pNext );
3125 VULKAN_HPP_HASH_COMBINE( seed, imageToMemoryCopy.pHostPointer );
3126 VULKAN_HPP_HASH_COMBINE( seed, imageToMemoryCopy.memoryRowLength );
3127 VULKAN_HPP_HASH_COMBINE( seed, imageToMemoryCopy.memoryImageHeight );
3128 VULKAN_HPP_HASH_COMBINE( seed, imageToMemoryCopy.imageSubresource );
3129 VULKAN_HPP_HASH_COMBINE( seed, imageToMemoryCopy.imageOffset );
3130 VULKAN_HPP_HASH_COMBINE( seed, imageToMemoryCopy.imageExtent );
3131 return seed;
3132 }
3133 };
3134
3135 template <>
3136 struct hash<VULKAN_HPP_NAMESPACE::CopyImageToMemoryInfo>
3137 {
3138 std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyImageToMemoryInfo const & copyImageToMemoryInfo ) const VULKAN_HPP_NOEXCEPT
3139 {
3140 std::size_t seed = 0;
3141 VULKAN_HPP_HASH_COMBINE( seed, copyImageToMemoryInfo.sType );
3142 VULKAN_HPP_HASH_COMBINE( seed, copyImageToMemoryInfo.pNext );
3143 VULKAN_HPP_HASH_COMBINE( seed, copyImageToMemoryInfo.flags );
3144 VULKAN_HPP_HASH_COMBINE( seed, copyImageToMemoryInfo.srcImage );
3145 VULKAN_HPP_HASH_COMBINE( seed, copyImageToMemoryInfo.srcImageLayout );
3146 VULKAN_HPP_HASH_COMBINE( seed, copyImageToMemoryInfo.regionCount );
3147 VULKAN_HPP_HASH_COMBINE( seed, copyImageToMemoryInfo.pRegions );
3148 return seed;
3149 }
3150 };
3151
3152 template <>
3153 struct hash<VULKAN_HPP_NAMESPACE::CopyMemoryIndirectCommandKHR>
3154 {
3155 std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyMemoryIndirectCommandKHR const & copyMemoryIndirectCommandKHR ) const VULKAN_HPP_NOEXCEPT
3156 {
3157 std::size_t seed = 0;
3158 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryIndirectCommandKHR.srcAddress );
3159 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryIndirectCommandKHR.dstAddress );
3160 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryIndirectCommandKHR.size );
3161 return seed;
3162 }
3163 };
3164
3165 template <>
3166 struct hash<VULKAN_HPP_NAMESPACE::StridedDeviceAddressRangeKHR>
3167 {
3168 std::size_t operator()( VULKAN_HPP_NAMESPACE::StridedDeviceAddressRangeKHR const & stridedDeviceAddressRangeKHR ) const VULKAN_HPP_NOEXCEPT
3169 {
3170 std::size_t seed = 0;
3171 VULKAN_HPP_HASH_COMBINE( seed, stridedDeviceAddressRangeKHR.address );
3172 VULKAN_HPP_HASH_COMBINE( seed, stridedDeviceAddressRangeKHR.size );
3173 VULKAN_HPP_HASH_COMBINE( seed, stridedDeviceAddressRangeKHR.stride );
3174 return seed;
3175 }
3176 };
3177
3178 template <>
3179 struct hash<VULKAN_HPP_NAMESPACE::CopyMemoryIndirectInfoKHR>
3180 {
3181 std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyMemoryIndirectInfoKHR const & copyMemoryIndirectInfoKHR ) const VULKAN_HPP_NOEXCEPT
3182 {
3183 std::size_t seed = 0;
3184 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryIndirectInfoKHR.sType );
3185 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryIndirectInfoKHR.pNext );
3186 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryIndirectInfoKHR.srcCopyFlags );
3187 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryIndirectInfoKHR.dstCopyFlags );
3188 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryIndirectInfoKHR.copyCount );
3189 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryIndirectInfoKHR.copyAddressRange );
3190 return seed;
3191 }
3192 };
3193
3194 template <>
3195 struct hash<VULKAN_HPP_NAMESPACE::CopyMemoryToImageIndirectCommandKHR>
3196 {
3197 std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyMemoryToImageIndirectCommandKHR const & copyMemoryToImageIndirectCommandKHR ) const VULKAN_HPP_NOEXCEPT
3198 {
3199 std::size_t seed = 0;
3200 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectCommandKHR.srcAddress );
3201 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectCommandKHR.bufferRowLength );
3202 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectCommandKHR.bufferImageHeight );
3203 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectCommandKHR.imageSubresource );
3204 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectCommandKHR.imageOffset );
3205 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectCommandKHR.imageExtent );
3206 return seed;
3207 }
3208 };
3209
3210 template <>
3211 struct hash<VULKAN_HPP_NAMESPACE::CopyMemoryToImageIndirectInfoKHR>
3212 {
3213 std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyMemoryToImageIndirectInfoKHR const & copyMemoryToImageIndirectInfoKHR ) const VULKAN_HPP_NOEXCEPT
3214 {
3215 std::size_t seed = 0;
3216 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectInfoKHR.sType );
3217 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectInfoKHR.pNext );
3218 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectInfoKHR.srcCopyFlags );
3219 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectInfoKHR.copyCount );
3220 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectInfoKHR.copyAddressRange );
3221 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectInfoKHR.dstImage );
3222 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectInfoKHR.dstImageLayout );
3223 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectInfoKHR.pImageSubresources );
3224 return seed;
3225 }
3226 };
3227
3228 template <>
3229 struct hash<VULKAN_HPP_NAMESPACE::MemoryToImageCopy>
3230 {
3231 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryToImageCopy const & memoryToImageCopy ) const VULKAN_HPP_NOEXCEPT
3232 {
3233 std::size_t seed = 0;
3234 VULKAN_HPP_HASH_COMBINE( seed, memoryToImageCopy.sType );
3235 VULKAN_HPP_HASH_COMBINE( seed, memoryToImageCopy.pNext );
3236 VULKAN_HPP_HASH_COMBINE( seed, memoryToImageCopy.pHostPointer );
3237 VULKAN_HPP_HASH_COMBINE( seed, memoryToImageCopy.memoryRowLength );
3238 VULKAN_HPP_HASH_COMBINE( seed, memoryToImageCopy.memoryImageHeight );
3239 VULKAN_HPP_HASH_COMBINE( seed, memoryToImageCopy.imageSubresource );
3240 VULKAN_HPP_HASH_COMBINE( seed, memoryToImageCopy.imageOffset );
3241 VULKAN_HPP_HASH_COMBINE( seed, memoryToImageCopy.imageExtent );
3242 return seed;
3243 }
3244 };
3245
3246 template <>
3247 struct hash<VULKAN_HPP_NAMESPACE::CopyMemoryToImageInfo>
3248 {
3249 std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyMemoryToImageInfo const & copyMemoryToImageInfo ) const VULKAN_HPP_NOEXCEPT
3250 {
3251 std::size_t seed = 0;
3252 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageInfo.sType );
3253 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageInfo.pNext );
3254 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageInfo.flags );
3255 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageInfo.dstImage );
3256 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageInfo.dstImageLayout );
3257 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageInfo.regionCount );
3258 VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageInfo.pRegions );
3259 return seed;
3260 }
3261 };
3262
3263 template <>
3264 struct hash<VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT>
3265 {
3266 std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT const & copyMicromapInfoEXT ) const VULKAN_HPP_NOEXCEPT
3267 {
3268 std::size_t seed = 0;
3269 VULKAN_HPP_HASH_COMBINE( seed, copyMicromapInfoEXT.sType );
3270 VULKAN_HPP_HASH_COMBINE( seed, copyMicromapInfoEXT.pNext );
3271 VULKAN_HPP_HASH_COMBINE( seed, copyMicromapInfoEXT.src );
3272 VULKAN_HPP_HASH_COMBINE( seed, copyMicromapInfoEXT.dst );
3273 VULKAN_HPP_HASH_COMBINE( seed, copyMicromapInfoEXT.mode );
3274 return seed;
3275 }
3276 };
3277
3278 template <>
3279 struct hash<VULKAN_HPP_NAMESPACE::TensorCopyARM>
3280 {
3281 std::size_t operator()( VULKAN_HPP_NAMESPACE::TensorCopyARM const & tensorCopyARM ) const VULKAN_HPP_NOEXCEPT
3282 {
3283 std::size_t seed = 0;
3284 VULKAN_HPP_HASH_COMBINE( seed, tensorCopyARM.sType );
3285 VULKAN_HPP_HASH_COMBINE( seed, tensorCopyARM.pNext );
3286 VULKAN_HPP_HASH_COMBINE( seed, tensorCopyARM.dimensionCount );
3287 VULKAN_HPP_HASH_COMBINE( seed, tensorCopyARM.pSrcOffset );
3288 VULKAN_HPP_HASH_COMBINE( seed, tensorCopyARM.pDstOffset );
3289 VULKAN_HPP_HASH_COMBINE( seed, tensorCopyARM.pExtent );
3290 return seed;
3291 }
3292 };
3293
3294 template <>
3295 struct hash<VULKAN_HPP_NAMESPACE::CopyTensorInfoARM>
3296 {
3297 std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyTensorInfoARM const & copyTensorInfoARM ) const VULKAN_HPP_NOEXCEPT
3298 {
3299 std::size_t seed = 0;
3300 VULKAN_HPP_HASH_COMBINE( seed, copyTensorInfoARM.sType );
3301 VULKAN_HPP_HASH_COMBINE( seed, copyTensorInfoARM.pNext );
3302 VULKAN_HPP_HASH_COMBINE( seed, copyTensorInfoARM.srcTensor );
3303 VULKAN_HPP_HASH_COMBINE( seed, copyTensorInfoARM.dstTensor );
3304 VULKAN_HPP_HASH_COMBINE( seed, copyTensorInfoARM.regionCount );
3305 VULKAN_HPP_HASH_COMBINE( seed, copyTensorInfoARM.pRegions );
3306 return seed;
3307 }
3308 };
3309
3310 template <>
3311 struct hash<VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX>
3312 {
3313 std::size_t operator()( VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX const & cuFunctionCreateInfoNVX ) const VULKAN_HPP_NOEXCEPT
3314 {
3315 std::size_t seed = 0;
3316 VULKAN_HPP_HASH_COMBINE( seed, cuFunctionCreateInfoNVX.sType );
3317 VULKAN_HPP_HASH_COMBINE( seed, cuFunctionCreateInfoNVX.pNext );
3318 VULKAN_HPP_HASH_COMBINE( seed, cuFunctionCreateInfoNVX.module );
3319 for ( const char * p = cuFunctionCreateInfoNVX.pName; *p != '\0'; ++p )
3320 {
3321 VULKAN_HPP_HASH_COMBINE( seed, *p );
3322 }
3323 return seed;
3324 }
3325 };
3326
3327 template <>
3328 struct hash<VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX>
3329 {
3330 std::size_t operator()( VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX const & cuLaunchInfoNVX ) const VULKAN_HPP_NOEXCEPT
3331 {
3332 std::size_t seed = 0;
3333 VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.sType );
3334 VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.pNext );
3335 VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.function );
3336 VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.gridDimX );
3337 VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.gridDimY );
3338 VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.gridDimZ );
3339 VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.blockDimX );
3340 VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.blockDimY );
3341 VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.blockDimZ );
3342 VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.sharedMemBytes );
3343 VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.paramCount );
3344 VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.pParams );
3345 VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.extraCount );
3346 VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.pExtras );
3347 return seed;
3348 }
3349 };
3350
3351 template <>
3352 struct hash<VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX>
3353 {
3354 std::size_t operator()( VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX const & cuModuleCreateInfoNVX ) const VULKAN_HPP_NOEXCEPT
3355 {
3356 std::size_t seed = 0;
3357 VULKAN_HPP_HASH_COMBINE( seed, cuModuleCreateInfoNVX.sType );
3358 VULKAN_HPP_HASH_COMBINE( seed, cuModuleCreateInfoNVX.pNext );
3359 VULKAN_HPP_HASH_COMBINE( seed, cuModuleCreateInfoNVX.dataSize );
3360 VULKAN_HPP_HASH_COMBINE( seed, cuModuleCreateInfoNVX.pData );
3361 return seed;
3362 }
3363 };
3364
3365 template <>
3366 struct hash<VULKAN_HPP_NAMESPACE::CuModuleTexturingModeCreateInfoNVX>
3367 {
3368 std::size_t operator()( VULKAN_HPP_NAMESPACE::CuModuleTexturingModeCreateInfoNVX const & cuModuleTexturingModeCreateInfoNVX ) const VULKAN_HPP_NOEXCEPT
3369 {
3370 std::size_t seed = 0;
3371 VULKAN_HPP_HASH_COMBINE( seed, cuModuleTexturingModeCreateInfoNVX.sType );
3372 VULKAN_HPP_HASH_COMBINE( seed, cuModuleTexturingModeCreateInfoNVX.pNext );
3373 VULKAN_HPP_HASH_COMBINE( seed, cuModuleTexturingModeCreateInfoNVX.use64bitTexturing );
3374 return seed;
3375 }
3376 };
3377
3378 # if defined( VK_ENABLE_BETA_EXTENSIONS )
3379 template <>
3380 struct hash<VULKAN_HPP_NAMESPACE::CudaFunctionCreateInfoNV>
3381 {
3382 std::size_t operator()( VULKAN_HPP_NAMESPACE::CudaFunctionCreateInfoNV const & cudaFunctionCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
3383 {
3384 std::size_t seed = 0;
3385 VULKAN_HPP_HASH_COMBINE( seed, cudaFunctionCreateInfoNV.sType );
3386 VULKAN_HPP_HASH_COMBINE( seed, cudaFunctionCreateInfoNV.pNext );
3387 VULKAN_HPP_HASH_COMBINE( seed, cudaFunctionCreateInfoNV.module );
3388 for ( const char * p = cudaFunctionCreateInfoNV.pName; *p != '\0'; ++p )
3389 {
3390 VULKAN_HPP_HASH_COMBINE( seed, *p );
3391 }
3392 return seed;
3393 }
3394 };
3395 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
3396
3397 # if defined( VK_ENABLE_BETA_EXTENSIONS )
3398 template <>
3399 struct hash<VULKAN_HPP_NAMESPACE::CudaLaunchInfoNV>
3400 {
3401 std::size_t operator()( VULKAN_HPP_NAMESPACE::CudaLaunchInfoNV const & cudaLaunchInfoNV ) const VULKAN_HPP_NOEXCEPT
3402 {
3403 std::size_t seed = 0;
3404 VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.sType );
3405 VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.pNext );
3406 VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.function );
3407 VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.gridDimX );
3408 VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.gridDimY );
3409 VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.gridDimZ );
3410 VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.blockDimX );
3411 VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.blockDimY );
3412 VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.blockDimZ );
3413 VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.sharedMemBytes );
3414 VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.paramCount );
3415 VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.pParams );
3416 VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.extraCount );
3417 VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.pExtras );
3418 return seed;
3419 }
3420 };
3421 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
3422
3423 # if defined( VK_ENABLE_BETA_EXTENSIONS )
3424 template <>
3425 struct hash<VULKAN_HPP_NAMESPACE::CudaModuleCreateInfoNV>
3426 {
3427 std::size_t operator()( VULKAN_HPP_NAMESPACE::CudaModuleCreateInfoNV const & cudaModuleCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
3428 {
3429 std::size_t seed = 0;
3430 VULKAN_HPP_HASH_COMBINE( seed, cudaModuleCreateInfoNV.sType );
3431 VULKAN_HPP_HASH_COMBINE( seed, cudaModuleCreateInfoNV.pNext );
3432 VULKAN_HPP_HASH_COMBINE( seed, cudaModuleCreateInfoNV.dataSize );
3433 VULKAN_HPP_HASH_COMBINE( seed, cudaModuleCreateInfoNV.pData );
3434 return seed;
3435 }
3436 };
3437 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
3438
3439 template <>
3440 struct hash<VULKAN_HPP_NAMESPACE::CustomResolveCreateInfoEXT>
3441 {
3442 std::size_t operator()( VULKAN_HPP_NAMESPACE::CustomResolveCreateInfoEXT const & customResolveCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
3443 {
3444 std::size_t seed = 0;
3445 VULKAN_HPP_HASH_COMBINE( seed, customResolveCreateInfoEXT.sType );
3446 VULKAN_HPP_HASH_COMBINE( seed, customResolveCreateInfoEXT.pNext );
3447 VULKAN_HPP_HASH_COMBINE( seed, customResolveCreateInfoEXT.customResolve );
3448 VULKAN_HPP_HASH_COMBINE( seed, customResolveCreateInfoEXT.colorAttachmentCount );
3449 VULKAN_HPP_HASH_COMBINE( seed, customResolveCreateInfoEXT.pColorAttachmentFormats );
3450 VULKAN_HPP_HASH_COMBINE( seed, customResolveCreateInfoEXT.depthAttachmentFormat );
3451 VULKAN_HPP_HASH_COMBINE( seed, customResolveCreateInfoEXT.stencilAttachmentFormat );
3452 return seed;
3453 }
3454 };
3455
3456 # if defined( VK_USE_PLATFORM_WIN32_KHR )
3457 template <>
3458 struct hash<VULKAN_HPP_NAMESPACE::D3D12FenceSubmitInfoKHR>
3459 {
3460 std::size_t operator()( VULKAN_HPP_NAMESPACE::D3D12FenceSubmitInfoKHR const & d3D12FenceSubmitInfoKHR ) const VULKAN_HPP_NOEXCEPT
3461 {
3462 std::size_t seed = 0;
3463 VULKAN_HPP_HASH_COMBINE( seed, d3D12FenceSubmitInfoKHR.sType );
3464 VULKAN_HPP_HASH_COMBINE( seed, d3D12FenceSubmitInfoKHR.pNext );
3465 VULKAN_HPP_HASH_COMBINE( seed, d3D12FenceSubmitInfoKHR.waitSemaphoreValuesCount );
3466 VULKAN_HPP_HASH_COMBINE( seed, d3D12FenceSubmitInfoKHR.pWaitSemaphoreValues );
3467 VULKAN_HPP_HASH_COMBINE( seed, d3D12FenceSubmitInfoKHR.signalSemaphoreValuesCount );
3468 VULKAN_HPP_HASH_COMBINE( seed, d3D12FenceSubmitInfoKHR.pSignalSemaphoreValues );
3469 return seed;
3470 }
3471 };
3472 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
3473
3474 template <>
3475 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphOperationSupportARM>
3476 {
3477 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphOperationSupportARM const & physicalDeviceDataGraphOperationSupportARM ) const
3478 VULKAN_HPP_NOEXCEPT
3479 {
3480 std::size_t seed = 0;
3481 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDataGraphOperationSupportARM.operationType );
3482 for ( size_t i = 0; i < VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM; ++i )
3483 {
3484 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDataGraphOperationSupportARM.name[i] );
3485 }
3486 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDataGraphOperationSupportARM.version );
3487 return seed;
3488 }
3489 };
3490
3491 template <>
3492 struct hash<VULKAN_HPP_NAMESPACE::DataGraphPipelineBuiltinModelCreateInfoQCOM>
3493 {
3494 std::size_t operator()( VULKAN_HPP_NAMESPACE::DataGraphPipelineBuiltinModelCreateInfoQCOM const & dataGraphPipelineBuiltinModelCreateInfoQCOM ) const
3495 VULKAN_HPP_NOEXCEPT
3496 {
3497 std::size_t seed = 0;
3498 VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineBuiltinModelCreateInfoQCOM.sType );
3499 VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineBuiltinModelCreateInfoQCOM.pNext );
3500 VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineBuiltinModelCreateInfoQCOM.pOperation );
3501 return seed;
3502 }
3503 };
3504
3505 template <>
3506 struct hash<VULKAN_HPP_NAMESPACE::DataGraphPipelineCompilerControlCreateInfoARM>
3507 {
3508 std::size_t operator()( VULKAN_HPP_NAMESPACE::DataGraphPipelineCompilerControlCreateInfoARM const & dataGraphPipelineCompilerControlCreateInfoARM ) const
3509 VULKAN_HPP_NOEXCEPT
3510 {
3511 std::size_t seed = 0;
3512 VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineCompilerControlCreateInfoARM.sType );
3513 VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineCompilerControlCreateInfoARM.pNext );
3514 for ( const char * p = dataGraphPipelineCompilerControlCreateInfoARM.pVendorOptions; *p != '\0'; ++p )
3515 {
3516 VULKAN_HPP_HASH_COMBINE( seed, *p );
3517 }
3518 return seed;
3519 }
3520 };
3521
3522 template <>
3523 struct hash<VULKAN_HPP_NAMESPACE::DataGraphPipelineConstantARM>
3524 {
3525 std::size_t operator()( VULKAN_HPP_NAMESPACE::DataGraphPipelineConstantARM const & dataGraphPipelineConstantARM ) const VULKAN_HPP_NOEXCEPT
3526 {
3527 std::size_t seed = 0;
3528 VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineConstantARM.sType );
3529 VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineConstantARM.pNext );
3530 VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineConstantARM.id );
3531 VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineConstantARM.pConstantData );
3532 return seed;
3533 }
3534 };
3535
3536 template <>
3537 struct hash<VULKAN_HPP_NAMESPACE::DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM>
3538 {
3539 std::size_t operator()( VULKAN_HPP_NAMESPACE::DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM const &
3540 dataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM ) const VULKAN_HPP_NOEXCEPT
3541 {
3542 std::size_t seed = 0;
3543 VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM.sType );
3544 VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM.pNext );
3545 VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM.dimension );
3546 VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM.zeroCount );
3547 VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM.groupSize );
3548 return seed;
3549 }
3550 };
3551
3552 template <>
3553 struct hash<VULKAN_HPP_NAMESPACE::DataGraphPipelineResourceInfoARM>
3554 {
3555 std::size_t operator()( VULKAN_HPP_NAMESPACE::DataGraphPipelineResourceInfoARM const & dataGraphPipelineResourceInfoARM ) const VULKAN_HPP_NOEXCEPT
3556 {
3557 std::size_t seed = 0;
3558 VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineResourceInfoARM.sType );
3559 VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineResourceInfoARM.pNext );
3560 VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineResourceInfoARM.descriptorSet );
3561 VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineResourceInfoARM.binding );
3562 VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineResourceInfoARM.arrayElement );
3563 return seed;
3564 }
3565 };
3566
3567 template <>
3568 struct hash<VULKAN_HPP_NAMESPACE::DataGraphPipelineCreateInfoARM>
3569 {
3570 std::size_t operator()( VULKAN_HPP_NAMESPACE::DataGraphPipelineCreateInfoARM const & dataGraphPipelineCreateInfoARM ) const VULKAN_HPP_NOEXCEPT
3571 {
3572 std::size_t seed = 0;
3573 VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineCreateInfoARM.sType );
3574 VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineCreateInfoARM.pNext );
3575 VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineCreateInfoARM.flags );
3576 VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineCreateInfoARM.layout );
3577 VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineCreateInfoARM.resourceInfoCount );
3578 VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineCreateInfoARM.pResourceInfos );
3579 return seed;
3580 }
3581 };
3582
3583 template <>
3584 struct hash<VULKAN_HPP_NAMESPACE::DataGraphPipelineDispatchInfoARM>
3585 {
3586 std::size_t operator()( VULKAN_HPP_NAMESPACE::DataGraphPipelineDispatchInfoARM const & dataGraphPipelineDispatchInfoARM ) const VULKAN_HPP_NOEXCEPT
3587 {
3588 std::size_t seed = 0;
3589 VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineDispatchInfoARM.sType );
3590 VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineDispatchInfoARM.pNext );
3591 VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineDispatchInfoARM.flags );
3592 return seed;
3593 }
3594 };
3595
3596 template <>
3597 struct hash<VULKAN_HPP_NAMESPACE::DataGraphPipelineIdentifierCreateInfoARM>
3598 {
3599 std::size_t
3600 operator()( VULKAN_HPP_NAMESPACE::DataGraphPipelineIdentifierCreateInfoARM const & dataGraphPipelineIdentifierCreateInfoARM ) const VULKAN_HPP_NOEXCEPT
3601 {
3602 std::size_t seed = 0;
3603 VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineIdentifierCreateInfoARM.sType );
3604 VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineIdentifierCreateInfoARM.pNext );
3605 VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineIdentifierCreateInfoARM.identifierSize );
3606 VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineIdentifierCreateInfoARM.pIdentifier );
3607 return seed;
3608 }
3609 };
3610
3611 template <>
3612 struct hash<VULKAN_HPP_NAMESPACE::DataGraphPipelineInfoARM>
3613 {
3614 std::size_t operator()( VULKAN_HPP_NAMESPACE::DataGraphPipelineInfoARM const & dataGraphPipelineInfoARM ) const VULKAN_HPP_NOEXCEPT
3615 {
3616 std::size_t seed = 0;
3617 VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineInfoARM.sType );
3618 VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineInfoARM.pNext );
3619 VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineInfoARM.dataGraphPipeline );
3620 return seed;
3621 }
3622 };
3623
3624 template <>
3625 struct hash<VULKAN_HPP_NAMESPACE::DataGraphPipelinePropertyQueryResultARM>
3626 {
3627 std::size_t
3628 operator()( VULKAN_HPP_NAMESPACE::DataGraphPipelinePropertyQueryResultARM const & dataGraphPipelinePropertyQueryResultARM ) const VULKAN_HPP_NOEXCEPT
3629 {
3630 std::size_t seed = 0;
3631 VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelinePropertyQueryResultARM.sType );
3632 VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelinePropertyQueryResultARM.pNext );
3633 VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelinePropertyQueryResultARM.property );
3634 VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelinePropertyQueryResultARM.isText );
3635 VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelinePropertyQueryResultARM.dataSize );
3636 VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelinePropertyQueryResultARM.pData );
3637 return seed;
3638 }
3639 };
3640
3641 template <>
3642 struct hash<VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionBindPointRequirementARM>
3643 {
3644 std::size_t operator()(
3645 VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionBindPointRequirementARM const & dataGraphPipelineSessionBindPointRequirementARM ) const VULKAN_HPP_NOEXCEPT
3646 {
3647 std::size_t seed = 0;
3648 VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineSessionBindPointRequirementARM.sType );
3649 VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineSessionBindPointRequirementARM.pNext );
3650 VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineSessionBindPointRequirementARM.bindPoint );
3651 VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineSessionBindPointRequirementARM.bindPointType );
3652 VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineSessionBindPointRequirementARM.numObjects );
3653 return seed;
3654 }
3655 };
3656
3657 template <>
3658 struct hash<VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionBindPointRequirementsInfoARM>
3659 {
3660 std::size_t operator()( VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionBindPointRequirementsInfoARM const &
3661 dataGraphPipelineSessionBindPointRequirementsInfoARM ) const VULKAN_HPP_NOEXCEPT
3662 {
3663 std::size_t seed = 0;
3664 VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineSessionBindPointRequirementsInfoARM.sType );
3665 VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineSessionBindPointRequirementsInfoARM.pNext );
3666 VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineSessionBindPointRequirementsInfoARM.session );
3667 return seed;
3668 }
3669 };
3670
3671 template <>
3672 struct hash<VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionCreateInfoARM>
3673 {
3674 std::size_t
3675 operator()( VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionCreateInfoARM const & dataGraphPipelineSessionCreateInfoARM ) const VULKAN_HPP_NOEXCEPT
3676 {
3677 std::size_t seed = 0;
3678 VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineSessionCreateInfoARM.sType );
3679 VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineSessionCreateInfoARM.pNext );
3680 VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineSessionCreateInfoARM.flags );
3681 VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineSessionCreateInfoARM.dataGraphPipeline );
3682 return seed;
3683 }
3684 };
3685
3686 template <>
3687 struct hash<VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionMemoryRequirementsInfoARM>
3688 {
3689 std::size_t operator()( VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionMemoryRequirementsInfoARM const & dataGraphPipelineSessionMemoryRequirementsInfoARM )
3690 const VULKAN_HPP_NOEXCEPT
3691 {
3692 std::size_t seed = 0;
3693 VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineSessionMemoryRequirementsInfoARM.sType );
3694 VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineSessionMemoryRequirementsInfoARM.pNext );
3695 VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineSessionMemoryRequirementsInfoARM.session );
3696 VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineSessionMemoryRequirementsInfoARM.bindPoint );
3697 VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineSessionMemoryRequirementsInfoARM.objectIndex );
3698 return seed;
3699 }
3700 };
3701
3702 template <>
3703 struct hash<VULKAN_HPP_NAMESPACE::DataGraphPipelineShaderModuleCreateInfoARM>
3704 {
3705 std::size_t operator()( VULKAN_HPP_NAMESPACE::DataGraphPipelineShaderModuleCreateInfoARM const & dataGraphPipelineShaderModuleCreateInfoARM ) const
3706 VULKAN_HPP_NOEXCEPT
3707 {
3708 std::size_t seed = 0;
3709 VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineShaderModuleCreateInfoARM.sType );
3710 VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineShaderModuleCreateInfoARM.pNext );
3711 VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineShaderModuleCreateInfoARM.module );
3712 for ( const char * p = dataGraphPipelineShaderModuleCreateInfoARM.pName; *p != '\0'; ++p )
3713 {
3714 VULKAN_HPP_HASH_COMBINE( seed, *p );
3715 }
3716 VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineShaderModuleCreateInfoARM.pSpecializationInfo );
3717 VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineShaderModuleCreateInfoARM.constantCount );
3718 VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineShaderModuleCreateInfoARM.pConstants );
3719 return seed;
3720 }
3721 };
3722
3723 template <>
3724 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphProcessingEngineARM>
3725 {
3726 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphProcessingEngineARM const & physicalDeviceDataGraphProcessingEngineARM ) const
3727 VULKAN_HPP_NOEXCEPT
3728 {
3729 std::size_t seed = 0;
3730 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDataGraphProcessingEngineARM.type );
3731 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDataGraphProcessingEngineARM.isForeign );
3732 return seed;
3733 }
3734 };
3735
3736 template <>
3737 struct hash<VULKAN_HPP_NAMESPACE::DataGraphProcessingEngineCreateInfoARM>
3738 {
3739 std::size_t
3740 operator()( VULKAN_HPP_NAMESPACE::DataGraphProcessingEngineCreateInfoARM const & dataGraphProcessingEngineCreateInfoARM ) const VULKAN_HPP_NOEXCEPT
3741 {
3742 std::size_t seed = 0;
3743 VULKAN_HPP_HASH_COMBINE( seed, dataGraphProcessingEngineCreateInfoARM.sType );
3744 VULKAN_HPP_HASH_COMBINE( seed, dataGraphProcessingEngineCreateInfoARM.pNext );
3745 VULKAN_HPP_HASH_COMBINE( seed, dataGraphProcessingEngineCreateInfoARM.processingEngineCount );
3746 VULKAN_HPP_HASH_COMBINE( seed, dataGraphProcessingEngineCreateInfoARM.pProcessingEngines );
3747 return seed;
3748 }
3749 };
3750
3751 template <>
3752 struct hash<VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT>
3753 {
3754 std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT const & debugMarkerMarkerInfoEXT ) const VULKAN_HPP_NOEXCEPT
3755 {
3756 std::size_t seed = 0;
3757 VULKAN_HPP_HASH_COMBINE( seed, debugMarkerMarkerInfoEXT.sType );
3758 VULKAN_HPP_HASH_COMBINE( seed, debugMarkerMarkerInfoEXT.pNext );
3759 for ( const char * p = debugMarkerMarkerInfoEXT.pMarkerName; *p != '\0'; ++p )
3760 {
3761 VULKAN_HPP_HASH_COMBINE( seed, *p );
3762 }
3763 for ( size_t i = 0; i < 4; ++i )
3764 {
3765 VULKAN_HPP_HASH_COMBINE( seed, debugMarkerMarkerInfoEXT.color[i] );
3766 }
3767 return seed;
3768 }
3769 };
3770
3771 template <>
3772 struct hash<VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT>
3773 {
3774 std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT const & debugMarkerObjectNameInfoEXT ) const VULKAN_HPP_NOEXCEPT
3775 {
3776 std::size_t seed = 0;
3777 VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectNameInfoEXT.sType );
3778 VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectNameInfoEXT.pNext );
3779 VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectNameInfoEXT.objectType );
3780 VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectNameInfoEXT.object );
3781 for ( const char * p = debugMarkerObjectNameInfoEXT.pObjectName; *p != '\0'; ++p )
3782 {
3783 VULKAN_HPP_HASH_COMBINE( seed, *p );
3784 }
3785 return seed;
3786 }
3787 };
3788
3789 template <>
3790 struct hash<VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT>
3791 {
3792 std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT const & debugMarkerObjectTagInfoEXT ) const VULKAN_HPP_NOEXCEPT
3793 {
3794 std::size_t seed = 0;
3795 VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectTagInfoEXT.sType );
3796 VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectTagInfoEXT.pNext );
3797 VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectTagInfoEXT.objectType );
3798 VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectTagInfoEXT.object );
3799 VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectTagInfoEXT.tagName );
3800 VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectTagInfoEXT.tagSize );
3801 VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectTagInfoEXT.pTag );
3802 return seed;
3803 }
3804 };
3805
3806 template <>
3807 struct hash<VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT>
3808 {
3809 std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT const & debugReportCallbackCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
3810 {
3811 std::size_t seed = 0;
3812 VULKAN_HPP_HASH_COMBINE( seed, debugReportCallbackCreateInfoEXT.sType );
3813 VULKAN_HPP_HASH_COMBINE( seed, debugReportCallbackCreateInfoEXT.pNext );
3814 VULKAN_HPP_HASH_COMBINE( seed, debugReportCallbackCreateInfoEXT.flags );
3815 VULKAN_HPP_HASH_COMBINE( seed, debugReportCallbackCreateInfoEXT.pfnCallback );
3816 VULKAN_HPP_HASH_COMBINE( seed, debugReportCallbackCreateInfoEXT.pUserData );
3817 return seed;
3818 }
3819 };
3820
3821 template <>
3822 struct hash<VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT>
3823 {
3824 std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT const & debugUtilsLabelEXT ) const VULKAN_HPP_NOEXCEPT
3825 {
3826 std::size_t seed = 0;
3827 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsLabelEXT.sType );
3828 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsLabelEXT.pNext );
3829 for ( const char * p = debugUtilsLabelEXT.pLabelName; *p != '\0'; ++p )
3830 {
3831 VULKAN_HPP_HASH_COMBINE( seed, *p );
3832 }
3833 for ( size_t i = 0; i < 4; ++i )
3834 {
3835 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsLabelEXT.color[i] );
3836 }
3837 return seed;
3838 }
3839 };
3840
3841 template <>
3842 struct hash<VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT>
3843 {
3844 std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT const & debugUtilsObjectNameInfoEXT ) const VULKAN_HPP_NOEXCEPT
3845 {
3846 std::size_t seed = 0;
3847 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectNameInfoEXT.sType );
3848 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectNameInfoEXT.pNext );
3849 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectNameInfoEXT.objectType );
3850 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectNameInfoEXT.objectHandle );
3851 for ( const char * p = debugUtilsObjectNameInfoEXT.pObjectName; *p != '\0'; ++p )
3852 {
3853 VULKAN_HPP_HASH_COMBINE( seed, *p );
3854 }
3855 return seed;
3856 }
3857 };
3858
3859 template <>
3860 struct hash<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataEXT>
3861 {
3862 std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataEXT const & debugUtilsMessengerCallbackDataEXT ) const VULKAN_HPP_NOEXCEPT
3863 {
3864 std::size_t seed = 0;
3865 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.sType );
3866 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.pNext );
3867 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.flags );
3868 for ( const char * p = debugUtilsMessengerCallbackDataEXT.pMessageIdName; *p != '\0'; ++p )
3869 {
3870 VULKAN_HPP_HASH_COMBINE( seed, *p );
3871 }
3872 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.messageIdNumber );
3873 for ( const char * p = debugUtilsMessengerCallbackDataEXT.pMessage; *p != '\0'; ++p )
3874 {
3875 VULKAN_HPP_HASH_COMBINE( seed, *p );
3876 }
3877 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.queueLabelCount );
3878 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.pQueueLabels );
3879 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.cmdBufLabelCount );
3880 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.pCmdBufLabels );
3881 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.objectCount );
3882 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.pObjects );
3883 return seed;
3884 }
3885 };
3886
3887 template <>
3888 struct hash<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT>
3889 {
3890 std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT const & debugUtilsMessengerCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
3891 {
3892 std::size_t seed = 0;
3893 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCreateInfoEXT.sType );
3894 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCreateInfoEXT.pNext );
3895 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCreateInfoEXT.flags );
3896 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCreateInfoEXT.messageSeverity );
3897 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCreateInfoEXT.messageType );
3898 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCreateInfoEXT.pfnUserCallback );
3899 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCreateInfoEXT.pUserData );
3900 return seed;
3901 }
3902 };
3903
3904 template <>
3905 struct hash<VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT>
3906 {
3907 std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT const & debugUtilsObjectTagInfoEXT ) const VULKAN_HPP_NOEXCEPT
3908 {
3909 std::size_t seed = 0;
3910 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectTagInfoEXT.sType );
3911 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectTagInfoEXT.pNext );
3912 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectTagInfoEXT.objectType );
3913 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectTagInfoEXT.objectHandle );
3914 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectTagInfoEXT.tagName );
3915 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectTagInfoEXT.tagSize );
3916 VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectTagInfoEXT.pTag );
3917 return seed;
3918 }
3919 };
3920
3921 template <>
3922 struct hash<VULKAN_HPP_NAMESPACE::DecompressMemoryRegionEXT>
3923 {
3924 std::size_t operator()( VULKAN_HPP_NAMESPACE::DecompressMemoryRegionEXT const & decompressMemoryRegionEXT ) const VULKAN_HPP_NOEXCEPT
3925 {
3926 std::size_t seed = 0;
3927 VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryRegionEXT.srcAddress );
3928 VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryRegionEXT.dstAddress );
3929 VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryRegionEXT.compressedSize );
3930 VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryRegionEXT.decompressedSize );
3931 return seed;
3932 }
3933 };
3934
3935 template <>
3936 struct hash<VULKAN_HPP_NAMESPACE::DecompressMemoryInfoEXT>
3937 {
3938 std::size_t operator()( VULKAN_HPP_NAMESPACE::DecompressMemoryInfoEXT const & decompressMemoryInfoEXT ) const VULKAN_HPP_NOEXCEPT
3939 {
3940 std::size_t seed = 0;
3941 VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryInfoEXT.sType );
3942 VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryInfoEXT.pNext );
3943 VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryInfoEXT.decompressionMethod );
3944 VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryInfoEXT.regionCount );
3945 VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryInfoEXT.pRegions );
3946 return seed;
3947 }
3948 };
3949
3950 template <>
3951 struct hash<VULKAN_HPP_NAMESPACE::DecompressMemoryRegionNV>
3952 {
3953 std::size_t operator()( VULKAN_HPP_NAMESPACE::DecompressMemoryRegionNV const & decompressMemoryRegionNV ) const VULKAN_HPP_NOEXCEPT
3954 {
3955 std::size_t seed = 0;
3956 VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryRegionNV.srcAddress );
3957 VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryRegionNV.dstAddress );
3958 VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryRegionNV.compressedSize );
3959 VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryRegionNV.decompressedSize );
3960 VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryRegionNV.decompressionMethod );
3961 return seed;
3962 }
3963 };
3964
3965 template <>
3966 struct hash<VULKAN_HPP_NAMESPACE::DedicatedAllocationBufferCreateInfoNV>
3967 {
3968 std::size_t
3969 operator()( VULKAN_HPP_NAMESPACE::DedicatedAllocationBufferCreateInfoNV const & dedicatedAllocationBufferCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
3970 {
3971 std::size_t seed = 0;
3972 VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationBufferCreateInfoNV.sType );
3973 VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationBufferCreateInfoNV.pNext );
3974 VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationBufferCreateInfoNV.dedicatedAllocation );
3975 return seed;
3976 }
3977 };
3978
3979 template <>
3980 struct hash<VULKAN_HPP_NAMESPACE::DedicatedAllocationImageCreateInfoNV>
3981 {
3982 std::size_t operator()( VULKAN_HPP_NAMESPACE::DedicatedAllocationImageCreateInfoNV const & dedicatedAllocationImageCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
3983 {
3984 std::size_t seed = 0;
3985 VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationImageCreateInfoNV.sType );
3986 VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationImageCreateInfoNV.pNext );
3987 VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationImageCreateInfoNV.dedicatedAllocation );
3988 return seed;
3989 }
3990 };
3991
3992 template <>
3993 struct hash<VULKAN_HPP_NAMESPACE::DedicatedAllocationMemoryAllocateInfoNV>
3994 {
3995 std::size_t
3996 operator()( VULKAN_HPP_NAMESPACE::DedicatedAllocationMemoryAllocateInfoNV const & dedicatedAllocationMemoryAllocateInfoNV ) const VULKAN_HPP_NOEXCEPT
3997 {
3998 std::size_t seed = 0;
3999 VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationMemoryAllocateInfoNV.sType );
4000 VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationMemoryAllocateInfoNV.pNext );
4001 VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationMemoryAllocateInfoNV.image );
4002 VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationMemoryAllocateInfoNV.buffer );
4003 return seed;
4004 }
4005 };
4006
4007 template <>
4008 struct hash<VULKAN_HPP_NAMESPACE::MemoryBarrier2>
4009 {
4010 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryBarrier2 const & memoryBarrier2 ) const VULKAN_HPP_NOEXCEPT
4011 {
4012 std::size_t seed = 0;
4013 VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier2.sType );
4014 VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier2.pNext );
4015 VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier2.srcStageMask );
4016 VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier2.srcAccessMask );
4017 VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier2.dstStageMask );
4018 VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier2.dstAccessMask );
4019 return seed;
4020 }
4021 };
4022
4023 template <>
4024 struct hash<VULKAN_HPP_NAMESPACE::ImageSubresourceRange>
4025 {
4026 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageSubresourceRange const & imageSubresourceRange ) const VULKAN_HPP_NOEXCEPT
4027 {
4028 std::size_t seed = 0;
4029 VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceRange.aspectMask );
4030 VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceRange.baseMipLevel );
4031 VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceRange.levelCount );
4032 VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceRange.baseArrayLayer );
4033 VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceRange.layerCount );
4034 return seed;
4035 }
4036 };
4037
4038 template <>
4039 struct hash<VULKAN_HPP_NAMESPACE::ImageMemoryBarrier2>
4040 {
4041 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageMemoryBarrier2 const & imageMemoryBarrier2 ) const VULKAN_HPP_NOEXCEPT
4042 {
4043 std::size_t seed = 0;
4044 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.sType );
4045 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.pNext );
4046 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.srcStageMask );
4047 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.srcAccessMask );
4048 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.dstStageMask );
4049 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.dstAccessMask );
4050 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.oldLayout );
4051 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.newLayout );
4052 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.srcQueueFamilyIndex );
4053 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.dstQueueFamilyIndex );
4054 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.image );
4055 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.subresourceRange );
4056 return seed;
4057 }
4058 };
4059
4060 template <>
4061 struct hash<VULKAN_HPP_NAMESPACE::DependencyInfo>
4062 {
4063 std::size_t operator()( VULKAN_HPP_NAMESPACE::DependencyInfo const & dependencyInfo ) const VULKAN_HPP_NOEXCEPT
4064 {
4065 std::size_t seed = 0;
4066 VULKAN_HPP_HASH_COMBINE( seed, dependencyInfo.sType );
4067 VULKAN_HPP_HASH_COMBINE( seed, dependencyInfo.pNext );
4068 VULKAN_HPP_HASH_COMBINE( seed, dependencyInfo.dependencyFlags );
4069 VULKAN_HPP_HASH_COMBINE( seed, dependencyInfo.memoryBarrierCount );
4070 VULKAN_HPP_HASH_COMBINE( seed, dependencyInfo.pMemoryBarriers );
4071 VULKAN_HPP_HASH_COMBINE( seed, dependencyInfo.bufferMemoryBarrierCount );
4072 VULKAN_HPP_HASH_COMBINE( seed, dependencyInfo.pBufferMemoryBarriers );
4073 VULKAN_HPP_HASH_COMBINE( seed, dependencyInfo.imageMemoryBarrierCount );
4074 VULKAN_HPP_HASH_COMBINE( seed, dependencyInfo.pImageMemoryBarriers );
4075 return seed;
4076 }
4077 };
4078
4079 template <>
4080 struct hash<VULKAN_HPP_NAMESPACE::DepthBiasInfoEXT>
4081 {
4082 std::size_t operator()( VULKAN_HPP_NAMESPACE::DepthBiasInfoEXT const & depthBiasInfoEXT ) const VULKAN_HPP_NOEXCEPT
4083 {
4084 std::size_t seed = 0;
4085 VULKAN_HPP_HASH_COMBINE( seed, depthBiasInfoEXT.sType );
4086 VULKAN_HPP_HASH_COMBINE( seed, depthBiasInfoEXT.pNext );
4087 VULKAN_HPP_HASH_COMBINE( seed, depthBiasInfoEXT.depthBiasConstantFactor );
4088 VULKAN_HPP_HASH_COMBINE( seed, depthBiasInfoEXT.depthBiasClamp );
4089 VULKAN_HPP_HASH_COMBINE( seed, depthBiasInfoEXT.depthBiasSlopeFactor );
4090 return seed;
4091 }
4092 };
4093
4094 template <>
4095 struct hash<VULKAN_HPP_NAMESPACE::DepthBiasRepresentationInfoEXT>
4096 {
4097 std::size_t operator()( VULKAN_HPP_NAMESPACE::DepthBiasRepresentationInfoEXT const & depthBiasRepresentationInfoEXT ) const VULKAN_HPP_NOEXCEPT
4098 {
4099 std::size_t seed = 0;
4100 VULKAN_HPP_HASH_COMBINE( seed, depthBiasRepresentationInfoEXT.sType );
4101 VULKAN_HPP_HASH_COMBINE( seed, depthBiasRepresentationInfoEXT.pNext );
4102 VULKAN_HPP_HASH_COMBINE( seed, depthBiasRepresentationInfoEXT.depthBiasRepresentation );
4103 VULKAN_HPP_HASH_COMBINE( seed, depthBiasRepresentationInfoEXT.depthBiasExact );
4104 return seed;
4105 }
4106 };
4107
4108 template <>
4109 struct hash<VULKAN_HPP_NAMESPACE::DepthClampRangeEXT>
4110 {
4111 std::size_t operator()( VULKAN_HPP_NAMESPACE::DepthClampRangeEXT const & depthClampRangeEXT ) const VULKAN_HPP_NOEXCEPT
4112 {
4113 std::size_t seed = 0;
4114 VULKAN_HPP_HASH_COMBINE( seed, depthClampRangeEXT.minDepthClamp );
4115 VULKAN_HPP_HASH_COMBINE( seed, depthClampRangeEXT.maxDepthClamp );
4116 return seed;
4117 }
4118 };
4119
4120 template <>
4121 struct hash<VULKAN_HPP_NAMESPACE::DescriptorAddressInfoEXT>
4122 {
4123 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorAddressInfoEXT const & descriptorAddressInfoEXT ) const VULKAN_HPP_NOEXCEPT
4124 {
4125 std::size_t seed = 0;
4126 VULKAN_HPP_HASH_COMBINE( seed, descriptorAddressInfoEXT.sType );
4127 VULKAN_HPP_HASH_COMBINE( seed, descriptorAddressInfoEXT.pNext );
4128 VULKAN_HPP_HASH_COMBINE( seed, descriptorAddressInfoEXT.address );
4129 VULKAN_HPP_HASH_COMBINE( seed, descriptorAddressInfoEXT.range );
4130 VULKAN_HPP_HASH_COMBINE( seed, descriptorAddressInfoEXT.format );
4131 return seed;
4132 }
4133 };
4134
4135 template <>
4136 struct hash<VULKAN_HPP_NAMESPACE::DescriptorBufferBindingInfoEXT>
4137 {
4138 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorBufferBindingInfoEXT const & descriptorBufferBindingInfoEXT ) const VULKAN_HPP_NOEXCEPT
4139 {
4140 std::size_t seed = 0;
4141 VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferBindingInfoEXT.sType );
4142 VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferBindingInfoEXT.pNext );
4143 VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferBindingInfoEXT.address );
4144 VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferBindingInfoEXT.usage );
4145 return seed;
4146 }
4147 };
4148
4149 template <>
4150 struct hash<VULKAN_HPP_NAMESPACE::DescriptorBufferBindingPushDescriptorBufferHandleEXT>
4151 {
4152 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorBufferBindingPushDescriptorBufferHandleEXT const &
4153 descriptorBufferBindingPushDescriptorBufferHandleEXT ) const VULKAN_HPP_NOEXCEPT
4154 {
4155 std::size_t seed = 0;
4156 VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferBindingPushDescriptorBufferHandleEXT.sType );
4157 VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferBindingPushDescriptorBufferHandleEXT.pNext );
4158 VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferBindingPushDescriptorBufferHandleEXT.buffer );
4159 return seed;
4160 }
4161 };
4162
4163 template <>
4164 struct hash<VULKAN_HPP_NAMESPACE::DescriptorBufferInfo>
4165 {
4166 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorBufferInfo const & descriptorBufferInfo ) const VULKAN_HPP_NOEXCEPT
4167 {
4168 std::size_t seed = 0;
4169 VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferInfo.buffer );
4170 VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferInfo.offset );
4171 VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferInfo.range );
4172 return seed;
4173 }
4174 };
4175
4176 template <>
4177 struct hash<VULKAN_HPP_NAMESPACE::DescriptorImageInfo>
4178 {
4179 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorImageInfo const & descriptorImageInfo ) const VULKAN_HPP_NOEXCEPT
4180 {
4181 std::size_t seed = 0;
4182 VULKAN_HPP_HASH_COMBINE( seed, descriptorImageInfo.sampler );
4183 VULKAN_HPP_HASH_COMBINE( seed, descriptorImageInfo.imageView );
4184 VULKAN_HPP_HASH_COMBINE( seed, descriptorImageInfo.imageLayout );
4185 return seed;
4186 }
4187 };
4188
4189 template <>
4190 struct hash<VULKAN_HPP_NAMESPACE::DescriptorGetTensorInfoARM>
4191 {
4192 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorGetTensorInfoARM const & descriptorGetTensorInfoARM ) const VULKAN_HPP_NOEXCEPT
4193 {
4194 std::size_t seed = 0;
4195 VULKAN_HPP_HASH_COMBINE( seed, descriptorGetTensorInfoARM.sType );
4196 VULKAN_HPP_HASH_COMBINE( seed, descriptorGetTensorInfoARM.pNext );
4197 VULKAN_HPP_HASH_COMBINE( seed, descriptorGetTensorInfoARM.tensorView );
4198 return seed;
4199 }
4200 };
4201
4202 template <>
4203 struct hash<VULKAN_HPP_NAMESPACE::DescriptorPoolSize>
4204 {
4205 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorPoolSize const & descriptorPoolSize ) const VULKAN_HPP_NOEXCEPT
4206 {
4207 std::size_t seed = 0;
4208 VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolSize.type );
4209 VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolSize.descriptorCount );
4210 return seed;
4211 }
4212 };
4213
4214 template <>
4215 struct hash<VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo>
4216 {
4217 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo const & descriptorPoolCreateInfo ) const VULKAN_HPP_NOEXCEPT
4218 {
4219 std::size_t seed = 0;
4220 VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolCreateInfo.sType );
4221 VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolCreateInfo.pNext );
4222 VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolCreateInfo.flags );
4223 VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolCreateInfo.maxSets );
4224 VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolCreateInfo.poolSizeCount );
4225 VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolCreateInfo.pPoolSizes );
4226 return seed;
4227 }
4228 };
4229
4230 template <>
4231 struct hash<VULKAN_HPP_NAMESPACE::DescriptorPoolInlineUniformBlockCreateInfo>
4232 {
4233 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorPoolInlineUniformBlockCreateInfo const & descriptorPoolInlineUniformBlockCreateInfo ) const
4234 VULKAN_HPP_NOEXCEPT
4235 {
4236 std::size_t seed = 0;
4237 VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolInlineUniformBlockCreateInfo.sType );
4238 VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolInlineUniformBlockCreateInfo.pNext );
4239 VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolInlineUniformBlockCreateInfo.maxInlineUniformBlockBindings );
4240 return seed;
4241 }
4242 };
4243
4244 template <>
4245 struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo>
4246 {
4247 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo const & descriptorSetAllocateInfo ) const VULKAN_HPP_NOEXCEPT
4248 {
4249 std::size_t seed = 0;
4250 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetAllocateInfo.sType );
4251 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetAllocateInfo.pNext );
4252 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetAllocateInfo.descriptorPool );
4253 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetAllocateInfo.descriptorSetCount );
4254 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetAllocateInfo.pSetLayouts );
4255 return seed;
4256 }
4257 };
4258
4259 template <>
4260 struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetBindingReferenceVALVE>
4261 {
4262 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetBindingReferenceVALVE const & descriptorSetBindingReferenceVALVE ) const VULKAN_HPP_NOEXCEPT
4263 {
4264 std::size_t seed = 0;
4265 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetBindingReferenceVALVE.sType );
4266 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetBindingReferenceVALVE.pNext );
4267 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetBindingReferenceVALVE.descriptorSetLayout );
4268 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetBindingReferenceVALVE.binding );
4269 return seed;
4270 }
4271 };
4272
4273 template <>
4274 struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBinding>
4275 {
4276 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBinding const & descriptorSetLayoutBinding ) const VULKAN_HPP_NOEXCEPT
4277 {
4278 std::size_t seed = 0;
4279 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutBinding.binding );
4280 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutBinding.descriptorType );
4281 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutBinding.descriptorCount );
4282 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutBinding.stageFlags );
4283 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutBinding.pImmutableSamplers );
4284 return seed;
4285 }
4286 };
4287
4288 template <>
4289 struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBindingFlagsCreateInfo>
4290 {
4291 std::size_t
4292 operator()( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBindingFlagsCreateInfo const & descriptorSetLayoutBindingFlagsCreateInfo ) const VULKAN_HPP_NOEXCEPT
4293 {
4294 std::size_t seed = 0;
4295 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutBindingFlagsCreateInfo.sType );
4296 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutBindingFlagsCreateInfo.pNext );
4297 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutBindingFlagsCreateInfo.bindingCount );
4298 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutBindingFlagsCreateInfo.pBindingFlags );
4299 return seed;
4300 }
4301 };
4302
4303 template <>
4304 struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo>
4305 {
4306 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo const & descriptorSetLayoutCreateInfo ) const VULKAN_HPP_NOEXCEPT
4307 {
4308 std::size_t seed = 0;
4309 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutCreateInfo.sType );
4310 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutCreateInfo.pNext );
4311 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutCreateInfo.flags );
4312 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutCreateInfo.bindingCount );
4313 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutCreateInfo.pBindings );
4314 return seed;
4315 }
4316 };
4317
4318 template <>
4319 struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutHostMappingInfoVALVE>
4320 {
4321 std::size_t
4322 operator()( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutHostMappingInfoVALVE const & descriptorSetLayoutHostMappingInfoVALVE ) const VULKAN_HPP_NOEXCEPT
4323 {
4324 std::size_t seed = 0;
4325 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutHostMappingInfoVALVE.sType );
4326 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutHostMappingInfoVALVE.pNext );
4327 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutHostMappingInfoVALVE.descriptorOffset );
4328 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutHostMappingInfoVALVE.descriptorSize );
4329 return seed;
4330 }
4331 };
4332
4333 template <>
4334 struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport>
4335 {
4336 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport const & descriptorSetLayoutSupport ) const VULKAN_HPP_NOEXCEPT
4337 {
4338 std::size_t seed = 0;
4339 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutSupport.sType );
4340 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutSupport.pNext );
4341 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutSupport.supported );
4342 return seed;
4343 }
4344 };
4345
4346 template <>
4347 struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetVariableDescriptorCountAllocateInfo>
4348 {
4349 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetVariableDescriptorCountAllocateInfo const & descriptorSetVariableDescriptorCountAllocateInfo )
4350 const VULKAN_HPP_NOEXCEPT
4351 {
4352 std::size_t seed = 0;
4353 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetVariableDescriptorCountAllocateInfo.sType );
4354 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetVariableDescriptorCountAllocateInfo.pNext );
4355 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetVariableDescriptorCountAllocateInfo.descriptorSetCount );
4356 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetVariableDescriptorCountAllocateInfo.pDescriptorCounts );
4357 return seed;
4358 }
4359 };
4360
4361 template <>
4362 struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetVariableDescriptorCountLayoutSupport>
4363 {
4364 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetVariableDescriptorCountLayoutSupport const & descriptorSetVariableDescriptorCountLayoutSupport )
4365 const VULKAN_HPP_NOEXCEPT
4366 {
4367 std::size_t seed = 0;
4368 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetVariableDescriptorCountLayoutSupport.sType );
4369 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetVariableDescriptorCountLayoutSupport.pNext );
4370 VULKAN_HPP_HASH_COMBINE( seed, descriptorSetVariableDescriptorCountLayoutSupport.maxVariableDescriptorCount );
4371 return seed;
4372 }
4373 };
4374
4375 template <>
4376 struct hash<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateEntry>
4377 {
4378 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateEntry const & descriptorUpdateTemplateEntry ) const VULKAN_HPP_NOEXCEPT
4379 {
4380 std::size_t seed = 0;
4381 VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateEntry.dstBinding );
4382 VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateEntry.dstArrayElement );
4383 VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateEntry.descriptorCount );
4384 VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateEntry.descriptorType );
4385 VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateEntry.offset );
4386 VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateEntry.stride );
4387 return seed;
4388 }
4389 };
4390
4391 template <>
4392 struct hash<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo>
4393 {
4394 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo const & descriptorUpdateTemplateCreateInfo ) const VULKAN_HPP_NOEXCEPT
4395 {
4396 std::size_t seed = 0;
4397 VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.sType );
4398 VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.pNext );
4399 VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.flags );
4400 VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.descriptorUpdateEntryCount );
4401 VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.pDescriptorUpdateEntries );
4402 VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.templateType );
4403 VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.descriptorSetLayout );
4404 VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.pipelineBindPoint );
4405 VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.pipelineLayout );
4406 VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.set );
4407 return seed;
4408 }
4409 };
4410
4411 template <>
4412 struct hash<VULKAN_HPP_NAMESPACE::DeviceAddressBindingCallbackDataEXT>
4413 {
4414 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceAddressBindingCallbackDataEXT const & deviceAddressBindingCallbackDataEXT ) const VULKAN_HPP_NOEXCEPT
4415 {
4416 std::size_t seed = 0;
4417 VULKAN_HPP_HASH_COMBINE( seed, deviceAddressBindingCallbackDataEXT.sType );
4418 VULKAN_HPP_HASH_COMBINE( seed, deviceAddressBindingCallbackDataEXT.pNext );
4419 VULKAN_HPP_HASH_COMBINE( seed, deviceAddressBindingCallbackDataEXT.flags );
4420 VULKAN_HPP_HASH_COMBINE( seed, deviceAddressBindingCallbackDataEXT.baseAddress );
4421 VULKAN_HPP_HASH_COMBINE( seed, deviceAddressBindingCallbackDataEXT.size );
4422 VULKAN_HPP_HASH_COMBINE( seed, deviceAddressBindingCallbackDataEXT.bindingType );
4423 return seed;
4424 }
4425 };
4426
4427 template <>
4428 struct hash<VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements>
4429 {
4430 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements const & deviceBufferMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
4431 {
4432 std::size_t seed = 0;
4433 VULKAN_HPP_HASH_COMBINE( seed, deviceBufferMemoryRequirements.sType );
4434 VULKAN_HPP_HASH_COMBINE( seed, deviceBufferMemoryRequirements.pNext );
4435 VULKAN_HPP_HASH_COMBINE( seed, deviceBufferMemoryRequirements.pCreateInfo );
4436 return seed;
4437 }
4438 };
4439
4440 template <>
4441 struct hash<VULKAN_HPP_NAMESPACE::DeviceQueueCreateInfo>
4442 {
4443 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceQueueCreateInfo const & deviceQueueCreateInfo ) const VULKAN_HPP_NOEXCEPT
4444 {
4445 std::size_t seed = 0;
4446 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueCreateInfo.sType );
4447 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueCreateInfo.pNext );
4448 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueCreateInfo.flags );
4449 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueCreateInfo.queueFamilyIndex );
4450 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueCreateInfo.queueCount );
4451 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueCreateInfo.pQueuePriorities );
4452 return seed;
4453 }
4454 };
4455
4456 template <>
4457 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures>
4458 {
4459 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures const & physicalDeviceFeatures ) const VULKAN_HPP_NOEXCEPT
4460 {
4461 std::size_t seed = 0;
4462 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.robustBufferAccess );
4463 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.fullDrawIndexUint32 );
4464 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.imageCubeArray );
4465 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.independentBlend );
4466 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.geometryShader );
4467 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.tessellationShader );
4468 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sampleRateShading );
4469 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.dualSrcBlend );
4470 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.logicOp );
4471 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.multiDrawIndirect );
4472 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.drawIndirectFirstInstance );
4473 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.depthClamp );
4474 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.depthBiasClamp );
4475 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.fillModeNonSolid );
4476 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.depthBounds );
4477 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.wideLines );
4478 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.largePoints );
4479 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.alphaToOne );
4480 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.multiViewport );
4481 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.samplerAnisotropy );
4482 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.textureCompressionETC2 );
4483 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.textureCompressionASTC_LDR );
4484 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.textureCompressionBC );
4485 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.occlusionQueryPrecise );
4486 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.pipelineStatisticsQuery );
4487 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.vertexPipelineStoresAndAtomics );
4488 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.fragmentStoresAndAtomics );
4489 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderTessellationAndGeometryPointSize );
4490 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderImageGatherExtended );
4491 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderStorageImageExtendedFormats );
4492 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderStorageImageMultisample );
4493 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderStorageImageReadWithoutFormat );
4494 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderStorageImageWriteWithoutFormat );
4495 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderUniformBufferArrayDynamicIndexing );
4496 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderSampledImageArrayDynamicIndexing );
4497 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderStorageBufferArrayDynamicIndexing );
4498 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderStorageImageArrayDynamicIndexing );
4499 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderClipDistance );
4500 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderCullDistance );
4501 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderFloat64 );
4502 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderInt64 );
4503 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderInt16 );
4504 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderResourceResidency );
4505 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderResourceMinLod );
4506 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sparseBinding );
4507 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sparseResidencyBuffer );
4508 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sparseResidencyImage2D );
4509 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sparseResidencyImage3D );
4510 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sparseResidency2Samples );
4511 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sparseResidency4Samples );
4512 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sparseResidency8Samples );
4513 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sparseResidency16Samples );
4514 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sparseResidencyAliased );
4515 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.variableMultisampleRate );
4516 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.inheritedQueries );
4517 return seed;
4518 }
4519 };
4520
4521 template <>
4522 struct hash<VULKAN_HPP_NAMESPACE::DeviceCreateInfo>
4523 {
4524 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceCreateInfo const & deviceCreateInfo ) const VULKAN_HPP_NOEXCEPT
4525 {
4526 std::size_t seed = 0;
4527 VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.sType );
4528 VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.pNext );
4529 VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.flags );
4530 VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.queueCreateInfoCount );
4531 VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.pQueueCreateInfos );
4532 VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.enabledExtensionCount );
4533 for ( size_t i = 0; i < deviceCreateInfo.enabledExtensionCount; ++i )
4534 {
4535 for ( const char * p = deviceCreateInfo.ppEnabledExtensionNames[i]; *p != '\0'; ++p )
4536 {
4537 VULKAN_HPP_HASH_COMBINE( seed, *p );
4538 }
4539 }
4540 VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.pEnabledFeatures );
4541 return seed;
4542 }
4543 };
4544
4545 template <>
4546 struct hash<VULKAN_HPP_NAMESPACE::DeviceDeviceMemoryReportCreateInfoEXT>
4547 {
4548 std::size_t
4549 operator()( VULKAN_HPP_NAMESPACE::DeviceDeviceMemoryReportCreateInfoEXT const & deviceDeviceMemoryReportCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
4550 {
4551 std::size_t seed = 0;
4552 VULKAN_HPP_HASH_COMBINE( seed, deviceDeviceMemoryReportCreateInfoEXT.sType );
4553 VULKAN_HPP_HASH_COMBINE( seed, deviceDeviceMemoryReportCreateInfoEXT.pNext );
4554 VULKAN_HPP_HASH_COMBINE( seed, deviceDeviceMemoryReportCreateInfoEXT.flags );
4555 VULKAN_HPP_HASH_COMBINE( seed, deviceDeviceMemoryReportCreateInfoEXT.pfnUserCallback );
4556 VULKAN_HPP_HASH_COMBINE( seed, deviceDeviceMemoryReportCreateInfoEXT.pUserData );
4557 return seed;
4558 }
4559 };
4560
4561 template <>
4562 struct hash<VULKAN_HPP_NAMESPACE::DeviceDiagnosticsConfigCreateInfoNV>
4563 {
4564 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceDiagnosticsConfigCreateInfoNV const & deviceDiagnosticsConfigCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
4565 {
4566 std::size_t seed = 0;
4567 VULKAN_HPP_HASH_COMBINE( seed, deviceDiagnosticsConfigCreateInfoNV.sType );
4568 VULKAN_HPP_HASH_COMBINE( seed, deviceDiagnosticsConfigCreateInfoNV.pNext );
4569 VULKAN_HPP_HASH_COMBINE( seed, deviceDiagnosticsConfigCreateInfoNV.flags );
4570 return seed;
4571 }
4572 };
4573
4574 template <>
4575 struct hash<VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT>
4576 {
4577 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT const & deviceEventInfoEXT ) const VULKAN_HPP_NOEXCEPT
4578 {
4579 std::size_t seed = 0;
4580 VULKAN_HPP_HASH_COMBINE( seed, deviceEventInfoEXT.sType );
4581 VULKAN_HPP_HASH_COMBINE( seed, deviceEventInfoEXT.pNext );
4582 VULKAN_HPP_HASH_COMBINE( seed, deviceEventInfoEXT.deviceEvent );
4583 return seed;
4584 }
4585 };
4586
4587 template <>
4588 struct hash<VULKAN_HPP_NAMESPACE::DeviceFaultAddressInfoEXT>
4589 {
4590 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceFaultAddressInfoEXT const & deviceFaultAddressInfoEXT ) const VULKAN_HPP_NOEXCEPT
4591 {
4592 std::size_t seed = 0;
4593 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultAddressInfoEXT.addressType );
4594 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultAddressInfoEXT.reportedAddress );
4595 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultAddressInfoEXT.addressPrecision );
4596 return seed;
4597 }
4598 };
4599
4600 template <>
4601 struct hash<VULKAN_HPP_NAMESPACE::DeviceFaultCountsEXT>
4602 {
4603 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceFaultCountsEXT const & deviceFaultCountsEXT ) const VULKAN_HPP_NOEXCEPT
4604 {
4605 std::size_t seed = 0;
4606 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultCountsEXT.sType );
4607 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultCountsEXT.pNext );
4608 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultCountsEXT.addressInfoCount );
4609 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultCountsEXT.vendorInfoCount );
4610 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultCountsEXT.vendorBinarySize );
4611 return seed;
4612 }
4613 };
4614
4615 template <>
4616 struct hash<VULKAN_HPP_NAMESPACE::DeviceFaultVendorInfoEXT>
4617 {
4618 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceFaultVendorInfoEXT const & deviceFaultVendorInfoEXT ) const VULKAN_HPP_NOEXCEPT
4619 {
4620 std::size_t seed = 0;
4621 for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i )
4622 {
4623 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorInfoEXT.description[i] );
4624 }
4625 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorInfoEXT.vendorFaultCode );
4626 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorInfoEXT.vendorFaultData );
4627 return seed;
4628 }
4629 };
4630
4631 template <>
4632 struct hash<VULKAN_HPP_NAMESPACE::DeviceFaultInfoEXT>
4633 {
4634 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceFaultInfoEXT const & deviceFaultInfoEXT ) const VULKAN_HPP_NOEXCEPT
4635 {
4636 std::size_t seed = 0;
4637 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultInfoEXT.sType );
4638 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultInfoEXT.pNext );
4639 for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i )
4640 {
4641 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultInfoEXT.description[i] );
4642 }
4643 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultInfoEXT.pAddressInfos );
4644 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultInfoEXT.pVendorInfos );
4645 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultInfoEXT.pVendorBinaryData );
4646 return seed;
4647 }
4648 };
4649
4650 template <>
4651 struct hash<VULKAN_HPP_NAMESPACE::DeviceFaultVendorBinaryHeaderVersionOneEXT>
4652 {
4653 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceFaultVendorBinaryHeaderVersionOneEXT const & deviceFaultVendorBinaryHeaderVersionOneEXT ) const
4654 VULKAN_HPP_NOEXCEPT
4655 {
4656 std::size_t seed = 0;
4657 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.headerSize );
4658 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.headerVersion );
4659 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.vendorID );
4660 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.deviceID );
4661 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.driverVersion );
4662 for ( size_t i = 0; i < VK_UUID_SIZE; ++i )
4663 {
4664 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.pipelineCacheUUID[i] );
4665 }
4666 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.applicationNameOffset );
4667 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.applicationVersion );
4668 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.engineNameOffset );
4669 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.engineVersion );
4670 VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.apiVersion );
4671 return seed;
4672 }
4673 };
4674
4675 template <>
4676 struct hash<VULKAN_HPP_NAMESPACE::DeviceGroupBindSparseInfo>
4677 {
4678 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupBindSparseInfo const & deviceGroupBindSparseInfo ) const VULKAN_HPP_NOEXCEPT
4679 {
4680 std::size_t seed = 0;
4681 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupBindSparseInfo.sType );
4682 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupBindSparseInfo.pNext );
4683 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupBindSparseInfo.resourceDeviceIndex );
4684 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupBindSparseInfo.memoryDeviceIndex );
4685 return seed;
4686 }
4687 };
4688
4689 template <>
4690 struct hash<VULKAN_HPP_NAMESPACE::DeviceGroupCommandBufferBeginInfo>
4691 {
4692 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupCommandBufferBeginInfo const & deviceGroupCommandBufferBeginInfo ) const VULKAN_HPP_NOEXCEPT
4693 {
4694 std::size_t seed = 0;
4695 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupCommandBufferBeginInfo.sType );
4696 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupCommandBufferBeginInfo.pNext );
4697 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupCommandBufferBeginInfo.deviceMask );
4698 return seed;
4699 }
4700 };
4701
4702 template <>
4703 struct hash<VULKAN_HPP_NAMESPACE::DeviceGroupDeviceCreateInfo>
4704 {
4705 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupDeviceCreateInfo const & deviceGroupDeviceCreateInfo ) const VULKAN_HPP_NOEXCEPT
4706 {
4707 std::size_t seed = 0;
4708 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupDeviceCreateInfo.sType );
4709 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupDeviceCreateInfo.pNext );
4710 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupDeviceCreateInfo.physicalDeviceCount );
4711 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupDeviceCreateInfo.pPhysicalDevices );
4712 return seed;
4713 }
4714 };
4715
4716 template <>
4717 struct hash<VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR>
4718 {
4719 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR const & deviceGroupPresentCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT
4720 {
4721 std::size_t seed = 0;
4722 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupPresentCapabilitiesKHR.sType );
4723 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupPresentCapabilitiesKHR.pNext );
4724 for ( size_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; ++i )
4725 {
4726 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupPresentCapabilitiesKHR.presentMask[i] );
4727 }
4728 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupPresentCapabilitiesKHR.modes );
4729 return seed;
4730 }
4731 };
4732
4733 template <>
4734 struct hash<VULKAN_HPP_NAMESPACE::DeviceGroupPresentInfoKHR>
4735 {
4736 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupPresentInfoKHR const & deviceGroupPresentInfoKHR ) const VULKAN_HPP_NOEXCEPT
4737 {
4738 std::size_t seed = 0;
4739 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupPresentInfoKHR.sType );
4740 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupPresentInfoKHR.pNext );
4741 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupPresentInfoKHR.swapchainCount );
4742 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupPresentInfoKHR.pDeviceMasks );
4743 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupPresentInfoKHR.mode );
4744 return seed;
4745 }
4746 };
4747
4748 template <>
4749 struct hash<VULKAN_HPP_NAMESPACE::DeviceGroupRenderPassBeginInfo>
4750 {
4751 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupRenderPassBeginInfo const & deviceGroupRenderPassBeginInfo ) const VULKAN_HPP_NOEXCEPT
4752 {
4753 std::size_t seed = 0;
4754 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupRenderPassBeginInfo.sType );
4755 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupRenderPassBeginInfo.pNext );
4756 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupRenderPassBeginInfo.deviceMask );
4757 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupRenderPassBeginInfo.deviceRenderAreaCount );
4758 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupRenderPassBeginInfo.pDeviceRenderAreas );
4759 return seed;
4760 }
4761 };
4762
4763 template <>
4764 struct hash<VULKAN_HPP_NAMESPACE::DeviceGroupSubmitInfo>
4765 {
4766 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupSubmitInfo const & deviceGroupSubmitInfo ) const VULKAN_HPP_NOEXCEPT
4767 {
4768 std::size_t seed = 0;
4769 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSubmitInfo.sType );
4770 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSubmitInfo.pNext );
4771 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSubmitInfo.waitSemaphoreCount );
4772 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSubmitInfo.pWaitSemaphoreDeviceIndices );
4773 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSubmitInfo.commandBufferCount );
4774 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSubmitInfo.pCommandBufferDeviceMasks );
4775 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSubmitInfo.signalSemaphoreCount );
4776 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSubmitInfo.pSignalSemaphoreDeviceIndices );
4777 return seed;
4778 }
4779 };
4780
4781 template <>
4782 struct hash<VULKAN_HPP_NAMESPACE::DeviceGroupSwapchainCreateInfoKHR>
4783 {
4784 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupSwapchainCreateInfoKHR const & deviceGroupSwapchainCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
4785 {
4786 std::size_t seed = 0;
4787 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSwapchainCreateInfoKHR.sType );
4788 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSwapchainCreateInfoKHR.pNext );
4789 VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSwapchainCreateInfoKHR.modes );
4790 return seed;
4791 }
4792 };
4793
4794 template <>
4795 struct hash<VULKAN_HPP_NAMESPACE::ImageCreateInfo>
4796 {
4797 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageCreateInfo const & imageCreateInfo ) const VULKAN_HPP_NOEXCEPT
4798 {
4799 std::size_t seed = 0;
4800 VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.sType );
4801 VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.pNext );
4802 VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.flags );
4803 VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.imageType );
4804 VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.format );
4805 VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.extent );
4806 VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.mipLevels );
4807 VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.arrayLayers );
4808 VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.samples );
4809 VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.tiling );
4810 VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.usage );
4811 VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.sharingMode );
4812 VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.queueFamilyIndexCount );
4813 VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.pQueueFamilyIndices );
4814 VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.initialLayout );
4815 return seed;
4816 }
4817 };
4818
4819 template <>
4820 struct hash<VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements>
4821 {
4822 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements const & deviceImageMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
4823 {
4824 std::size_t seed = 0;
4825 VULKAN_HPP_HASH_COMBINE( seed, deviceImageMemoryRequirements.sType );
4826 VULKAN_HPP_HASH_COMBINE( seed, deviceImageMemoryRequirements.pNext );
4827 VULKAN_HPP_HASH_COMBINE( seed, deviceImageMemoryRequirements.pCreateInfo );
4828 VULKAN_HPP_HASH_COMBINE( seed, deviceImageMemoryRequirements.planeAspect );
4829 return seed;
4830 }
4831 };
4832
4833 template <>
4834 struct hash<VULKAN_HPP_NAMESPACE::ImageSubresource2>
4835 {
4836 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageSubresource2 const & imageSubresource2 ) const VULKAN_HPP_NOEXCEPT
4837 {
4838 std::size_t seed = 0;
4839 VULKAN_HPP_HASH_COMBINE( seed, imageSubresource2.sType );
4840 VULKAN_HPP_HASH_COMBINE( seed, imageSubresource2.pNext );
4841 VULKAN_HPP_HASH_COMBINE( seed, imageSubresource2.imageSubresource );
4842 return seed;
4843 }
4844 };
4845
4846 template <>
4847 struct hash<VULKAN_HPP_NAMESPACE::DeviceImageSubresourceInfo>
4848 {
4849 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceImageSubresourceInfo const & deviceImageSubresourceInfo ) const VULKAN_HPP_NOEXCEPT
4850 {
4851 std::size_t seed = 0;
4852 VULKAN_HPP_HASH_COMBINE( seed, deviceImageSubresourceInfo.sType );
4853 VULKAN_HPP_HASH_COMBINE( seed, deviceImageSubresourceInfo.pNext );
4854 VULKAN_HPP_HASH_COMBINE( seed, deviceImageSubresourceInfo.pCreateInfo );
4855 VULKAN_HPP_HASH_COMBINE( seed, deviceImageSubresourceInfo.pSubresource );
4856 return seed;
4857 }
4858 };
4859
4860 template <>
4861 struct hash<VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo>
4862 {
4863 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo const & deviceMemoryOpaqueCaptureAddressInfo ) const VULKAN_HPP_NOEXCEPT
4864 {
4865 std::size_t seed = 0;
4866 VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryOpaqueCaptureAddressInfo.sType );
4867 VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryOpaqueCaptureAddressInfo.pNext );
4868 VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryOpaqueCaptureAddressInfo.memory );
4869 return seed;
4870 }
4871 };
4872
4873 template <>
4874 struct hash<VULKAN_HPP_NAMESPACE::DeviceMemoryOverallocationCreateInfoAMD>
4875 {
4876 std::size_t
4877 operator()( VULKAN_HPP_NAMESPACE::DeviceMemoryOverallocationCreateInfoAMD const & deviceMemoryOverallocationCreateInfoAMD ) const VULKAN_HPP_NOEXCEPT
4878 {
4879 std::size_t seed = 0;
4880 VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryOverallocationCreateInfoAMD.sType );
4881 VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryOverallocationCreateInfoAMD.pNext );
4882 VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryOverallocationCreateInfoAMD.overallocationBehavior );
4883 return seed;
4884 }
4885 };
4886
4887 template <>
4888 struct hash<VULKAN_HPP_NAMESPACE::DeviceMemoryReportCallbackDataEXT>
4889 {
4890 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceMemoryReportCallbackDataEXT const & deviceMemoryReportCallbackDataEXT ) const VULKAN_HPP_NOEXCEPT
4891 {
4892 std::size_t seed = 0;
4893 VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryReportCallbackDataEXT.sType );
4894 VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryReportCallbackDataEXT.pNext );
4895 VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryReportCallbackDataEXT.flags );
4896 VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryReportCallbackDataEXT.type );
4897 VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryReportCallbackDataEXT.memoryObjectId );
4898 VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryReportCallbackDataEXT.size );
4899 VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryReportCallbackDataEXT.objectType );
4900 VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryReportCallbackDataEXT.objectHandle );
4901 VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryReportCallbackDataEXT.heapIndex );
4902 return seed;
4903 }
4904 };
4905
4906 template <>
4907 struct hash<VULKAN_HPP_NAMESPACE::DevicePipelineBinaryInternalCacheControlKHR>
4908 {
4909 std::size_t operator()( VULKAN_HPP_NAMESPACE::DevicePipelineBinaryInternalCacheControlKHR const & devicePipelineBinaryInternalCacheControlKHR ) const
4910 VULKAN_HPP_NOEXCEPT
4911 {
4912 std::size_t seed = 0;
4913 VULKAN_HPP_HASH_COMBINE( seed, devicePipelineBinaryInternalCacheControlKHR.sType );
4914 VULKAN_HPP_HASH_COMBINE( seed, devicePipelineBinaryInternalCacheControlKHR.pNext );
4915 VULKAN_HPP_HASH_COMBINE( seed, devicePipelineBinaryInternalCacheControlKHR.disableInternalCache );
4916 return seed;
4917 }
4918 };
4919
4920 template <>
4921 struct hash<VULKAN_HPP_NAMESPACE::DevicePrivateDataCreateInfo>
4922 {
4923 std::size_t operator()( VULKAN_HPP_NAMESPACE::DevicePrivateDataCreateInfo const & devicePrivateDataCreateInfo ) const VULKAN_HPP_NOEXCEPT
4924 {
4925 std::size_t seed = 0;
4926 VULKAN_HPP_HASH_COMBINE( seed, devicePrivateDataCreateInfo.sType );
4927 VULKAN_HPP_HASH_COMBINE( seed, devicePrivateDataCreateInfo.pNext );
4928 VULKAN_HPP_HASH_COMBINE( seed, devicePrivateDataCreateInfo.privateDataSlotRequestCount );
4929 return seed;
4930 }
4931 };
4932
4933 template <>
4934 struct hash<VULKAN_HPP_NAMESPACE::DeviceQueueGlobalPriorityCreateInfo>
4935 {
4936 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceQueueGlobalPriorityCreateInfo const & deviceQueueGlobalPriorityCreateInfo ) const VULKAN_HPP_NOEXCEPT
4937 {
4938 std::size_t seed = 0;
4939 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueGlobalPriorityCreateInfo.sType );
4940 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueGlobalPriorityCreateInfo.pNext );
4941 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueGlobalPriorityCreateInfo.globalPriority );
4942 return seed;
4943 }
4944 };
4945
4946 template <>
4947 struct hash<VULKAN_HPP_NAMESPACE::DeviceQueueInfo2>
4948 {
4949 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceQueueInfo2 const & deviceQueueInfo2 ) const VULKAN_HPP_NOEXCEPT
4950 {
4951 std::size_t seed = 0;
4952 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueInfo2.sType );
4953 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueInfo2.pNext );
4954 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueInfo2.flags );
4955 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueInfo2.queueFamilyIndex );
4956 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueInfo2.queueIndex );
4957 return seed;
4958 }
4959 };
4960
4961 template <>
4962 struct hash<VULKAN_HPP_NAMESPACE::DeviceQueueShaderCoreControlCreateInfoARM>
4963 {
4964 std::size_t
4965 operator()( VULKAN_HPP_NAMESPACE::DeviceQueueShaderCoreControlCreateInfoARM const & deviceQueueShaderCoreControlCreateInfoARM ) const VULKAN_HPP_NOEXCEPT
4966 {
4967 std::size_t seed = 0;
4968 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueShaderCoreControlCreateInfoARM.sType );
4969 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueShaderCoreControlCreateInfoARM.pNext );
4970 VULKAN_HPP_HASH_COMBINE( seed, deviceQueueShaderCoreControlCreateInfoARM.shaderCoreCount );
4971 return seed;
4972 }
4973 };
4974
4975 template <>
4976 struct hash<VULKAN_HPP_NAMESPACE::TensorDescriptionARM>
4977 {
4978 std::size_t operator()( VULKAN_HPP_NAMESPACE::TensorDescriptionARM const & tensorDescriptionARM ) const VULKAN_HPP_NOEXCEPT
4979 {
4980 std::size_t seed = 0;
4981 VULKAN_HPP_HASH_COMBINE( seed, tensorDescriptionARM.sType );
4982 VULKAN_HPP_HASH_COMBINE( seed, tensorDescriptionARM.pNext );
4983 VULKAN_HPP_HASH_COMBINE( seed, tensorDescriptionARM.tiling );
4984 VULKAN_HPP_HASH_COMBINE( seed, tensorDescriptionARM.format );
4985 VULKAN_HPP_HASH_COMBINE( seed, tensorDescriptionARM.dimensionCount );
4986 VULKAN_HPP_HASH_COMBINE( seed, tensorDescriptionARM.pDimensions );
4987 VULKAN_HPP_HASH_COMBINE( seed, tensorDescriptionARM.pStrides );
4988 VULKAN_HPP_HASH_COMBINE( seed, tensorDescriptionARM.usage );
4989 return seed;
4990 }
4991 };
4992
4993 template <>
4994 struct hash<VULKAN_HPP_NAMESPACE::TensorCreateInfoARM>
4995 {
4996 std::size_t operator()( VULKAN_HPP_NAMESPACE::TensorCreateInfoARM const & tensorCreateInfoARM ) const VULKAN_HPP_NOEXCEPT
4997 {
4998 std::size_t seed = 0;
4999 VULKAN_HPP_HASH_COMBINE( seed, tensorCreateInfoARM.sType );
5000 VULKAN_HPP_HASH_COMBINE( seed, tensorCreateInfoARM.pNext );
5001 VULKAN_HPP_HASH_COMBINE( seed, tensorCreateInfoARM.flags );
5002 VULKAN_HPP_HASH_COMBINE( seed, tensorCreateInfoARM.pDescription );
5003 VULKAN_HPP_HASH_COMBINE( seed, tensorCreateInfoARM.sharingMode );
5004 VULKAN_HPP_HASH_COMBINE( seed, tensorCreateInfoARM.queueFamilyIndexCount );
5005 VULKAN_HPP_HASH_COMBINE( seed, tensorCreateInfoARM.pQueueFamilyIndices );
5006 return seed;
5007 }
5008 };
5009
5010 template <>
5011 struct hash<VULKAN_HPP_NAMESPACE::DeviceTensorMemoryRequirementsARM>
5012 {
5013 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceTensorMemoryRequirementsARM const & deviceTensorMemoryRequirementsARM ) const VULKAN_HPP_NOEXCEPT
5014 {
5015 std::size_t seed = 0;
5016 VULKAN_HPP_HASH_COMBINE( seed, deviceTensorMemoryRequirementsARM.sType );
5017 VULKAN_HPP_HASH_COMBINE( seed, deviceTensorMemoryRequirementsARM.pNext );
5018 VULKAN_HPP_HASH_COMBINE( seed, deviceTensorMemoryRequirementsARM.pCreateInfo );
5019 return seed;
5020 }
5021 };
5022
5023 template <>
5024 struct hash<VULKAN_HPP_NAMESPACE::DirectDriverLoadingInfoLUNARG>
5025 {
5026 std::size_t operator()( VULKAN_HPP_NAMESPACE::DirectDriverLoadingInfoLUNARG const & directDriverLoadingInfoLUNARG ) const VULKAN_HPP_NOEXCEPT
5027 {
5028 std::size_t seed = 0;
5029 VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingInfoLUNARG.sType );
5030 VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingInfoLUNARG.pNext );
5031 VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingInfoLUNARG.flags );
5032 VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingInfoLUNARG.pfnGetInstanceProcAddr );
5033 return seed;
5034 }
5035 };
5036
5037 template <>
5038 struct hash<VULKAN_HPP_NAMESPACE::DirectDriverLoadingListLUNARG>
5039 {
5040 std::size_t operator()( VULKAN_HPP_NAMESPACE::DirectDriverLoadingListLUNARG const & directDriverLoadingListLUNARG ) const VULKAN_HPP_NOEXCEPT
5041 {
5042 std::size_t seed = 0;
5043 VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingListLUNARG.sType );
5044 VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingListLUNARG.pNext );
5045 VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingListLUNARG.mode );
5046 VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingListLUNARG.driverCount );
5047 VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingListLUNARG.pDrivers );
5048 return seed;
5049 }
5050 };
5051
5052 # if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
5053 template <>
5054 struct hash<VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT>
5055 {
5056 std::size_t operator()( VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT const & directFBSurfaceCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
5057 {
5058 std::size_t seed = 0;
5059 VULKAN_HPP_HASH_COMBINE( seed, directFBSurfaceCreateInfoEXT.sType );
5060 VULKAN_HPP_HASH_COMBINE( seed, directFBSurfaceCreateInfoEXT.pNext );
5061 VULKAN_HPP_HASH_COMBINE( seed, directFBSurfaceCreateInfoEXT.flags );
5062 VULKAN_HPP_HASH_COMBINE( seed, directFBSurfaceCreateInfoEXT.dfb );
5063 VULKAN_HPP_HASH_COMBINE( seed, directFBSurfaceCreateInfoEXT.surface );
5064 return seed;
5065 }
5066 };
5067 # endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
5068
5069 template <>
5070 struct hash<VULKAN_HPP_NAMESPACE::DispatchIndirectCommand>
5071 {
5072 std::size_t operator()( VULKAN_HPP_NAMESPACE::DispatchIndirectCommand const & dispatchIndirectCommand ) const VULKAN_HPP_NOEXCEPT
5073 {
5074 std::size_t seed = 0;
5075 VULKAN_HPP_HASH_COMBINE( seed, dispatchIndirectCommand.x );
5076 VULKAN_HPP_HASH_COMBINE( seed, dispatchIndirectCommand.y );
5077 VULKAN_HPP_HASH_COMBINE( seed, dispatchIndirectCommand.z );
5078 return seed;
5079 }
5080 };
5081
5082 template <>
5083 struct hash<VULKAN_HPP_NAMESPACE::DispatchTileInfoQCOM>
5084 {
5085 std::size_t operator()( VULKAN_HPP_NAMESPACE::DispatchTileInfoQCOM const & dispatchTileInfoQCOM ) const VULKAN_HPP_NOEXCEPT
5086 {
5087 std::size_t seed = 0;
5088 VULKAN_HPP_HASH_COMBINE( seed, dispatchTileInfoQCOM.sType );
5089 VULKAN_HPP_HASH_COMBINE( seed, dispatchTileInfoQCOM.pNext );
5090 return seed;
5091 }
5092 };
5093
5094 template <>
5095 struct hash<VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT>
5096 {
5097 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT const & displayEventInfoEXT ) const VULKAN_HPP_NOEXCEPT
5098 {
5099 std::size_t seed = 0;
5100 VULKAN_HPP_HASH_COMBINE( seed, displayEventInfoEXT.sType );
5101 VULKAN_HPP_HASH_COMBINE( seed, displayEventInfoEXT.pNext );
5102 VULKAN_HPP_HASH_COMBINE( seed, displayEventInfoEXT.displayEvent );
5103 return seed;
5104 }
5105 };
5106
5107 template <>
5108 struct hash<VULKAN_HPP_NAMESPACE::DisplayModeParametersKHR>
5109 {
5110 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayModeParametersKHR const & displayModeParametersKHR ) const VULKAN_HPP_NOEXCEPT
5111 {
5112 std::size_t seed = 0;
5113 VULKAN_HPP_HASH_COMBINE( seed, displayModeParametersKHR.visibleRegion );
5114 VULKAN_HPP_HASH_COMBINE( seed, displayModeParametersKHR.refreshRate );
5115 return seed;
5116 }
5117 };
5118
5119 template <>
5120 struct hash<VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR>
5121 {
5122 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR const & displayModeCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
5123 {
5124 std::size_t seed = 0;
5125 VULKAN_HPP_HASH_COMBINE( seed, displayModeCreateInfoKHR.sType );
5126 VULKAN_HPP_HASH_COMBINE( seed, displayModeCreateInfoKHR.pNext );
5127 VULKAN_HPP_HASH_COMBINE( seed, displayModeCreateInfoKHR.flags );
5128 VULKAN_HPP_HASH_COMBINE( seed, displayModeCreateInfoKHR.parameters );
5129 return seed;
5130 }
5131 };
5132
5133 template <>
5134 struct hash<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR>
5135 {
5136 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR const & displayModePropertiesKHR ) const VULKAN_HPP_NOEXCEPT
5137 {
5138 std::size_t seed = 0;
5139 VULKAN_HPP_HASH_COMBINE( seed, displayModePropertiesKHR.displayMode );
5140 VULKAN_HPP_HASH_COMBINE( seed, displayModePropertiesKHR.parameters );
5141 return seed;
5142 }
5143 };
5144
5145 template <>
5146 struct hash<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR>
5147 {
5148 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR const & displayModeProperties2KHR ) const VULKAN_HPP_NOEXCEPT
5149 {
5150 std::size_t seed = 0;
5151 VULKAN_HPP_HASH_COMBINE( seed, displayModeProperties2KHR.sType );
5152 VULKAN_HPP_HASH_COMBINE( seed, displayModeProperties2KHR.pNext );
5153 VULKAN_HPP_HASH_COMBINE( seed, displayModeProperties2KHR.displayModeProperties );
5154 return seed;
5155 }
5156 };
5157
5158 template <>
5159 struct hash<VULKAN_HPP_NAMESPACE::DisplayModeStereoPropertiesNV>
5160 {
5161 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayModeStereoPropertiesNV const & displayModeStereoPropertiesNV ) const VULKAN_HPP_NOEXCEPT
5162 {
5163 std::size_t seed = 0;
5164 VULKAN_HPP_HASH_COMBINE( seed, displayModeStereoPropertiesNV.sType );
5165 VULKAN_HPP_HASH_COMBINE( seed, displayModeStereoPropertiesNV.pNext );
5166 VULKAN_HPP_HASH_COMBINE( seed, displayModeStereoPropertiesNV.hdmi3DSupported );
5167 return seed;
5168 }
5169 };
5170
5171 template <>
5172 struct hash<VULKAN_HPP_NAMESPACE::DisplayNativeHdrSurfaceCapabilitiesAMD>
5173 {
5174 std::size_t
5175 operator()( VULKAN_HPP_NAMESPACE::DisplayNativeHdrSurfaceCapabilitiesAMD const & displayNativeHdrSurfaceCapabilitiesAMD ) const VULKAN_HPP_NOEXCEPT
5176 {
5177 std::size_t seed = 0;
5178 VULKAN_HPP_HASH_COMBINE( seed, displayNativeHdrSurfaceCapabilitiesAMD.sType );
5179 VULKAN_HPP_HASH_COMBINE( seed, displayNativeHdrSurfaceCapabilitiesAMD.pNext );
5180 VULKAN_HPP_HASH_COMBINE( seed, displayNativeHdrSurfaceCapabilitiesAMD.localDimmingSupport );
5181 return seed;
5182 }
5183 };
5184
5185 template <>
5186 struct hash<VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR>
5187 {
5188 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR const & displayPlaneCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT
5189 {
5190 std::size_t seed = 0;
5191 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilitiesKHR.supportedAlpha );
5192 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilitiesKHR.minSrcPosition );
5193 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilitiesKHR.maxSrcPosition );
5194 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilitiesKHR.minSrcExtent );
5195 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilitiesKHR.maxSrcExtent );
5196 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilitiesKHR.minDstPosition );
5197 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilitiesKHR.maxDstPosition );
5198 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilitiesKHR.minDstExtent );
5199 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilitiesKHR.maxDstExtent );
5200 return seed;
5201 }
5202 };
5203
5204 template <>
5205 struct hash<VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR>
5206 {
5207 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR const & displayPlaneCapabilities2KHR ) const VULKAN_HPP_NOEXCEPT
5208 {
5209 std::size_t seed = 0;
5210 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilities2KHR.sType );
5211 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilities2KHR.pNext );
5212 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilities2KHR.capabilities );
5213 return seed;
5214 }
5215 };
5216
5217 template <>
5218 struct hash<VULKAN_HPP_NAMESPACE::DisplayPlaneInfo2KHR>
5219 {
5220 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPlaneInfo2KHR const & displayPlaneInfo2KHR ) const VULKAN_HPP_NOEXCEPT
5221 {
5222 std::size_t seed = 0;
5223 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneInfo2KHR.sType );
5224 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneInfo2KHR.pNext );
5225 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneInfo2KHR.mode );
5226 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneInfo2KHR.planeIndex );
5227 return seed;
5228 }
5229 };
5230
5231 template <>
5232 struct hash<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR>
5233 {
5234 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR const & displayPlanePropertiesKHR ) const VULKAN_HPP_NOEXCEPT
5235 {
5236 std::size_t seed = 0;
5237 VULKAN_HPP_HASH_COMBINE( seed, displayPlanePropertiesKHR.currentDisplay );
5238 VULKAN_HPP_HASH_COMBINE( seed, displayPlanePropertiesKHR.currentStackIndex );
5239 return seed;
5240 }
5241 };
5242
5243 template <>
5244 struct hash<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR>
5245 {
5246 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR const & displayPlaneProperties2KHR ) const VULKAN_HPP_NOEXCEPT
5247 {
5248 std::size_t seed = 0;
5249 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneProperties2KHR.sType );
5250 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneProperties2KHR.pNext );
5251 VULKAN_HPP_HASH_COMBINE( seed, displayPlaneProperties2KHR.displayPlaneProperties );
5252 return seed;
5253 }
5254 };
5255
5256 template <>
5257 struct hash<VULKAN_HPP_NAMESPACE::DisplayPowerInfoEXT>
5258 {
5259 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPowerInfoEXT const & displayPowerInfoEXT ) const VULKAN_HPP_NOEXCEPT
5260 {
5261 std::size_t seed = 0;
5262 VULKAN_HPP_HASH_COMBINE( seed, displayPowerInfoEXT.sType );
5263 VULKAN_HPP_HASH_COMBINE( seed, displayPowerInfoEXT.pNext );
5264 VULKAN_HPP_HASH_COMBINE( seed, displayPowerInfoEXT.powerState );
5265 return seed;
5266 }
5267 };
5268
5269 template <>
5270 struct hash<VULKAN_HPP_NAMESPACE::DisplayPresentInfoKHR>
5271 {
5272 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPresentInfoKHR const & displayPresentInfoKHR ) const VULKAN_HPP_NOEXCEPT
5273 {
5274 std::size_t seed = 0;
5275 VULKAN_HPP_HASH_COMBINE( seed, displayPresentInfoKHR.sType );
5276 VULKAN_HPP_HASH_COMBINE( seed, displayPresentInfoKHR.pNext );
5277 VULKAN_HPP_HASH_COMBINE( seed, displayPresentInfoKHR.srcRect );
5278 VULKAN_HPP_HASH_COMBINE( seed, displayPresentInfoKHR.dstRect );
5279 VULKAN_HPP_HASH_COMBINE( seed, displayPresentInfoKHR.persistent );
5280 return seed;
5281 }
5282 };
5283
5284 template <>
5285 struct hash<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR>
5286 {
5287 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR const & displayPropertiesKHR ) const VULKAN_HPP_NOEXCEPT
5288 {
5289 std::size_t seed = 0;
5290 VULKAN_HPP_HASH_COMBINE( seed, displayPropertiesKHR.display );
5291 for ( const char * p = displayPropertiesKHR.displayName; *p != '\0'; ++p )
5292 {
5293 VULKAN_HPP_HASH_COMBINE( seed, *p );
5294 }
5295 VULKAN_HPP_HASH_COMBINE( seed, displayPropertiesKHR.physicalDimensions );
5296 VULKAN_HPP_HASH_COMBINE( seed, displayPropertiesKHR.physicalResolution );
5297 VULKAN_HPP_HASH_COMBINE( seed, displayPropertiesKHR.supportedTransforms );
5298 VULKAN_HPP_HASH_COMBINE( seed, displayPropertiesKHR.planeReorderPossible );
5299 VULKAN_HPP_HASH_COMBINE( seed, displayPropertiesKHR.persistentContent );
5300 return seed;
5301 }
5302 };
5303
5304 template <>
5305 struct hash<VULKAN_HPP_NAMESPACE::DisplayProperties2KHR>
5306 {
5307 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayProperties2KHR const & displayProperties2KHR ) const VULKAN_HPP_NOEXCEPT
5308 {
5309 std::size_t seed = 0;
5310 VULKAN_HPP_HASH_COMBINE( seed, displayProperties2KHR.sType );
5311 VULKAN_HPP_HASH_COMBINE( seed, displayProperties2KHR.pNext );
5312 VULKAN_HPP_HASH_COMBINE( seed, displayProperties2KHR.displayProperties );
5313 return seed;
5314 }
5315 };
5316
5317 template <>
5318 struct hash<VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR>
5319 {
5320 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR const & displaySurfaceCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
5321 {
5322 std::size_t seed = 0;
5323 VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.sType );
5324 VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.pNext );
5325 VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.flags );
5326 VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.displayMode );
5327 VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.planeIndex );
5328 VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.planeStackIndex );
5329 VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.transform );
5330 VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.globalAlpha );
5331 VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.alphaMode );
5332 VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.imageExtent );
5333 return seed;
5334 }
5335 };
5336
5337 template <>
5338 struct hash<VULKAN_HPP_NAMESPACE::DisplaySurfaceStereoCreateInfoNV>
5339 {
5340 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplaySurfaceStereoCreateInfoNV const & displaySurfaceStereoCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
5341 {
5342 std::size_t seed = 0;
5343 VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceStereoCreateInfoNV.sType );
5344 VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceStereoCreateInfoNV.pNext );
5345 VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceStereoCreateInfoNV.stereoType );
5346 return seed;
5347 }
5348 };
5349
5350 template <>
5351 struct hash<VULKAN_HPP_NAMESPACE::DrawIndexedIndirectCommand>
5352 {
5353 std::size_t operator()( VULKAN_HPP_NAMESPACE::DrawIndexedIndirectCommand const & drawIndexedIndirectCommand ) const VULKAN_HPP_NOEXCEPT
5354 {
5355 std::size_t seed = 0;
5356 VULKAN_HPP_HASH_COMBINE( seed, drawIndexedIndirectCommand.indexCount );
5357 VULKAN_HPP_HASH_COMBINE( seed, drawIndexedIndirectCommand.instanceCount );
5358 VULKAN_HPP_HASH_COMBINE( seed, drawIndexedIndirectCommand.firstIndex );
5359 VULKAN_HPP_HASH_COMBINE( seed, drawIndexedIndirectCommand.vertexOffset );
5360 VULKAN_HPP_HASH_COMBINE( seed, drawIndexedIndirectCommand.firstInstance );
5361 return seed;
5362 }
5363 };
5364
5365 template <>
5366 struct hash<VULKAN_HPP_NAMESPACE::DrawIndirectCommand>
5367 {
5368 std::size_t operator()( VULKAN_HPP_NAMESPACE::DrawIndirectCommand const & drawIndirectCommand ) const VULKAN_HPP_NOEXCEPT
5369 {
5370 std::size_t seed = 0;
5371 VULKAN_HPP_HASH_COMBINE( seed, drawIndirectCommand.vertexCount );
5372 VULKAN_HPP_HASH_COMBINE( seed, drawIndirectCommand.instanceCount );
5373 VULKAN_HPP_HASH_COMBINE( seed, drawIndirectCommand.firstVertex );
5374 VULKAN_HPP_HASH_COMBINE( seed, drawIndirectCommand.firstInstance );
5375 return seed;
5376 }
5377 };
5378
5379 template <>
5380 struct hash<VULKAN_HPP_NAMESPACE::DrawIndirectCountIndirectCommandEXT>
5381 {
5382 std::size_t operator()( VULKAN_HPP_NAMESPACE::DrawIndirectCountIndirectCommandEXT const & drawIndirectCountIndirectCommandEXT ) const VULKAN_HPP_NOEXCEPT
5383 {
5384 std::size_t seed = 0;
5385 VULKAN_HPP_HASH_COMBINE( seed, drawIndirectCountIndirectCommandEXT.bufferAddress );
5386 VULKAN_HPP_HASH_COMBINE( seed, drawIndirectCountIndirectCommandEXT.stride );
5387 VULKAN_HPP_HASH_COMBINE( seed, drawIndirectCountIndirectCommandEXT.commandCount );
5388 return seed;
5389 }
5390 };
5391
5392 template <>
5393 struct hash<VULKAN_HPP_NAMESPACE::DrawMeshTasksIndirectCommandEXT>
5394 {
5395 std::size_t operator()( VULKAN_HPP_NAMESPACE::DrawMeshTasksIndirectCommandEXT const & drawMeshTasksIndirectCommandEXT ) const VULKAN_HPP_NOEXCEPT
5396 {
5397 std::size_t seed = 0;
5398 VULKAN_HPP_HASH_COMBINE( seed, drawMeshTasksIndirectCommandEXT.groupCountX );
5399 VULKAN_HPP_HASH_COMBINE( seed, drawMeshTasksIndirectCommandEXT.groupCountY );
5400 VULKAN_HPP_HASH_COMBINE( seed, drawMeshTasksIndirectCommandEXT.groupCountZ );
5401 return seed;
5402 }
5403 };
5404
5405 template <>
5406 struct hash<VULKAN_HPP_NAMESPACE::DrawMeshTasksIndirectCommandNV>
5407 {
5408 std::size_t operator()( VULKAN_HPP_NAMESPACE::DrawMeshTasksIndirectCommandNV const & drawMeshTasksIndirectCommandNV ) const VULKAN_HPP_NOEXCEPT
5409 {
5410 std::size_t seed = 0;
5411 VULKAN_HPP_HASH_COMBINE( seed, drawMeshTasksIndirectCommandNV.taskCount );
5412 VULKAN_HPP_HASH_COMBINE( seed, drawMeshTasksIndirectCommandNV.firstTask );
5413 return seed;
5414 }
5415 };
5416
5417 template <>
5418 struct hash<VULKAN_HPP_NAMESPACE::DrmFormatModifierProperties2EXT>
5419 {
5420 std::size_t operator()( VULKAN_HPP_NAMESPACE::DrmFormatModifierProperties2EXT const & drmFormatModifierProperties2EXT ) const VULKAN_HPP_NOEXCEPT
5421 {
5422 std::size_t seed = 0;
5423 VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierProperties2EXT.drmFormatModifier );
5424 VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierProperties2EXT.drmFormatModifierPlaneCount );
5425 VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierProperties2EXT.drmFormatModifierTilingFeatures );
5426 return seed;
5427 }
5428 };
5429
5430 template <>
5431 struct hash<VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesEXT>
5432 {
5433 std::size_t operator()( VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesEXT const & drmFormatModifierPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
5434 {
5435 std::size_t seed = 0;
5436 VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesEXT.drmFormatModifier );
5437 VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesEXT.drmFormatModifierPlaneCount );
5438 VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesEXT.drmFormatModifierTilingFeatures );
5439 return seed;
5440 }
5441 };
5442
5443 template <>
5444 struct hash<VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesList2EXT>
5445 {
5446 std::size_t operator()( VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesList2EXT const & drmFormatModifierPropertiesList2EXT ) const VULKAN_HPP_NOEXCEPT
5447 {
5448 std::size_t seed = 0;
5449 VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesList2EXT.sType );
5450 VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesList2EXT.pNext );
5451 VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesList2EXT.drmFormatModifierCount );
5452 VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesList2EXT.pDrmFormatModifierProperties );
5453 return seed;
5454 }
5455 };
5456
5457 template <>
5458 struct hash<VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesListEXT>
5459 {
5460 std::size_t operator()( VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesListEXT const & drmFormatModifierPropertiesListEXT ) const VULKAN_HPP_NOEXCEPT
5461 {
5462 std::size_t seed = 0;
5463 VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesListEXT.sType );
5464 VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesListEXT.pNext );
5465 VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesListEXT.drmFormatModifierCount );
5466 VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesListEXT.pDrmFormatModifierProperties );
5467 return seed;
5468 }
5469 };
5470
5471 template <>
5472 struct hash<VULKAN_HPP_NAMESPACE::EventCreateInfo>
5473 {
5474 std::size_t operator()( VULKAN_HPP_NAMESPACE::EventCreateInfo const & eventCreateInfo ) const VULKAN_HPP_NOEXCEPT
5475 {
5476 std::size_t seed = 0;
5477 VULKAN_HPP_HASH_COMBINE( seed, eventCreateInfo.sType );
5478 VULKAN_HPP_HASH_COMBINE( seed, eventCreateInfo.pNext );
5479 VULKAN_HPP_HASH_COMBINE( seed, eventCreateInfo.flags );
5480 return seed;
5481 }
5482 };
5483
5484 template <>
5485 struct hash<VULKAN_HPP_NAMESPACE::PipelineLibraryCreateInfoKHR>
5486 {
5487 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineLibraryCreateInfoKHR const & pipelineLibraryCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
5488 {
5489 std::size_t seed = 0;
5490 VULKAN_HPP_HASH_COMBINE( seed, pipelineLibraryCreateInfoKHR.sType );
5491 VULKAN_HPP_HASH_COMBINE( seed, pipelineLibraryCreateInfoKHR.pNext );
5492 VULKAN_HPP_HASH_COMBINE( seed, pipelineLibraryCreateInfoKHR.libraryCount );
5493 VULKAN_HPP_HASH_COMBINE( seed, pipelineLibraryCreateInfoKHR.pLibraries );
5494 return seed;
5495 }
5496 };
5497
5498 # if defined( VK_ENABLE_BETA_EXTENSIONS )
5499 template <>
5500 struct hash<VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX>
5501 {
5502 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX const & executionGraphPipelineCreateInfoAMDX ) const VULKAN_HPP_NOEXCEPT
5503 {
5504 std::size_t seed = 0;
5505 VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineCreateInfoAMDX.sType );
5506 VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineCreateInfoAMDX.pNext );
5507 VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineCreateInfoAMDX.flags );
5508 VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineCreateInfoAMDX.stageCount );
5509 VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineCreateInfoAMDX.pStages );
5510 VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineCreateInfoAMDX.pLibraryInfo );
5511 VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineCreateInfoAMDX.layout );
5512 VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineCreateInfoAMDX.basePipelineHandle );
5513 VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineCreateInfoAMDX.basePipelineIndex );
5514 return seed;
5515 }
5516 };
5517 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
5518
5519 # if defined( VK_ENABLE_BETA_EXTENSIONS )
5520 template <>
5521 struct hash<VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineScratchSizeAMDX>
5522 {
5523 std::size_t
5524 operator()( VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineScratchSizeAMDX const & executionGraphPipelineScratchSizeAMDX ) const VULKAN_HPP_NOEXCEPT
5525 {
5526 std::size_t seed = 0;
5527 VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineScratchSizeAMDX.sType );
5528 VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineScratchSizeAMDX.pNext );
5529 VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineScratchSizeAMDX.minSize );
5530 VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineScratchSizeAMDX.maxSize );
5531 VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineScratchSizeAMDX.sizeGranularity );
5532 return seed;
5533 }
5534 };
5535 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
5536
5537 template <>
5538 struct hash<VULKAN_HPP_NAMESPACE::ExportFenceCreateInfo>
5539 {
5540 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportFenceCreateInfo const & exportFenceCreateInfo ) const VULKAN_HPP_NOEXCEPT
5541 {
5542 std::size_t seed = 0;
5543 VULKAN_HPP_HASH_COMBINE( seed, exportFenceCreateInfo.sType );
5544 VULKAN_HPP_HASH_COMBINE( seed, exportFenceCreateInfo.pNext );
5545 VULKAN_HPP_HASH_COMBINE( seed, exportFenceCreateInfo.handleTypes );
5546 return seed;
5547 }
5548 };
5549
5550 # if defined( VK_USE_PLATFORM_WIN32_KHR )
5551 template <>
5552 struct hash<VULKAN_HPP_NAMESPACE::ExportFenceWin32HandleInfoKHR>
5553 {
5554 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportFenceWin32HandleInfoKHR const & exportFenceWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT
5555 {
5556 std::size_t seed = 0;
5557 VULKAN_HPP_HASH_COMBINE( seed, exportFenceWin32HandleInfoKHR.sType );
5558 VULKAN_HPP_HASH_COMBINE( seed, exportFenceWin32HandleInfoKHR.pNext );
5559 VULKAN_HPP_HASH_COMBINE( seed, exportFenceWin32HandleInfoKHR.pAttributes );
5560 VULKAN_HPP_HASH_COMBINE( seed, exportFenceWin32HandleInfoKHR.dwAccess );
5561 VULKAN_HPP_HASH_COMBINE( seed, exportFenceWin32HandleInfoKHR.name );
5562 return seed;
5563 }
5564 };
5565 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
5566
5567 template <>
5568 struct hash<VULKAN_HPP_NAMESPACE::ExportMemoryAllocateInfo>
5569 {
5570 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMemoryAllocateInfo const & exportMemoryAllocateInfo ) const VULKAN_HPP_NOEXCEPT
5571 {
5572 std::size_t seed = 0;
5573 VULKAN_HPP_HASH_COMBINE( seed, exportMemoryAllocateInfo.sType );
5574 VULKAN_HPP_HASH_COMBINE( seed, exportMemoryAllocateInfo.pNext );
5575 VULKAN_HPP_HASH_COMBINE( seed, exportMemoryAllocateInfo.handleTypes );
5576 return seed;
5577 }
5578 };
5579
5580 template <>
5581 struct hash<VULKAN_HPP_NAMESPACE::ExportMemoryAllocateInfoNV>
5582 {
5583 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMemoryAllocateInfoNV const & exportMemoryAllocateInfoNV ) const VULKAN_HPP_NOEXCEPT
5584 {
5585 std::size_t seed = 0;
5586 VULKAN_HPP_HASH_COMBINE( seed, exportMemoryAllocateInfoNV.sType );
5587 VULKAN_HPP_HASH_COMBINE( seed, exportMemoryAllocateInfoNV.pNext );
5588 VULKAN_HPP_HASH_COMBINE( seed, exportMemoryAllocateInfoNV.handleTypes );
5589 return seed;
5590 }
5591 };
5592
5593 # if defined( VK_USE_PLATFORM_WIN32_KHR )
5594 template <>
5595 struct hash<VULKAN_HPP_NAMESPACE::ExportMemoryWin32HandleInfoKHR>
5596 {
5597 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMemoryWin32HandleInfoKHR const & exportMemoryWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT
5598 {
5599 std::size_t seed = 0;
5600 VULKAN_HPP_HASH_COMBINE( seed, exportMemoryWin32HandleInfoKHR.sType );
5601 VULKAN_HPP_HASH_COMBINE( seed, exportMemoryWin32HandleInfoKHR.pNext );
5602 VULKAN_HPP_HASH_COMBINE( seed, exportMemoryWin32HandleInfoKHR.pAttributes );
5603 VULKAN_HPP_HASH_COMBINE( seed, exportMemoryWin32HandleInfoKHR.dwAccess );
5604 VULKAN_HPP_HASH_COMBINE( seed, exportMemoryWin32HandleInfoKHR.name );
5605 return seed;
5606 }
5607 };
5608 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
5609
5610 # if defined( VK_USE_PLATFORM_WIN32_KHR )
5611 template <>
5612 struct hash<VULKAN_HPP_NAMESPACE::ExportMemoryWin32HandleInfoNV>
5613 {
5614 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMemoryWin32HandleInfoNV const & exportMemoryWin32HandleInfoNV ) const VULKAN_HPP_NOEXCEPT
5615 {
5616 std::size_t seed = 0;
5617 VULKAN_HPP_HASH_COMBINE( seed, exportMemoryWin32HandleInfoNV.sType );
5618 VULKAN_HPP_HASH_COMBINE( seed, exportMemoryWin32HandleInfoNV.pNext );
5619 VULKAN_HPP_HASH_COMBINE( seed, exportMemoryWin32HandleInfoNV.pAttributes );
5620 VULKAN_HPP_HASH_COMBINE( seed, exportMemoryWin32HandleInfoNV.dwAccess );
5621 return seed;
5622 }
5623 };
5624 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
5625
5626 # if defined( VK_USE_PLATFORM_METAL_EXT )
5627 template <>
5628 struct hash<VULKAN_HPP_NAMESPACE::ExportMetalBufferInfoEXT>
5629 {
5630 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMetalBufferInfoEXT const & exportMetalBufferInfoEXT ) const VULKAN_HPP_NOEXCEPT
5631 {
5632 std::size_t seed = 0;
5633 VULKAN_HPP_HASH_COMBINE( seed, exportMetalBufferInfoEXT.sType );
5634 VULKAN_HPP_HASH_COMBINE( seed, exportMetalBufferInfoEXT.pNext );
5635 VULKAN_HPP_HASH_COMBINE( seed, exportMetalBufferInfoEXT.memory );
5636 VULKAN_HPP_HASH_COMBINE( seed, exportMetalBufferInfoEXT.mtlBuffer );
5637 return seed;
5638 }
5639 };
5640 # endif /*VK_USE_PLATFORM_METAL_EXT*/
5641
5642 # if defined( VK_USE_PLATFORM_METAL_EXT )
5643 template <>
5644 struct hash<VULKAN_HPP_NAMESPACE::ExportMetalCommandQueueInfoEXT>
5645 {
5646 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMetalCommandQueueInfoEXT const & exportMetalCommandQueueInfoEXT ) const VULKAN_HPP_NOEXCEPT
5647 {
5648 std::size_t seed = 0;
5649 VULKAN_HPP_HASH_COMBINE( seed, exportMetalCommandQueueInfoEXT.sType );
5650 VULKAN_HPP_HASH_COMBINE( seed, exportMetalCommandQueueInfoEXT.pNext );
5651 VULKAN_HPP_HASH_COMBINE( seed, exportMetalCommandQueueInfoEXT.queue );
5652 VULKAN_HPP_HASH_COMBINE( seed, exportMetalCommandQueueInfoEXT.mtlCommandQueue );
5653 return seed;
5654 }
5655 };
5656 # endif /*VK_USE_PLATFORM_METAL_EXT*/
5657
5658 # if defined( VK_USE_PLATFORM_METAL_EXT )
5659 template <>
5660 struct hash<VULKAN_HPP_NAMESPACE::ExportMetalDeviceInfoEXT>
5661 {
5662 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMetalDeviceInfoEXT const & exportMetalDeviceInfoEXT ) const VULKAN_HPP_NOEXCEPT
5663 {
5664 std::size_t seed = 0;
5665 VULKAN_HPP_HASH_COMBINE( seed, exportMetalDeviceInfoEXT.sType );
5666 VULKAN_HPP_HASH_COMBINE( seed, exportMetalDeviceInfoEXT.pNext );
5667 VULKAN_HPP_HASH_COMBINE( seed, exportMetalDeviceInfoEXT.mtlDevice );
5668 return seed;
5669 }
5670 };
5671 # endif /*VK_USE_PLATFORM_METAL_EXT*/
5672
5673 # if defined( VK_USE_PLATFORM_METAL_EXT )
5674 template <>
5675 struct hash<VULKAN_HPP_NAMESPACE::ExportMetalIOSurfaceInfoEXT>
5676 {
5677 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMetalIOSurfaceInfoEXT const & exportMetalIOSurfaceInfoEXT ) const VULKAN_HPP_NOEXCEPT
5678 {
5679 std::size_t seed = 0;
5680 VULKAN_HPP_HASH_COMBINE( seed, exportMetalIOSurfaceInfoEXT.sType );
5681 VULKAN_HPP_HASH_COMBINE( seed, exportMetalIOSurfaceInfoEXT.pNext );
5682 VULKAN_HPP_HASH_COMBINE( seed, exportMetalIOSurfaceInfoEXT.image );
5683 VULKAN_HPP_HASH_COMBINE( seed, exportMetalIOSurfaceInfoEXT.ioSurface );
5684 return seed;
5685 }
5686 };
5687 # endif /*VK_USE_PLATFORM_METAL_EXT*/
5688
5689 # if defined( VK_USE_PLATFORM_METAL_EXT )
5690 template <>
5691 struct hash<VULKAN_HPP_NAMESPACE::ExportMetalObjectCreateInfoEXT>
5692 {
5693 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMetalObjectCreateInfoEXT const & exportMetalObjectCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
5694 {
5695 std::size_t seed = 0;
5696 VULKAN_HPP_HASH_COMBINE( seed, exportMetalObjectCreateInfoEXT.sType );
5697 VULKAN_HPP_HASH_COMBINE( seed, exportMetalObjectCreateInfoEXT.pNext );
5698 VULKAN_HPP_HASH_COMBINE( seed, exportMetalObjectCreateInfoEXT.exportObjectType );
5699 return seed;
5700 }
5701 };
5702 # endif /*VK_USE_PLATFORM_METAL_EXT*/
5703
5704 # if defined( VK_USE_PLATFORM_METAL_EXT )
5705 template <>
5706 struct hash<VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT>
5707 {
5708 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT const & exportMetalObjectsInfoEXT ) const VULKAN_HPP_NOEXCEPT
5709 {
5710 std::size_t seed = 0;
5711 VULKAN_HPP_HASH_COMBINE( seed, exportMetalObjectsInfoEXT.sType );
5712 VULKAN_HPP_HASH_COMBINE( seed, exportMetalObjectsInfoEXT.pNext );
5713 return seed;
5714 }
5715 };
5716 # endif /*VK_USE_PLATFORM_METAL_EXT*/
5717
5718 # if defined( VK_USE_PLATFORM_METAL_EXT )
5719 template <>
5720 struct hash<VULKAN_HPP_NAMESPACE::ExportMetalSharedEventInfoEXT>
5721 {
5722 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMetalSharedEventInfoEXT const & exportMetalSharedEventInfoEXT ) const VULKAN_HPP_NOEXCEPT
5723 {
5724 std::size_t seed = 0;
5725 VULKAN_HPP_HASH_COMBINE( seed, exportMetalSharedEventInfoEXT.sType );
5726 VULKAN_HPP_HASH_COMBINE( seed, exportMetalSharedEventInfoEXT.pNext );
5727 VULKAN_HPP_HASH_COMBINE( seed, exportMetalSharedEventInfoEXT.semaphore );
5728 VULKAN_HPP_HASH_COMBINE( seed, exportMetalSharedEventInfoEXT.event );
5729 VULKAN_HPP_HASH_COMBINE( seed, exportMetalSharedEventInfoEXT.mtlSharedEvent );
5730 return seed;
5731 }
5732 };
5733 # endif /*VK_USE_PLATFORM_METAL_EXT*/
5734
5735 # if defined( VK_USE_PLATFORM_METAL_EXT )
5736 template <>
5737 struct hash<VULKAN_HPP_NAMESPACE::ExportMetalTextureInfoEXT>
5738 {
5739 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMetalTextureInfoEXT const & exportMetalTextureInfoEXT ) const VULKAN_HPP_NOEXCEPT
5740 {
5741 std::size_t seed = 0;
5742 VULKAN_HPP_HASH_COMBINE( seed, exportMetalTextureInfoEXT.sType );
5743 VULKAN_HPP_HASH_COMBINE( seed, exportMetalTextureInfoEXT.pNext );
5744 VULKAN_HPP_HASH_COMBINE( seed, exportMetalTextureInfoEXT.image );
5745 VULKAN_HPP_HASH_COMBINE( seed, exportMetalTextureInfoEXT.imageView );
5746 VULKAN_HPP_HASH_COMBINE( seed, exportMetalTextureInfoEXT.bufferView );
5747 VULKAN_HPP_HASH_COMBINE( seed, exportMetalTextureInfoEXT.plane );
5748 VULKAN_HPP_HASH_COMBINE( seed, exportMetalTextureInfoEXT.mtlTexture );
5749 return seed;
5750 }
5751 };
5752 # endif /*VK_USE_PLATFORM_METAL_EXT*/
5753
5754 template <>
5755 struct hash<VULKAN_HPP_NAMESPACE::ExportSemaphoreCreateInfo>
5756 {
5757 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportSemaphoreCreateInfo const & exportSemaphoreCreateInfo ) const VULKAN_HPP_NOEXCEPT
5758 {
5759 std::size_t seed = 0;
5760 VULKAN_HPP_HASH_COMBINE( seed, exportSemaphoreCreateInfo.sType );
5761 VULKAN_HPP_HASH_COMBINE( seed, exportSemaphoreCreateInfo.pNext );
5762 VULKAN_HPP_HASH_COMBINE( seed, exportSemaphoreCreateInfo.handleTypes );
5763 return seed;
5764 }
5765 };
5766
5767 # if defined( VK_USE_PLATFORM_WIN32_KHR )
5768 template <>
5769 struct hash<VULKAN_HPP_NAMESPACE::ExportSemaphoreWin32HandleInfoKHR>
5770 {
5771 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportSemaphoreWin32HandleInfoKHR const & exportSemaphoreWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT
5772 {
5773 std::size_t seed = 0;
5774 VULKAN_HPP_HASH_COMBINE( seed, exportSemaphoreWin32HandleInfoKHR.sType );
5775 VULKAN_HPP_HASH_COMBINE( seed, exportSemaphoreWin32HandleInfoKHR.pNext );
5776 VULKAN_HPP_HASH_COMBINE( seed, exportSemaphoreWin32HandleInfoKHR.pAttributes );
5777 VULKAN_HPP_HASH_COMBINE( seed, exportSemaphoreWin32HandleInfoKHR.dwAccess );
5778 VULKAN_HPP_HASH_COMBINE( seed, exportSemaphoreWin32HandleInfoKHR.name );
5779 return seed;
5780 }
5781 };
5782 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
5783
5784 template <>
5785 struct hash<VULKAN_HPP_NAMESPACE::ExtensionProperties>
5786 {
5787 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExtensionProperties const & extensionProperties ) const VULKAN_HPP_NOEXCEPT
5788 {
5789 std::size_t seed = 0;
5790 for ( size_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i )
5791 {
5792 VULKAN_HPP_HASH_COMBINE( seed, extensionProperties.extensionName[i] );
5793 }
5794 VULKAN_HPP_HASH_COMBINE( seed, extensionProperties.specVersion );
5795 return seed;
5796 }
5797 };
5798
5799 template <>
5800 struct hash<VULKAN_HPP_NAMESPACE::ExternalMemoryProperties>
5801 {
5802 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalMemoryProperties const & externalMemoryProperties ) const VULKAN_HPP_NOEXCEPT
5803 {
5804 std::size_t seed = 0;
5805 VULKAN_HPP_HASH_COMBINE( seed, externalMemoryProperties.externalMemoryFeatures );
5806 VULKAN_HPP_HASH_COMBINE( seed, externalMemoryProperties.exportFromImportedHandleTypes );
5807 VULKAN_HPP_HASH_COMBINE( seed, externalMemoryProperties.compatibleHandleTypes );
5808 return seed;
5809 }
5810 };
5811
5812 template <>
5813 struct hash<VULKAN_HPP_NAMESPACE::ExternalBufferProperties>
5814 {
5815 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalBufferProperties const & externalBufferProperties ) const VULKAN_HPP_NOEXCEPT
5816 {
5817 std::size_t seed = 0;
5818 VULKAN_HPP_HASH_COMBINE( seed, externalBufferProperties.sType );
5819 VULKAN_HPP_HASH_COMBINE( seed, externalBufferProperties.pNext );
5820 VULKAN_HPP_HASH_COMBINE( seed, externalBufferProperties.externalMemoryProperties );
5821 return seed;
5822 }
5823 };
5824
5825 template <>
5826 struct hash<VULKAN_HPP_NAMESPACE::ExternalComputeQueueCreateInfoNV>
5827 {
5828 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalComputeQueueCreateInfoNV const & externalComputeQueueCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
5829 {
5830 std::size_t seed = 0;
5831 VULKAN_HPP_HASH_COMBINE( seed, externalComputeQueueCreateInfoNV.sType );
5832 VULKAN_HPP_HASH_COMBINE( seed, externalComputeQueueCreateInfoNV.pNext );
5833 VULKAN_HPP_HASH_COMBINE( seed, externalComputeQueueCreateInfoNV.preferredQueue );
5834 return seed;
5835 }
5836 };
5837
5838 template <>
5839 struct hash<VULKAN_HPP_NAMESPACE::ExternalComputeQueueDataParamsNV>
5840 {
5841 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalComputeQueueDataParamsNV const & externalComputeQueueDataParamsNV ) const VULKAN_HPP_NOEXCEPT
5842 {
5843 std::size_t seed = 0;
5844 VULKAN_HPP_HASH_COMBINE( seed, externalComputeQueueDataParamsNV.sType );
5845 VULKAN_HPP_HASH_COMBINE( seed, externalComputeQueueDataParamsNV.pNext );
5846 VULKAN_HPP_HASH_COMBINE( seed, externalComputeQueueDataParamsNV.deviceIndex );
5847 return seed;
5848 }
5849 };
5850
5851 template <>
5852 struct hash<VULKAN_HPP_NAMESPACE::ExternalComputeQueueDeviceCreateInfoNV>
5853 {
5854 std::size_t
5855 operator()( VULKAN_HPP_NAMESPACE::ExternalComputeQueueDeviceCreateInfoNV const & externalComputeQueueDeviceCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
5856 {
5857 std::size_t seed = 0;
5858 VULKAN_HPP_HASH_COMBINE( seed, externalComputeQueueDeviceCreateInfoNV.sType );
5859 VULKAN_HPP_HASH_COMBINE( seed, externalComputeQueueDeviceCreateInfoNV.pNext );
5860 VULKAN_HPP_HASH_COMBINE( seed, externalComputeQueueDeviceCreateInfoNV.reservedExternalQueues );
5861 return seed;
5862 }
5863 };
5864
5865 template <>
5866 struct hash<VULKAN_HPP_NAMESPACE::ExternalFenceProperties>
5867 {
5868 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalFenceProperties const & externalFenceProperties ) const VULKAN_HPP_NOEXCEPT
5869 {
5870 std::size_t seed = 0;
5871 VULKAN_HPP_HASH_COMBINE( seed, externalFenceProperties.sType );
5872 VULKAN_HPP_HASH_COMBINE( seed, externalFenceProperties.pNext );
5873 VULKAN_HPP_HASH_COMBINE( seed, externalFenceProperties.exportFromImportedHandleTypes );
5874 VULKAN_HPP_HASH_COMBINE( seed, externalFenceProperties.compatibleHandleTypes );
5875 VULKAN_HPP_HASH_COMBINE( seed, externalFenceProperties.externalFenceFeatures );
5876 return seed;
5877 }
5878 };
5879
5880 # if defined( VK_USE_PLATFORM_ANDROID_KHR )
5881 template <>
5882 struct hash<VULKAN_HPP_NAMESPACE::ExternalFormatANDROID>
5883 {
5884 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalFormatANDROID const & externalFormatANDROID ) const VULKAN_HPP_NOEXCEPT
5885 {
5886 std::size_t seed = 0;
5887 VULKAN_HPP_HASH_COMBINE( seed, externalFormatANDROID.sType );
5888 VULKAN_HPP_HASH_COMBINE( seed, externalFormatANDROID.pNext );
5889 VULKAN_HPP_HASH_COMBINE( seed, externalFormatANDROID.externalFormat );
5890 return seed;
5891 }
5892 };
5893 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/
5894
5895 # if defined( VK_USE_PLATFORM_OHOS )
5896 template <>
5897 struct hash<VULKAN_HPP_NAMESPACE::ExternalFormatOHOS>
5898 {
5899 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalFormatOHOS const & externalFormatOHOS ) const VULKAN_HPP_NOEXCEPT
5900 {
5901 std::size_t seed = 0;
5902 VULKAN_HPP_HASH_COMBINE( seed, externalFormatOHOS.sType );
5903 VULKAN_HPP_HASH_COMBINE( seed, externalFormatOHOS.pNext );
5904 VULKAN_HPP_HASH_COMBINE( seed, externalFormatOHOS.externalFormat );
5905 return seed;
5906 }
5907 };
5908 # endif /*VK_USE_PLATFORM_OHOS*/
5909
5910 # if defined( VK_USE_PLATFORM_SCREEN_QNX )
5911 template <>
5912 struct hash<VULKAN_HPP_NAMESPACE::ExternalFormatQNX>
5913 {
5914 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalFormatQNX const & externalFormatQNX ) const VULKAN_HPP_NOEXCEPT
5915 {
5916 std::size_t seed = 0;
5917 VULKAN_HPP_HASH_COMBINE( seed, externalFormatQNX.sType );
5918 VULKAN_HPP_HASH_COMBINE( seed, externalFormatQNX.pNext );
5919 VULKAN_HPP_HASH_COMBINE( seed, externalFormatQNX.externalFormat );
5920 return seed;
5921 }
5922 };
5923 # endif /*VK_USE_PLATFORM_SCREEN_QNX*/
5924
5925 template <>
5926 struct hash<VULKAN_HPP_NAMESPACE::ExternalImageFormatProperties>
5927 {
5928 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalImageFormatProperties const & externalImageFormatProperties ) const VULKAN_HPP_NOEXCEPT
5929 {
5930 std::size_t seed = 0;
5931 VULKAN_HPP_HASH_COMBINE( seed, externalImageFormatProperties.sType );
5932 VULKAN_HPP_HASH_COMBINE( seed, externalImageFormatProperties.pNext );
5933 VULKAN_HPP_HASH_COMBINE( seed, externalImageFormatProperties.externalMemoryProperties );
5934 return seed;
5935 }
5936 };
5937
5938 template <>
5939 struct hash<VULKAN_HPP_NAMESPACE::ImageFormatProperties>
5940 {
5941 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageFormatProperties const & imageFormatProperties ) const VULKAN_HPP_NOEXCEPT
5942 {
5943 std::size_t seed = 0;
5944 VULKAN_HPP_HASH_COMBINE( seed, imageFormatProperties.maxExtent );
5945 VULKAN_HPP_HASH_COMBINE( seed, imageFormatProperties.maxMipLevels );
5946 VULKAN_HPP_HASH_COMBINE( seed, imageFormatProperties.maxArrayLayers );
5947 VULKAN_HPP_HASH_COMBINE( seed, imageFormatProperties.sampleCounts );
5948 VULKAN_HPP_HASH_COMBINE( seed, imageFormatProperties.maxResourceSize );
5949 return seed;
5950 }
5951 };
5952
5953 template <>
5954 struct hash<VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV>
5955 {
5956 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV const & externalImageFormatPropertiesNV ) const VULKAN_HPP_NOEXCEPT
5957 {
5958 std::size_t seed = 0;
5959 VULKAN_HPP_HASH_COMBINE( seed, externalImageFormatPropertiesNV.imageFormatProperties );
5960 VULKAN_HPP_HASH_COMBINE( seed, externalImageFormatPropertiesNV.externalMemoryFeatures );
5961 VULKAN_HPP_HASH_COMBINE( seed, externalImageFormatPropertiesNV.exportFromImportedHandleTypes );
5962 VULKAN_HPP_HASH_COMBINE( seed, externalImageFormatPropertiesNV.compatibleHandleTypes );
5963 return seed;
5964 }
5965 };
5966
5967 template <>
5968 struct hash<VULKAN_HPP_NAMESPACE::ExternalMemoryAcquireUnmodifiedEXT>
5969 {
5970 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalMemoryAcquireUnmodifiedEXT const & externalMemoryAcquireUnmodifiedEXT ) const VULKAN_HPP_NOEXCEPT
5971 {
5972 std::size_t seed = 0;
5973 VULKAN_HPP_HASH_COMBINE( seed, externalMemoryAcquireUnmodifiedEXT.sType );
5974 VULKAN_HPP_HASH_COMBINE( seed, externalMemoryAcquireUnmodifiedEXT.pNext );
5975 VULKAN_HPP_HASH_COMBINE( seed, externalMemoryAcquireUnmodifiedEXT.acquireUnmodifiedMemory );
5976 return seed;
5977 }
5978 };
5979
5980 template <>
5981 struct hash<VULKAN_HPP_NAMESPACE::ExternalMemoryBufferCreateInfo>
5982 {
5983 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalMemoryBufferCreateInfo const & externalMemoryBufferCreateInfo ) const VULKAN_HPP_NOEXCEPT
5984 {
5985 std::size_t seed = 0;
5986 VULKAN_HPP_HASH_COMBINE( seed, externalMemoryBufferCreateInfo.sType );
5987 VULKAN_HPP_HASH_COMBINE( seed, externalMemoryBufferCreateInfo.pNext );
5988 VULKAN_HPP_HASH_COMBINE( seed, externalMemoryBufferCreateInfo.handleTypes );
5989 return seed;
5990 }
5991 };
5992
5993 template <>
5994 struct hash<VULKAN_HPP_NAMESPACE::ExternalMemoryImageCreateInfo>
5995 {
5996 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalMemoryImageCreateInfo const & externalMemoryImageCreateInfo ) const VULKAN_HPP_NOEXCEPT
5997 {
5998 std::size_t seed = 0;
5999 VULKAN_HPP_HASH_COMBINE( seed, externalMemoryImageCreateInfo.sType );
6000 VULKAN_HPP_HASH_COMBINE( seed, externalMemoryImageCreateInfo.pNext );
6001 VULKAN_HPP_HASH_COMBINE( seed, externalMemoryImageCreateInfo.handleTypes );
6002 return seed;
6003 }
6004 };
6005
6006 template <>
6007 struct hash<VULKAN_HPP_NAMESPACE::ExternalMemoryImageCreateInfoNV>
6008 {
6009 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalMemoryImageCreateInfoNV const & externalMemoryImageCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
6010 {
6011 std::size_t seed = 0;
6012 VULKAN_HPP_HASH_COMBINE( seed, externalMemoryImageCreateInfoNV.sType );
6013 VULKAN_HPP_HASH_COMBINE( seed, externalMemoryImageCreateInfoNV.pNext );
6014 VULKAN_HPP_HASH_COMBINE( seed, externalMemoryImageCreateInfoNV.handleTypes );
6015 return seed;
6016 }
6017 };
6018
6019 template <>
6020 struct hash<VULKAN_HPP_NAMESPACE::ExternalMemoryTensorCreateInfoARM>
6021 {
6022 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalMemoryTensorCreateInfoARM const & externalMemoryTensorCreateInfoARM ) const VULKAN_HPP_NOEXCEPT
6023 {
6024 std::size_t seed = 0;
6025 VULKAN_HPP_HASH_COMBINE( seed, externalMemoryTensorCreateInfoARM.sType );
6026 VULKAN_HPP_HASH_COMBINE( seed, externalMemoryTensorCreateInfoARM.pNext );
6027 VULKAN_HPP_HASH_COMBINE( seed, externalMemoryTensorCreateInfoARM.handleTypes );
6028 return seed;
6029 }
6030 };
6031
6032 template <>
6033 struct hash<VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties>
6034 {
6035 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties const & externalSemaphoreProperties ) const VULKAN_HPP_NOEXCEPT
6036 {
6037 std::size_t seed = 0;
6038 VULKAN_HPP_HASH_COMBINE( seed, externalSemaphoreProperties.sType );
6039 VULKAN_HPP_HASH_COMBINE( seed, externalSemaphoreProperties.pNext );
6040 VULKAN_HPP_HASH_COMBINE( seed, externalSemaphoreProperties.exportFromImportedHandleTypes );
6041 VULKAN_HPP_HASH_COMBINE( seed, externalSemaphoreProperties.compatibleHandleTypes );
6042 VULKAN_HPP_HASH_COMBINE( seed, externalSemaphoreProperties.externalSemaphoreFeatures );
6043 return seed;
6044 }
6045 };
6046
6047 template <>
6048 struct hash<VULKAN_HPP_NAMESPACE::ExternalTensorPropertiesARM>
6049 {
6050 std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalTensorPropertiesARM const & externalTensorPropertiesARM ) const VULKAN_HPP_NOEXCEPT
6051 {
6052 std::size_t seed = 0;
6053 VULKAN_HPP_HASH_COMBINE( seed, externalTensorPropertiesARM.sType );
6054 VULKAN_HPP_HASH_COMBINE( seed, externalTensorPropertiesARM.pNext );
6055 VULKAN_HPP_HASH_COMBINE( seed, externalTensorPropertiesARM.externalMemoryProperties );
6056 return seed;
6057 }
6058 };
6059
6060 template <>
6061 struct hash<VULKAN_HPP_NAMESPACE::FenceCreateInfo>
6062 {
6063 std::size_t operator()( VULKAN_HPP_NAMESPACE::FenceCreateInfo const & fenceCreateInfo ) const VULKAN_HPP_NOEXCEPT
6064 {
6065 std::size_t seed = 0;
6066 VULKAN_HPP_HASH_COMBINE( seed, fenceCreateInfo.sType );
6067 VULKAN_HPP_HASH_COMBINE( seed, fenceCreateInfo.pNext );
6068 VULKAN_HPP_HASH_COMBINE( seed, fenceCreateInfo.flags );
6069 return seed;
6070 }
6071 };
6072
6073 template <>
6074 struct hash<VULKAN_HPP_NAMESPACE::FenceGetFdInfoKHR>
6075 {
6076 std::size_t operator()( VULKAN_HPP_NAMESPACE::FenceGetFdInfoKHR const & fenceGetFdInfoKHR ) const VULKAN_HPP_NOEXCEPT
6077 {
6078 std::size_t seed = 0;
6079 VULKAN_HPP_HASH_COMBINE( seed, fenceGetFdInfoKHR.sType );
6080 VULKAN_HPP_HASH_COMBINE( seed, fenceGetFdInfoKHR.pNext );
6081 VULKAN_HPP_HASH_COMBINE( seed, fenceGetFdInfoKHR.fence );
6082 VULKAN_HPP_HASH_COMBINE( seed, fenceGetFdInfoKHR.handleType );
6083 return seed;
6084 }
6085 };
6086
6087 # if defined( VK_USE_PLATFORM_WIN32_KHR )
6088 template <>
6089 struct hash<VULKAN_HPP_NAMESPACE::FenceGetWin32HandleInfoKHR>
6090 {
6091 std::size_t operator()( VULKAN_HPP_NAMESPACE::FenceGetWin32HandleInfoKHR const & fenceGetWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT
6092 {
6093 std::size_t seed = 0;
6094 VULKAN_HPP_HASH_COMBINE( seed, fenceGetWin32HandleInfoKHR.sType );
6095 VULKAN_HPP_HASH_COMBINE( seed, fenceGetWin32HandleInfoKHR.pNext );
6096 VULKAN_HPP_HASH_COMBINE( seed, fenceGetWin32HandleInfoKHR.fence );
6097 VULKAN_HPP_HASH_COMBINE( seed, fenceGetWin32HandleInfoKHR.handleType );
6098 return seed;
6099 }
6100 };
6101 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
6102
6103 template <>
6104 struct hash<VULKAN_HPP_NAMESPACE::FilterCubicImageViewImageFormatPropertiesEXT>
6105 {
6106 std::size_t operator()( VULKAN_HPP_NAMESPACE::FilterCubicImageViewImageFormatPropertiesEXT const & filterCubicImageViewImageFormatPropertiesEXT ) const
6107 VULKAN_HPP_NOEXCEPT
6108 {
6109 std::size_t seed = 0;
6110 VULKAN_HPP_HASH_COMBINE( seed, filterCubicImageViewImageFormatPropertiesEXT.sType );
6111 VULKAN_HPP_HASH_COMBINE( seed, filterCubicImageViewImageFormatPropertiesEXT.pNext );
6112 VULKAN_HPP_HASH_COMBINE( seed, filterCubicImageViewImageFormatPropertiesEXT.filterCubic );
6113 VULKAN_HPP_HASH_COMBINE( seed, filterCubicImageViewImageFormatPropertiesEXT.filterCubicMinmax );
6114 return seed;
6115 }
6116 };
6117
6118 template <>
6119 struct hash<VULKAN_HPP_NAMESPACE::FormatProperties>
6120 {
6121 std::size_t operator()( VULKAN_HPP_NAMESPACE::FormatProperties const & formatProperties ) const VULKAN_HPP_NOEXCEPT
6122 {
6123 std::size_t seed = 0;
6124 VULKAN_HPP_HASH_COMBINE( seed, formatProperties.linearTilingFeatures );
6125 VULKAN_HPP_HASH_COMBINE( seed, formatProperties.optimalTilingFeatures );
6126 VULKAN_HPP_HASH_COMBINE( seed, formatProperties.bufferFeatures );
6127 return seed;
6128 }
6129 };
6130
6131 template <>
6132 struct hash<VULKAN_HPP_NAMESPACE::FormatProperties2>
6133 {
6134 std::size_t operator()( VULKAN_HPP_NAMESPACE::FormatProperties2 const & formatProperties2 ) const VULKAN_HPP_NOEXCEPT
6135 {
6136 std::size_t seed = 0;
6137 VULKAN_HPP_HASH_COMBINE( seed, formatProperties2.sType );
6138 VULKAN_HPP_HASH_COMBINE( seed, formatProperties2.pNext );
6139 VULKAN_HPP_HASH_COMBINE( seed, formatProperties2.formatProperties );
6140 return seed;
6141 }
6142 };
6143
6144 template <>
6145 struct hash<VULKAN_HPP_NAMESPACE::FormatProperties3>
6146 {
6147 std::size_t operator()( VULKAN_HPP_NAMESPACE::FormatProperties3 const & formatProperties3 ) const VULKAN_HPP_NOEXCEPT
6148 {
6149 std::size_t seed = 0;
6150 VULKAN_HPP_HASH_COMBINE( seed, formatProperties3.sType );
6151 VULKAN_HPP_HASH_COMBINE( seed, formatProperties3.pNext );
6152 VULKAN_HPP_HASH_COMBINE( seed, formatProperties3.linearTilingFeatures );
6153 VULKAN_HPP_HASH_COMBINE( seed, formatProperties3.optimalTilingFeatures );
6154 VULKAN_HPP_HASH_COMBINE( seed, formatProperties3.bufferFeatures );
6155 return seed;
6156 }
6157 };
6158
6159 template <>
6160 struct hash<VULKAN_HPP_NAMESPACE::FragmentShadingRateAttachmentInfoKHR>
6161 {
6162 std::size_t operator()( VULKAN_HPP_NAMESPACE::FragmentShadingRateAttachmentInfoKHR const & fragmentShadingRateAttachmentInfoKHR ) const VULKAN_HPP_NOEXCEPT
6163 {
6164 std::size_t seed = 0;
6165 VULKAN_HPP_HASH_COMBINE( seed, fragmentShadingRateAttachmentInfoKHR.sType );
6166 VULKAN_HPP_HASH_COMBINE( seed, fragmentShadingRateAttachmentInfoKHR.pNext );
6167 VULKAN_HPP_HASH_COMBINE( seed, fragmentShadingRateAttachmentInfoKHR.pFragmentShadingRateAttachment );
6168 VULKAN_HPP_HASH_COMBINE( seed, fragmentShadingRateAttachmentInfoKHR.shadingRateAttachmentTexelSize );
6169 return seed;
6170 }
6171 };
6172
6173 template <>
6174 struct hash<VULKAN_HPP_NAMESPACE::FrameBoundaryEXT>
6175 {
6176 std::size_t operator()( VULKAN_HPP_NAMESPACE::FrameBoundaryEXT const & frameBoundaryEXT ) const VULKAN_HPP_NOEXCEPT
6177 {
6178 std::size_t seed = 0;
6179 VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.sType );
6180 VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.pNext );
6181 VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.flags );
6182 VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.frameID );
6183 VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.imageCount );
6184 VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.pImages );
6185 VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.bufferCount );
6186 VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.pBuffers );
6187 VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.tagName );
6188 VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.tagSize );
6189 VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.pTag );
6190 return seed;
6191 }
6192 };
6193
6194 template <>
6195 struct hash<VULKAN_HPP_NAMESPACE::FrameBoundaryTensorsARM>
6196 {
6197 std::size_t operator()( VULKAN_HPP_NAMESPACE::FrameBoundaryTensorsARM const & frameBoundaryTensorsARM ) const VULKAN_HPP_NOEXCEPT
6198 {
6199 std::size_t seed = 0;
6200 VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryTensorsARM.sType );
6201 VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryTensorsARM.pNext );
6202 VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryTensorsARM.tensorCount );
6203 VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryTensorsARM.pTensors );
6204 return seed;
6205 }
6206 };
6207
6208 template <>
6209 struct hash<VULKAN_HPP_NAMESPACE::FramebufferAttachmentImageInfo>
6210 {
6211 std::size_t operator()( VULKAN_HPP_NAMESPACE::FramebufferAttachmentImageInfo const & framebufferAttachmentImageInfo ) const VULKAN_HPP_NOEXCEPT
6212 {
6213 std::size_t seed = 0;
6214 VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentImageInfo.sType );
6215 VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentImageInfo.pNext );
6216 VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentImageInfo.flags );
6217 VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentImageInfo.usage );
6218 VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentImageInfo.width );
6219 VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentImageInfo.height );
6220 VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentImageInfo.layerCount );
6221 VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentImageInfo.viewFormatCount );
6222 VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentImageInfo.pViewFormats );
6223 return seed;
6224 }
6225 };
6226
6227 template <>
6228 struct hash<VULKAN_HPP_NAMESPACE::FramebufferAttachmentsCreateInfo>
6229 {
6230 std::size_t operator()( VULKAN_HPP_NAMESPACE::FramebufferAttachmentsCreateInfo const & framebufferAttachmentsCreateInfo ) const VULKAN_HPP_NOEXCEPT
6231 {
6232 std::size_t seed = 0;
6233 VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentsCreateInfo.sType );
6234 VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentsCreateInfo.pNext );
6235 VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentsCreateInfo.attachmentImageInfoCount );
6236 VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentsCreateInfo.pAttachmentImageInfos );
6237 return seed;
6238 }
6239 };
6240
6241 template <>
6242 struct hash<VULKAN_HPP_NAMESPACE::FramebufferCreateInfo>
6243 {
6244 std::size_t operator()( VULKAN_HPP_NAMESPACE::FramebufferCreateInfo const & framebufferCreateInfo ) const VULKAN_HPP_NOEXCEPT
6245 {
6246 std::size_t seed = 0;
6247 VULKAN_HPP_HASH_COMBINE( seed, framebufferCreateInfo.sType );
6248 VULKAN_HPP_HASH_COMBINE( seed, framebufferCreateInfo.pNext );
6249 VULKAN_HPP_HASH_COMBINE( seed, framebufferCreateInfo.flags );
6250 VULKAN_HPP_HASH_COMBINE( seed, framebufferCreateInfo.renderPass );
6251 VULKAN_HPP_HASH_COMBINE( seed, framebufferCreateInfo.attachmentCount );
6252 VULKAN_HPP_HASH_COMBINE( seed, framebufferCreateInfo.pAttachments );
6253 VULKAN_HPP_HASH_COMBINE( seed, framebufferCreateInfo.width );
6254 VULKAN_HPP_HASH_COMBINE( seed, framebufferCreateInfo.height );
6255 VULKAN_HPP_HASH_COMBINE( seed, framebufferCreateInfo.layers );
6256 return seed;
6257 }
6258 };
6259
6260 template <>
6261 struct hash<VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV>
6262 {
6263 std::size_t operator()( VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV const & framebufferMixedSamplesCombinationNV ) const VULKAN_HPP_NOEXCEPT
6264 {
6265 std::size_t seed = 0;
6266 VULKAN_HPP_HASH_COMBINE( seed, framebufferMixedSamplesCombinationNV.sType );
6267 VULKAN_HPP_HASH_COMBINE( seed, framebufferMixedSamplesCombinationNV.pNext );
6268 VULKAN_HPP_HASH_COMBINE( seed, framebufferMixedSamplesCombinationNV.coverageReductionMode );
6269 VULKAN_HPP_HASH_COMBINE( seed, framebufferMixedSamplesCombinationNV.rasterizationSamples );
6270 VULKAN_HPP_HASH_COMBINE( seed, framebufferMixedSamplesCombinationNV.depthStencilSamples );
6271 VULKAN_HPP_HASH_COMBINE( seed, framebufferMixedSamplesCombinationNV.colorSamples );
6272 return seed;
6273 }
6274 };
6275
6276 template <>
6277 struct hash<VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoEXT>
6278 {
6279 std::size_t operator()( VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoEXT const & generatedCommandsInfoEXT ) const VULKAN_HPP_NOEXCEPT
6280 {
6281 std::size_t seed = 0;
6282 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoEXT.sType );
6283 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoEXT.pNext );
6284 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoEXT.shaderStages );
6285 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoEXT.indirectExecutionSet );
6286 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoEXT.indirectCommandsLayout );
6287 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoEXT.indirectAddress );
6288 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoEXT.indirectAddressSize );
6289 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoEXT.preprocessAddress );
6290 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoEXT.preprocessSize );
6291 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoEXT.maxSequenceCount );
6292 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoEXT.sequenceCountAddress );
6293 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoEXT.maxDrawCount );
6294 return seed;
6295 }
6296 };
6297
6298 template <>
6299 struct hash<VULKAN_HPP_NAMESPACE::IndirectCommandsStreamNV>
6300 {
6301 std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectCommandsStreamNV const & indirectCommandsStreamNV ) const VULKAN_HPP_NOEXCEPT
6302 {
6303 std::size_t seed = 0;
6304 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsStreamNV.buffer );
6305 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsStreamNV.offset );
6306 return seed;
6307 }
6308 };
6309
6310 template <>
6311 struct hash<VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV>
6312 {
6313 std::size_t operator()( VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV const & generatedCommandsInfoNV ) const VULKAN_HPP_NOEXCEPT
6314 {
6315 std::size_t seed = 0;
6316 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.sType );
6317 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.pNext );
6318 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.pipelineBindPoint );
6319 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.pipeline );
6320 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.indirectCommandsLayout );
6321 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.streamCount );
6322 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.pStreams );
6323 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.sequencesCount );
6324 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.preprocessBuffer );
6325 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.preprocessOffset );
6326 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.preprocessSize );
6327 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.sequencesCountBuffer );
6328 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.sequencesCountOffset );
6329 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.sequencesIndexBuffer );
6330 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.sequencesIndexOffset );
6331 return seed;
6332 }
6333 };
6334
6335 template <>
6336 struct hash<VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoEXT>
6337 {
6338 std::size_t operator()( VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoEXT const & generatedCommandsMemoryRequirementsInfoEXT ) const
6339 VULKAN_HPP_NOEXCEPT
6340 {
6341 std::size_t seed = 0;
6342 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsMemoryRequirementsInfoEXT.sType );
6343 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsMemoryRequirementsInfoEXT.pNext );
6344 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsMemoryRequirementsInfoEXT.indirectExecutionSet );
6345 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsMemoryRequirementsInfoEXT.indirectCommandsLayout );
6346 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsMemoryRequirementsInfoEXT.maxSequenceCount );
6347 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsMemoryRequirementsInfoEXT.maxDrawCount );
6348 return seed;
6349 }
6350 };
6351
6352 template <>
6353 struct hash<VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV>
6354 {
6355 std::size_t
6356 operator()( VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV const & generatedCommandsMemoryRequirementsInfoNV ) const VULKAN_HPP_NOEXCEPT
6357 {
6358 std::size_t seed = 0;
6359 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsMemoryRequirementsInfoNV.sType );
6360 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsMemoryRequirementsInfoNV.pNext );
6361 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsMemoryRequirementsInfoNV.pipelineBindPoint );
6362 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsMemoryRequirementsInfoNV.pipeline );
6363 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsMemoryRequirementsInfoNV.indirectCommandsLayout );
6364 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsMemoryRequirementsInfoNV.maxSequencesCount );
6365 return seed;
6366 }
6367 };
6368
6369 template <>
6370 struct hash<VULKAN_HPP_NAMESPACE::GeneratedCommandsPipelineInfoEXT>
6371 {
6372 std::size_t operator()( VULKAN_HPP_NAMESPACE::GeneratedCommandsPipelineInfoEXT const & generatedCommandsPipelineInfoEXT ) const VULKAN_HPP_NOEXCEPT
6373 {
6374 std::size_t seed = 0;
6375 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsPipelineInfoEXT.sType );
6376 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsPipelineInfoEXT.pNext );
6377 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsPipelineInfoEXT.pipeline );
6378 return seed;
6379 }
6380 };
6381
6382 template <>
6383 struct hash<VULKAN_HPP_NAMESPACE::GeneratedCommandsShaderInfoEXT>
6384 {
6385 std::size_t operator()( VULKAN_HPP_NAMESPACE::GeneratedCommandsShaderInfoEXT const & generatedCommandsShaderInfoEXT ) const VULKAN_HPP_NOEXCEPT
6386 {
6387 std::size_t seed = 0;
6388 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsShaderInfoEXT.sType );
6389 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsShaderInfoEXT.pNext );
6390 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsShaderInfoEXT.shaderCount );
6391 VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsShaderInfoEXT.pShaders );
6392 return seed;
6393 }
6394 };
6395
6396 template <>
6397 struct hash<VULKAN_HPP_NAMESPACE::LatencyTimingsFrameReportNV>
6398 {
6399 std::size_t operator()( VULKAN_HPP_NAMESPACE::LatencyTimingsFrameReportNV const & latencyTimingsFrameReportNV ) const VULKAN_HPP_NOEXCEPT
6400 {
6401 std::size_t seed = 0;
6402 VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.sType );
6403 VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.pNext );
6404 VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.presentID );
6405 VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.inputSampleTimeUs );
6406 VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.simStartTimeUs );
6407 VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.simEndTimeUs );
6408 VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.renderSubmitStartTimeUs );
6409 VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.renderSubmitEndTimeUs );
6410 VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.presentStartTimeUs );
6411 VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.presentEndTimeUs );
6412 VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.driverStartTimeUs );
6413 VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.driverEndTimeUs );
6414 VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.osRenderQueueStartTimeUs );
6415 VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.osRenderQueueEndTimeUs );
6416 VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.gpuRenderStartTimeUs );
6417 VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.gpuRenderEndTimeUs );
6418 return seed;
6419 }
6420 };
6421
6422 template <>
6423 struct hash<VULKAN_HPP_NAMESPACE::GetLatencyMarkerInfoNV>
6424 {
6425 std::size_t operator()( VULKAN_HPP_NAMESPACE::GetLatencyMarkerInfoNV const & getLatencyMarkerInfoNV ) const VULKAN_HPP_NOEXCEPT
6426 {
6427 std::size_t seed = 0;
6428 VULKAN_HPP_HASH_COMBINE( seed, getLatencyMarkerInfoNV.sType );
6429 VULKAN_HPP_HASH_COMBINE( seed, getLatencyMarkerInfoNV.pNext );
6430 VULKAN_HPP_HASH_COMBINE( seed, getLatencyMarkerInfoNV.timingCount );
6431 VULKAN_HPP_HASH_COMBINE( seed, getLatencyMarkerInfoNV.pTimings );
6432 return seed;
6433 }
6434 };
6435
6436 template <>
6437 struct hash<VULKAN_HPP_NAMESPACE::VertexInputBindingDescription>
6438 {
6439 std::size_t operator()( VULKAN_HPP_NAMESPACE::VertexInputBindingDescription const & vertexInputBindingDescription ) const VULKAN_HPP_NOEXCEPT
6440 {
6441 std::size_t seed = 0;
6442 VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDescription.binding );
6443 VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDescription.stride );
6444 VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDescription.inputRate );
6445 return seed;
6446 }
6447 };
6448
6449 template <>
6450 struct hash<VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription>
6451 {
6452 std::size_t operator()( VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription const & vertexInputAttributeDescription ) const VULKAN_HPP_NOEXCEPT
6453 {
6454 std::size_t seed = 0;
6455 VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription.location );
6456 VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription.binding );
6457 VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription.format );
6458 VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription.offset );
6459 return seed;
6460 }
6461 };
6462
6463 template <>
6464 struct hash<VULKAN_HPP_NAMESPACE::PipelineVertexInputStateCreateInfo>
6465 {
6466 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineVertexInputStateCreateInfo const & pipelineVertexInputStateCreateInfo ) const VULKAN_HPP_NOEXCEPT
6467 {
6468 std::size_t seed = 0;
6469 VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputStateCreateInfo.sType );
6470 VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputStateCreateInfo.pNext );
6471 VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputStateCreateInfo.flags );
6472 VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputStateCreateInfo.vertexBindingDescriptionCount );
6473 VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputStateCreateInfo.pVertexBindingDescriptions );
6474 VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputStateCreateInfo.vertexAttributeDescriptionCount );
6475 VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputStateCreateInfo.pVertexAttributeDescriptions );
6476 return seed;
6477 }
6478 };
6479
6480 template <>
6481 struct hash<VULKAN_HPP_NAMESPACE::PipelineInputAssemblyStateCreateInfo>
6482 {
6483 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineInputAssemblyStateCreateInfo const & pipelineInputAssemblyStateCreateInfo ) const VULKAN_HPP_NOEXCEPT
6484 {
6485 std::size_t seed = 0;
6486 VULKAN_HPP_HASH_COMBINE( seed, pipelineInputAssemblyStateCreateInfo.sType );
6487 VULKAN_HPP_HASH_COMBINE( seed, pipelineInputAssemblyStateCreateInfo.pNext );
6488 VULKAN_HPP_HASH_COMBINE( seed, pipelineInputAssemblyStateCreateInfo.flags );
6489 VULKAN_HPP_HASH_COMBINE( seed, pipelineInputAssemblyStateCreateInfo.topology );
6490 VULKAN_HPP_HASH_COMBINE( seed, pipelineInputAssemblyStateCreateInfo.primitiveRestartEnable );
6491 return seed;
6492 }
6493 };
6494
6495 template <>
6496 struct hash<VULKAN_HPP_NAMESPACE::PipelineTessellationStateCreateInfo>
6497 {
6498 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineTessellationStateCreateInfo const & pipelineTessellationStateCreateInfo ) const VULKAN_HPP_NOEXCEPT
6499 {
6500 std::size_t seed = 0;
6501 VULKAN_HPP_HASH_COMBINE( seed, pipelineTessellationStateCreateInfo.sType );
6502 VULKAN_HPP_HASH_COMBINE( seed, pipelineTessellationStateCreateInfo.pNext );
6503 VULKAN_HPP_HASH_COMBINE( seed, pipelineTessellationStateCreateInfo.flags );
6504 VULKAN_HPP_HASH_COMBINE( seed, pipelineTessellationStateCreateInfo.patchControlPoints );
6505 return seed;
6506 }
6507 };
6508
6509 template <>
6510 struct hash<VULKAN_HPP_NAMESPACE::PipelineViewportStateCreateInfo>
6511 {
6512 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineViewportStateCreateInfo const & pipelineViewportStateCreateInfo ) const VULKAN_HPP_NOEXCEPT
6513 {
6514 std::size_t seed = 0;
6515 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportStateCreateInfo.sType );
6516 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportStateCreateInfo.pNext );
6517 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportStateCreateInfo.flags );
6518 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportStateCreateInfo.viewportCount );
6519 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportStateCreateInfo.pViewports );
6520 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportStateCreateInfo.scissorCount );
6521 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportStateCreateInfo.pScissors );
6522 return seed;
6523 }
6524 };
6525
6526 template <>
6527 struct hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationStateCreateInfo>
6528 {
6529 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationStateCreateInfo const & pipelineRasterizationStateCreateInfo ) const VULKAN_HPP_NOEXCEPT
6530 {
6531 std::size_t seed = 0;
6532 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.sType );
6533 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.pNext );
6534 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.flags );
6535 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.depthClampEnable );
6536 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.rasterizerDiscardEnable );
6537 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.polygonMode );
6538 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.cullMode );
6539 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.frontFace );
6540 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.depthBiasEnable );
6541 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.depthBiasConstantFactor );
6542 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.depthBiasClamp );
6543 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.depthBiasSlopeFactor );
6544 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.lineWidth );
6545 return seed;
6546 }
6547 };
6548
6549 template <>
6550 struct hash<VULKAN_HPP_NAMESPACE::PipelineMultisampleStateCreateInfo>
6551 {
6552 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineMultisampleStateCreateInfo const & pipelineMultisampleStateCreateInfo ) const VULKAN_HPP_NOEXCEPT
6553 {
6554 std::size_t seed = 0;
6555 VULKAN_HPP_HASH_COMBINE( seed, pipelineMultisampleStateCreateInfo.sType );
6556 VULKAN_HPP_HASH_COMBINE( seed, pipelineMultisampleStateCreateInfo.pNext );
6557 VULKAN_HPP_HASH_COMBINE( seed, pipelineMultisampleStateCreateInfo.flags );
6558 VULKAN_HPP_HASH_COMBINE( seed, pipelineMultisampleStateCreateInfo.rasterizationSamples );
6559 VULKAN_HPP_HASH_COMBINE( seed, pipelineMultisampleStateCreateInfo.sampleShadingEnable );
6560 VULKAN_HPP_HASH_COMBINE( seed, pipelineMultisampleStateCreateInfo.minSampleShading );
6561 VULKAN_HPP_HASH_COMBINE( seed, pipelineMultisampleStateCreateInfo.pSampleMask );
6562 VULKAN_HPP_HASH_COMBINE( seed, pipelineMultisampleStateCreateInfo.alphaToCoverageEnable );
6563 VULKAN_HPP_HASH_COMBINE( seed, pipelineMultisampleStateCreateInfo.alphaToOneEnable );
6564 return seed;
6565 }
6566 };
6567
6568 template <>
6569 struct hash<VULKAN_HPP_NAMESPACE::StencilOpState>
6570 {
6571 std::size_t operator()( VULKAN_HPP_NAMESPACE::StencilOpState const & stencilOpState ) const VULKAN_HPP_NOEXCEPT
6572 {
6573 std::size_t seed = 0;
6574 VULKAN_HPP_HASH_COMBINE( seed, stencilOpState.failOp );
6575 VULKAN_HPP_HASH_COMBINE( seed, stencilOpState.passOp );
6576 VULKAN_HPP_HASH_COMBINE( seed, stencilOpState.depthFailOp );
6577 VULKAN_HPP_HASH_COMBINE( seed, stencilOpState.compareOp );
6578 VULKAN_HPP_HASH_COMBINE( seed, stencilOpState.compareMask );
6579 VULKAN_HPP_HASH_COMBINE( seed, stencilOpState.writeMask );
6580 VULKAN_HPP_HASH_COMBINE( seed, stencilOpState.reference );
6581 return seed;
6582 }
6583 };
6584
6585 template <>
6586 struct hash<VULKAN_HPP_NAMESPACE::PipelineDepthStencilStateCreateInfo>
6587 {
6588 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineDepthStencilStateCreateInfo const & pipelineDepthStencilStateCreateInfo ) const VULKAN_HPP_NOEXCEPT
6589 {
6590 std::size_t seed = 0;
6591 VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.sType );
6592 VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.pNext );
6593 VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.flags );
6594 VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.depthTestEnable );
6595 VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.depthWriteEnable );
6596 VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.depthCompareOp );
6597 VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.depthBoundsTestEnable );
6598 VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.stencilTestEnable );
6599 VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.front );
6600 VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.back );
6601 VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.minDepthBounds );
6602 VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.maxDepthBounds );
6603 return seed;
6604 }
6605 };
6606
6607 template <>
6608 struct hash<VULKAN_HPP_NAMESPACE::PipelineColorBlendAttachmentState>
6609 {
6610 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineColorBlendAttachmentState const & pipelineColorBlendAttachmentState ) const VULKAN_HPP_NOEXCEPT
6611 {
6612 std::size_t seed = 0;
6613 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAttachmentState.blendEnable );
6614 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAttachmentState.srcColorBlendFactor );
6615 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAttachmentState.dstColorBlendFactor );
6616 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAttachmentState.colorBlendOp );
6617 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAttachmentState.srcAlphaBlendFactor );
6618 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAttachmentState.dstAlphaBlendFactor );
6619 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAttachmentState.alphaBlendOp );
6620 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAttachmentState.colorWriteMask );
6621 return seed;
6622 }
6623 };
6624
6625 template <>
6626 struct hash<VULKAN_HPP_NAMESPACE::PipelineColorBlendStateCreateInfo>
6627 {
6628 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineColorBlendStateCreateInfo const & pipelineColorBlendStateCreateInfo ) const VULKAN_HPP_NOEXCEPT
6629 {
6630 std::size_t seed = 0;
6631 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendStateCreateInfo.sType );
6632 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendStateCreateInfo.pNext );
6633 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendStateCreateInfo.flags );
6634 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendStateCreateInfo.logicOpEnable );
6635 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendStateCreateInfo.logicOp );
6636 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendStateCreateInfo.attachmentCount );
6637 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendStateCreateInfo.pAttachments );
6638 for ( size_t i = 0; i < 4; ++i )
6639 {
6640 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendStateCreateInfo.blendConstants[i] );
6641 }
6642 return seed;
6643 }
6644 };
6645
6646 template <>
6647 struct hash<VULKAN_HPP_NAMESPACE::PipelineDynamicStateCreateInfo>
6648 {
6649 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineDynamicStateCreateInfo const & pipelineDynamicStateCreateInfo ) const VULKAN_HPP_NOEXCEPT
6650 {
6651 std::size_t seed = 0;
6652 VULKAN_HPP_HASH_COMBINE( seed, pipelineDynamicStateCreateInfo.sType );
6653 VULKAN_HPP_HASH_COMBINE( seed, pipelineDynamicStateCreateInfo.pNext );
6654 VULKAN_HPP_HASH_COMBINE( seed, pipelineDynamicStateCreateInfo.flags );
6655 VULKAN_HPP_HASH_COMBINE( seed, pipelineDynamicStateCreateInfo.dynamicStateCount );
6656 VULKAN_HPP_HASH_COMBINE( seed, pipelineDynamicStateCreateInfo.pDynamicStates );
6657 return seed;
6658 }
6659 };
6660
6661 template <>
6662 struct hash<VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo>
6663 {
6664 std::size_t operator()( VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo const & graphicsPipelineCreateInfo ) const VULKAN_HPP_NOEXCEPT
6665 {
6666 std::size_t seed = 0;
6667 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.sType );
6668 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pNext );
6669 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.flags );
6670 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.stageCount );
6671 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pStages );
6672 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pVertexInputState );
6673 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pInputAssemblyState );
6674 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pTessellationState );
6675 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pViewportState );
6676 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pRasterizationState );
6677 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pMultisampleState );
6678 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pDepthStencilState );
6679 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pColorBlendState );
6680 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pDynamicState );
6681 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.layout );
6682 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.renderPass );
6683 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.subpass );
6684 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.basePipelineHandle );
6685 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.basePipelineIndex );
6686 return seed;
6687 }
6688 };
6689
6690 template <>
6691 struct hash<VULKAN_HPP_NAMESPACE::GraphicsPipelineLibraryCreateInfoEXT>
6692 {
6693 std::size_t operator()( VULKAN_HPP_NAMESPACE::GraphicsPipelineLibraryCreateInfoEXT const & graphicsPipelineLibraryCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
6694 {
6695 std::size_t seed = 0;
6696 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineLibraryCreateInfoEXT.sType );
6697 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineLibraryCreateInfoEXT.pNext );
6698 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineLibraryCreateInfoEXT.flags );
6699 return seed;
6700 }
6701 };
6702
6703 template <>
6704 struct hash<VULKAN_HPP_NAMESPACE::GraphicsShaderGroupCreateInfoNV>
6705 {
6706 std::size_t operator()( VULKAN_HPP_NAMESPACE::GraphicsShaderGroupCreateInfoNV const & graphicsShaderGroupCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
6707 {
6708 std::size_t seed = 0;
6709 VULKAN_HPP_HASH_COMBINE( seed, graphicsShaderGroupCreateInfoNV.sType );
6710 VULKAN_HPP_HASH_COMBINE( seed, graphicsShaderGroupCreateInfoNV.pNext );
6711 VULKAN_HPP_HASH_COMBINE( seed, graphicsShaderGroupCreateInfoNV.stageCount );
6712 VULKAN_HPP_HASH_COMBINE( seed, graphicsShaderGroupCreateInfoNV.pStages );
6713 VULKAN_HPP_HASH_COMBINE( seed, graphicsShaderGroupCreateInfoNV.pVertexInputState );
6714 VULKAN_HPP_HASH_COMBINE( seed, graphicsShaderGroupCreateInfoNV.pTessellationState );
6715 return seed;
6716 }
6717 };
6718
6719 template <>
6720 struct hash<VULKAN_HPP_NAMESPACE::GraphicsPipelineShaderGroupsCreateInfoNV>
6721 {
6722 std::size_t
6723 operator()( VULKAN_HPP_NAMESPACE::GraphicsPipelineShaderGroupsCreateInfoNV const & graphicsPipelineShaderGroupsCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
6724 {
6725 std::size_t seed = 0;
6726 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineShaderGroupsCreateInfoNV.sType );
6727 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineShaderGroupsCreateInfoNV.pNext );
6728 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineShaderGroupsCreateInfoNV.groupCount );
6729 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineShaderGroupsCreateInfoNV.pGroups );
6730 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineShaderGroupsCreateInfoNV.pipelineCount );
6731 VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineShaderGroupsCreateInfoNV.pPipelines );
6732 return seed;
6733 }
6734 };
6735
6736 template <>
6737 struct hash<VULKAN_HPP_NAMESPACE::XYColorEXT>
6738 {
6739 std::size_t operator()( VULKAN_HPP_NAMESPACE::XYColorEXT const & xYColorEXT ) const VULKAN_HPP_NOEXCEPT
6740 {
6741 std::size_t seed = 0;
6742 VULKAN_HPP_HASH_COMBINE( seed, xYColorEXT.x );
6743 VULKAN_HPP_HASH_COMBINE( seed, xYColorEXT.y );
6744 return seed;
6745 }
6746 };
6747
6748 template <>
6749 struct hash<VULKAN_HPP_NAMESPACE::HdrMetadataEXT>
6750 {
6751 std::size_t operator()( VULKAN_HPP_NAMESPACE::HdrMetadataEXT const & hdrMetadataEXT ) const VULKAN_HPP_NOEXCEPT
6752 {
6753 std::size_t seed = 0;
6754 VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.sType );
6755 VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.pNext );
6756 VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.displayPrimaryRed );
6757 VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.displayPrimaryGreen );
6758 VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.displayPrimaryBlue );
6759 VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.whitePoint );
6760 VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.maxLuminance );
6761 VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.minLuminance );
6762 VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.maxContentLightLevel );
6763 VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.maxFrameAverageLightLevel );
6764 return seed;
6765 }
6766 };
6767
6768 template <>
6769 struct hash<VULKAN_HPP_NAMESPACE::HdrVividDynamicMetadataHUAWEI>
6770 {
6771 std::size_t operator()( VULKAN_HPP_NAMESPACE::HdrVividDynamicMetadataHUAWEI const & hdrVividDynamicMetadataHUAWEI ) const VULKAN_HPP_NOEXCEPT
6772 {
6773 std::size_t seed = 0;
6774 VULKAN_HPP_HASH_COMBINE( seed, hdrVividDynamicMetadataHUAWEI.sType );
6775 VULKAN_HPP_HASH_COMBINE( seed, hdrVividDynamicMetadataHUAWEI.pNext );
6776 VULKAN_HPP_HASH_COMBINE( seed, hdrVividDynamicMetadataHUAWEI.dynamicMetadataSize );
6777 VULKAN_HPP_HASH_COMBINE( seed, hdrVividDynamicMetadataHUAWEI.pDynamicMetadata );
6778 return seed;
6779 }
6780 };
6781
6782 template <>
6783 struct hash<VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT>
6784 {
6785 std::size_t operator()( VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT const & headlessSurfaceCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
6786 {
6787 std::size_t seed = 0;
6788 VULKAN_HPP_HASH_COMBINE( seed, headlessSurfaceCreateInfoEXT.sType );
6789 VULKAN_HPP_HASH_COMBINE( seed, headlessSurfaceCreateInfoEXT.pNext );
6790 VULKAN_HPP_HASH_COMBINE( seed, headlessSurfaceCreateInfoEXT.flags );
6791 return seed;
6792 }
6793 };
6794
6795 template <>
6796 struct hash<VULKAN_HPP_NAMESPACE::HostImageCopyDevicePerformanceQuery>
6797 {
6798 std::size_t operator()( VULKAN_HPP_NAMESPACE::HostImageCopyDevicePerformanceQuery const & hostImageCopyDevicePerformanceQuery ) const VULKAN_HPP_NOEXCEPT
6799 {
6800 std::size_t seed = 0;
6801 VULKAN_HPP_HASH_COMBINE( seed, hostImageCopyDevicePerformanceQuery.sType );
6802 VULKAN_HPP_HASH_COMBINE( seed, hostImageCopyDevicePerformanceQuery.pNext );
6803 VULKAN_HPP_HASH_COMBINE( seed, hostImageCopyDevicePerformanceQuery.optimalDeviceAccess );
6804 VULKAN_HPP_HASH_COMBINE( seed, hostImageCopyDevicePerformanceQuery.identicalMemoryLayout );
6805 return seed;
6806 }
6807 };
6808
6809 template <>
6810 struct hash<VULKAN_HPP_NAMESPACE::HostImageLayoutTransitionInfo>
6811 {
6812 std::size_t operator()( VULKAN_HPP_NAMESPACE::HostImageLayoutTransitionInfo const & hostImageLayoutTransitionInfo ) const VULKAN_HPP_NOEXCEPT
6813 {
6814 std::size_t seed = 0;
6815 VULKAN_HPP_HASH_COMBINE( seed, hostImageLayoutTransitionInfo.sType );
6816 VULKAN_HPP_HASH_COMBINE( seed, hostImageLayoutTransitionInfo.pNext );
6817 VULKAN_HPP_HASH_COMBINE( seed, hostImageLayoutTransitionInfo.image );
6818 VULKAN_HPP_HASH_COMBINE( seed, hostImageLayoutTransitionInfo.oldLayout );
6819 VULKAN_HPP_HASH_COMBINE( seed, hostImageLayoutTransitionInfo.newLayout );
6820 VULKAN_HPP_HASH_COMBINE( seed, hostImageLayoutTransitionInfo.subresourceRange );
6821 return seed;
6822 }
6823 };
6824
6825 # if defined( VK_USE_PLATFORM_IOS_MVK )
6826 template <>
6827 struct hash<VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK>
6828 {
6829 std::size_t operator()( VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK const & iOSSurfaceCreateInfoMVK ) const VULKAN_HPP_NOEXCEPT
6830 {
6831 std::size_t seed = 0;
6832 VULKAN_HPP_HASH_COMBINE( seed, iOSSurfaceCreateInfoMVK.sType );
6833 VULKAN_HPP_HASH_COMBINE( seed, iOSSurfaceCreateInfoMVK.pNext );
6834 VULKAN_HPP_HASH_COMBINE( seed, iOSSurfaceCreateInfoMVK.flags );
6835 VULKAN_HPP_HASH_COMBINE( seed, iOSSurfaceCreateInfoMVK.pView );
6836 return seed;
6837 }
6838 };
6839 # endif /*VK_USE_PLATFORM_IOS_MVK*/
6840
6841 template <>
6842 struct hash<VULKAN_HPP_NAMESPACE::ImageAlignmentControlCreateInfoMESA>
6843 {
6844 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageAlignmentControlCreateInfoMESA const & imageAlignmentControlCreateInfoMESA ) const VULKAN_HPP_NOEXCEPT
6845 {
6846 std::size_t seed = 0;
6847 VULKAN_HPP_HASH_COMBINE( seed, imageAlignmentControlCreateInfoMESA.sType );
6848 VULKAN_HPP_HASH_COMBINE( seed, imageAlignmentControlCreateInfoMESA.pNext );
6849 VULKAN_HPP_HASH_COMBINE( seed, imageAlignmentControlCreateInfoMESA.maximumRequestedAlignment );
6850 return seed;
6851 }
6852 };
6853
6854 template <>
6855 struct hash<VULKAN_HPP_NAMESPACE::ImageBlit>
6856 {
6857 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageBlit const & imageBlit ) const VULKAN_HPP_NOEXCEPT
6858 {
6859 std::size_t seed = 0;
6860 VULKAN_HPP_HASH_COMBINE( seed, imageBlit.srcSubresource );
6861 for ( size_t i = 0; i < 2; ++i )
6862 {
6863 VULKAN_HPP_HASH_COMBINE( seed, imageBlit.srcOffsets[i] );
6864 }
6865 VULKAN_HPP_HASH_COMBINE( seed, imageBlit.dstSubresource );
6866 for ( size_t i = 0; i < 2; ++i )
6867 {
6868 VULKAN_HPP_HASH_COMBINE( seed, imageBlit.dstOffsets[i] );
6869 }
6870 return seed;
6871 }
6872 };
6873
6874 template <>
6875 struct hash<VULKAN_HPP_NAMESPACE::ImageCaptureDescriptorDataInfoEXT>
6876 {
6877 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageCaptureDescriptorDataInfoEXT const & imageCaptureDescriptorDataInfoEXT ) const VULKAN_HPP_NOEXCEPT
6878 {
6879 std::size_t seed = 0;
6880 VULKAN_HPP_HASH_COMBINE( seed, imageCaptureDescriptorDataInfoEXT.sType );
6881 VULKAN_HPP_HASH_COMBINE( seed, imageCaptureDescriptorDataInfoEXT.pNext );
6882 VULKAN_HPP_HASH_COMBINE( seed, imageCaptureDescriptorDataInfoEXT.image );
6883 return seed;
6884 }
6885 };
6886
6887 template <>
6888 struct hash<VULKAN_HPP_NAMESPACE::ImageCompressionControlEXT>
6889 {
6890 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageCompressionControlEXT const & imageCompressionControlEXT ) const VULKAN_HPP_NOEXCEPT
6891 {
6892 std::size_t seed = 0;
6893 VULKAN_HPP_HASH_COMBINE( seed, imageCompressionControlEXT.sType );
6894 VULKAN_HPP_HASH_COMBINE( seed, imageCompressionControlEXT.pNext );
6895 VULKAN_HPP_HASH_COMBINE( seed, imageCompressionControlEXT.flags );
6896 VULKAN_HPP_HASH_COMBINE( seed, imageCompressionControlEXT.compressionControlPlaneCount );
6897 VULKAN_HPP_HASH_COMBINE( seed, imageCompressionControlEXT.pFixedRateFlags );
6898 return seed;
6899 }
6900 };
6901
6902 template <>
6903 struct hash<VULKAN_HPP_NAMESPACE::ImageCompressionPropertiesEXT>
6904 {
6905 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageCompressionPropertiesEXT const & imageCompressionPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
6906 {
6907 std::size_t seed = 0;
6908 VULKAN_HPP_HASH_COMBINE( seed, imageCompressionPropertiesEXT.sType );
6909 VULKAN_HPP_HASH_COMBINE( seed, imageCompressionPropertiesEXT.pNext );
6910 VULKAN_HPP_HASH_COMBINE( seed, imageCompressionPropertiesEXT.imageCompressionFlags );
6911 VULKAN_HPP_HASH_COMBINE( seed, imageCompressionPropertiesEXT.imageCompressionFixedRateFlags );
6912 return seed;
6913 }
6914 };
6915
6916 # if defined( VK_USE_PLATFORM_FUCHSIA )
6917 template <>
6918 struct hash<VULKAN_HPP_NAMESPACE::ImageFormatConstraintsInfoFUCHSIA>
6919 {
6920 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageFormatConstraintsInfoFUCHSIA const & imageFormatConstraintsInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT
6921 {
6922 std::size_t seed = 0;
6923 VULKAN_HPP_HASH_COMBINE( seed, imageFormatConstraintsInfoFUCHSIA.sType );
6924 VULKAN_HPP_HASH_COMBINE( seed, imageFormatConstraintsInfoFUCHSIA.pNext );
6925 VULKAN_HPP_HASH_COMBINE( seed, imageFormatConstraintsInfoFUCHSIA.imageCreateInfo );
6926 VULKAN_HPP_HASH_COMBINE( seed, imageFormatConstraintsInfoFUCHSIA.requiredFormatFeatures );
6927 VULKAN_HPP_HASH_COMBINE( seed, imageFormatConstraintsInfoFUCHSIA.flags );
6928 VULKAN_HPP_HASH_COMBINE( seed, imageFormatConstraintsInfoFUCHSIA.sysmemPixelFormat );
6929 VULKAN_HPP_HASH_COMBINE( seed, imageFormatConstraintsInfoFUCHSIA.colorSpaceCount );
6930 VULKAN_HPP_HASH_COMBINE( seed, imageFormatConstraintsInfoFUCHSIA.pColorSpaces );
6931 return seed;
6932 }
6933 };
6934 # endif /*VK_USE_PLATFORM_FUCHSIA*/
6935
6936 # if defined( VK_USE_PLATFORM_FUCHSIA )
6937 template <>
6938 struct hash<VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFUCHSIA>
6939 {
6940 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFUCHSIA const & imageConstraintsInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT
6941 {
6942 std::size_t seed = 0;
6943 VULKAN_HPP_HASH_COMBINE( seed, imageConstraintsInfoFUCHSIA.sType );
6944 VULKAN_HPP_HASH_COMBINE( seed, imageConstraintsInfoFUCHSIA.pNext );
6945 VULKAN_HPP_HASH_COMBINE( seed, imageConstraintsInfoFUCHSIA.formatConstraintsCount );
6946 VULKAN_HPP_HASH_COMBINE( seed, imageConstraintsInfoFUCHSIA.pFormatConstraints );
6947 VULKAN_HPP_HASH_COMBINE( seed, imageConstraintsInfoFUCHSIA.bufferCollectionConstraints );
6948 VULKAN_HPP_HASH_COMBINE( seed, imageConstraintsInfoFUCHSIA.flags );
6949 return seed;
6950 }
6951 };
6952 # endif /*VK_USE_PLATFORM_FUCHSIA*/
6953
6954 template <>
6955 struct hash<VULKAN_HPP_NAMESPACE::ImageCopy>
6956 {
6957 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageCopy const & imageCopy ) const VULKAN_HPP_NOEXCEPT
6958 {
6959 std::size_t seed = 0;
6960 VULKAN_HPP_HASH_COMBINE( seed, imageCopy.srcSubresource );
6961 VULKAN_HPP_HASH_COMBINE( seed, imageCopy.srcOffset );
6962 VULKAN_HPP_HASH_COMBINE( seed, imageCopy.dstSubresource );
6963 VULKAN_HPP_HASH_COMBINE( seed, imageCopy.dstOffset );
6964 VULKAN_HPP_HASH_COMBINE( seed, imageCopy.extent );
6965 return seed;
6966 }
6967 };
6968
6969 template <>
6970 struct hash<VULKAN_HPP_NAMESPACE::SubresourceLayout>
6971 {
6972 std::size_t operator()( VULKAN_HPP_NAMESPACE::SubresourceLayout const & subresourceLayout ) const VULKAN_HPP_NOEXCEPT
6973 {
6974 std::size_t seed = 0;
6975 VULKAN_HPP_HASH_COMBINE( seed, subresourceLayout.offset );
6976 VULKAN_HPP_HASH_COMBINE( seed, subresourceLayout.size );
6977 VULKAN_HPP_HASH_COMBINE( seed, subresourceLayout.rowPitch );
6978 VULKAN_HPP_HASH_COMBINE( seed, subresourceLayout.arrayPitch );
6979 VULKAN_HPP_HASH_COMBINE( seed, subresourceLayout.depthPitch );
6980 return seed;
6981 }
6982 };
6983
6984 template <>
6985 struct hash<VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierExplicitCreateInfoEXT>
6986 {
6987 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierExplicitCreateInfoEXT const & imageDrmFormatModifierExplicitCreateInfoEXT ) const
6988 VULKAN_HPP_NOEXCEPT
6989 {
6990 std::size_t seed = 0;
6991 VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierExplicitCreateInfoEXT.sType );
6992 VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierExplicitCreateInfoEXT.pNext );
6993 VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierExplicitCreateInfoEXT.drmFormatModifier );
6994 VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierExplicitCreateInfoEXT.drmFormatModifierPlaneCount );
6995 VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierExplicitCreateInfoEXT.pPlaneLayouts );
6996 return seed;
6997 }
6998 };
6999
7000 template <>
7001 struct hash<VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierListCreateInfoEXT>
7002 {
7003 std::size_t
7004 operator()( VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierListCreateInfoEXT const & imageDrmFormatModifierListCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
7005 {
7006 std::size_t seed = 0;
7007 VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierListCreateInfoEXT.sType );
7008 VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierListCreateInfoEXT.pNext );
7009 VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierListCreateInfoEXT.drmFormatModifierCount );
7010 VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierListCreateInfoEXT.pDrmFormatModifiers );
7011 return seed;
7012 }
7013 };
7014
7015 template <>
7016 struct hash<VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT>
7017 {
7018 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT const & imageDrmFormatModifierPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
7019 {
7020 std::size_t seed = 0;
7021 VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierPropertiesEXT.sType );
7022 VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierPropertiesEXT.pNext );
7023 VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierPropertiesEXT.drmFormatModifier );
7024 return seed;
7025 }
7026 };
7027
7028 template <>
7029 struct hash<VULKAN_HPP_NAMESPACE::ImageFormatListCreateInfo>
7030 {
7031 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageFormatListCreateInfo const & imageFormatListCreateInfo ) const VULKAN_HPP_NOEXCEPT
7032 {
7033 std::size_t seed = 0;
7034 VULKAN_HPP_HASH_COMBINE( seed, imageFormatListCreateInfo.sType );
7035 VULKAN_HPP_HASH_COMBINE( seed, imageFormatListCreateInfo.pNext );
7036 VULKAN_HPP_HASH_COMBINE( seed, imageFormatListCreateInfo.viewFormatCount );
7037 VULKAN_HPP_HASH_COMBINE( seed, imageFormatListCreateInfo.pViewFormats );
7038 return seed;
7039 }
7040 };
7041
7042 template <>
7043 struct hash<VULKAN_HPP_NAMESPACE::ImageFormatProperties2>
7044 {
7045 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageFormatProperties2 const & imageFormatProperties2 ) const VULKAN_HPP_NOEXCEPT
7046 {
7047 std::size_t seed = 0;
7048 VULKAN_HPP_HASH_COMBINE( seed, imageFormatProperties2.sType );
7049 VULKAN_HPP_HASH_COMBINE( seed, imageFormatProperties2.pNext );
7050 VULKAN_HPP_HASH_COMBINE( seed, imageFormatProperties2.imageFormatProperties );
7051 return seed;
7052 }
7053 };
7054
7055 template <>
7056 struct hash<VULKAN_HPP_NAMESPACE::ImageMemoryBarrier>
7057 {
7058 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageMemoryBarrier const & imageMemoryBarrier ) const VULKAN_HPP_NOEXCEPT
7059 {
7060 std::size_t seed = 0;
7061 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.sType );
7062 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.pNext );
7063 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.srcAccessMask );
7064 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.dstAccessMask );
7065 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.oldLayout );
7066 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.newLayout );
7067 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.srcQueueFamilyIndex );
7068 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.dstQueueFamilyIndex );
7069 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.image );
7070 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.subresourceRange );
7071 return seed;
7072 }
7073 };
7074
7075 template <>
7076 struct hash<VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2>
7077 {
7078 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 const & imageMemoryRequirementsInfo2 ) const VULKAN_HPP_NOEXCEPT
7079 {
7080 std::size_t seed = 0;
7081 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryRequirementsInfo2.sType );
7082 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryRequirementsInfo2.pNext );
7083 VULKAN_HPP_HASH_COMBINE( seed, imageMemoryRequirementsInfo2.image );
7084 return seed;
7085 }
7086 };
7087
7088 # if defined( VK_USE_PLATFORM_FUCHSIA )
7089 template <>
7090 struct hash<VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA>
7091 {
7092 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA const & imagePipeSurfaceCreateInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT
7093 {
7094 std::size_t seed = 0;
7095 VULKAN_HPP_HASH_COMBINE( seed, imagePipeSurfaceCreateInfoFUCHSIA.sType );
7096 VULKAN_HPP_HASH_COMBINE( seed, imagePipeSurfaceCreateInfoFUCHSIA.pNext );
7097 VULKAN_HPP_HASH_COMBINE( seed, imagePipeSurfaceCreateInfoFUCHSIA.flags );
7098 VULKAN_HPP_HASH_COMBINE( seed, imagePipeSurfaceCreateInfoFUCHSIA.imagePipeHandle );
7099 return seed;
7100 }
7101 };
7102 # endif /*VK_USE_PLATFORM_FUCHSIA*/
7103
7104 template <>
7105 struct hash<VULKAN_HPP_NAMESPACE::ImagePlaneMemoryRequirementsInfo>
7106 {
7107 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImagePlaneMemoryRequirementsInfo const & imagePlaneMemoryRequirementsInfo ) const VULKAN_HPP_NOEXCEPT
7108 {
7109 std::size_t seed = 0;
7110 VULKAN_HPP_HASH_COMBINE( seed, imagePlaneMemoryRequirementsInfo.sType );
7111 VULKAN_HPP_HASH_COMBINE( seed, imagePlaneMemoryRequirementsInfo.pNext );
7112 VULKAN_HPP_HASH_COMBINE( seed, imagePlaneMemoryRequirementsInfo.planeAspect );
7113 return seed;
7114 }
7115 };
7116
7117 template <>
7118 struct hash<VULKAN_HPP_NAMESPACE::ImageResolve>
7119 {
7120 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageResolve const & imageResolve ) const VULKAN_HPP_NOEXCEPT
7121 {
7122 std::size_t seed = 0;
7123 VULKAN_HPP_HASH_COMBINE( seed, imageResolve.srcSubresource );
7124 VULKAN_HPP_HASH_COMBINE( seed, imageResolve.srcOffset );
7125 VULKAN_HPP_HASH_COMBINE( seed, imageResolve.dstSubresource );
7126 VULKAN_HPP_HASH_COMBINE( seed, imageResolve.dstOffset );
7127 VULKAN_HPP_HASH_COMBINE( seed, imageResolve.extent );
7128 return seed;
7129 }
7130 };
7131
7132 template <>
7133 struct hash<VULKAN_HPP_NAMESPACE::ImageResolve2>
7134 {
7135 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageResolve2 const & imageResolve2 ) const VULKAN_HPP_NOEXCEPT
7136 {
7137 std::size_t seed = 0;
7138 VULKAN_HPP_HASH_COMBINE( seed, imageResolve2.sType );
7139 VULKAN_HPP_HASH_COMBINE( seed, imageResolve2.pNext );
7140 VULKAN_HPP_HASH_COMBINE( seed, imageResolve2.srcSubresource );
7141 VULKAN_HPP_HASH_COMBINE( seed, imageResolve2.srcOffset );
7142 VULKAN_HPP_HASH_COMBINE( seed, imageResolve2.dstSubresource );
7143 VULKAN_HPP_HASH_COMBINE( seed, imageResolve2.dstOffset );
7144 VULKAN_HPP_HASH_COMBINE( seed, imageResolve2.extent );
7145 return seed;
7146 }
7147 };
7148
7149 template <>
7150 struct hash<VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2>
7151 {
7152 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 const & imageSparseMemoryRequirementsInfo2 ) const VULKAN_HPP_NOEXCEPT
7153 {
7154 std::size_t seed = 0;
7155 VULKAN_HPP_HASH_COMBINE( seed, imageSparseMemoryRequirementsInfo2.sType );
7156 VULKAN_HPP_HASH_COMBINE( seed, imageSparseMemoryRequirementsInfo2.pNext );
7157 VULKAN_HPP_HASH_COMBINE( seed, imageSparseMemoryRequirementsInfo2.image );
7158 return seed;
7159 }
7160 };
7161
7162 template <>
7163 struct hash<VULKAN_HPP_NAMESPACE::ImageStencilUsageCreateInfo>
7164 {
7165 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageStencilUsageCreateInfo const & imageStencilUsageCreateInfo ) const VULKAN_HPP_NOEXCEPT
7166 {
7167 std::size_t seed = 0;
7168 VULKAN_HPP_HASH_COMBINE( seed, imageStencilUsageCreateInfo.sType );
7169 VULKAN_HPP_HASH_COMBINE( seed, imageStencilUsageCreateInfo.pNext );
7170 VULKAN_HPP_HASH_COMBINE( seed, imageStencilUsageCreateInfo.stencilUsage );
7171 return seed;
7172 }
7173 };
7174
7175 template <>
7176 struct hash<VULKAN_HPP_NAMESPACE::ImageSwapchainCreateInfoKHR>
7177 {
7178 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageSwapchainCreateInfoKHR const & imageSwapchainCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
7179 {
7180 std::size_t seed = 0;
7181 VULKAN_HPP_HASH_COMBINE( seed, imageSwapchainCreateInfoKHR.sType );
7182 VULKAN_HPP_HASH_COMBINE( seed, imageSwapchainCreateInfoKHR.pNext );
7183 VULKAN_HPP_HASH_COMBINE( seed, imageSwapchainCreateInfoKHR.swapchain );
7184 return seed;
7185 }
7186 };
7187
7188 template <>
7189 struct hash<VULKAN_HPP_NAMESPACE::ImageViewASTCDecodeModeEXT>
7190 {
7191 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewASTCDecodeModeEXT const & imageViewASTCDecodeModeEXT ) const VULKAN_HPP_NOEXCEPT
7192 {
7193 std::size_t seed = 0;
7194 VULKAN_HPP_HASH_COMBINE( seed, imageViewASTCDecodeModeEXT.sType );
7195 VULKAN_HPP_HASH_COMBINE( seed, imageViewASTCDecodeModeEXT.pNext );
7196 VULKAN_HPP_HASH_COMBINE( seed, imageViewASTCDecodeModeEXT.decodeMode );
7197 return seed;
7198 }
7199 };
7200
7201 template <>
7202 struct hash<VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX>
7203 {
7204 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX const & imageViewAddressPropertiesNVX ) const VULKAN_HPP_NOEXCEPT
7205 {
7206 std::size_t seed = 0;
7207 VULKAN_HPP_HASH_COMBINE( seed, imageViewAddressPropertiesNVX.sType );
7208 VULKAN_HPP_HASH_COMBINE( seed, imageViewAddressPropertiesNVX.pNext );
7209 VULKAN_HPP_HASH_COMBINE( seed, imageViewAddressPropertiesNVX.deviceAddress );
7210 VULKAN_HPP_HASH_COMBINE( seed, imageViewAddressPropertiesNVX.size );
7211 return seed;
7212 }
7213 };
7214
7215 template <>
7216 struct hash<VULKAN_HPP_NAMESPACE::ImageViewCaptureDescriptorDataInfoEXT>
7217 {
7218 std::size_t
7219 operator()( VULKAN_HPP_NAMESPACE::ImageViewCaptureDescriptorDataInfoEXT const & imageViewCaptureDescriptorDataInfoEXT ) const VULKAN_HPP_NOEXCEPT
7220 {
7221 std::size_t seed = 0;
7222 VULKAN_HPP_HASH_COMBINE( seed, imageViewCaptureDescriptorDataInfoEXT.sType );
7223 VULKAN_HPP_HASH_COMBINE( seed, imageViewCaptureDescriptorDataInfoEXT.pNext );
7224 VULKAN_HPP_HASH_COMBINE( seed, imageViewCaptureDescriptorDataInfoEXT.imageView );
7225 return seed;
7226 }
7227 };
7228
7229 template <>
7230 struct hash<VULKAN_HPP_NAMESPACE::ImageViewCreateInfo>
7231 {
7232 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewCreateInfo const & imageViewCreateInfo ) const VULKAN_HPP_NOEXCEPT
7233 {
7234 std::size_t seed = 0;
7235 VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.sType );
7236 VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.pNext );
7237 VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.flags );
7238 VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.image );
7239 VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.viewType );
7240 VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.format );
7241 VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.components );
7242 VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.subresourceRange );
7243 return seed;
7244 }
7245 };
7246
7247 template <>
7248 struct hash<VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX>
7249 {
7250 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX const & imageViewHandleInfoNVX ) const VULKAN_HPP_NOEXCEPT
7251 {
7252 std::size_t seed = 0;
7253 VULKAN_HPP_HASH_COMBINE( seed, imageViewHandleInfoNVX.sType );
7254 VULKAN_HPP_HASH_COMBINE( seed, imageViewHandleInfoNVX.pNext );
7255 VULKAN_HPP_HASH_COMBINE( seed, imageViewHandleInfoNVX.imageView );
7256 VULKAN_HPP_HASH_COMBINE( seed, imageViewHandleInfoNVX.descriptorType );
7257 VULKAN_HPP_HASH_COMBINE( seed, imageViewHandleInfoNVX.sampler );
7258 return seed;
7259 }
7260 };
7261
7262 template <>
7263 struct hash<VULKAN_HPP_NAMESPACE::ImageViewMinLodCreateInfoEXT>
7264 {
7265 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewMinLodCreateInfoEXT const & imageViewMinLodCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
7266 {
7267 std::size_t seed = 0;
7268 VULKAN_HPP_HASH_COMBINE( seed, imageViewMinLodCreateInfoEXT.sType );
7269 VULKAN_HPP_HASH_COMBINE( seed, imageViewMinLodCreateInfoEXT.pNext );
7270 VULKAN_HPP_HASH_COMBINE( seed, imageViewMinLodCreateInfoEXT.minLod );
7271 return seed;
7272 }
7273 };
7274
7275 template <>
7276 struct hash<VULKAN_HPP_NAMESPACE::ImageViewSampleWeightCreateInfoQCOM>
7277 {
7278 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewSampleWeightCreateInfoQCOM const & imageViewSampleWeightCreateInfoQCOM ) const VULKAN_HPP_NOEXCEPT
7279 {
7280 std::size_t seed = 0;
7281 VULKAN_HPP_HASH_COMBINE( seed, imageViewSampleWeightCreateInfoQCOM.sType );
7282 VULKAN_HPP_HASH_COMBINE( seed, imageViewSampleWeightCreateInfoQCOM.pNext );
7283 VULKAN_HPP_HASH_COMBINE( seed, imageViewSampleWeightCreateInfoQCOM.filterCenter );
7284 VULKAN_HPP_HASH_COMBINE( seed, imageViewSampleWeightCreateInfoQCOM.filterSize );
7285 VULKAN_HPP_HASH_COMBINE( seed, imageViewSampleWeightCreateInfoQCOM.numPhases );
7286 return seed;
7287 }
7288 };
7289
7290 template <>
7291 struct hash<VULKAN_HPP_NAMESPACE::ImageViewSlicedCreateInfoEXT>
7292 {
7293 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewSlicedCreateInfoEXT const & imageViewSlicedCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
7294 {
7295 std::size_t seed = 0;
7296 VULKAN_HPP_HASH_COMBINE( seed, imageViewSlicedCreateInfoEXT.sType );
7297 VULKAN_HPP_HASH_COMBINE( seed, imageViewSlicedCreateInfoEXT.pNext );
7298 VULKAN_HPP_HASH_COMBINE( seed, imageViewSlicedCreateInfoEXT.sliceOffset );
7299 VULKAN_HPP_HASH_COMBINE( seed, imageViewSlicedCreateInfoEXT.sliceCount );
7300 return seed;
7301 }
7302 };
7303
7304 template <>
7305 struct hash<VULKAN_HPP_NAMESPACE::ImageViewUsageCreateInfo>
7306 {
7307 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewUsageCreateInfo const & imageViewUsageCreateInfo ) const VULKAN_HPP_NOEXCEPT
7308 {
7309 std::size_t seed = 0;
7310 VULKAN_HPP_HASH_COMBINE( seed, imageViewUsageCreateInfo.sType );
7311 VULKAN_HPP_HASH_COMBINE( seed, imageViewUsageCreateInfo.pNext );
7312 VULKAN_HPP_HASH_COMBINE( seed, imageViewUsageCreateInfo.usage );
7313 return seed;
7314 }
7315 };
7316
7317 # if defined( VK_USE_PLATFORM_ANDROID_KHR )
7318 template <>
7319 struct hash<VULKAN_HPP_NAMESPACE::ImportAndroidHardwareBufferInfoANDROID>
7320 {
7321 std::size_t
7322 operator()( VULKAN_HPP_NAMESPACE::ImportAndroidHardwareBufferInfoANDROID const & importAndroidHardwareBufferInfoANDROID ) const VULKAN_HPP_NOEXCEPT
7323 {
7324 std::size_t seed = 0;
7325 VULKAN_HPP_HASH_COMBINE( seed, importAndroidHardwareBufferInfoANDROID.sType );
7326 VULKAN_HPP_HASH_COMBINE( seed, importAndroidHardwareBufferInfoANDROID.pNext );
7327 VULKAN_HPP_HASH_COMBINE( seed, importAndroidHardwareBufferInfoANDROID.buffer );
7328 return seed;
7329 }
7330 };
7331 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/
7332
7333 template <>
7334 struct hash<VULKAN_HPP_NAMESPACE::ImportFenceFdInfoKHR>
7335 {
7336 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportFenceFdInfoKHR const & importFenceFdInfoKHR ) const VULKAN_HPP_NOEXCEPT
7337 {
7338 std::size_t seed = 0;
7339 VULKAN_HPP_HASH_COMBINE( seed, importFenceFdInfoKHR.sType );
7340 VULKAN_HPP_HASH_COMBINE( seed, importFenceFdInfoKHR.pNext );
7341 VULKAN_HPP_HASH_COMBINE( seed, importFenceFdInfoKHR.fence );
7342 VULKAN_HPP_HASH_COMBINE( seed, importFenceFdInfoKHR.flags );
7343 VULKAN_HPP_HASH_COMBINE( seed, importFenceFdInfoKHR.handleType );
7344 VULKAN_HPP_HASH_COMBINE( seed, importFenceFdInfoKHR.fd );
7345 return seed;
7346 }
7347 };
7348
7349 # if defined( VK_USE_PLATFORM_WIN32_KHR )
7350 template <>
7351 struct hash<VULKAN_HPP_NAMESPACE::ImportFenceWin32HandleInfoKHR>
7352 {
7353 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportFenceWin32HandleInfoKHR const & importFenceWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT
7354 {
7355 std::size_t seed = 0;
7356 VULKAN_HPP_HASH_COMBINE( seed, importFenceWin32HandleInfoKHR.sType );
7357 VULKAN_HPP_HASH_COMBINE( seed, importFenceWin32HandleInfoKHR.pNext );
7358 VULKAN_HPP_HASH_COMBINE( seed, importFenceWin32HandleInfoKHR.fence );
7359 VULKAN_HPP_HASH_COMBINE( seed, importFenceWin32HandleInfoKHR.flags );
7360 VULKAN_HPP_HASH_COMBINE( seed, importFenceWin32HandleInfoKHR.handleType );
7361 VULKAN_HPP_HASH_COMBINE( seed, importFenceWin32HandleInfoKHR.handle );
7362 VULKAN_HPP_HASH_COMBINE( seed, importFenceWin32HandleInfoKHR.name );
7363 return seed;
7364 }
7365 };
7366 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
7367
7368 # if defined( VK_USE_PLATFORM_FUCHSIA )
7369 template <>
7370 struct hash<VULKAN_HPP_NAMESPACE::ImportMemoryBufferCollectionFUCHSIA>
7371 {
7372 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMemoryBufferCollectionFUCHSIA const & importMemoryBufferCollectionFUCHSIA ) const VULKAN_HPP_NOEXCEPT
7373 {
7374 std::size_t seed = 0;
7375 VULKAN_HPP_HASH_COMBINE( seed, importMemoryBufferCollectionFUCHSIA.sType );
7376 VULKAN_HPP_HASH_COMBINE( seed, importMemoryBufferCollectionFUCHSIA.pNext );
7377 VULKAN_HPP_HASH_COMBINE( seed, importMemoryBufferCollectionFUCHSIA.collection );
7378 VULKAN_HPP_HASH_COMBINE( seed, importMemoryBufferCollectionFUCHSIA.index );
7379 return seed;
7380 }
7381 };
7382 # endif /*VK_USE_PLATFORM_FUCHSIA*/
7383
7384 template <>
7385 struct hash<VULKAN_HPP_NAMESPACE::ImportMemoryFdInfoKHR>
7386 {
7387 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMemoryFdInfoKHR const & importMemoryFdInfoKHR ) const VULKAN_HPP_NOEXCEPT
7388 {
7389 std::size_t seed = 0;
7390 VULKAN_HPP_HASH_COMBINE( seed, importMemoryFdInfoKHR.sType );
7391 VULKAN_HPP_HASH_COMBINE( seed, importMemoryFdInfoKHR.pNext );
7392 VULKAN_HPP_HASH_COMBINE( seed, importMemoryFdInfoKHR.handleType );
7393 VULKAN_HPP_HASH_COMBINE( seed, importMemoryFdInfoKHR.fd );
7394 return seed;
7395 }
7396 };
7397
7398 template <>
7399 struct hash<VULKAN_HPP_NAMESPACE::ImportMemoryHostPointerInfoEXT>
7400 {
7401 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMemoryHostPointerInfoEXT const & importMemoryHostPointerInfoEXT ) const VULKAN_HPP_NOEXCEPT
7402 {
7403 std::size_t seed = 0;
7404 VULKAN_HPP_HASH_COMBINE( seed, importMemoryHostPointerInfoEXT.sType );
7405 VULKAN_HPP_HASH_COMBINE( seed, importMemoryHostPointerInfoEXT.pNext );
7406 VULKAN_HPP_HASH_COMBINE( seed, importMemoryHostPointerInfoEXT.handleType );
7407 VULKAN_HPP_HASH_COMBINE( seed, importMemoryHostPointerInfoEXT.pHostPointer );
7408 return seed;
7409 }
7410 };
7411
7412 # if defined( VK_USE_PLATFORM_METAL_EXT )
7413 template <>
7414 struct hash<VULKAN_HPP_NAMESPACE::ImportMemoryMetalHandleInfoEXT>
7415 {
7416 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMemoryMetalHandleInfoEXT const & importMemoryMetalHandleInfoEXT ) const VULKAN_HPP_NOEXCEPT
7417 {
7418 std::size_t seed = 0;
7419 VULKAN_HPP_HASH_COMBINE( seed, importMemoryMetalHandleInfoEXT.sType );
7420 VULKAN_HPP_HASH_COMBINE( seed, importMemoryMetalHandleInfoEXT.pNext );
7421 VULKAN_HPP_HASH_COMBINE( seed, importMemoryMetalHandleInfoEXT.handleType );
7422 VULKAN_HPP_HASH_COMBINE( seed, importMemoryMetalHandleInfoEXT.handle );
7423 return seed;
7424 }
7425 };
7426 # endif /*VK_USE_PLATFORM_METAL_EXT*/
7427
7428 # if defined( VK_USE_PLATFORM_WIN32_KHR )
7429 template <>
7430 struct hash<VULKAN_HPP_NAMESPACE::ImportMemoryWin32HandleInfoKHR>
7431 {
7432 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMemoryWin32HandleInfoKHR const & importMemoryWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT
7433 {
7434 std::size_t seed = 0;
7435 VULKAN_HPP_HASH_COMBINE( seed, importMemoryWin32HandleInfoKHR.sType );
7436 VULKAN_HPP_HASH_COMBINE( seed, importMemoryWin32HandleInfoKHR.pNext );
7437 VULKAN_HPP_HASH_COMBINE( seed, importMemoryWin32HandleInfoKHR.handleType );
7438 VULKAN_HPP_HASH_COMBINE( seed, importMemoryWin32HandleInfoKHR.handle );
7439 VULKAN_HPP_HASH_COMBINE( seed, importMemoryWin32HandleInfoKHR.name );
7440 return seed;
7441 }
7442 };
7443 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
7444
7445 # if defined( VK_USE_PLATFORM_WIN32_KHR )
7446 template <>
7447 struct hash<VULKAN_HPP_NAMESPACE::ImportMemoryWin32HandleInfoNV>
7448 {
7449 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMemoryWin32HandleInfoNV const & importMemoryWin32HandleInfoNV ) const VULKAN_HPP_NOEXCEPT
7450 {
7451 std::size_t seed = 0;
7452 VULKAN_HPP_HASH_COMBINE( seed, importMemoryWin32HandleInfoNV.sType );
7453 VULKAN_HPP_HASH_COMBINE( seed, importMemoryWin32HandleInfoNV.pNext );
7454 VULKAN_HPP_HASH_COMBINE( seed, importMemoryWin32HandleInfoNV.handleType );
7455 VULKAN_HPP_HASH_COMBINE( seed, importMemoryWin32HandleInfoNV.handle );
7456 return seed;
7457 }
7458 };
7459 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
7460
7461 # if defined( VK_USE_PLATFORM_FUCHSIA )
7462 template <>
7463 struct hash<VULKAN_HPP_NAMESPACE::ImportMemoryZirconHandleInfoFUCHSIA>
7464 {
7465 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMemoryZirconHandleInfoFUCHSIA const & importMemoryZirconHandleInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT
7466 {
7467 std::size_t seed = 0;
7468 VULKAN_HPP_HASH_COMBINE( seed, importMemoryZirconHandleInfoFUCHSIA.sType );
7469 VULKAN_HPP_HASH_COMBINE( seed, importMemoryZirconHandleInfoFUCHSIA.pNext );
7470 VULKAN_HPP_HASH_COMBINE( seed, importMemoryZirconHandleInfoFUCHSIA.handleType );
7471 VULKAN_HPP_HASH_COMBINE( seed, importMemoryZirconHandleInfoFUCHSIA.handle );
7472 return seed;
7473 }
7474 };
7475 # endif /*VK_USE_PLATFORM_FUCHSIA*/
7476
7477 # if defined( VK_USE_PLATFORM_METAL_EXT )
7478 template <>
7479 struct hash<VULKAN_HPP_NAMESPACE::ImportMetalBufferInfoEXT>
7480 {
7481 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMetalBufferInfoEXT const & importMetalBufferInfoEXT ) const VULKAN_HPP_NOEXCEPT
7482 {
7483 std::size_t seed = 0;
7484 VULKAN_HPP_HASH_COMBINE( seed, importMetalBufferInfoEXT.sType );
7485 VULKAN_HPP_HASH_COMBINE( seed, importMetalBufferInfoEXT.pNext );
7486 VULKAN_HPP_HASH_COMBINE( seed, importMetalBufferInfoEXT.mtlBuffer );
7487 return seed;
7488 }
7489 };
7490 # endif /*VK_USE_PLATFORM_METAL_EXT*/
7491
7492 # if defined( VK_USE_PLATFORM_METAL_EXT )
7493 template <>
7494 struct hash<VULKAN_HPP_NAMESPACE::ImportMetalIOSurfaceInfoEXT>
7495 {
7496 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMetalIOSurfaceInfoEXT const & importMetalIOSurfaceInfoEXT ) const VULKAN_HPP_NOEXCEPT
7497 {
7498 std::size_t seed = 0;
7499 VULKAN_HPP_HASH_COMBINE( seed, importMetalIOSurfaceInfoEXT.sType );
7500 VULKAN_HPP_HASH_COMBINE( seed, importMetalIOSurfaceInfoEXT.pNext );
7501 VULKAN_HPP_HASH_COMBINE( seed, importMetalIOSurfaceInfoEXT.ioSurface );
7502 return seed;
7503 }
7504 };
7505 # endif /*VK_USE_PLATFORM_METAL_EXT*/
7506
7507 # if defined( VK_USE_PLATFORM_METAL_EXT )
7508 template <>
7509 struct hash<VULKAN_HPP_NAMESPACE::ImportMetalSharedEventInfoEXT>
7510 {
7511 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMetalSharedEventInfoEXT const & importMetalSharedEventInfoEXT ) const VULKAN_HPP_NOEXCEPT
7512 {
7513 std::size_t seed = 0;
7514 VULKAN_HPP_HASH_COMBINE( seed, importMetalSharedEventInfoEXT.sType );
7515 VULKAN_HPP_HASH_COMBINE( seed, importMetalSharedEventInfoEXT.pNext );
7516 VULKAN_HPP_HASH_COMBINE( seed, importMetalSharedEventInfoEXT.mtlSharedEvent );
7517 return seed;
7518 }
7519 };
7520 # endif /*VK_USE_PLATFORM_METAL_EXT*/
7521
7522 # if defined( VK_USE_PLATFORM_METAL_EXT )
7523 template <>
7524 struct hash<VULKAN_HPP_NAMESPACE::ImportMetalTextureInfoEXT>
7525 {
7526 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMetalTextureInfoEXT const & importMetalTextureInfoEXT ) const VULKAN_HPP_NOEXCEPT
7527 {
7528 std::size_t seed = 0;
7529 VULKAN_HPP_HASH_COMBINE( seed, importMetalTextureInfoEXT.sType );
7530 VULKAN_HPP_HASH_COMBINE( seed, importMetalTextureInfoEXT.pNext );
7531 VULKAN_HPP_HASH_COMBINE( seed, importMetalTextureInfoEXT.plane );
7532 VULKAN_HPP_HASH_COMBINE( seed, importMetalTextureInfoEXT.mtlTexture );
7533 return seed;
7534 }
7535 };
7536 # endif /*VK_USE_PLATFORM_METAL_EXT*/
7537
7538 # if defined( VK_USE_PLATFORM_OHOS )
7539 template <>
7540 struct hash<VULKAN_HPP_NAMESPACE::ImportNativeBufferInfoOHOS>
7541 {
7542 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportNativeBufferInfoOHOS const & importNativeBufferInfoOHOS ) const VULKAN_HPP_NOEXCEPT
7543 {
7544 std::size_t seed = 0;
7545 VULKAN_HPP_HASH_COMBINE( seed, importNativeBufferInfoOHOS.sType );
7546 VULKAN_HPP_HASH_COMBINE( seed, importNativeBufferInfoOHOS.pNext );
7547 VULKAN_HPP_HASH_COMBINE( seed, importNativeBufferInfoOHOS.buffer );
7548 return seed;
7549 }
7550 };
7551 # endif /*VK_USE_PLATFORM_OHOS*/
7552
7553 # if defined( VK_USE_PLATFORM_SCREEN_QNX )
7554 template <>
7555 struct hash<VULKAN_HPP_NAMESPACE::ImportScreenBufferInfoQNX>
7556 {
7557 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportScreenBufferInfoQNX const & importScreenBufferInfoQNX ) const VULKAN_HPP_NOEXCEPT
7558 {
7559 std::size_t seed = 0;
7560 VULKAN_HPP_HASH_COMBINE( seed, importScreenBufferInfoQNX.sType );
7561 VULKAN_HPP_HASH_COMBINE( seed, importScreenBufferInfoQNX.pNext );
7562 VULKAN_HPP_HASH_COMBINE( seed, importScreenBufferInfoQNX.buffer );
7563 return seed;
7564 }
7565 };
7566 # endif /*VK_USE_PLATFORM_SCREEN_QNX*/
7567
7568 template <>
7569 struct hash<VULKAN_HPP_NAMESPACE::ImportSemaphoreFdInfoKHR>
7570 {
7571 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportSemaphoreFdInfoKHR const & importSemaphoreFdInfoKHR ) const VULKAN_HPP_NOEXCEPT
7572 {
7573 std::size_t seed = 0;
7574 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreFdInfoKHR.sType );
7575 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreFdInfoKHR.pNext );
7576 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreFdInfoKHR.semaphore );
7577 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreFdInfoKHR.flags );
7578 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreFdInfoKHR.handleType );
7579 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreFdInfoKHR.fd );
7580 return seed;
7581 }
7582 };
7583
7584 # if defined( VK_USE_PLATFORM_WIN32_KHR )
7585 template <>
7586 struct hash<VULKAN_HPP_NAMESPACE::ImportSemaphoreWin32HandleInfoKHR>
7587 {
7588 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportSemaphoreWin32HandleInfoKHR const & importSemaphoreWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT
7589 {
7590 std::size_t seed = 0;
7591 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreWin32HandleInfoKHR.sType );
7592 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreWin32HandleInfoKHR.pNext );
7593 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreWin32HandleInfoKHR.semaphore );
7594 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreWin32HandleInfoKHR.flags );
7595 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreWin32HandleInfoKHR.handleType );
7596 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreWin32HandleInfoKHR.handle );
7597 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreWin32HandleInfoKHR.name );
7598 return seed;
7599 }
7600 };
7601 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
7602
7603 # if defined( VK_USE_PLATFORM_FUCHSIA )
7604 template <>
7605 struct hash<VULKAN_HPP_NAMESPACE::ImportSemaphoreZirconHandleInfoFUCHSIA>
7606 {
7607 std::size_t
7608 operator()( VULKAN_HPP_NAMESPACE::ImportSemaphoreZirconHandleInfoFUCHSIA const & importSemaphoreZirconHandleInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT
7609 {
7610 std::size_t seed = 0;
7611 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreZirconHandleInfoFUCHSIA.sType );
7612 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreZirconHandleInfoFUCHSIA.pNext );
7613 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreZirconHandleInfoFUCHSIA.semaphore );
7614 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreZirconHandleInfoFUCHSIA.flags );
7615 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreZirconHandleInfoFUCHSIA.handleType );
7616 VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreZirconHandleInfoFUCHSIA.zirconHandle );
7617 return seed;
7618 }
7619 };
7620 # endif /*VK_USE_PLATFORM_FUCHSIA*/
7621
7622 template <>
7623 struct hash<VULKAN_HPP_NAMESPACE::IndirectCommandsExecutionSetTokenEXT>
7624 {
7625 std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectCommandsExecutionSetTokenEXT const & indirectCommandsExecutionSetTokenEXT ) const VULKAN_HPP_NOEXCEPT
7626 {
7627 std::size_t seed = 0;
7628 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsExecutionSetTokenEXT.type );
7629 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsExecutionSetTokenEXT.shaderStages );
7630 return seed;
7631 }
7632 };
7633
7634 template <>
7635 struct hash<VULKAN_HPP_NAMESPACE::IndirectCommandsIndexBufferTokenEXT>
7636 {
7637 std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectCommandsIndexBufferTokenEXT const & indirectCommandsIndexBufferTokenEXT ) const VULKAN_HPP_NOEXCEPT
7638 {
7639 std::size_t seed = 0;
7640 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsIndexBufferTokenEXT.mode );
7641 return seed;
7642 }
7643 };
7644
7645 template <>
7646 struct hash<VULKAN_HPP_NAMESPACE::PushConstantRange>
7647 {
7648 std::size_t operator()( VULKAN_HPP_NAMESPACE::PushConstantRange const & pushConstantRange ) const VULKAN_HPP_NOEXCEPT
7649 {
7650 std::size_t seed = 0;
7651 VULKAN_HPP_HASH_COMBINE( seed, pushConstantRange.stageFlags );
7652 VULKAN_HPP_HASH_COMBINE( seed, pushConstantRange.offset );
7653 VULKAN_HPP_HASH_COMBINE( seed, pushConstantRange.size );
7654 return seed;
7655 }
7656 };
7657
7658 template <>
7659 struct hash<VULKAN_HPP_NAMESPACE::IndirectCommandsPushConstantTokenEXT>
7660 {
7661 std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectCommandsPushConstantTokenEXT const & indirectCommandsPushConstantTokenEXT ) const VULKAN_HPP_NOEXCEPT
7662 {
7663 std::size_t seed = 0;
7664 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsPushConstantTokenEXT.updateRange );
7665 return seed;
7666 }
7667 };
7668
7669 template <>
7670 struct hash<VULKAN_HPP_NAMESPACE::IndirectCommandsVertexBufferTokenEXT>
7671 {
7672 std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectCommandsVertexBufferTokenEXT const & indirectCommandsVertexBufferTokenEXT ) const VULKAN_HPP_NOEXCEPT
7673 {
7674 std::size_t seed = 0;
7675 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsVertexBufferTokenEXT.vertexBindingUnit );
7676 return seed;
7677 }
7678 };
7679
7680 template <>
7681 struct hash<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoEXT>
7682 {
7683 std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoEXT const & indirectCommandsLayoutCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
7684 {
7685 std::size_t seed = 0;
7686 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoEXT.sType );
7687 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoEXT.pNext );
7688 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoEXT.flags );
7689 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoEXT.shaderStages );
7690 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoEXT.indirectStride );
7691 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoEXT.pipelineLayout );
7692 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoEXT.tokenCount );
7693 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoEXT.pTokens );
7694 return seed;
7695 }
7696 };
7697
7698 template <>
7699 struct hash<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutTokenNV>
7700 {
7701 std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutTokenNV const & indirectCommandsLayoutTokenNV ) const VULKAN_HPP_NOEXCEPT
7702 {
7703 std::size_t seed = 0;
7704 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.sType );
7705 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.pNext );
7706 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.tokenType );
7707 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.stream );
7708 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.offset );
7709 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.vertexBindingUnit );
7710 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.vertexDynamicStride );
7711 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.pushconstantPipelineLayout );
7712 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.pushconstantShaderStageFlags );
7713 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.pushconstantOffset );
7714 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.pushconstantSize );
7715 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.indirectStateFlags );
7716 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.indexTypeCount );
7717 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.pIndexTypes );
7718 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.pIndexTypeValues );
7719 return seed;
7720 }
7721 };
7722
7723 template <>
7724 struct hash<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV>
7725 {
7726 std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV const & indirectCommandsLayoutCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
7727 {
7728 std::size_t seed = 0;
7729 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoNV.sType );
7730 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoNV.pNext );
7731 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoNV.flags );
7732 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoNV.pipelineBindPoint );
7733 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoNV.tokenCount );
7734 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoNV.pTokens );
7735 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoNV.streamCount );
7736 VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoNV.pStreamStrides );
7737 return seed;
7738 }
7739 };
7740
7741 template <>
7742 struct hash<VULKAN_HPP_NAMESPACE::IndirectExecutionSetPipelineInfoEXT>
7743 {
7744 std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectExecutionSetPipelineInfoEXT const & indirectExecutionSetPipelineInfoEXT ) const VULKAN_HPP_NOEXCEPT
7745 {
7746 std::size_t seed = 0;
7747 VULKAN_HPP_HASH_COMBINE( seed, indirectExecutionSetPipelineInfoEXT.sType );
7748 VULKAN_HPP_HASH_COMBINE( seed, indirectExecutionSetPipelineInfoEXT.pNext );
7749 VULKAN_HPP_HASH_COMBINE( seed, indirectExecutionSetPipelineInfoEXT.initialPipeline );
7750 VULKAN_HPP_HASH_COMBINE( seed, indirectExecutionSetPipelineInfoEXT.maxPipelineCount );
7751 return seed;
7752 }
7753 };
7754
7755 template <>
7756 struct hash<VULKAN_HPP_NAMESPACE::IndirectExecutionSetShaderLayoutInfoEXT>
7757 {
7758 std::size_t
7759 operator()( VULKAN_HPP_NAMESPACE::IndirectExecutionSetShaderLayoutInfoEXT const & indirectExecutionSetShaderLayoutInfoEXT ) const VULKAN_HPP_NOEXCEPT
7760 {
7761 std::size_t seed = 0;
7762 VULKAN_HPP_HASH_COMBINE( seed, indirectExecutionSetShaderLayoutInfoEXT.sType );
7763 VULKAN_HPP_HASH_COMBINE( seed, indirectExecutionSetShaderLayoutInfoEXT.pNext );
7764 VULKAN_HPP_HASH_COMBINE( seed, indirectExecutionSetShaderLayoutInfoEXT.setLayoutCount );
7765 VULKAN_HPP_HASH_COMBINE( seed, indirectExecutionSetShaderLayoutInfoEXT.pSetLayouts );
7766 return seed;
7767 }
7768 };
7769
7770 template <>
7771 struct hash<VULKAN_HPP_NAMESPACE::IndirectExecutionSetShaderInfoEXT>
7772 {
7773 std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectExecutionSetShaderInfoEXT const & indirectExecutionSetShaderInfoEXT ) const VULKAN_HPP_NOEXCEPT
7774 {
7775 std::size_t seed = 0;
7776 VULKAN_HPP_HASH_COMBINE( seed, indirectExecutionSetShaderInfoEXT.sType );
7777 VULKAN_HPP_HASH_COMBINE( seed, indirectExecutionSetShaderInfoEXT.pNext );
7778 VULKAN_HPP_HASH_COMBINE( seed, indirectExecutionSetShaderInfoEXT.shaderCount );
7779 VULKAN_HPP_HASH_COMBINE( seed, indirectExecutionSetShaderInfoEXT.pInitialShaders );
7780 VULKAN_HPP_HASH_COMBINE( seed, indirectExecutionSetShaderInfoEXT.pSetLayoutInfos );
7781 VULKAN_HPP_HASH_COMBINE( seed, indirectExecutionSetShaderInfoEXT.maxShaderCount );
7782 VULKAN_HPP_HASH_COMBINE( seed, indirectExecutionSetShaderInfoEXT.pushConstantRangeCount );
7783 VULKAN_HPP_HASH_COMBINE( seed, indirectExecutionSetShaderInfoEXT.pPushConstantRanges );
7784 return seed;
7785 }
7786 };
7787
7788 template <>
7789 struct hash<VULKAN_HPP_NAMESPACE::InitializePerformanceApiInfoINTEL>
7790 {
7791 std::size_t operator()( VULKAN_HPP_NAMESPACE::InitializePerformanceApiInfoINTEL const & initializePerformanceApiInfoINTEL ) const VULKAN_HPP_NOEXCEPT
7792 {
7793 std::size_t seed = 0;
7794 VULKAN_HPP_HASH_COMBINE( seed, initializePerformanceApiInfoINTEL.sType );
7795 VULKAN_HPP_HASH_COMBINE( seed, initializePerformanceApiInfoINTEL.pNext );
7796 VULKAN_HPP_HASH_COMBINE( seed, initializePerformanceApiInfoINTEL.pUserData );
7797 return seed;
7798 }
7799 };
7800
7801 template <>
7802 struct hash<VULKAN_HPP_NAMESPACE::InputAttachmentAspectReference>
7803 {
7804 std::size_t operator()( VULKAN_HPP_NAMESPACE::InputAttachmentAspectReference const & inputAttachmentAspectReference ) const VULKAN_HPP_NOEXCEPT
7805 {
7806 std::size_t seed = 0;
7807 VULKAN_HPP_HASH_COMBINE( seed, inputAttachmentAspectReference.subpass );
7808 VULKAN_HPP_HASH_COMBINE( seed, inputAttachmentAspectReference.inputAttachmentIndex );
7809 VULKAN_HPP_HASH_COMBINE( seed, inputAttachmentAspectReference.aspectMask );
7810 return seed;
7811 }
7812 };
7813
7814 template <>
7815 struct hash<VULKAN_HPP_NAMESPACE::InstanceCreateInfo>
7816 {
7817 std::size_t operator()( VULKAN_HPP_NAMESPACE::InstanceCreateInfo const & instanceCreateInfo ) const VULKAN_HPP_NOEXCEPT
7818 {
7819 std::size_t seed = 0;
7820 VULKAN_HPP_HASH_COMBINE( seed, instanceCreateInfo.sType );
7821 VULKAN_HPP_HASH_COMBINE( seed, instanceCreateInfo.pNext );
7822 VULKAN_HPP_HASH_COMBINE( seed, instanceCreateInfo.flags );
7823 VULKAN_HPP_HASH_COMBINE( seed, instanceCreateInfo.pApplicationInfo );
7824 VULKAN_HPP_HASH_COMBINE( seed, instanceCreateInfo.enabledLayerCount );
7825 for ( size_t i = 0; i < instanceCreateInfo.enabledLayerCount; ++i )
7826 {
7827 for ( const char * p = instanceCreateInfo.ppEnabledLayerNames[i]; *p != '\0'; ++p )
7828 {
7829 VULKAN_HPP_HASH_COMBINE( seed, *p );
7830 }
7831 }
7832 VULKAN_HPP_HASH_COMBINE( seed, instanceCreateInfo.enabledExtensionCount );
7833 for ( size_t i = 0; i < instanceCreateInfo.enabledExtensionCount; ++i )
7834 {
7835 for ( const char * p = instanceCreateInfo.ppEnabledExtensionNames[i]; *p != '\0'; ++p )
7836 {
7837 VULKAN_HPP_HASH_COMBINE( seed, *p );
7838 }
7839 }
7840 return seed;
7841 }
7842 };
7843
7844 template <>
7845 struct hash<VULKAN_HPP_NAMESPACE::LatencySleepInfoNV>
7846 {
7847 std::size_t operator()( VULKAN_HPP_NAMESPACE::LatencySleepInfoNV const & latencySleepInfoNV ) const VULKAN_HPP_NOEXCEPT
7848 {
7849 std::size_t seed = 0;
7850 VULKAN_HPP_HASH_COMBINE( seed, latencySleepInfoNV.sType );
7851 VULKAN_HPP_HASH_COMBINE( seed, latencySleepInfoNV.pNext );
7852 VULKAN_HPP_HASH_COMBINE( seed, latencySleepInfoNV.signalSemaphore );
7853 VULKAN_HPP_HASH_COMBINE( seed, latencySleepInfoNV.value );
7854 return seed;
7855 }
7856 };
7857
7858 template <>
7859 struct hash<VULKAN_HPP_NAMESPACE::LatencySleepModeInfoNV>
7860 {
7861 std::size_t operator()( VULKAN_HPP_NAMESPACE::LatencySleepModeInfoNV const & latencySleepModeInfoNV ) const VULKAN_HPP_NOEXCEPT
7862 {
7863 std::size_t seed = 0;
7864 VULKAN_HPP_HASH_COMBINE( seed, latencySleepModeInfoNV.sType );
7865 VULKAN_HPP_HASH_COMBINE( seed, latencySleepModeInfoNV.pNext );
7866 VULKAN_HPP_HASH_COMBINE( seed, latencySleepModeInfoNV.lowLatencyMode );
7867 VULKAN_HPP_HASH_COMBINE( seed, latencySleepModeInfoNV.lowLatencyBoost );
7868 VULKAN_HPP_HASH_COMBINE( seed, latencySleepModeInfoNV.minimumIntervalUs );
7869 return seed;
7870 }
7871 };
7872
7873 template <>
7874 struct hash<VULKAN_HPP_NAMESPACE::LatencySubmissionPresentIdNV>
7875 {
7876 std::size_t operator()( VULKAN_HPP_NAMESPACE::LatencySubmissionPresentIdNV const & latencySubmissionPresentIdNV ) const VULKAN_HPP_NOEXCEPT
7877 {
7878 std::size_t seed = 0;
7879 VULKAN_HPP_HASH_COMBINE( seed, latencySubmissionPresentIdNV.sType );
7880 VULKAN_HPP_HASH_COMBINE( seed, latencySubmissionPresentIdNV.pNext );
7881 VULKAN_HPP_HASH_COMBINE( seed, latencySubmissionPresentIdNV.presentID );
7882 return seed;
7883 }
7884 };
7885
7886 template <>
7887 struct hash<VULKAN_HPP_NAMESPACE::LatencySurfaceCapabilitiesNV>
7888 {
7889 std::size_t operator()( VULKAN_HPP_NAMESPACE::LatencySurfaceCapabilitiesNV const & latencySurfaceCapabilitiesNV ) const VULKAN_HPP_NOEXCEPT
7890 {
7891 std::size_t seed = 0;
7892 VULKAN_HPP_HASH_COMBINE( seed, latencySurfaceCapabilitiesNV.sType );
7893 VULKAN_HPP_HASH_COMBINE( seed, latencySurfaceCapabilitiesNV.pNext );
7894 VULKAN_HPP_HASH_COMBINE( seed, latencySurfaceCapabilitiesNV.presentModeCount );
7895 VULKAN_HPP_HASH_COMBINE( seed, latencySurfaceCapabilitiesNV.pPresentModes );
7896 return seed;
7897 }
7898 };
7899
7900 template <>
7901 struct hash<VULKAN_HPP_NAMESPACE::LayerProperties>
7902 {
7903 std::size_t operator()( VULKAN_HPP_NAMESPACE::LayerProperties const & layerProperties ) const VULKAN_HPP_NOEXCEPT
7904 {
7905 std::size_t seed = 0;
7906 for ( size_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i )
7907 {
7908 VULKAN_HPP_HASH_COMBINE( seed, layerProperties.layerName[i] );
7909 }
7910 VULKAN_HPP_HASH_COMBINE( seed, layerProperties.specVersion );
7911 VULKAN_HPP_HASH_COMBINE( seed, layerProperties.implementationVersion );
7912 for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i )
7913 {
7914 VULKAN_HPP_HASH_COMBINE( seed, layerProperties.description[i] );
7915 }
7916 return seed;
7917 }
7918 };
7919
7920 template <>
7921 struct hash<VULKAN_HPP_NAMESPACE::LayerSettingEXT>
7922 {
7923 std::size_t operator()( VULKAN_HPP_NAMESPACE::LayerSettingEXT const & layerSettingEXT ) const VULKAN_HPP_NOEXCEPT
7924 {
7925 std::size_t seed = 0;
7926 for ( const char * p = layerSettingEXT.pLayerName; *p != '\0'; ++p )
7927 {
7928 VULKAN_HPP_HASH_COMBINE( seed, *p );
7929 }
7930 for ( const char * p = layerSettingEXT.pSettingName; *p != '\0'; ++p )
7931 {
7932 VULKAN_HPP_HASH_COMBINE( seed, *p );
7933 }
7934 VULKAN_HPP_HASH_COMBINE( seed, layerSettingEXT.type );
7935 VULKAN_HPP_HASH_COMBINE( seed, layerSettingEXT.valueCount );
7936 VULKAN_HPP_HASH_COMBINE( seed, layerSettingEXT.pValues );
7937 return seed;
7938 }
7939 };
7940
7941 template <>
7942 struct hash<VULKAN_HPP_NAMESPACE::LayerSettingsCreateInfoEXT>
7943 {
7944 std::size_t operator()( VULKAN_HPP_NAMESPACE::LayerSettingsCreateInfoEXT const & layerSettingsCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
7945 {
7946 std::size_t seed = 0;
7947 VULKAN_HPP_HASH_COMBINE( seed, layerSettingsCreateInfoEXT.sType );
7948 VULKAN_HPP_HASH_COMBINE( seed, layerSettingsCreateInfoEXT.pNext );
7949 VULKAN_HPP_HASH_COMBINE( seed, layerSettingsCreateInfoEXT.settingCount );
7950 VULKAN_HPP_HASH_COMBINE( seed, layerSettingsCreateInfoEXT.pSettings );
7951 return seed;
7952 }
7953 };
7954
7955 # if defined( VK_USE_PLATFORM_MACOS_MVK )
7956 template <>
7957 struct hash<VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK>
7958 {
7959 std::size_t operator()( VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK const & macOSSurfaceCreateInfoMVK ) const VULKAN_HPP_NOEXCEPT
7960 {
7961 std::size_t seed = 0;
7962 VULKAN_HPP_HASH_COMBINE( seed, macOSSurfaceCreateInfoMVK.sType );
7963 VULKAN_HPP_HASH_COMBINE( seed, macOSSurfaceCreateInfoMVK.pNext );
7964 VULKAN_HPP_HASH_COMBINE( seed, macOSSurfaceCreateInfoMVK.flags );
7965 VULKAN_HPP_HASH_COMBINE( seed, macOSSurfaceCreateInfoMVK.pView );
7966 return seed;
7967 }
7968 };
7969 # endif /*VK_USE_PLATFORM_MACOS_MVK*/
7970
7971 template <>
7972 struct hash<VULKAN_HPP_NAMESPACE::MappedMemoryRange>
7973 {
7974 std::size_t operator()( VULKAN_HPP_NAMESPACE::MappedMemoryRange const & mappedMemoryRange ) const VULKAN_HPP_NOEXCEPT
7975 {
7976 std::size_t seed = 0;
7977 VULKAN_HPP_HASH_COMBINE( seed, mappedMemoryRange.sType );
7978 VULKAN_HPP_HASH_COMBINE( seed, mappedMemoryRange.pNext );
7979 VULKAN_HPP_HASH_COMBINE( seed, mappedMemoryRange.memory );
7980 VULKAN_HPP_HASH_COMBINE( seed, mappedMemoryRange.offset );
7981 VULKAN_HPP_HASH_COMBINE( seed, mappedMemoryRange.size );
7982 return seed;
7983 }
7984 };
7985
7986 template <>
7987 struct hash<VULKAN_HPP_NAMESPACE::MemoryAllocateFlagsInfo>
7988 {
7989 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryAllocateFlagsInfo const & memoryAllocateFlagsInfo ) const VULKAN_HPP_NOEXCEPT
7990 {
7991 std::size_t seed = 0;
7992 VULKAN_HPP_HASH_COMBINE( seed, memoryAllocateFlagsInfo.sType );
7993 VULKAN_HPP_HASH_COMBINE( seed, memoryAllocateFlagsInfo.pNext );
7994 VULKAN_HPP_HASH_COMBINE( seed, memoryAllocateFlagsInfo.flags );
7995 VULKAN_HPP_HASH_COMBINE( seed, memoryAllocateFlagsInfo.deviceMask );
7996 return seed;
7997 }
7998 };
7999
8000 template <>
8001 struct hash<VULKAN_HPP_NAMESPACE::MemoryAllocateInfo>
8002 {
8003 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryAllocateInfo const & memoryAllocateInfo ) const VULKAN_HPP_NOEXCEPT
8004 {
8005 std::size_t seed = 0;
8006 VULKAN_HPP_HASH_COMBINE( seed, memoryAllocateInfo.sType );
8007 VULKAN_HPP_HASH_COMBINE( seed, memoryAllocateInfo.pNext );
8008 VULKAN_HPP_HASH_COMBINE( seed, memoryAllocateInfo.allocationSize );
8009 VULKAN_HPP_HASH_COMBINE( seed, memoryAllocateInfo.memoryTypeIndex );
8010 return seed;
8011 }
8012 };
8013
8014 template <>
8015 struct hash<VULKAN_HPP_NAMESPACE::MemoryBarrier>
8016 {
8017 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryBarrier const & memoryBarrier ) const VULKAN_HPP_NOEXCEPT
8018 {
8019 std::size_t seed = 0;
8020 VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier.sType );
8021 VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier.pNext );
8022 VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier.srcAccessMask );
8023 VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier.dstAccessMask );
8024 return seed;
8025 }
8026 };
8027
8028 template <>
8029 struct hash<VULKAN_HPP_NAMESPACE::MemoryBarrierAccessFlags3KHR>
8030 {
8031 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryBarrierAccessFlags3KHR const & memoryBarrierAccessFlags3KHR ) const VULKAN_HPP_NOEXCEPT
8032 {
8033 std::size_t seed = 0;
8034 VULKAN_HPP_HASH_COMBINE( seed, memoryBarrierAccessFlags3KHR.sType );
8035 VULKAN_HPP_HASH_COMBINE( seed, memoryBarrierAccessFlags3KHR.pNext );
8036 VULKAN_HPP_HASH_COMBINE( seed, memoryBarrierAccessFlags3KHR.srcAccessMask3 );
8037 VULKAN_HPP_HASH_COMBINE( seed, memoryBarrierAccessFlags3KHR.dstAccessMask3 );
8038 return seed;
8039 }
8040 };
8041
8042 template <>
8043 struct hash<VULKAN_HPP_NAMESPACE::MemoryDedicatedAllocateInfo>
8044 {
8045 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryDedicatedAllocateInfo const & memoryDedicatedAllocateInfo ) const VULKAN_HPP_NOEXCEPT
8046 {
8047 std::size_t seed = 0;
8048 VULKAN_HPP_HASH_COMBINE( seed, memoryDedicatedAllocateInfo.sType );
8049 VULKAN_HPP_HASH_COMBINE( seed, memoryDedicatedAllocateInfo.pNext );
8050 VULKAN_HPP_HASH_COMBINE( seed, memoryDedicatedAllocateInfo.image );
8051 VULKAN_HPP_HASH_COMBINE( seed, memoryDedicatedAllocateInfo.buffer );
8052 return seed;
8053 }
8054 };
8055
8056 template <>
8057 struct hash<VULKAN_HPP_NAMESPACE::MemoryDedicatedAllocateInfoTensorARM>
8058 {
8059 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryDedicatedAllocateInfoTensorARM const & memoryDedicatedAllocateInfoTensorARM ) const VULKAN_HPP_NOEXCEPT
8060 {
8061 std::size_t seed = 0;
8062 VULKAN_HPP_HASH_COMBINE( seed, memoryDedicatedAllocateInfoTensorARM.sType );
8063 VULKAN_HPP_HASH_COMBINE( seed, memoryDedicatedAllocateInfoTensorARM.pNext );
8064 VULKAN_HPP_HASH_COMBINE( seed, memoryDedicatedAllocateInfoTensorARM.tensor );
8065 return seed;
8066 }
8067 };
8068
8069 template <>
8070 struct hash<VULKAN_HPP_NAMESPACE::MemoryDedicatedRequirements>
8071 {
8072 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryDedicatedRequirements const & memoryDedicatedRequirements ) const VULKAN_HPP_NOEXCEPT
8073 {
8074 std::size_t seed = 0;
8075 VULKAN_HPP_HASH_COMBINE( seed, memoryDedicatedRequirements.sType );
8076 VULKAN_HPP_HASH_COMBINE( seed, memoryDedicatedRequirements.pNext );
8077 VULKAN_HPP_HASH_COMBINE( seed, memoryDedicatedRequirements.prefersDedicatedAllocation );
8078 VULKAN_HPP_HASH_COMBINE( seed, memoryDedicatedRequirements.requiresDedicatedAllocation );
8079 return seed;
8080 }
8081 };
8082
8083 template <>
8084 struct hash<VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR>
8085 {
8086 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR const & memoryFdPropertiesKHR ) const VULKAN_HPP_NOEXCEPT
8087 {
8088 std::size_t seed = 0;
8089 VULKAN_HPP_HASH_COMBINE( seed, memoryFdPropertiesKHR.sType );
8090 VULKAN_HPP_HASH_COMBINE( seed, memoryFdPropertiesKHR.pNext );
8091 VULKAN_HPP_HASH_COMBINE( seed, memoryFdPropertiesKHR.memoryTypeBits );
8092 return seed;
8093 }
8094 };
8095
8096 # if defined( VK_USE_PLATFORM_ANDROID_KHR )
8097 template <>
8098 struct hash<VULKAN_HPP_NAMESPACE::MemoryGetAndroidHardwareBufferInfoANDROID>
8099 {
8100 std::size_t
8101 operator()( VULKAN_HPP_NAMESPACE::MemoryGetAndroidHardwareBufferInfoANDROID const & memoryGetAndroidHardwareBufferInfoANDROID ) const VULKAN_HPP_NOEXCEPT
8102 {
8103 std::size_t seed = 0;
8104 VULKAN_HPP_HASH_COMBINE( seed, memoryGetAndroidHardwareBufferInfoANDROID.sType );
8105 VULKAN_HPP_HASH_COMBINE( seed, memoryGetAndroidHardwareBufferInfoANDROID.pNext );
8106 VULKAN_HPP_HASH_COMBINE( seed, memoryGetAndroidHardwareBufferInfoANDROID.memory );
8107 return seed;
8108 }
8109 };
8110 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/
8111
8112 template <>
8113 struct hash<VULKAN_HPP_NAMESPACE::MemoryGetFdInfoKHR>
8114 {
8115 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryGetFdInfoKHR const & memoryGetFdInfoKHR ) const VULKAN_HPP_NOEXCEPT
8116 {
8117 std::size_t seed = 0;
8118 VULKAN_HPP_HASH_COMBINE( seed, memoryGetFdInfoKHR.sType );
8119 VULKAN_HPP_HASH_COMBINE( seed, memoryGetFdInfoKHR.pNext );
8120 VULKAN_HPP_HASH_COMBINE( seed, memoryGetFdInfoKHR.memory );
8121 VULKAN_HPP_HASH_COMBINE( seed, memoryGetFdInfoKHR.handleType );
8122 return seed;
8123 }
8124 };
8125
8126 # if defined( VK_USE_PLATFORM_METAL_EXT )
8127 template <>
8128 struct hash<VULKAN_HPP_NAMESPACE::MemoryGetMetalHandleInfoEXT>
8129 {
8130 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryGetMetalHandleInfoEXT const & memoryGetMetalHandleInfoEXT ) const VULKAN_HPP_NOEXCEPT
8131 {
8132 std::size_t seed = 0;
8133 VULKAN_HPP_HASH_COMBINE( seed, memoryGetMetalHandleInfoEXT.sType );
8134 VULKAN_HPP_HASH_COMBINE( seed, memoryGetMetalHandleInfoEXT.pNext );
8135 VULKAN_HPP_HASH_COMBINE( seed, memoryGetMetalHandleInfoEXT.memory );
8136 VULKAN_HPP_HASH_COMBINE( seed, memoryGetMetalHandleInfoEXT.handleType );
8137 return seed;
8138 }
8139 };
8140 # endif /*VK_USE_PLATFORM_METAL_EXT*/
8141
8142 # if defined( VK_USE_PLATFORM_OHOS )
8143 template <>
8144 struct hash<VULKAN_HPP_NAMESPACE::MemoryGetNativeBufferInfoOHOS>
8145 {
8146 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryGetNativeBufferInfoOHOS const & memoryGetNativeBufferInfoOHOS ) const VULKAN_HPP_NOEXCEPT
8147 {
8148 std::size_t seed = 0;
8149 VULKAN_HPP_HASH_COMBINE( seed, memoryGetNativeBufferInfoOHOS.sType );
8150 VULKAN_HPP_HASH_COMBINE( seed, memoryGetNativeBufferInfoOHOS.pNext );
8151 VULKAN_HPP_HASH_COMBINE( seed, memoryGetNativeBufferInfoOHOS.memory );
8152 return seed;
8153 }
8154 };
8155 # endif /*VK_USE_PLATFORM_OHOS*/
8156
8157 template <>
8158 struct hash<VULKAN_HPP_NAMESPACE::MemoryGetRemoteAddressInfoNV>
8159 {
8160 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryGetRemoteAddressInfoNV const & memoryGetRemoteAddressInfoNV ) const VULKAN_HPP_NOEXCEPT
8161 {
8162 std::size_t seed = 0;
8163 VULKAN_HPP_HASH_COMBINE( seed, memoryGetRemoteAddressInfoNV.sType );
8164 VULKAN_HPP_HASH_COMBINE( seed, memoryGetRemoteAddressInfoNV.pNext );
8165 VULKAN_HPP_HASH_COMBINE( seed, memoryGetRemoteAddressInfoNV.memory );
8166 VULKAN_HPP_HASH_COMBINE( seed, memoryGetRemoteAddressInfoNV.handleType );
8167 return seed;
8168 }
8169 };
8170
8171 # if defined( VK_USE_PLATFORM_WIN32_KHR )
8172 template <>
8173 struct hash<VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR>
8174 {
8175 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR const & memoryGetWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT
8176 {
8177 std::size_t seed = 0;
8178 VULKAN_HPP_HASH_COMBINE( seed, memoryGetWin32HandleInfoKHR.sType );
8179 VULKAN_HPP_HASH_COMBINE( seed, memoryGetWin32HandleInfoKHR.pNext );
8180 VULKAN_HPP_HASH_COMBINE( seed, memoryGetWin32HandleInfoKHR.memory );
8181 VULKAN_HPP_HASH_COMBINE( seed, memoryGetWin32HandleInfoKHR.handleType );
8182 return seed;
8183 }
8184 };
8185 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
8186
8187 # if defined( VK_USE_PLATFORM_FUCHSIA )
8188 template <>
8189 struct hash<VULKAN_HPP_NAMESPACE::MemoryGetZirconHandleInfoFUCHSIA>
8190 {
8191 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryGetZirconHandleInfoFUCHSIA const & memoryGetZirconHandleInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT
8192 {
8193 std::size_t seed = 0;
8194 VULKAN_HPP_HASH_COMBINE( seed, memoryGetZirconHandleInfoFUCHSIA.sType );
8195 VULKAN_HPP_HASH_COMBINE( seed, memoryGetZirconHandleInfoFUCHSIA.pNext );
8196 VULKAN_HPP_HASH_COMBINE( seed, memoryGetZirconHandleInfoFUCHSIA.memory );
8197 VULKAN_HPP_HASH_COMBINE( seed, memoryGetZirconHandleInfoFUCHSIA.handleType );
8198 return seed;
8199 }
8200 };
8201 # endif /*VK_USE_PLATFORM_FUCHSIA*/
8202
8203 template <>
8204 struct hash<VULKAN_HPP_NAMESPACE::MemoryHeap>
8205 {
8206 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryHeap const & memoryHeap ) const VULKAN_HPP_NOEXCEPT
8207 {
8208 std::size_t seed = 0;
8209 VULKAN_HPP_HASH_COMBINE( seed, memoryHeap.size );
8210 VULKAN_HPP_HASH_COMBINE( seed, memoryHeap.flags );
8211 return seed;
8212 }
8213 };
8214
8215 template <>
8216 struct hash<VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT>
8217 {
8218 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT const & memoryHostPointerPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
8219 {
8220 std::size_t seed = 0;
8221 VULKAN_HPP_HASH_COMBINE( seed, memoryHostPointerPropertiesEXT.sType );
8222 VULKAN_HPP_HASH_COMBINE( seed, memoryHostPointerPropertiesEXT.pNext );
8223 VULKAN_HPP_HASH_COMBINE( seed, memoryHostPointerPropertiesEXT.memoryTypeBits );
8224 return seed;
8225 }
8226 };
8227
8228 template <>
8229 struct hash<VULKAN_HPP_NAMESPACE::MemoryMapInfo>
8230 {
8231 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryMapInfo const & memoryMapInfo ) const VULKAN_HPP_NOEXCEPT
8232 {
8233 std::size_t seed = 0;
8234 VULKAN_HPP_HASH_COMBINE( seed, memoryMapInfo.sType );
8235 VULKAN_HPP_HASH_COMBINE( seed, memoryMapInfo.pNext );
8236 VULKAN_HPP_HASH_COMBINE( seed, memoryMapInfo.flags );
8237 VULKAN_HPP_HASH_COMBINE( seed, memoryMapInfo.memory );
8238 VULKAN_HPP_HASH_COMBINE( seed, memoryMapInfo.offset );
8239 VULKAN_HPP_HASH_COMBINE( seed, memoryMapInfo.size );
8240 return seed;
8241 }
8242 };
8243
8244 template <>
8245 struct hash<VULKAN_HPP_NAMESPACE::MemoryMapPlacedInfoEXT>
8246 {
8247 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryMapPlacedInfoEXT const & memoryMapPlacedInfoEXT ) const VULKAN_HPP_NOEXCEPT
8248 {
8249 std::size_t seed = 0;
8250 VULKAN_HPP_HASH_COMBINE( seed, memoryMapPlacedInfoEXT.sType );
8251 VULKAN_HPP_HASH_COMBINE( seed, memoryMapPlacedInfoEXT.pNext );
8252 VULKAN_HPP_HASH_COMBINE( seed, memoryMapPlacedInfoEXT.pPlacedAddress );
8253 return seed;
8254 }
8255 };
8256
8257 # if defined( VK_USE_PLATFORM_METAL_EXT )
8258 template <>
8259 struct hash<VULKAN_HPP_NAMESPACE::MemoryMetalHandlePropertiesEXT>
8260 {
8261 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryMetalHandlePropertiesEXT const & memoryMetalHandlePropertiesEXT ) const VULKAN_HPP_NOEXCEPT
8262 {
8263 std::size_t seed = 0;
8264 VULKAN_HPP_HASH_COMBINE( seed, memoryMetalHandlePropertiesEXT.sType );
8265 VULKAN_HPP_HASH_COMBINE( seed, memoryMetalHandlePropertiesEXT.pNext );
8266 VULKAN_HPP_HASH_COMBINE( seed, memoryMetalHandlePropertiesEXT.memoryTypeBits );
8267 return seed;
8268 }
8269 };
8270 # endif /*VK_USE_PLATFORM_METAL_EXT*/
8271
8272 template <>
8273 struct hash<VULKAN_HPP_NAMESPACE::MemoryOpaqueCaptureAddressAllocateInfo>
8274 {
8275 std::size_t
8276 operator()( VULKAN_HPP_NAMESPACE::MemoryOpaqueCaptureAddressAllocateInfo const & memoryOpaqueCaptureAddressAllocateInfo ) const VULKAN_HPP_NOEXCEPT
8277 {
8278 std::size_t seed = 0;
8279 VULKAN_HPP_HASH_COMBINE( seed, memoryOpaqueCaptureAddressAllocateInfo.sType );
8280 VULKAN_HPP_HASH_COMBINE( seed, memoryOpaqueCaptureAddressAllocateInfo.pNext );
8281 VULKAN_HPP_HASH_COMBINE( seed, memoryOpaqueCaptureAddressAllocateInfo.opaqueCaptureAddress );
8282 return seed;
8283 }
8284 };
8285
8286 template <>
8287 struct hash<VULKAN_HPP_NAMESPACE::MemoryPriorityAllocateInfoEXT>
8288 {
8289 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryPriorityAllocateInfoEXT const & memoryPriorityAllocateInfoEXT ) const VULKAN_HPP_NOEXCEPT
8290 {
8291 std::size_t seed = 0;
8292 VULKAN_HPP_HASH_COMBINE( seed, memoryPriorityAllocateInfoEXT.sType );
8293 VULKAN_HPP_HASH_COMBINE( seed, memoryPriorityAllocateInfoEXT.pNext );
8294 VULKAN_HPP_HASH_COMBINE( seed, memoryPriorityAllocateInfoEXT.priority );
8295 return seed;
8296 }
8297 };
8298
8299 template <>
8300 struct hash<VULKAN_HPP_NAMESPACE::MemoryRequirements>
8301 {
8302 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryRequirements const & memoryRequirements ) const VULKAN_HPP_NOEXCEPT
8303 {
8304 std::size_t seed = 0;
8305 VULKAN_HPP_HASH_COMBINE( seed, memoryRequirements.size );
8306 VULKAN_HPP_HASH_COMBINE( seed, memoryRequirements.alignment );
8307 VULKAN_HPP_HASH_COMBINE( seed, memoryRequirements.memoryTypeBits );
8308 return seed;
8309 }
8310 };
8311
8312 template <>
8313 struct hash<VULKAN_HPP_NAMESPACE::MemoryRequirements2>
8314 {
8315 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryRequirements2 const & memoryRequirements2 ) const VULKAN_HPP_NOEXCEPT
8316 {
8317 std::size_t seed = 0;
8318 VULKAN_HPP_HASH_COMBINE( seed, memoryRequirements2.sType );
8319 VULKAN_HPP_HASH_COMBINE( seed, memoryRequirements2.pNext );
8320 VULKAN_HPP_HASH_COMBINE( seed, memoryRequirements2.memoryRequirements );
8321 return seed;
8322 }
8323 };
8324
8325 template <>
8326 struct hash<VULKAN_HPP_NAMESPACE::MemoryType>
8327 {
8328 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryType const & memoryType ) const VULKAN_HPP_NOEXCEPT
8329 {
8330 std::size_t seed = 0;
8331 VULKAN_HPP_HASH_COMBINE( seed, memoryType.propertyFlags );
8332 VULKAN_HPP_HASH_COMBINE( seed, memoryType.heapIndex );
8333 return seed;
8334 }
8335 };
8336
8337 template <>
8338 struct hash<VULKAN_HPP_NAMESPACE::MemoryUnmapInfo>
8339 {
8340 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryUnmapInfo const & memoryUnmapInfo ) const VULKAN_HPP_NOEXCEPT
8341 {
8342 std::size_t seed = 0;
8343 VULKAN_HPP_HASH_COMBINE( seed, memoryUnmapInfo.sType );
8344 VULKAN_HPP_HASH_COMBINE( seed, memoryUnmapInfo.pNext );
8345 VULKAN_HPP_HASH_COMBINE( seed, memoryUnmapInfo.flags );
8346 VULKAN_HPP_HASH_COMBINE( seed, memoryUnmapInfo.memory );
8347 return seed;
8348 }
8349 };
8350
8351 # if defined( VK_USE_PLATFORM_WIN32_KHR )
8352 template <>
8353 struct hash<VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR>
8354 {
8355 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR const & memoryWin32HandlePropertiesKHR ) const VULKAN_HPP_NOEXCEPT
8356 {
8357 std::size_t seed = 0;
8358 VULKAN_HPP_HASH_COMBINE( seed, memoryWin32HandlePropertiesKHR.sType );
8359 VULKAN_HPP_HASH_COMBINE( seed, memoryWin32HandlePropertiesKHR.pNext );
8360 VULKAN_HPP_HASH_COMBINE( seed, memoryWin32HandlePropertiesKHR.memoryTypeBits );
8361 return seed;
8362 }
8363 };
8364 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
8365
8366 # if defined( VK_USE_PLATFORM_FUCHSIA )
8367 template <>
8368 struct hash<VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA>
8369 {
8370 std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA const & memoryZirconHandlePropertiesFUCHSIA ) const VULKAN_HPP_NOEXCEPT
8371 {
8372 std::size_t seed = 0;
8373 VULKAN_HPP_HASH_COMBINE( seed, memoryZirconHandlePropertiesFUCHSIA.sType );
8374 VULKAN_HPP_HASH_COMBINE( seed, memoryZirconHandlePropertiesFUCHSIA.pNext );
8375 VULKAN_HPP_HASH_COMBINE( seed, memoryZirconHandlePropertiesFUCHSIA.memoryTypeBits );
8376 return seed;
8377 }
8378 };
8379 # endif /*VK_USE_PLATFORM_FUCHSIA*/
8380
8381 # if defined( VK_USE_PLATFORM_METAL_EXT )
8382 template <>
8383 struct hash<VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT>
8384 {
8385 std::size_t operator()( VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT const & metalSurfaceCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
8386 {
8387 std::size_t seed = 0;
8388 VULKAN_HPP_HASH_COMBINE( seed, metalSurfaceCreateInfoEXT.sType );
8389 VULKAN_HPP_HASH_COMBINE( seed, metalSurfaceCreateInfoEXT.pNext );
8390 VULKAN_HPP_HASH_COMBINE( seed, metalSurfaceCreateInfoEXT.flags );
8391 VULKAN_HPP_HASH_COMBINE( seed, metalSurfaceCreateInfoEXT.pLayer );
8392 return seed;
8393 }
8394 };
8395 # endif /*VK_USE_PLATFORM_METAL_EXT*/
8396
8397 template <>
8398 struct hash<VULKAN_HPP_NAMESPACE::MicromapBuildSizesInfoEXT>
8399 {
8400 std::size_t operator()( VULKAN_HPP_NAMESPACE::MicromapBuildSizesInfoEXT const & micromapBuildSizesInfoEXT ) const VULKAN_HPP_NOEXCEPT
8401 {
8402 std::size_t seed = 0;
8403 VULKAN_HPP_HASH_COMBINE( seed, micromapBuildSizesInfoEXT.sType );
8404 VULKAN_HPP_HASH_COMBINE( seed, micromapBuildSizesInfoEXT.pNext );
8405 VULKAN_HPP_HASH_COMBINE( seed, micromapBuildSizesInfoEXT.micromapSize );
8406 VULKAN_HPP_HASH_COMBINE( seed, micromapBuildSizesInfoEXT.buildScratchSize );
8407 VULKAN_HPP_HASH_COMBINE( seed, micromapBuildSizesInfoEXT.discardable );
8408 return seed;
8409 }
8410 };
8411
8412 template <>
8413 struct hash<VULKAN_HPP_NAMESPACE::MicromapCreateInfoEXT>
8414 {
8415 std::size_t operator()( VULKAN_HPP_NAMESPACE::MicromapCreateInfoEXT const & micromapCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
8416 {
8417 std::size_t seed = 0;
8418 VULKAN_HPP_HASH_COMBINE( seed, micromapCreateInfoEXT.sType );
8419 VULKAN_HPP_HASH_COMBINE( seed, micromapCreateInfoEXT.pNext );
8420 VULKAN_HPP_HASH_COMBINE( seed, micromapCreateInfoEXT.createFlags );
8421 VULKAN_HPP_HASH_COMBINE( seed, micromapCreateInfoEXT.buffer );
8422 VULKAN_HPP_HASH_COMBINE( seed, micromapCreateInfoEXT.offset );
8423 VULKAN_HPP_HASH_COMBINE( seed, micromapCreateInfoEXT.size );
8424 VULKAN_HPP_HASH_COMBINE( seed, micromapCreateInfoEXT.type );
8425 VULKAN_HPP_HASH_COMBINE( seed, micromapCreateInfoEXT.deviceAddress );
8426 return seed;
8427 }
8428 };
8429
8430 template <>
8431 struct hash<VULKAN_HPP_NAMESPACE::MicromapTriangleEXT>
8432 {
8433 std::size_t operator()( VULKAN_HPP_NAMESPACE::MicromapTriangleEXT const & micromapTriangleEXT ) const VULKAN_HPP_NOEXCEPT
8434 {
8435 std::size_t seed = 0;
8436 VULKAN_HPP_HASH_COMBINE( seed, micromapTriangleEXT.dataOffset );
8437 VULKAN_HPP_HASH_COMBINE( seed, micromapTriangleEXT.subdivisionLevel );
8438 VULKAN_HPP_HASH_COMBINE( seed, micromapTriangleEXT.format );
8439 return seed;
8440 }
8441 };
8442
8443 template <>
8444 struct hash<VULKAN_HPP_NAMESPACE::MicromapVersionInfoEXT>
8445 {
8446 std::size_t operator()( VULKAN_HPP_NAMESPACE::MicromapVersionInfoEXT const & micromapVersionInfoEXT ) const VULKAN_HPP_NOEXCEPT
8447 {
8448 std::size_t seed = 0;
8449 VULKAN_HPP_HASH_COMBINE( seed, micromapVersionInfoEXT.sType );
8450 VULKAN_HPP_HASH_COMBINE( seed, micromapVersionInfoEXT.pNext );
8451 VULKAN_HPP_HASH_COMBINE( seed, micromapVersionInfoEXT.pVersionData );
8452 return seed;
8453 }
8454 };
8455
8456 template <>
8457 struct hash<VULKAN_HPP_NAMESPACE::MultiDrawIndexedInfoEXT>
8458 {
8459 std::size_t operator()( VULKAN_HPP_NAMESPACE::MultiDrawIndexedInfoEXT const & multiDrawIndexedInfoEXT ) const VULKAN_HPP_NOEXCEPT
8460 {
8461 std::size_t seed = 0;
8462 VULKAN_HPP_HASH_COMBINE( seed, multiDrawIndexedInfoEXT.firstIndex );
8463 VULKAN_HPP_HASH_COMBINE( seed, multiDrawIndexedInfoEXT.indexCount );
8464 VULKAN_HPP_HASH_COMBINE( seed, multiDrawIndexedInfoEXT.vertexOffset );
8465 return seed;
8466 }
8467 };
8468
8469 template <>
8470 struct hash<VULKAN_HPP_NAMESPACE::MultiDrawInfoEXT>
8471 {
8472 std::size_t operator()( VULKAN_HPP_NAMESPACE::MultiDrawInfoEXT const & multiDrawInfoEXT ) const VULKAN_HPP_NOEXCEPT
8473 {
8474 std::size_t seed = 0;
8475 VULKAN_HPP_HASH_COMBINE( seed, multiDrawInfoEXT.firstVertex );
8476 VULKAN_HPP_HASH_COMBINE( seed, multiDrawInfoEXT.vertexCount );
8477 return seed;
8478 }
8479 };
8480
8481 template <>
8482 struct hash<VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT>
8483 {
8484 std::size_t operator()( VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT const & multisamplePropertiesEXT ) const VULKAN_HPP_NOEXCEPT
8485 {
8486 std::size_t seed = 0;
8487 VULKAN_HPP_HASH_COMBINE( seed, multisamplePropertiesEXT.sType );
8488 VULKAN_HPP_HASH_COMBINE( seed, multisamplePropertiesEXT.pNext );
8489 VULKAN_HPP_HASH_COMBINE( seed, multisamplePropertiesEXT.maxSampleLocationGridSize );
8490 return seed;
8491 }
8492 };
8493
8494 template <>
8495 struct hash<VULKAN_HPP_NAMESPACE::MultisampledRenderToSingleSampledInfoEXT>
8496 {
8497 std::size_t
8498 operator()( VULKAN_HPP_NAMESPACE::MultisampledRenderToSingleSampledInfoEXT const & multisampledRenderToSingleSampledInfoEXT ) const VULKAN_HPP_NOEXCEPT
8499 {
8500 std::size_t seed = 0;
8501 VULKAN_HPP_HASH_COMBINE( seed, multisampledRenderToSingleSampledInfoEXT.sType );
8502 VULKAN_HPP_HASH_COMBINE( seed, multisampledRenderToSingleSampledInfoEXT.pNext );
8503 VULKAN_HPP_HASH_COMBINE( seed, multisampledRenderToSingleSampledInfoEXT.multisampledRenderToSingleSampledEnable );
8504 VULKAN_HPP_HASH_COMBINE( seed, multisampledRenderToSingleSampledInfoEXT.rasterizationSamples );
8505 return seed;
8506 }
8507 };
8508
8509 template <>
8510 struct hash<VULKAN_HPP_NAMESPACE::MultiviewPerViewAttributesInfoNVX>
8511 {
8512 std::size_t operator()( VULKAN_HPP_NAMESPACE::MultiviewPerViewAttributesInfoNVX const & multiviewPerViewAttributesInfoNVX ) const VULKAN_HPP_NOEXCEPT
8513 {
8514 std::size_t seed = 0;
8515 VULKAN_HPP_HASH_COMBINE( seed, multiviewPerViewAttributesInfoNVX.sType );
8516 VULKAN_HPP_HASH_COMBINE( seed, multiviewPerViewAttributesInfoNVX.pNext );
8517 VULKAN_HPP_HASH_COMBINE( seed, multiviewPerViewAttributesInfoNVX.perViewAttributes );
8518 VULKAN_HPP_HASH_COMBINE( seed, multiviewPerViewAttributesInfoNVX.perViewAttributesPositionXOnly );
8519 return seed;
8520 }
8521 };
8522
8523 template <>
8524 struct hash<VULKAN_HPP_NAMESPACE::MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM>
8525 {
8526 std::size_t
8527 operator()( VULKAN_HPP_NAMESPACE::MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM const & multiviewPerViewRenderAreasRenderPassBeginInfoQCOM ) const
8528 VULKAN_HPP_NOEXCEPT
8529 {
8530 std::size_t seed = 0;
8531 VULKAN_HPP_HASH_COMBINE( seed, multiviewPerViewRenderAreasRenderPassBeginInfoQCOM.sType );
8532 VULKAN_HPP_HASH_COMBINE( seed, multiviewPerViewRenderAreasRenderPassBeginInfoQCOM.pNext );
8533 VULKAN_HPP_HASH_COMBINE( seed, multiviewPerViewRenderAreasRenderPassBeginInfoQCOM.perViewRenderAreaCount );
8534 VULKAN_HPP_HASH_COMBINE( seed, multiviewPerViewRenderAreasRenderPassBeginInfoQCOM.pPerViewRenderAreas );
8535 return seed;
8536 }
8537 };
8538
8539 template <>
8540 struct hash<VULKAN_HPP_NAMESPACE::MutableDescriptorTypeListEXT>
8541 {
8542 std::size_t operator()( VULKAN_HPP_NAMESPACE::MutableDescriptorTypeListEXT const & mutableDescriptorTypeListEXT ) const VULKAN_HPP_NOEXCEPT
8543 {
8544 std::size_t seed = 0;
8545 VULKAN_HPP_HASH_COMBINE( seed, mutableDescriptorTypeListEXT.descriptorTypeCount );
8546 VULKAN_HPP_HASH_COMBINE( seed, mutableDescriptorTypeListEXT.pDescriptorTypes );
8547 return seed;
8548 }
8549 };
8550
8551 template <>
8552 struct hash<VULKAN_HPP_NAMESPACE::MutableDescriptorTypeCreateInfoEXT>
8553 {
8554 std::size_t operator()( VULKAN_HPP_NAMESPACE::MutableDescriptorTypeCreateInfoEXT const & mutableDescriptorTypeCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
8555 {
8556 std::size_t seed = 0;
8557 VULKAN_HPP_HASH_COMBINE( seed, mutableDescriptorTypeCreateInfoEXT.sType );
8558 VULKAN_HPP_HASH_COMBINE( seed, mutableDescriptorTypeCreateInfoEXT.pNext );
8559 VULKAN_HPP_HASH_COMBINE( seed, mutableDescriptorTypeCreateInfoEXT.mutableDescriptorTypeListCount );
8560 VULKAN_HPP_HASH_COMBINE( seed, mutableDescriptorTypeCreateInfoEXT.pMutableDescriptorTypeLists );
8561 return seed;
8562 }
8563 };
8564
8565 # if defined( VK_USE_PLATFORM_OHOS )
8566 template <>
8567 struct hash<VULKAN_HPP_NAMESPACE::NativeBufferFormatPropertiesOHOS>
8568 {
8569 std::size_t operator()( VULKAN_HPP_NAMESPACE::NativeBufferFormatPropertiesOHOS const & nativeBufferFormatPropertiesOHOS ) const VULKAN_HPP_NOEXCEPT
8570 {
8571 std::size_t seed = 0;
8572 VULKAN_HPP_HASH_COMBINE( seed, nativeBufferFormatPropertiesOHOS.sType );
8573 VULKAN_HPP_HASH_COMBINE( seed, nativeBufferFormatPropertiesOHOS.pNext );
8574 VULKAN_HPP_HASH_COMBINE( seed, nativeBufferFormatPropertiesOHOS.format );
8575 VULKAN_HPP_HASH_COMBINE( seed, nativeBufferFormatPropertiesOHOS.externalFormat );
8576 VULKAN_HPP_HASH_COMBINE( seed, nativeBufferFormatPropertiesOHOS.formatFeatures );
8577 VULKAN_HPP_HASH_COMBINE( seed, nativeBufferFormatPropertiesOHOS.samplerYcbcrConversionComponents );
8578 VULKAN_HPP_HASH_COMBINE( seed, nativeBufferFormatPropertiesOHOS.suggestedYcbcrModel );
8579 VULKAN_HPP_HASH_COMBINE( seed, nativeBufferFormatPropertiesOHOS.suggestedYcbcrRange );
8580 VULKAN_HPP_HASH_COMBINE( seed, nativeBufferFormatPropertiesOHOS.suggestedXChromaOffset );
8581 VULKAN_HPP_HASH_COMBINE( seed, nativeBufferFormatPropertiesOHOS.suggestedYChromaOffset );
8582 return seed;
8583 }
8584 };
8585 # endif /*VK_USE_PLATFORM_OHOS*/
8586
8587 # if defined( VK_USE_PLATFORM_OHOS )
8588 template <>
8589 struct hash<VULKAN_HPP_NAMESPACE::NativeBufferOHOS>
8590 {
8591 std::size_t operator()( VULKAN_HPP_NAMESPACE::NativeBufferOHOS const & nativeBufferOHOS ) const VULKAN_HPP_NOEXCEPT
8592 {
8593 std::size_t seed = 0;
8594 VULKAN_HPP_HASH_COMBINE( seed, nativeBufferOHOS.sType );
8595 VULKAN_HPP_HASH_COMBINE( seed, nativeBufferOHOS.pNext );
8596 VULKAN_HPP_HASH_COMBINE( seed, nativeBufferOHOS.handle );
8597 return seed;
8598 }
8599 };
8600 # endif /*VK_USE_PLATFORM_OHOS*/
8601
8602 # if defined( VK_USE_PLATFORM_OHOS )
8603 template <>
8604 struct hash<VULKAN_HPP_NAMESPACE::NativeBufferPropertiesOHOS>
8605 {
8606 std::size_t operator()( VULKAN_HPP_NAMESPACE::NativeBufferPropertiesOHOS const & nativeBufferPropertiesOHOS ) const VULKAN_HPP_NOEXCEPT
8607 {
8608 std::size_t seed = 0;
8609 VULKAN_HPP_HASH_COMBINE( seed, nativeBufferPropertiesOHOS.sType );
8610 VULKAN_HPP_HASH_COMBINE( seed, nativeBufferPropertiesOHOS.pNext );
8611 VULKAN_HPP_HASH_COMBINE( seed, nativeBufferPropertiesOHOS.allocationSize );
8612 VULKAN_HPP_HASH_COMBINE( seed, nativeBufferPropertiesOHOS.memoryTypeBits );
8613 return seed;
8614 }
8615 };
8616 # endif /*VK_USE_PLATFORM_OHOS*/
8617
8618 # if defined( VK_USE_PLATFORM_OHOS )
8619 template <>
8620 struct hash<VULKAN_HPP_NAMESPACE::NativeBufferUsageOHOS>
8621 {
8622 std::size_t operator()( VULKAN_HPP_NAMESPACE::NativeBufferUsageOHOS const & nativeBufferUsageOHOS ) const VULKAN_HPP_NOEXCEPT
8623 {
8624 std::size_t seed = 0;
8625 VULKAN_HPP_HASH_COMBINE( seed, nativeBufferUsageOHOS.sType );
8626 VULKAN_HPP_HASH_COMBINE( seed, nativeBufferUsageOHOS.pNext );
8627 VULKAN_HPP_HASH_COMBINE( seed, nativeBufferUsageOHOS.OHOSNativeBufferUsage );
8628 return seed;
8629 }
8630 };
8631 # endif /*VK_USE_PLATFORM_OHOS*/
8632
8633 template <>
8634 struct hash<VULKAN_HPP_NAMESPACE::OpaqueCaptureDescriptorDataCreateInfoEXT>
8635 {
8636 std::size_t
8637 operator()( VULKAN_HPP_NAMESPACE::OpaqueCaptureDescriptorDataCreateInfoEXT const & opaqueCaptureDescriptorDataCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
8638 {
8639 std::size_t seed = 0;
8640 VULKAN_HPP_HASH_COMBINE( seed, opaqueCaptureDescriptorDataCreateInfoEXT.sType );
8641 VULKAN_HPP_HASH_COMBINE( seed, opaqueCaptureDescriptorDataCreateInfoEXT.pNext );
8642 VULKAN_HPP_HASH_COMBINE( seed, opaqueCaptureDescriptorDataCreateInfoEXT.opaqueCaptureDescriptorData );
8643 return seed;
8644 }
8645 };
8646
8647 template <>
8648 struct hash<VULKAN_HPP_NAMESPACE::OpticalFlowExecuteInfoNV>
8649 {
8650 std::size_t operator()( VULKAN_HPP_NAMESPACE::OpticalFlowExecuteInfoNV const & opticalFlowExecuteInfoNV ) const VULKAN_HPP_NOEXCEPT
8651 {
8652 std::size_t seed = 0;
8653 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowExecuteInfoNV.sType );
8654 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowExecuteInfoNV.pNext );
8655 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowExecuteInfoNV.flags );
8656 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowExecuteInfoNV.regionCount );
8657 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowExecuteInfoNV.pRegions );
8658 return seed;
8659 }
8660 };
8661
8662 template <>
8663 struct hash<VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatInfoNV>
8664 {
8665 std::size_t operator()( VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatInfoNV const & opticalFlowImageFormatInfoNV ) const VULKAN_HPP_NOEXCEPT
8666 {
8667 std::size_t seed = 0;
8668 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowImageFormatInfoNV.sType );
8669 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowImageFormatInfoNV.pNext );
8670 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowImageFormatInfoNV.usage );
8671 return seed;
8672 }
8673 };
8674
8675 template <>
8676 struct hash<VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV>
8677 {
8678 std::size_t operator()( VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV const & opticalFlowImageFormatPropertiesNV ) const VULKAN_HPP_NOEXCEPT
8679 {
8680 std::size_t seed = 0;
8681 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowImageFormatPropertiesNV.sType );
8682 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowImageFormatPropertiesNV.pNext );
8683 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowImageFormatPropertiesNV.format );
8684 return seed;
8685 }
8686 };
8687
8688 template <>
8689 struct hash<VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreateInfoNV>
8690 {
8691 std::size_t operator()( VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreateInfoNV const & opticalFlowSessionCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
8692 {
8693 std::size_t seed = 0;
8694 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.sType );
8695 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.pNext );
8696 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.width );
8697 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.height );
8698 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.imageFormat );
8699 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.flowVectorFormat );
8700 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.costFormat );
8701 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.outputGridSize );
8702 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.hintGridSize );
8703 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.performanceLevel );
8704 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.flags );
8705 return seed;
8706 }
8707 };
8708
8709 template <>
8710 struct hash<VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreatePrivateDataInfoNV>
8711 {
8712 std::size_t
8713 operator()( VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreatePrivateDataInfoNV const & opticalFlowSessionCreatePrivateDataInfoNV ) const VULKAN_HPP_NOEXCEPT
8714 {
8715 std::size_t seed = 0;
8716 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreatePrivateDataInfoNV.sType );
8717 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreatePrivateDataInfoNV.pNext );
8718 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreatePrivateDataInfoNV.id );
8719 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreatePrivateDataInfoNV.size );
8720 VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreatePrivateDataInfoNV.pPrivateData );
8721 return seed;
8722 }
8723 };
8724
8725 template <>
8726 struct hash<VULKAN_HPP_NAMESPACE::OutOfBandQueueTypeInfoNV>
8727 {
8728 std::size_t operator()( VULKAN_HPP_NAMESPACE::OutOfBandQueueTypeInfoNV const & outOfBandQueueTypeInfoNV ) const VULKAN_HPP_NOEXCEPT
8729 {
8730 std::size_t seed = 0;
8731 VULKAN_HPP_HASH_COMBINE( seed, outOfBandQueueTypeInfoNV.sType );
8732 VULKAN_HPP_HASH_COMBINE( seed, outOfBandQueueTypeInfoNV.pNext );
8733 VULKAN_HPP_HASH_COMBINE( seed, outOfBandQueueTypeInfoNV.queueType );
8734 return seed;
8735 }
8736 };
8737
8738 template <>
8739 struct hash<VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureFlagsNV>
8740 {
8741 std::size_t
8742 operator()( VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureFlagsNV const & partitionedAccelerationStructureFlagsNV ) const VULKAN_HPP_NOEXCEPT
8743 {
8744 std::size_t seed = 0;
8745 VULKAN_HPP_HASH_COMBINE( seed, partitionedAccelerationStructureFlagsNV.sType );
8746 VULKAN_HPP_HASH_COMBINE( seed, partitionedAccelerationStructureFlagsNV.pNext );
8747 VULKAN_HPP_HASH_COMBINE( seed, partitionedAccelerationStructureFlagsNV.enablePartitionTranslation );
8748 return seed;
8749 }
8750 };
8751
8752 template <>
8753 struct hash<VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureUpdateInstanceDataNV>
8754 {
8755 std::size_t operator()( VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureUpdateInstanceDataNV const &
8756 partitionedAccelerationStructureUpdateInstanceDataNV ) const VULKAN_HPP_NOEXCEPT
8757 {
8758 std::size_t seed = 0;
8759 VULKAN_HPP_HASH_COMBINE( seed, partitionedAccelerationStructureUpdateInstanceDataNV.instanceIndex );
8760 VULKAN_HPP_HASH_COMBINE( seed, partitionedAccelerationStructureUpdateInstanceDataNV.instanceContributionToHitGroupIndex );
8761 VULKAN_HPP_HASH_COMBINE( seed, partitionedAccelerationStructureUpdateInstanceDataNV.accelerationStructure );
8762 return seed;
8763 }
8764 };
8765
8766 template <>
8767 struct hash<VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureWriteInstanceDataNV>
8768 {
8769 std::size_t
8770 operator()( VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureWriteInstanceDataNV const & partitionedAccelerationStructureWriteInstanceDataNV ) const
8771 VULKAN_HPP_NOEXCEPT
8772 {
8773 std::size_t seed = 0;
8774 VULKAN_HPP_HASH_COMBINE( seed, partitionedAccelerationStructureWriteInstanceDataNV.transform );
8775 for ( size_t i = 0; i < 6; ++i )
8776 {
8777 VULKAN_HPP_HASH_COMBINE( seed, partitionedAccelerationStructureWriteInstanceDataNV.explicitAABB[i] );
8778 }
8779 VULKAN_HPP_HASH_COMBINE( seed, partitionedAccelerationStructureWriteInstanceDataNV.instanceID );
8780 VULKAN_HPP_HASH_COMBINE( seed, partitionedAccelerationStructureWriteInstanceDataNV.instanceMask );
8781 VULKAN_HPP_HASH_COMBINE( seed, partitionedAccelerationStructureWriteInstanceDataNV.instanceContributionToHitGroupIndex );
8782 VULKAN_HPP_HASH_COMBINE( seed, partitionedAccelerationStructureWriteInstanceDataNV.instanceFlags );
8783 VULKAN_HPP_HASH_COMBINE( seed, partitionedAccelerationStructureWriteInstanceDataNV.instanceIndex );
8784 VULKAN_HPP_HASH_COMBINE( seed, partitionedAccelerationStructureWriteInstanceDataNV.partitionIndex );
8785 VULKAN_HPP_HASH_COMBINE( seed, partitionedAccelerationStructureWriteInstanceDataNV.accelerationStructure );
8786 return seed;
8787 }
8788 };
8789
8790 template <>
8791 struct hash<VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureWritePartitionTranslationDataNV>
8792 {
8793 std::size_t operator()( VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureWritePartitionTranslationDataNV const &
8794 partitionedAccelerationStructureWritePartitionTranslationDataNV ) const VULKAN_HPP_NOEXCEPT
8795 {
8796 std::size_t seed = 0;
8797 VULKAN_HPP_HASH_COMBINE( seed, partitionedAccelerationStructureWritePartitionTranslationDataNV.partitionIndex );
8798 for ( size_t i = 0; i < 3; ++i )
8799 {
8800 VULKAN_HPP_HASH_COMBINE( seed, partitionedAccelerationStructureWritePartitionTranslationDataNV.partitionTranslation[i] );
8801 }
8802 return seed;
8803 }
8804 };
8805
8806 template <>
8807 struct hash<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE>
8808 {
8809 std::size_t operator()( VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE const & pastPresentationTimingGOOGLE ) const VULKAN_HPP_NOEXCEPT
8810 {
8811 std::size_t seed = 0;
8812 VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingGOOGLE.presentID );
8813 VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingGOOGLE.desiredPresentTime );
8814 VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingGOOGLE.actualPresentTime );
8815 VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingGOOGLE.earliestPresentTime );
8816 VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingGOOGLE.presentMargin );
8817 return seed;
8818 }
8819 };
8820
8821 template <>
8822 struct hash<VULKAN_HPP_NAMESPACE::PerTileBeginInfoQCOM>
8823 {
8824 std::size_t operator()( VULKAN_HPP_NAMESPACE::PerTileBeginInfoQCOM const & perTileBeginInfoQCOM ) const VULKAN_HPP_NOEXCEPT
8825 {
8826 std::size_t seed = 0;
8827 VULKAN_HPP_HASH_COMBINE( seed, perTileBeginInfoQCOM.sType );
8828 VULKAN_HPP_HASH_COMBINE( seed, perTileBeginInfoQCOM.pNext );
8829 return seed;
8830 }
8831 };
8832
8833 template <>
8834 struct hash<VULKAN_HPP_NAMESPACE::PerTileEndInfoQCOM>
8835 {
8836 std::size_t operator()( VULKAN_HPP_NAMESPACE::PerTileEndInfoQCOM const & perTileEndInfoQCOM ) const VULKAN_HPP_NOEXCEPT
8837 {
8838 std::size_t seed = 0;
8839 VULKAN_HPP_HASH_COMBINE( seed, perTileEndInfoQCOM.sType );
8840 VULKAN_HPP_HASH_COMBINE( seed, perTileEndInfoQCOM.pNext );
8841 return seed;
8842 }
8843 };
8844
8845 template <>
8846 struct hash<VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL>
8847 {
8848 std::size_t
8849 operator()( VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL const & performanceConfigurationAcquireInfoINTEL ) const VULKAN_HPP_NOEXCEPT
8850 {
8851 std::size_t seed = 0;
8852 VULKAN_HPP_HASH_COMBINE( seed, performanceConfigurationAcquireInfoINTEL.sType );
8853 VULKAN_HPP_HASH_COMBINE( seed, performanceConfigurationAcquireInfoINTEL.pNext );
8854 VULKAN_HPP_HASH_COMBINE( seed, performanceConfigurationAcquireInfoINTEL.type );
8855 return seed;
8856 }
8857 };
8858
8859 template <>
8860 struct hash<VULKAN_HPP_NAMESPACE::PerformanceCounterARM>
8861 {
8862 std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceCounterARM const & performanceCounterARM ) const VULKAN_HPP_NOEXCEPT
8863 {
8864 std::size_t seed = 0;
8865 VULKAN_HPP_HASH_COMBINE( seed, performanceCounterARM.sType );
8866 VULKAN_HPP_HASH_COMBINE( seed, performanceCounterARM.pNext );
8867 VULKAN_HPP_HASH_COMBINE( seed, performanceCounterARM.counterID );
8868 return seed;
8869 }
8870 };
8871
8872 template <>
8873 struct hash<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionARM>
8874 {
8875 std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionARM const & performanceCounterDescriptionARM ) const VULKAN_HPP_NOEXCEPT
8876 {
8877 std::size_t seed = 0;
8878 VULKAN_HPP_HASH_COMBINE( seed, performanceCounterDescriptionARM.sType );
8879 VULKAN_HPP_HASH_COMBINE( seed, performanceCounterDescriptionARM.pNext );
8880 VULKAN_HPP_HASH_COMBINE( seed, performanceCounterDescriptionARM.flags );
8881 for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i )
8882 {
8883 VULKAN_HPP_HASH_COMBINE( seed, performanceCounterDescriptionARM.name[i] );
8884 }
8885 return seed;
8886 }
8887 };
8888
8889 template <>
8890 struct hash<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR>
8891 {
8892 std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR const & performanceCounterDescriptionKHR ) const VULKAN_HPP_NOEXCEPT
8893 {
8894 std::size_t seed = 0;
8895 VULKAN_HPP_HASH_COMBINE( seed, performanceCounterDescriptionKHR.sType );
8896 VULKAN_HPP_HASH_COMBINE( seed, performanceCounterDescriptionKHR.pNext );
8897 VULKAN_HPP_HASH_COMBINE( seed, performanceCounterDescriptionKHR.flags );
8898 for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i )
8899 {
8900 VULKAN_HPP_HASH_COMBINE( seed, performanceCounterDescriptionKHR.name[i] );
8901 }
8902 for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i )
8903 {
8904 VULKAN_HPP_HASH_COMBINE( seed, performanceCounterDescriptionKHR.category[i] );
8905 }
8906 for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i )
8907 {
8908 VULKAN_HPP_HASH_COMBINE( seed, performanceCounterDescriptionKHR.description[i] );
8909 }
8910 return seed;
8911 }
8912 };
8913
8914 template <>
8915 struct hash<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR>
8916 {
8917 std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceCounterKHR const & performanceCounterKHR ) const VULKAN_HPP_NOEXCEPT
8918 {
8919 std::size_t seed = 0;
8920 VULKAN_HPP_HASH_COMBINE( seed, performanceCounterKHR.sType );
8921 VULKAN_HPP_HASH_COMBINE( seed, performanceCounterKHR.pNext );
8922 VULKAN_HPP_HASH_COMBINE( seed, performanceCounterKHR.unit );
8923 VULKAN_HPP_HASH_COMBINE( seed, performanceCounterKHR.scope );
8924 VULKAN_HPP_HASH_COMBINE( seed, performanceCounterKHR.storage );
8925 for ( size_t i = 0; i < VK_UUID_SIZE; ++i )
8926 {
8927 VULKAN_HPP_HASH_COMBINE( seed, performanceCounterKHR.uuid[i] );
8928 }
8929 return seed;
8930 }
8931 };
8932
8933 template <>
8934 struct hash<VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL>
8935 {
8936 std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL const & performanceMarkerInfoINTEL ) const VULKAN_HPP_NOEXCEPT
8937 {
8938 std::size_t seed = 0;
8939 VULKAN_HPP_HASH_COMBINE( seed, performanceMarkerInfoINTEL.sType );
8940 VULKAN_HPP_HASH_COMBINE( seed, performanceMarkerInfoINTEL.pNext );
8941 VULKAN_HPP_HASH_COMBINE( seed, performanceMarkerInfoINTEL.marker );
8942 return seed;
8943 }
8944 };
8945
8946 template <>
8947 struct hash<VULKAN_HPP_NAMESPACE::PerformanceOverrideInfoINTEL>
8948 {
8949 std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceOverrideInfoINTEL const & performanceOverrideInfoINTEL ) const VULKAN_HPP_NOEXCEPT
8950 {
8951 std::size_t seed = 0;
8952 VULKAN_HPP_HASH_COMBINE( seed, performanceOverrideInfoINTEL.sType );
8953 VULKAN_HPP_HASH_COMBINE( seed, performanceOverrideInfoINTEL.pNext );
8954 VULKAN_HPP_HASH_COMBINE( seed, performanceOverrideInfoINTEL.type );
8955 VULKAN_HPP_HASH_COMBINE( seed, performanceOverrideInfoINTEL.enable );
8956 VULKAN_HPP_HASH_COMBINE( seed, performanceOverrideInfoINTEL.parameter );
8957 return seed;
8958 }
8959 };
8960
8961 template <>
8962 struct hash<VULKAN_HPP_NAMESPACE::PerformanceQuerySubmitInfoKHR>
8963 {
8964 std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceQuerySubmitInfoKHR const & performanceQuerySubmitInfoKHR ) const VULKAN_HPP_NOEXCEPT
8965 {
8966 std::size_t seed = 0;
8967 VULKAN_HPP_HASH_COMBINE( seed, performanceQuerySubmitInfoKHR.sType );
8968 VULKAN_HPP_HASH_COMBINE( seed, performanceQuerySubmitInfoKHR.pNext );
8969 VULKAN_HPP_HASH_COMBINE( seed, performanceQuerySubmitInfoKHR.counterPassIndex );
8970 return seed;
8971 }
8972 };
8973
8974 template <>
8975 struct hash<VULKAN_HPP_NAMESPACE::PerformanceStreamMarkerInfoINTEL>
8976 {
8977 std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceStreamMarkerInfoINTEL const & performanceStreamMarkerInfoINTEL ) const VULKAN_HPP_NOEXCEPT
8978 {
8979 std::size_t seed = 0;
8980 VULKAN_HPP_HASH_COMBINE( seed, performanceStreamMarkerInfoINTEL.sType );
8981 VULKAN_HPP_HASH_COMBINE( seed, performanceStreamMarkerInfoINTEL.pNext );
8982 VULKAN_HPP_HASH_COMBINE( seed, performanceStreamMarkerInfoINTEL.marker );
8983 return seed;
8984 }
8985 };
8986
8987 template <>
8988 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevice16BitStorageFeatures>
8989 {
8990 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevice16BitStorageFeatures const & physicalDevice16BitStorageFeatures ) const VULKAN_HPP_NOEXCEPT
8991 {
8992 std::size_t seed = 0;
8993 VULKAN_HPP_HASH_COMBINE( seed, physicalDevice16BitStorageFeatures.sType );
8994 VULKAN_HPP_HASH_COMBINE( seed, physicalDevice16BitStorageFeatures.pNext );
8995 VULKAN_HPP_HASH_COMBINE( seed, physicalDevice16BitStorageFeatures.storageBuffer16BitAccess );
8996 VULKAN_HPP_HASH_COMBINE( seed, physicalDevice16BitStorageFeatures.uniformAndStorageBuffer16BitAccess );
8997 VULKAN_HPP_HASH_COMBINE( seed, physicalDevice16BitStorageFeatures.storagePushConstant16 );
8998 VULKAN_HPP_HASH_COMBINE( seed, physicalDevice16BitStorageFeatures.storageInputOutput16 );
8999 return seed;
9000 }
9001 };
9002
9003 template <>
9004 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevice4444FormatsFeaturesEXT>
9005 {
9006 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevice4444FormatsFeaturesEXT const & physicalDevice4444FormatsFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
9007 {
9008 std::size_t seed = 0;
9009 VULKAN_HPP_HASH_COMBINE( seed, physicalDevice4444FormatsFeaturesEXT.sType );
9010 VULKAN_HPP_HASH_COMBINE( seed, physicalDevice4444FormatsFeaturesEXT.pNext );
9011 VULKAN_HPP_HASH_COMBINE( seed, physicalDevice4444FormatsFeaturesEXT.formatA4R4G4B4 );
9012 VULKAN_HPP_HASH_COMBINE( seed, physicalDevice4444FormatsFeaturesEXT.formatA4B4G4R4 );
9013 return seed;
9014 }
9015 };
9016
9017 template <>
9018 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevice8BitStorageFeatures>
9019 {
9020 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevice8BitStorageFeatures const & physicalDevice8BitStorageFeatures ) const VULKAN_HPP_NOEXCEPT
9021 {
9022 std::size_t seed = 0;
9023 VULKAN_HPP_HASH_COMBINE( seed, physicalDevice8BitStorageFeatures.sType );
9024 VULKAN_HPP_HASH_COMBINE( seed, physicalDevice8BitStorageFeatures.pNext );
9025 VULKAN_HPP_HASH_COMBINE( seed, physicalDevice8BitStorageFeatures.storageBuffer8BitAccess );
9026 VULKAN_HPP_HASH_COMBINE( seed, physicalDevice8BitStorageFeatures.uniformAndStorageBuffer8BitAccess );
9027 VULKAN_HPP_HASH_COMBINE( seed, physicalDevice8BitStorageFeatures.storagePushConstant8 );
9028 return seed;
9029 }
9030 };
9031
9032 template <>
9033 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceASTCDecodeFeaturesEXT>
9034 {
9035 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceASTCDecodeFeaturesEXT const & physicalDeviceASTCDecodeFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
9036 {
9037 std::size_t seed = 0;
9038 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceASTCDecodeFeaturesEXT.sType );
9039 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceASTCDecodeFeaturesEXT.pNext );
9040 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceASTCDecodeFeaturesEXT.decodeModeSharedExponent );
9041 return seed;
9042 }
9043 };
9044
9045 template <>
9046 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceAccelerationStructureFeaturesKHR>
9047 {
9048 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceAccelerationStructureFeaturesKHR const & physicalDeviceAccelerationStructureFeaturesKHR ) const
9049 VULKAN_HPP_NOEXCEPT
9050 {
9051 std::size_t seed = 0;
9052 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructureFeaturesKHR.sType );
9053 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructureFeaturesKHR.pNext );
9054 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructureFeaturesKHR.accelerationStructure );
9055 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructureFeaturesKHR.accelerationStructureCaptureReplay );
9056 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructureFeaturesKHR.accelerationStructureIndirectBuild );
9057 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructureFeaturesKHR.accelerationStructureHostCommands );
9058 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructureFeaturesKHR.descriptorBindingAccelerationStructureUpdateAfterBind );
9059 return seed;
9060 }
9061 };
9062
9063 template <>
9064 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceAccelerationStructurePropertiesKHR>
9065 {
9066 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceAccelerationStructurePropertiesKHR const & physicalDeviceAccelerationStructurePropertiesKHR )
9067 const VULKAN_HPP_NOEXCEPT
9068 {
9069 std::size_t seed = 0;
9070 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.sType );
9071 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.pNext );
9072 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.maxGeometryCount );
9073 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.maxInstanceCount );
9074 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.maxPrimitiveCount );
9075 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.maxPerStageDescriptorAccelerationStructures );
9076 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.maxPerStageDescriptorUpdateAfterBindAccelerationStructures );
9077 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.maxDescriptorSetAccelerationStructures );
9078 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.maxDescriptorSetUpdateAfterBindAccelerationStructures );
9079 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.minAccelerationStructureScratchOffsetAlignment );
9080 return seed;
9081 }
9082 };
9083
9084 template <>
9085 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceAddressBindingReportFeaturesEXT>
9086 {
9087 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceAddressBindingReportFeaturesEXT const & physicalDeviceAddressBindingReportFeaturesEXT ) const
9088 VULKAN_HPP_NOEXCEPT
9089 {
9090 std::size_t seed = 0;
9091 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAddressBindingReportFeaturesEXT.sType );
9092 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAddressBindingReportFeaturesEXT.pNext );
9093 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAddressBindingReportFeaturesEXT.reportAddressBinding );
9094 return seed;
9095 }
9096 };
9097
9098 template <>
9099 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceAmigoProfilingFeaturesSEC>
9100 {
9101 std::size_t
9102 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceAmigoProfilingFeaturesSEC const & physicalDeviceAmigoProfilingFeaturesSEC ) const VULKAN_HPP_NOEXCEPT
9103 {
9104 std::size_t seed = 0;
9105 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAmigoProfilingFeaturesSEC.sType );
9106 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAmigoProfilingFeaturesSEC.pNext );
9107 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAmigoProfilingFeaturesSEC.amigoProfiling );
9108 return seed;
9109 }
9110 };
9111
9112 template <>
9113 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceAntiLagFeaturesAMD>
9114 {
9115 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceAntiLagFeaturesAMD const & physicalDeviceAntiLagFeaturesAMD ) const VULKAN_HPP_NOEXCEPT
9116 {
9117 std::size_t seed = 0;
9118 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAntiLagFeaturesAMD.sType );
9119 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAntiLagFeaturesAMD.pNext );
9120 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAntiLagFeaturesAMD.antiLag );
9121 return seed;
9122 }
9123 };
9124
9125 template <>
9126 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT>
9127 {
9128 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT const &
9129 physicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
9130 {
9131 std::size_t seed = 0;
9132 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT.sType );
9133 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT.pNext );
9134 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT.attachmentFeedbackLoopDynamicState );
9135 return seed;
9136 }
9137 };
9138
9139 template <>
9140 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT>
9141 {
9142 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT const &
9143 physicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
9144 {
9145 std::size_t seed = 0;
9146 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT.sType );
9147 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT.pNext );
9148 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT.attachmentFeedbackLoopLayout );
9149 return seed;
9150 }
9151 };
9152
9153 template <>
9154 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceBlendOperationAdvancedFeaturesEXT>
9155 {
9156 std::size_t operator()(
9157 VULKAN_HPP_NAMESPACE::PhysicalDeviceBlendOperationAdvancedFeaturesEXT const & physicalDeviceBlendOperationAdvancedFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
9158 {
9159 std::size_t seed = 0;
9160 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedFeaturesEXT.sType );
9161 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedFeaturesEXT.pNext );
9162 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedFeaturesEXT.advancedBlendCoherentOperations );
9163 return seed;
9164 }
9165 };
9166
9167 template <>
9168 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceBlendOperationAdvancedPropertiesEXT>
9169 {
9170 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceBlendOperationAdvancedPropertiesEXT const & physicalDeviceBlendOperationAdvancedPropertiesEXT )
9171 const VULKAN_HPP_NOEXCEPT
9172 {
9173 std::size_t seed = 0;
9174 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.sType );
9175 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.pNext );
9176 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendMaxColorAttachments );
9177 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendIndependentBlend );
9178 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendNonPremultipliedSrcColor );
9179 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendNonPremultipliedDstColor );
9180 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendCorrelatedOverlap );
9181 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendAllOperations );
9182 return seed;
9183 }
9184 };
9185
9186 template <>
9187 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceBorderColorSwizzleFeaturesEXT>
9188 {
9189 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceBorderColorSwizzleFeaturesEXT const & physicalDeviceBorderColorSwizzleFeaturesEXT ) const
9190 VULKAN_HPP_NOEXCEPT
9191 {
9192 std::size_t seed = 0;
9193 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBorderColorSwizzleFeaturesEXT.sType );
9194 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBorderColorSwizzleFeaturesEXT.pNext );
9195 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBorderColorSwizzleFeaturesEXT.borderColorSwizzle );
9196 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBorderColorSwizzleFeaturesEXT.borderColorSwizzleFromImage );
9197 return seed;
9198 }
9199 };
9200
9201 template <>
9202 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceBufferDeviceAddressFeatures>
9203 {
9204 std::size_t
9205 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceBufferDeviceAddressFeatures const & physicalDeviceBufferDeviceAddressFeatures ) const VULKAN_HPP_NOEXCEPT
9206 {
9207 std::size_t seed = 0;
9208 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeatures.sType );
9209 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeatures.pNext );
9210 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeatures.bufferDeviceAddress );
9211 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeatures.bufferDeviceAddressCaptureReplay );
9212 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeatures.bufferDeviceAddressMultiDevice );
9213 return seed;
9214 }
9215 };
9216
9217 template <>
9218 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceBufferDeviceAddressFeaturesEXT>
9219 {
9220 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceBufferDeviceAddressFeaturesEXT const & physicalDeviceBufferDeviceAddressFeaturesEXT ) const
9221 VULKAN_HPP_NOEXCEPT
9222 {
9223 std::size_t seed = 0;
9224 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeaturesEXT.sType );
9225 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeaturesEXT.pNext );
9226 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeaturesEXT.bufferDeviceAddress );
9227 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeaturesEXT.bufferDeviceAddressCaptureReplay );
9228 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeaturesEXT.bufferDeviceAddressMultiDevice );
9229 return seed;
9230 }
9231 };
9232
9233 template <>
9234 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterAccelerationStructureFeaturesNV>
9235 {
9236 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterAccelerationStructureFeaturesNV const &
9237 physicalDeviceClusterAccelerationStructureFeaturesNV ) const VULKAN_HPP_NOEXCEPT
9238 {
9239 std::size_t seed = 0;
9240 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterAccelerationStructureFeaturesNV.sType );
9241 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterAccelerationStructureFeaturesNV.pNext );
9242 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterAccelerationStructureFeaturesNV.clusterAccelerationStructure );
9243 return seed;
9244 }
9245 };
9246
9247 template <>
9248 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterAccelerationStructurePropertiesNV>
9249 {
9250 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterAccelerationStructurePropertiesNV const &
9251 physicalDeviceClusterAccelerationStructurePropertiesNV ) const VULKAN_HPP_NOEXCEPT
9252 {
9253 std::size_t seed = 0;
9254 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterAccelerationStructurePropertiesNV.sType );
9255 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterAccelerationStructurePropertiesNV.pNext );
9256 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterAccelerationStructurePropertiesNV.maxVerticesPerCluster );
9257 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterAccelerationStructurePropertiesNV.maxTrianglesPerCluster );
9258 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterAccelerationStructurePropertiesNV.clusterScratchByteAlignment );
9259 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterAccelerationStructurePropertiesNV.clusterByteAlignment );
9260 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterAccelerationStructurePropertiesNV.clusterTemplateByteAlignment );
9261 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterAccelerationStructurePropertiesNV.clusterBottomLevelByteAlignment );
9262 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterAccelerationStructurePropertiesNV.clusterTemplateBoundsByteAlignment );
9263 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterAccelerationStructurePropertiesNV.maxClusterGeometryIndex );
9264 return seed;
9265 }
9266 };
9267
9268 template <>
9269 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterCullingShaderFeaturesHUAWEI>
9270 {
9271 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterCullingShaderFeaturesHUAWEI const & physicalDeviceClusterCullingShaderFeaturesHUAWEI )
9272 const VULKAN_HPP_NOEXCEPT
9273 {
9274 std::size_t seed = 0;
9275 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderFeaturesHUAWEI.sType );
9276 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderFeaturesHUAWEI.pNext );
9277 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderFeaturesHUAWEI.clustercullingShader );
9278 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderFeaturesHUAWEI.multiviewClusterCullingShader );
9279 return seed;
9280 }
9281 };
9282
9283 template <>
9284 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterCullingShaderPropertiesHUAWEI>
9285 {
9286 std::size_t
9287 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterCullingShaderPropertiesHUAWEI const & physicalDeviceClusterCullingShaderPropertiesHUAWEI ) const
9288 VULKAN_HPP_NOEXCEPT
9289 {
9290 std::size_t seed = 0;
9291 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderPropertiesHUAWEI.sType );
9292 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderPropertiesHUAWEI.pNext );
9293 for ( size_t i = 0; i < 3; ++i )
9294 {
9295 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderPropertiesHUAWEI.maxWorkGroupCount[i] );
9296 }
9297 for ( size_t i = 0; i < 3; ++i )
9298 {
9299 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderPropertiesHUAWEI.maxWorkGroupSize[i] );
9300 }
9301 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderPropertiesHUAWEI.maxOutputClusterCount );
9302 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderPropertiesHUAWEI.indirectBufferOffsetAlignment );
9303 return seed;
9304 }
9305 };
9306
9307 template <>
9308 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI>
9309 {
9310 std::size_t
9311 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI const & physicalDeviceClusterCullingShaderVrsFeaturesHUAWEI ) const
9312 VULKAN_HPP_NOEXCEPT
9313 {
9314 std::size_t seed = 0;
9315 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderVrsFeaturesHUAWEI.sType );
9316 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderVrsFeaturesHUAWEI.pNext );
9317 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderVrsFeaturesHUAWEI.clusterShadingRate );
9318 return seed;
9319 }
9320 };
9321
9322 template <>
9323 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCoherentMemoryFeaturesAMD>
9324 {
9325 std::size_t
9326 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCoherentMemoryFeaturesAMD const & physicalDeviceCoherentMemoryFeaturesAMD ) const VULKAN_HPP_NOEXCEPT
9327 {
9328 std::size_t seed = 0;
9329 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCoherentMemoryFeaturesAMD.sType );
9330 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCoherentMemoryFeaturesAMD.pNext );
9331 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCoherentMemoryFeaturesAMD.deviceCoherentMemory );
9332 return seed;
9333 }
9334 };
9335
9336 template <>
9337 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceColorWriteEnableFeaturesEXT>
9338 {
9339 std::size_t
9340 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceColorWriteEnableFeaturesEXT const & physicalDeviceColorWriteEnableFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
9341 {
9342 std::size_t seed = 0;
9343 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceColorWriteEnableFeaturesEXT.sType );
9344 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceColorWriteEnableFeaturesEXT.pNext );
9345 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceColorWriteEnableFeaturesEXT.colorWriteEnable );
9346 return seed;
9347 }
9348 };
9349
9350 template <>
9351 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCommandBufferInheritanceFeaturesNV>
9352 {
9353 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCommandBufferInheritanceFeaturesNV const & physicalDeviceCommandBufferInheritanceFeaturesNV )
9354 const VULKAN_HPP_NOEXCEPT
9355 {
9356 std::size_t seed = 0;
9357 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCommandBufferInheritanceFeaturesNV.sType );
9358 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCommandBufferInheritanceFeaturesNV.pNext );
9359 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCommandBufferInheritanceFeaturesNV.commandBufferInheritance );
9360 return seed;
9361 }
9362 };
9363
9364 template <>
9365 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceComputeShaderDerivativesFeaturesKHR>
9366 {
9367 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceComputeShaderDerivativesFeaturesKHR const & physicalDeviceComputeShaderDerivativesFeaturesKHR )
9368 const VULKAN_HPP_NOEXCEPT
9369 {
9370 std::size_t seed = 0;
9371 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceComputeShaderDerivativesFeaturesKHR.sType );
9372 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceComputeShaderDerivativesFeaturesKHR.pNext );
9373 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceComputeShaderDerivativesFeaturesKHR.computeDerivativeGroupQuads );
9374 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceComputeShaderDerivativesFeaturesKHR.computeDerivativeGroupLinear );
9375 return seed;
9376 }
9377 };
9378
9379 template <>
9380 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceComputeShaderDerivativesPropertiesKHR>
9381 {
9382 std::size_t
9383 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceComputeShaderDerivativesPropertiesKHR const & physicalDeviceComputeShaderDerivativesPropertiesKHR ) const
9384 VULKAN_HPP_NOEXCEPT
9385 {
9386 std::size_t seed = 0;
9387 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceComputeShaderDerivativesPropertiesKHR.sType );
9388 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceComputeShaderDerivativesPropertiesKHR.pNext );
9389 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceComputeShaderDerivativesPropertiesKHR.meshAndTaskShaderDerivatives );
9390 return seed;
9391 }
9392 };
9393
9394 template <>
9395 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceConditionalRenderingFeaturesEXT>
9396 {
9397 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceConditionalRenderingFeaturesEXT const & physicalDeviceConditionalRenderingFeaturesEXT ) const
9398 VULKAN_HPP_NOEXCEPT
9399 {
9400 std::size_t seed = 0;
9401 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConditionalRenderingFeaturesEXT.sType );
9402 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConditionalRenderingFeaturesEXT.pNext );
9403 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConditionalRenderingFeaturesEXT.conditionalRendering );
9404 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConditionalRenderingFeaturesEXT.inheritedConditionalRendering );
9405 return seed;
9406 }
9407 };
9408
9409 template <>
9410 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceConservativeRasterizationPropertiesEXT>
9411 {
9412 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceConservativeRasterizationPropertiesEXT const &
9413 physicalDeviceConservativeRasterizationPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
9414 {
9415 std::size_t seed = 0;
9416 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.sType );
9417 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.pNext );
9418 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.primitiveOverestimationSize );
9419 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.maxExtraPrimitiveOverestimationSize );
9420 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.extraPrimitiveOverestimationSizeGranularity );
9421 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.primitiveUnderestimation );
9422 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.conservativePointAndLineRasterization );
9423 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.degenerateTrianglesRasterized );
9424 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.degenerateLinesRasterized );
9425 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.fullyCoveredFragmentShaderInputVariable );
9426 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.conservativeRasterizationPostDepthCoverage );
9427 return seed;
9428 }
9429 };
9430
9431 template <>
9432 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrix2FeaturesNV>
9433 {
9434 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrix2FeaturesNV const & physicalDeviceCooperativeMatrix2FeaturesNV ) const
9435 VULKAN_HPP_NOEXCEPT
9436 {
9437 std::size_t seed = 0;
9438 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrix2FeaturesNV.sType );
9439 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrix2FeaturesNV.pNext );
9440 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrix2FeaturesNV.cooperativeMatrixWorkgroupScope );
9441 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrix2FeaturesNV.cooperativeMatrixFlexibleDimensions );
9442 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrix2FeaturesNV.cooperativeMatrixReductions );
9443 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrix2FeaturesNV.cooperativeMatrixConversions );
9444 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrix2FeaturesNV.cooperativeMatrixPerElementOperations );
9445 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrix2FeaturesNV.cooperativeMatrixTensorAddressing );
9446 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrix2FeaturesNV.cooperativeMatrixBlockLoads );
9447 return seed;
9448 }
9449 };
9450
9451 template <>
9452 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrix2PropertiesNV>
9453 {
9454 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrix2PropertiesNV const & physicalDeviceCooperativeMatrix2PropertiesNV ) const
9455 VULKAN_HPP_NOEXCEPT
9456 {
9457 std::size_t seed = 0;
9458 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrix2PropertiesNV.sType );
9459 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrix2PropertiesNV.pNext );
9460 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrix2PropertiesNV.cooperativeMatrixWorkgroupScopeMaxWorkgroupSize );
9461 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrix2PropertiesNV.cooperativeMatrixFlexibleDimensionsMaxDimension );
9462 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrix2PropertiesNV.cooperativeMatrixWorkgroupScopeReservedSharedMemory );
9463 return seed;
9464 }
9465 };
9466
9467 template <>
9468 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixFeaturesKHR>
9469 {
9470 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixFeaturesKHR const & physicalDeviceCooperativeMatrixFeaturesKHR ) const
9471 VULKAN_HPP_NOEXCEPT
9472 {
9473 std::size_t seed = 0;
9474 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixFeaturesKHR.sType );
9475 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixFeaturesKHR.pNext );
9476 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixFeaturesKHR.cooperativeMatrix );
9477 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixFeaturesKHR.cooperativeMatrixRobustBufferAccess );
9478 return seed;
9479 }
9480 };
9481
9482 template <>
9483 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixFeaturesNV>
9484 {
9485 std::size_t
9486 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixFeaturesNV const & physicalDeviceCooperativeMatrixFeaturesNV ) const VULKAN_HPP_NOEXCEPT
9487 {
9488 std::size_t seed = 0;
9489 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixFeaturesNV.sType );
9490 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixFeaturesNV.pNext );
9491 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixFeaturesNV.cooperativeMatrix );
9492 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixFeaturesNV.cooperativeMatrixRobustBufferAccess );
9493 return seed;
9494 }
9495 };
9496
9497 template <>
9498 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixPropertiesKHR>
9499 {
9500 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixPropertiesKHR const & physicalDeviceCooperativeMatrixPropertiesKHR ) const
9501 VULKAN_HPP_NOEXCEPT
9502 {
9503 std::size_t seed = 0;
9504 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixPropertiesKHR.sType );
9505 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixPropertiesKHR.pNext );
9506 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixPropertiesKHR.cooperativeMatrixSupportedStages );
9507 return seed;
9508 }
9509 };
9510
9511 template <>
9512 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixPropertiesNV>
9513 {
9514 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixPropertiesNV const & physicalDeviceCooperativeMatrixPropertiesNV ) const
9515 VULKAN_HPP_NOEXCEPT
9516 {
9517 std::size_t seed = 0;
9518 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixPropertiesNV.sType );
9519 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixPropertiesNV.pNext );
9520 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixPropertiesNV.cooperativeMatrixSupportedStages );
9521 return seed;
9522 }
9523 };
9524
9525 template <>
9526 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeVectorFeaturesNV>
9527 {
9528 std::size_t
9529 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeVectorFeaturesNV const & physicalDeviceCooperativeVectorFeaturesNV ) const VULKAN_HPP_NOEXCEPT
9530 {
9531 std::size_t seed = 0;
9532 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeVectorFeaturesNV.sType );
9533 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeVectorFeaturesNV.pNext );
9534 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeVectorFeaturesNV.cooperativeVector );
9535 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeVectorFeaturesNV.cooperativeVectorTraining );
9536 return seed;
9537 }
9538 };
9539
9540 template <>
9541 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeVectorPropertiesNV>
9542 {
9543 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeVectorPropertiesNV const & physicalDeviceCooperativeVectorPropertiesNV ) const
9544 VULKAN_HPP_NOEXCEPT
9545 {
9546 std::size_t seed = 0;
9547 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeVectorPropertiesNV.sType );
9548 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeVectorPropertiesNV.pNext );
9549 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeVectorPropertiesNV.cooperativeVectorSupportedStages );
9550 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeVectorPropertiesNV.cooperativeVectorTrainingFloat16Accumulation );
9551 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeVectorPropertiesNV.cooperativeVectorTrainingFloat32Accumulation );
9552 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeVectorPropertiesNV.maxCooperativeVectorComponents );
9553 return seed;
9554 }
9555 };
9556
9557 template <>
9558 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectFeaturesKHR>
9559 {
9560 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectFeaturesKHR const & physicalDeviceCopyMemoryIndirectFeaturesKHR ) const
9561 VULKAN_HPP_NOEXCEPT
9562 {
9563 std::size_t seed = 0;
9564 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCopyMemoryIndirectFeaturesKHR.sType );
9565 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCopyMemoryIndirectFeaturesKHR.pNext );
9566 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCopyMemoryIndirectFeaturesKHR.indirectMemoryCopy );
9567 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCopyMemoryIndirectFeaturesKHR.indirectMemoryToImageCopy );
9568 return seed;
9569 }
9570 };
9571
9572 template <>
9573 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectFeaturesNV>
9574 {
9575 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectFeaturesNV const & physicalDeviceCopyMemoryIndirectFeaturesNV ) const
9576 VULKAN_HPP_NOEXCEPT
9577 {
9578 std::size_t seed = 0;
9579 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCopyMemoryIndirectFeaturesNV.sType );
9580 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCopyMemoryIndirectFeaturesNV.pNext );
9581 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCopyMemoryIndirectFeaturesNV.indirectCopy );
9582 return seed;
9583 }
9584 };
9585
9586 template <>
9587 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectPropertiesKHR>
9588 {
9589 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectPropertiesKHR const & physicalDeviceCopyMemoryIndirectPropertiesKHR ) const
9590 VULKAN_HPP_NOEXCEPT
9591 {
9592 std::size_t seed = 0;
9593 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCopyMemoryIndirectPropertiesKHR.sType );
9594 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCopyMemoryIndirectPropertiesKHR.pNext );
9595 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCopyMemoryIndirectPropertiesKHR.supportedQueues );
9596 return seed;
9597 }
9598 };
9599
9600 template <>
9601 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCornerSampledImageFeaturesNV>
9602 {
9603 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCornerSampledImageFeaturesNV const & physicalDeviceCornerSampledImageFeaturesNV ) const
9604 VULKAN_HPP_NOEXCEPT
9605 {
9606 std::size_t seed = 0;
9607 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCornerSampledImageFeaturesNV.sType );
9608 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCornerSampledImageFeaturesNV.pNext );
9609 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCornerSampledImageFeaturesNV.cornerSampledImage );
9610 return seed;
9611 }
9612 };
9613
9614 template <>
9615 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCoverageReductionModeFeaturesNV>
9616 {
9617 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCoverageReductionModeFeaturesNV const & physicalDeviceCoverageReductionModeFeaturesNV ) const
9618 VULKAN_HPP_NOEXCEPT
9619 {
9620 std::size_t seed = 0;
9621 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCoverageReductionModeFeaturesNV.sType );
9622 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCoverageReductionModeFeaturesNV.pNext );
9623 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCoverageReductionModeFeaturesNV.coverageReductionMode );
9624 return seed;
9625 }
9626 };
9627
9628 template <>
9629 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCubicClampFeaturesQCOM>
9630 {
9631 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCubicClampFeaturesQCOM const & physicalDeviceCubicClampFeaturesQCOM ) const VULKAN_HPP_NOEXCEPT
9632 {
9633 std::size_t seed = 0;
9634 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCubicClampFeaturesQCOM.sType );
9635 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCubicClampFeaturesQCOM.pNext );
9636 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCubicClampFeaturesQCOM.cubicRangeClamp );
9637 return seed;
9638 }
9639 };
9640
9641 template <>
9642 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCubicWeightsFeaturesQCOM>
9643 {
9644 std::size_t
9645 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCubicWeightsFeaturesQCOM const & physicalDeviceCubicWeightsFeaturesQCOM ) const VULKAN_HPP_NOEXCEPT
9646 {
9647 std::size_t seed = 0;
9648 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCubicWeightsFeaturesQCOM.sType );
9649 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCubicWeightsFeaturesQCOM.pNext );
9650 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCubicWeightsFeaturesQCOM.selectableCubicWeights );
9651 return seed;
9652 }
9653 };
9654
9655 # if defined( VK_ENABLE_BETA_EXTENSIONS )
9656 template <>
9657 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCudaKernelLaunchFeaturesNV>
9658 {
9659 std::size_t
9660 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCudaKernelLaunchFeaturesNV const & physicalDeviceCudaKernelLaunchFeaturesNV ) const VULKAN_HPP_NOEXCEPT
9661 {
9662 std::size_t seed = 0;
9663 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCudaKernelLaunchFeaturesNV.sType );
9664 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCudaKernelLaunchFeaturesNV.pNext );
9665 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCudaKernelLaunchFeaturesNV.cudaKernelLaunchFeatures );
9666 return seed;
9667 }
9668 };
9669 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
9670
9671 # if defined( VK_ENABLE_BETA_EXTENSIONS )
9672 template <>
9673 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCudaKernelLaunchPropertiesNV>
9674 {
9675 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCudaKernelLaunchPropertiesNV const & physicalDeviceCudaKernelLaunchPropertiesNV ) const
9676 VULKAN_HPP_NOEXCEPT
9677 {
9678 std::size_t seed = 0;
9679 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCudaKernelLaunchPropertiesNV.sType );
9680 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCudaKernelLaunchPropertiesNV.pNext );
9681 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCudaKernelLaunchPropertiesNV.computeCapabilityMinor );
9682 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCudaKernelLaunchPropertiesNV.computeCapabilityMajor );
9683 return seed;
9684 }
9685 };
9686 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
9687
9688 template <>
9689 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomBorderColorFeaturesEXT>
9690 {
9691 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomBorderColorFeaturesEXT const & physicalDeviceCustomBorderColorFeaturesEXT ) const
9692 VULKAN_HPP_NOEXCEPT
9693 {
9694 std::size_t seed = 0;
9695 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCustomBorderColorFeaturesEXT.sType );
9696 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCustomBorderColorFeaturesEXT.pNext );
9697 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCustomBorderColorFeaturesEXT.customBorderColors );
9698 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCustomBorderColorFeaturesEXT.customBorderColorWithoutFormat );
9699 return seed;
9700 }
9701 };
9702
9703 template <>
9704 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomBorderColorPropertiesEXT>
9705 {
9706 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomBorderColorPropertiesEXT const & physicalDeviceCustomBorderColorPropertiesEXT ) const
9707 VULKAN_HPP_NOEXCEPT
9708 {
9709 std::size_t seed = 0;
9710 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCustomBorderColorPropertiesEXT.sType );
9711 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCustomBorderColorPropertiesEXT.pNext );
9712 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCustomBorderColorPropertiesEXT.maxCustomBorderColorSamplers );
9713 return seed;
9714 }
9715 };
9716
9717 template <>
9718 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomResolveFeaturesEXT>
9719 {
9720 std::size_t
9721 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomResolveFeaturesEXT const & physicalDeviceCustomResolveFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
9722 {
9723 std::size_t seed = 0;
9724 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCustomResolveFeaturesEXT.sType );
9725 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCustomResolveFeaturesEXT.pNext );
9726 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCustomResolveFeaturesEXT.customResolve );
9727 return seed;
9728 }
9729 };
9730
9731 template <>
9732 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphFeaturesARM>
9733 {
9734 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphFeaturesARM const & physicalDeviceDataGraphFeaturesARM ) const VULKAN_HPP_NOEXCEPT
9735 {
9736 std::size_t seed = 0;
9737 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDataGraphFeaturesARM.sType );
9738 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDataGraphFeaturesARM.pNext );
9739 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDataGraphFeaturesARM.dataGraph );
9740 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDataGraphFeaturesARM.dataGraphUpdateAfterBind );
9741 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDataGraphFeaturesARM.dataGraphSpecializationConstants );
9742 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDataGraphFeaturesARM.dataGraphDescriptorBuffer );
9743 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDataGraphFeaturesARM.dataGraphShaderModule );
9744 return seed;
9745 }
9746 };
9747
9748 template <>
9749 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphModelFeaturesQCOM>
9750 {
9751 std::size_t
9752 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphModelFeaturesQCOM const & physicalDeviceDataGraphModelFeaturesQCOM ) const VULKAN_HPP_NOEXCEPT
9753 {
9754 std::size_t seed = 0;
9755 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDataGraphModelFeaturesQCOM.sType );
9756 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDataGraphModelFeaturesQCOM.pNext );
9757 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDataGraphModelFeaturesQCOM.dataGraphModel );
9758 return seed;
9759 }
9760 };
9761
9762 template <>
9763 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV>
9764 {
9765 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const &
9766 physicalDeviceDedicatedAllocationImageAliasingFeaturesNV ) const VULKAN_HPP_NOEXCEPT
9767 {
9768 std::size_t seed = 0;
9769 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDedicatedAllocationImageAliasingFeaturesNV.sType );
9770 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDedicatedAllocationImageAliasingFeaturesNV.pNext );
9771 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDedicatedAllocationImageAliasingFeaturesNV.dedicatedAllocationImageAliasing );
9772 return seed;
9773 }
9774 };
9775
9776 # if defined( VK_ENABLE_BETA_EXTENSIONS )
9777 template <>
9778 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDenseGeometryFormatFeaturesAMDX>
9779 {
9780 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDenseGeometryFormatFeaturesAMDX const & physicalDeviceDenseGeometryFormatFeaturesAMDX ) const
9781 VULKAN_HPP_NOEXCEPT
9782 {
9783 std::size_t seed = 0;
9784 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDenseGeometryFormatFeaturesAMDX.sType );
9785 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDenseGeometryFormatFeaturesAMDX.pNext );
9786 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDenseGeometryFormatFeaturesAMDX.denseGeometryFormat );
9787 return seed;
9788 }
9789 };
9790 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
9791
9792 template <>
9793 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthBiasControlFeaturesEXT>
9794 {
9795 std::size_t
9796 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthBiasControlFeaturesEXT const & physicalDeviceDepthBiasControlFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
9797 {
9798 std::size_t seed = 0;
9799 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthBiasControlFeaturesEXT.sType );
9800 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthBiasControlFeaturesEXT.pNext );
9801 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthBiasControlFeaturesEXT.depthBiasControl );
9802 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthBiasControlFeaturesEXT.leastRepresentableValueForceUnormRepresentation );
9803 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthBiasControlFeaturesEXT.floatRepresentation );
9804 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthBiasControlFeaturesEXT.depthBiasExact );
9805 return seed;
9806 }
9807 };
9808
9809 template <>
9810 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClampControlFeaturesEXT>
9811 {
9812 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClampControlFeaturesEXT const & physicalDeviceDepthClampControlFeaturesEXT ) const
9813 VULKAN_HPP_NOEXCEPT
9814 {
9815 std::size_t seed = 0;
9816 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClampControlFeaturesEXT.sType );
9817 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClampControlFeaturesEXT.pNext );
9818 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClampControlFeaturesEXT.depthClampControl );
9819 return seed;
9820 }
9821 };
9822
9823 template <>
9824 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClampZeroOneFeaturesKHR>
9825 {
9826 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClampZeroOneFeaturesKHR const & physicalDeviceDepthClampZeroOneFeaturesKHR ) const
9827 VULKAN_HPP_NOEXCEPT
9828 {
9829 std::size_t seed = 0;
9830 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClampZeroOneFeaturesKHR.sType );
9831 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClampZeroOneFeaturesKHR.pNext );
9832 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClampZeroOneFeaturesKHR.depthClampZeroOne );
9833 return seed;
9834 }
9835 };
9836
9837 template <>
9838 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClipControlFeaturesEXT>
9839 {
9840 std::size_t
9841 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClipControlFeaturesEXT const & physicalDeviceDepthClipControlFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
9842 {
9843 std::size_t seed = 0;
9844 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClipControlFeaturesEXT.sType );
9845 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClipControlFeaturesEXT.pNext );
9846 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClipControlFeaturesEXT.depthClipControl );
9847 return seed;
9848 }
9849 };
9850
9851 template <>
9852 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClipEnableFeaturesEXT>
9853 {
9854 std::size_t
9855 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClipEnableFeaturesEXT const & physicalDeviceDepthClipEnableFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
9856 {
9857 std::size_t seed = 0;
9858 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClipEnableFeaturesEXT.sType );
9859 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClipEnableFeaturesEXT.pNext );
9860 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClipEnableFeaturesEXT.depthClipEnable );
9861 return seed;
9862 }
9863 };
9864
9865 template <>
9866 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthStencilResolveProperties>
9867 {
9868 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthStencilResolveProperties const & physicalDeviceDepthStencilResolveProperties ) const
9869 VULKAN_HPP_NOEXCEPT
9870 {
9871 std::size_t seed = 0;
9872 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthStencilResolveProperties.sType );
9873 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthStencilResolveProperties.pNext );
9874 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthStencilResolveProperties.supportedDepthResolveModes );
9875 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthStencilResolveProperties.supportedStencilResolveModes );
9876 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthStencilResolveProperties.independentResolveNone );
9877 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthStencilResolveProperties.independentResolve );
9878 return seed;
9879 }
9880 };
9881
9882 template <>
9883 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT>
9884 {
9885 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT const &
9886 physicalDeviceDescriptorBufferDensityMapPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
9887 {
9888 std::size_t seed = 0;
9889 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferDensityMapPropertiesEXT.sType );
9890 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferDensityMapPropertiesEXT.pNext );
9891 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferDensityMapPropertiesEXT.combinedImageSamplerDensityMapDescriptorSize );
9892 return seed;
9893 }
9894 };
9895
9896 template <>
9897 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferFeaturesEXT>
9898 {
9899 std::size_t
9900 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferFeaturesEXT const & physicalDeviceDescriptorBufferFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
9901 {
9902 std::size_t seed = 0;
9903 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferFeaturesEXT.sType );
9904 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferFeaturesEXT.pNext );
9905 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferFeaturesEXT.descriptorBuffer );
9906 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferFeaturesEXT.descriptorBufferCaptureReplay );
9907 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferFeaturesEXT.descriptorBufferImageLayoutIgnored );
9908 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferFeaturesEXT.descriptorBufferPushDescriptors );
9909 return seed;
9910 }
9911 };
9912
9913 template <>
9914 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferPropertiesEXT>
9915 {
9916 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferPropertiesEXT const & physicalDeviceDescriptorBufferPropertiesEXT ) const
9917 VULKAN_HPP_NOEXCEPT
9918 {
9919 std::size_t seed = 0;
9920 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.sType );
9921 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.pNext );
9922 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.combinedImageSamplerDescriptorSingleArray );
9923 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.bufferlessPushDescriptors );
9924 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.allowSamplerImageViewPostSubmitCreation );
9925 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.descriptorBufferOffsetAlignment );
9926 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.maxDescriptorBufferBindings );
9927 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.maxResourceDescriptorBufferBindings );
9928 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.maxSamplerDescriptorBufferBindings );
9929 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.maxEmbeddedImmutableSamplerBindings );
9930 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.maxEmbeddedImmutableSamplers );
9931 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.bufferCaptureReplayDescriptorDataSize );
9932 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.imageCaptureReplayDescriptorDataSize );
9933 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.imageViewCaptureReplayDescriptorDataSize );
9934 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.samplerCaptureReplayDescriptorDataSize );
9935 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.accelerationStructureCaptureReplayDescriptorDataSize );
9936 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.samplerDescriptorSize );
9937 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.combinedImageSamplerDescriptorSize );
9938 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.sampledImageDescriptorSize );
9939 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.storageImageDescriptorSize );
9940 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.uniformTexelBufferDescriptorSize );
9941 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.robustUniformTexelBufferDescriptorSize );
9942 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.storageTexelBufferDescriptorSize );
9943 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.robustStorageTexelBufferDescriptorSize );
9944 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.uniformBufferDescriptorSize );
9945 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.robustUniformBufferDescriptorSize );
9946 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.storageBufferDescriptorSize );
9947 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.robustStorageBufferDescriptorSize );
9948 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.inputAttachmentDescriptorSize );
9949 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.accelerationStructureDescriptorSize );
9950 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.maxSamplerDescriptorBufferRange );
9951 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.maxResourceDescriptorBufferRange );
9952 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.samplerDescriptorBufferAddressSpaceSize );
9953 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.resourceDescriptorBufferAddressSpaceSize );
9954 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.descriptorBufferAddressSpaceSize );
9955 return seed;
9956 }
9957 };
9958
9959 template <>
9960 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferTensorFeaturesARM>
9961 {
9962 std::size_t operator()(
9963 VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferTensorFeaturesARM const & physicalDeviceDescriptorBufferTensorFeaturesARM ) const VULKAN_HPP_NOEXCEPT
9964 {
9965 std::size_t seed = 0;
9966 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferTensorFeaturesARM.sType );
9967 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferTensorFeaturesARM.pNext );
9968 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferTensorFeaturesARM.descriptorBufferTensorDescriptors );
9969 return seed;
9970 }
9971 };
9972
9973 template <>
9974 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferTensorPropertiesARM>
9975 {
9976 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferTensorPropertiesARM const & physicalDeviceDescriptorBufferTensorPropertiesARM )
9977 const VULKAN_HPP_NOEXCEPT
9978 {
9979 std::size_t seed = 0;
9980 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferTensorPropertiesARM.sType );
9981 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferTensorPropertiesARM.pNext );
9982 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferTensorPropertiesARM.tensorCaptureReplayDescriptorDataSize );
9983 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferTensorPropertiesARM.tensorViewCaptureReplayDescriptorDataSize );
9984 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferTensorPropertiesARM.tensorDescriptorSize );
9985 return seed;
9986 }
9987 };
9988
9989 template <>
9990 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorIndexingFeatures>
9991 {
9992 std::size_t
9993 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorIndexingFeatures const & physicalDeviceDescriptorIndexingFeatures ) const VULKAN_HPP_NOEXCEPT
9994 {
9995 std::size_t seed = 0;
9996 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.sType );
9997 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.pNext );
9998 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderInputAttachmentArrayDynamicIndexing );
9999 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderUniformTexelBufferArrayDynamicIndexing );
10000 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderStorageTexelBufferArrayDynamicIndexing );
10001 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderUniformBufferArrayNonUniformIndexing );
10002 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderSampledImageArrayNonUniformIndexing );
10003 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderStorageBufferArrayNonUniformIndexing );
10004 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderStorageImageArrayNonUniformIndexing );
10005 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderInputAttachmentArrayNonUniformIndexing );
10006 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderUniformTexelBufferArrayNonUniformIndexing );
10007 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderStorageTexelBufferArrayNonUniformIndexing );
10008 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingUniformBufferUpdateAfterBind );
10009 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingSampledImageUpdateAfterBind );
10010 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingStorageImageUpdateAfterBind );
10011 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingStorageBufferUpdateAfterBind );
10012 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingUniformTexelBufferUpdateAfterBind );
10013 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingStorageTexelBufferUpdateAfterBind );
10014 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingUpdateUnusedWhilePending );
10015 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingPartiallyBound );
10016 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingVariableDescriptorCount );
10017 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.runtimeDescriptorArray );
10018 return seed;
10019 }
10020 };
10021
10022 template <>
10023 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorIndexingProperties>
10024 {
10025 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorIndexingProperties const & physicalDeviceDescriptorIndexingProperties ) const
10026 VULKAN_HPP_NOEXCEPT
10027 {
10028 std::size_t seed = 0;
10029 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.sType );
10030 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.pNext );
10031 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxUpdateAfterBindDescriptorsInAllPools );
10032 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.shaderUniformBufferArrayNonUniformIndexingNative );
10033 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.shaderSampledImageArrayNonUniformIndexingNative );
10034 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.shaderStorageBufferArrayNonUniformIndexingNative );
10035 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.shaderStorageImageArrayNonUniformIndexingNative );
10036 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.shaderInputAttachmentArrayNonUniformIndexingNative );
10037 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.robustBufferAccessUpdateAfterBind );
10038 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.quadDivergentImplicitLod );
10039 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindSamplers );
10040 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindUniformBuffers );
10041 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindStorageBuffers );
10042 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindSampledImages );
10043 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindStorageImages );
10044 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindInputAttachments );
10045 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxPerStageUpdateAfterBindResources );
10046 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindSamplers );
10047 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindUniformBuffers );
10048 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic );
10049 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindStorageBuffers );
10050 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic );
10051 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindSampledImages );
10052 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindStorageImages );
10053 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindInputAttachments );
10054 return seed;
10055 }
10056 };
10057
10058 template <>
10059 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorPoolOverallocationFeaturesNV>
10060 {
10061 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorPoolOverallocationFeaturesNV const &
10062 physicalDeviceDescriptorPoolOverallocationFeaturesNV ) const VULKAN_HPP_NOEXCEPT
10063 {
10064 std::size_t seed = 0;
10065 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorPoolOverallocationFeaturesNV.sType );
10066 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorPoolOverallocationFeaturesNV.pNext );
10067 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorPoolOverallocationFeaturesNV.descriptorPoolOverallocation );
10068 return seed;
10069 }
10070 };
10071
10072 template <>
10073 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE>
10074 {
10075 std::size_t
10076 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE const & physicalDeviceDescriptorSetHostMappingFeaturesVALVE ) const
10077 VULKAN_HPP_NOEXCEPT
10078 {
10079 std::size_t seed = 0;
10080 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorSetHostMappingFeaturesVALVE.sType );
10081 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorSetHostMappingFeaturesVALVE.pNext );
10082 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorSetHostMappingFeaturesVALVE.descriptorSetHostMapping );
10083 return seed;
10084 }
10085 };
10086
10087 template <>
10088 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV>
10089 {
10090 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV const &
10091 physicalDeviceDeviceGeneratedCommandsComputeFeaturesNV ) const VULKAN_HPP_NOEXCEPT
10092 {
10093 std::size_t seed = 0;
10094 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsComputeFeaturesNV.sType );
10095 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsComputeFeaturesNV.pNext );
10096 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsComputeFeaturesNV.deviceGeneratedCompute );
10097 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsComputeFeaturesNV.deviceGeneratedComputePipelines );
10098 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsComputeFeaturesNV.deviceGeneratedComputeCaptureReplay );
10099 return seed;
10100 }
10101 };
10102
10103 template <>
10104 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT>
10105 {
10106 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT const & physicalDeviceDeviceGeneratedCommandsFeaturesEXT )
10107 const VULKAN_HPP_NOEXCEPT
10108 {
10109 std::size_t seed = 0;
10110 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsFeaturesEXT.sType );
10111 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsFeaturesEXT.pNext );
10112 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsFeaturesEXT.deviceGeneratedCommands );
10113 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsFeaturesEXT.dynamicGeneratedPipelineLayout );
10114 return seed;
10115 }
10116 };
10117
10118 template <>
10119 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsFeaturesNV>
10120 {
10121 std::size_t operator()(
10122 VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsFeaturesNV const & physicalDeviceDeviceGeneratedCommandsFeaturesNV ) const VULKAN_HPP_NOEXCEPT
10123 {
10124 std::size_t seed = 0;
10125 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsFeaturesNV.sType );
10126 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsFeaturesNV.pNext );
10127 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsFeaturesNV.deviceGeneratedCommands );
10128 return seed;
10129 }
10130 };
10131
10132 template <>
10133 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT>
10134 {
10135 std::size_t
10136 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT const & physicalDeviceDeviceGeneratedCommandsPropertiesEXT ) const
10137 VULKAN_HPP_NOEXCEPT
10138 {
10139 std::size_t seed = 0;
10140 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesEXT.sType );
10141 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesEXT.pNext );
10142 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesEXT.maxIndirectPipelineCount );
10143 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesEXT.maxIndirectShaderObjectCount );
10144 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesEXT.maxIndirectSequenceCount );
10145 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesEXT.maxIndirectCommandsTokenCount );
10146 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesEXT.maxIndirectCommandsTokenOffset );
10147 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesEXT.maxIndirectCommandsIndirectStride );
10148 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesEXT.supportedIndirectCommandsInputModes );
10149 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesEXT.supportedIndirectCommandsShaderStages );
10150 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesEXT.supportedIndirectCommandsShaderStagesPipelineBinding );
10151 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesEXT.supportedIndirectCommandsShaderStagesShaderBinding );
10152 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesEXT.deviceGeneratedCommandsTransformFeedback );
10153 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesEXT.deviceGeneratedCommandsMultiDrawIndirectCount );
10154 return seed;
10155 }
10156 };
10157
10158 template <>
10159 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsPropertiesNV>
10160 {
10161 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsPropertiesNV const & physicalDeviceDeviceGeneratedCommandsPropertiesNV )
10162 const VULKAN_HPP_NOEXCEPT
10163 {
10164 std::size_t seed = 0;
10165 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.sType );
10166 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.pNext );
10167 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxGraphicsShaderGroupCount );
10168 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxIndirectSequenceCount );
10169 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxIndirectCommandsTokenCount );
10170 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxIndirectCommandsStreamCount );
10171 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxIndirectCommandsTokenOffset );
10172 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxIndirectCommandsStreamStride );
10173 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.minSequencesCountBufferOffsetAlignment );
10174 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.minSequencesIndexBufferOffsetAlignment );
10175 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.minIndirectCommandsBufferOffsetAlignment );
10176 return seed;
10177 }
10178 };
10179
10180 template <>
10181 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceMemoryReportFeaturesEXT>
10182 {
10183 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceMemoryReportFeaturesEXT const & physicalDeviceDeviceMemoryReportFeaturesEXT ) const
10184 VULKAN_HPP_NOEXCEPT
10185 {
10186 std::size_t seed = 0;
10187 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceMemoryReportFeaturesEXT.sType );
10188 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceMemoryReportFeaturesEXT.pNext );
10189 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceMemoryReportFeaturesEXT.deviceMemoryReport );
10190 return seed;
10191 }
10192 };
10193
10194 template <>
10195 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDiagnosticsConfigFeaturesNV>
10196 {
10197 std::size_t
10198 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDiagnosticsConfigFeaturesNV const & physicalDeviceDiagnosticsConfigFeaturesNV ) const VULKAN_HPP_NOEXCEPT
10199 {
10200 std::size_t seed = 0;
10201 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDiagnosticsConfigFeaturesNV.sType );
10202 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDiagnosticsConfigFeaturesNV.pNext );
10203 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDiagnosticsConfigFeaturesNV.diagnosticsConfig );
10204 return seed;
10205 }
10206 };
10207
10208 template <>
10209 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDiscardRectanglePropertiesEXT>
10210 {
10211 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDiscardRectanglePropertiesEXT const & physicalDeviceDiscardRectanglePropertiesEXT ) const
10212 VULKAN_HPP_NOEXCEPT
10213 {
10214 std::size_t seed = 0;
10215 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDiscardRectanglePropertiesEXT.sType );
10216 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDiscardRectanglePropertiesEXT.pNext );
10217 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDiscardRectanglePropertiesEXT.maxDiscardRectangles );
10218 return seed;
10219 }
10220 };
10221
10222 # if defined( VK_ENABLE_BETA_EXTENSIONS )
10223 template <>
10224 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDisplacementMicromapFeaturesNV>
10225 {
10226 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDisplacementMicromapFeaturesNV const & physicalDeviceDisplacementMicromapFeaturesNV ) const
10227 VULKAN_HPP_NOEXCEPT
10228 {
10229 std::size_t seed = 0;
10230 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDisplacementMicromapFeaturesNV.sType );
10231 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDisplacementMicromapFeaturesNV.pNext );
10232 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDisplacementMicromapFeaturesNV.displacementMicromap );
10233 return seed;
10234 }
10235 };
10236 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
10237
10238 # if defined( VK_ENABLE_BETA_EXTENSIONS )
10239 template <>
10240 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDisplacementMicromapPropertiesNV>
10241 {
10242 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDisplacementMicromapPropertiesNV const & physicalDeviceDisplacementMicromapPropertiesNV ) const
10243 VULKAN_HPP_NOEXCEPT
10244 {
10245 std::size_t seed = 0;
10246 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDisplacementMicromapPropertiesNV.sType );
10247 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDisplacementMicromapPropertiesNV.pNext );
10248 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDisplacementMicromapPropertiesNV.maxDisplacementMicromapSubdivisionLevel );
10249 return seed;
10250 }
10251 };
10252 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
10253
10254 template <>
10255 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDriverProperties>
10256 {
10257 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDriverProperties const & physicalDeviceDriverProperties ) const VULKAN_HPP_NOEXCEPT
10258 {
10259 std::size_t seed = 0;
10260 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDriverProperties.sType );
10261 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDriverProperties.pNext );
10262 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDriverProperties.driverID );
10263 for ( size_t i = 0; i < VK_MAX_DRIVER_NAME_SIZE; ++i )
10264 {
10265 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDriverProperties.driverName[i] );
10266 }
10267 for ( size_t i = 0; i < VK_MAX_DRIVER_INFO_SIZE; ++i )
10268 {
10269 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDriverProperties.driverInfo[i] );
10270 }
10271 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDriverProperties.conformanceVersion );
10272 return seed;
10273 }
10274 };
10275
10276 template <>
10277 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDrmPropertiesEXT>
10278 {
10279 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDrmPropertiesEXT const & physicalDeviceDrmPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
10280 {
10281 std::size_t seed = 0;
10282 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDrmPropertiesEXT.sType );
10283 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDrmPropertiesEXT.pNext );
10284 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDrmPropertiesEXT.hasPrimary );
10285 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDrmPropertiesEXT.hasRender );
10286 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDrmPropertiesEXT.primaryMajor );
10287 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDrmPropertiesEXT.primaryMinor );
10288 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDrmPropertiesEXT.renderMajor );
10289 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDrmPropertiesEXT.renderMinor );
10290 return seed;
10291 }
10292 };
10293
10294 template <>
10295 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingFeatures>
10296 {
10297 std::size_t
10298 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingFeatures const & physicalDeviceDynamicRenderingFeatures ) const VULKAN_HPP_NOEXCEPT
10299 {
10300 std::size_t seed = 0;
10301 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDynamicRenderingFeatures.sType );
10302 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDynamicRenderingFeatures.pNext );
10303 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDynamicRenderingFeatures.dynamicRendering );
10304 return seed;
10305 }
10306 };
10307
10308 template <>
10309 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingLocalReadFeatures>
10310 {
10311 std::size_t operator()(
10312 VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingLocalReadFeatures const & physicalDeviceDynamicRenderingLocalReadFeatures ) const VULKAN_HPP_NOEXCEPT
10313 {
10314 std::size_t seed = 0;
10315 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDynamicRenderingLocalReadFeatures.sType );
10316 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDynamicRenderingLocalReadFeatures.pNext );
10317 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDynamicRenderingLocalReadFeatures.dynamicRenderingLocalRead );
10318 return seed;
10319 }
10320 };
10321
10322 template <>
10323 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT>
10324 {
10325 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT const &
10326 physicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
10327 {
10328 std::size_t seed = 0;
10329 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT.sType );
10330 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT.pNext );
10331 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT.dynamicRenderingUnusedAttachments );
10332 return seed;
10333 }
10334 };
10335
10336 template <>
10337 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExclusiveScissorFeaturesNV>
10338 {
10339 std::size_t
10340 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExclusiveScissorFeaturesNV const & physicalDeviceExclusiveScissorFeaturesNV ) const VULKAN_HPP_NOEXCEPT
10341 {
10342 std::size_t seed = 0;
10343 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExclusiveScissorFeaturesNV.sType );
10344 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExclusiveScissorFeaturesNV.pNext );
10345 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExclusiveScissorFeaturesNV.exclusiveScissor );
10346 return seed;
10347 }
10348 };
10349
10350 template <>
10351 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState2FeaturesEXT>
10352 {
10353 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState2FeaturesEXT const & physicalDeviceExtendedDynamicState2FeaturesEXT ) const
10354 VULKAN_HPP_NOEXCEPT
10355 {
10356 std::size_t seed = 0;
10357 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState2FeaturesEXT.sType );
10358 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState2FeaturesEXT.pNext );
10359 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState2FeaturesEXT.extendedDynamicState2 );
10360 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState2FeaturesEXT.extendedDynamicState2LogicOp );
10361 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState2FeaturesEXT.extendedDynamicState2PatchControlPoints );
10362 return seed;
10363 }
10364 };
10365
10366 template <>
10367 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState3FeaturesEXT>
10368 {
10369 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState3FeaturesEXT const & physicalDeviceExtendedDynamicState3FeaturesEXT ) const
10370 VULKAN_HPP_NOEXCEPT
10371 {
10372 std::size_t seed = 0;
10373 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.sType );
10374 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.pNext );
10375 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3TessellationDomainOrigin );
10376 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3DepthClampEnable );
10377 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3PolygonMode );
10378 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3RasterizationSamples );
10379 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3SampleMask );
10380 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3AlphaToCoverageEnable );
10381 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3AlphaToOneEnable );
10382 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3LogicOpEnable );
10383 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ColorBlendEnable );
10384 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ColorBlendEquation );
10385 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ColorWriteMask );
10386 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3RasterizationStream );
10387 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ConservativeRasterizationMode );
10388 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ExtraPrimitiveOverestimationSize );
10389 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3DepthClipEnable );
10390 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3SampleLocationsEnable );
10391 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ColorBlendAdvanced );
10392 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ProvokingVertexMode );
10393 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3LineRasterizationMode );
10394 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3LineStippleEnable );
10395 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3DepthClipNegativeOneToOne );
10396 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ViewportWScalingEnable );
10397 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ViewportSwizzle );
10398 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3CoverageToColorEnable );
10399 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3CoverageToColorLocation );
10400 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3CoverageModulationMode );
10401 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3CoverageModulationTableEnable );
10402 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3CoverageModulationTable );
10403 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3CoverageReductionMode );
10404 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3RepresentativeFragmentTestEnable );
10405 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ShadingRateImageEnable );
10406 return seed;
10407 }
10408 };
10409
10410 template <>
10411 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState3PropertiesEXT>
10412 {
10413 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState3PropertiesEXT const & physicalDeviceExtendedDynamicState3PropertiesEXT )
10414 const VULKAN_HPP_NOEXCEPT
10415 {
10416 std::size_t seed = 0;
10417 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3PropertiesEXT.sType );
10418 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3PropertiesEXT.pNext );
10419 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3PropertiesEXT.dynamicPrimitiveTopologyUnrestricted );
10420 return seed;
10421 }
10422 };
10423
10424 template <>
10425 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicStateFeaturesEXT>
10426 {
10427 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicStateFeaturesEXT const & physicalDeviceExtendedDynamicStateFeaturesEXT ) const
10428 VULKAN_HPP_NOEXCEPT
10429 {
10430 std::size_t seed = 0;
10431 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicStateFeaturesEXT.sType );
10432 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicStateFeaturesEXT.pNext );
10433 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicStateFeaturesEXT.extendedDynamicState );
10434 return seed;
10435 }
10436 };
10437
10438 template <>
10439 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV>
10440 {
10441 std::size_t
10442 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV const & physicalDeviceExtendedSparseAddressSpaceFeaturesNV ) const
10443 VULKAN_HPP_NOEXCEPT
10444 {
10445 std::size_t seed = 0;
10446 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedSparseAddressSpaceFeaturesNV.sType );
10447 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedSparseAddressSpaceFeaturesNV.pNext );
10448 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedSparseAddressSpaceFeaturesNV.extendedSparseAddressSpace );
10449 return seed;
10450 }
10451 };
10452
10453 template <>
10454 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedSparseAddressSpacePropertiesNV>
10455 {
10456 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedSparseAddressSpacePropertiesNV const &
10457 physicalDeviceExtendedSparseAddressSpacePropertiesNV ) const VULKAN_HPP_NOEXCEPT
10458 {
10459 std::size_t seed = 0;
10460 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedSparseAddressSpacePropertiesNV.sType );
10461 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedSparseAddressSpacePropertiesNV.pNext );
10462 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedSparseAddressSpacePropertiesNV.extendedSparseAddressSpaceSize );
10463 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedSparseAddressSpacePropertiesNV.extendedSparseImageUsageFlags );
10464 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedSparseAddressSpacePropertiesNV.extendedSparseBufferUsageFlags );
10465 return seed;
10466 }
10467 };
10468
10469 template <>
10470 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo>
10471 {
10472 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo const & physicalDeviceExternalBufferInfo ) const VULKAN_HPP_NOEXCEPT
10473 {
10474 std::size_t seed = 0;
10475 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalBufferInfo.sType );
10476 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalBufferInfo.pNext );
10477 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalBufferInfo.flags );
10478 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalBufferInfo.usage );
10479 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalBufferInfo.handleType );
10480 return seed;
10481 }
10482 };
10483
10484 template <>
10485 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalComputeQueuePropertiesNV>
10486 {
10487 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalComputeQueuePropertiesNV const & physicalDeviceExternalComputeQueuePropertiesNV ) const
10488 VULKAN_HPP_NOEXCEPT
10489 {
10490 std::size_t seed = 0;
10491 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalComputeQueuePropertiesNV.sType );
10492 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalComputeQueuePropertiesNV.pNext );
10493 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalComputeQueuePropertiesNV.externalDataSize );
10494 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalComputeQueuePropertiesNV.maxExternalQueues );
10495 return seed;
10496 }
10497 };
10498
10499 template <>
10500 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo>
10501 {
10502 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo const & physicalDeviceExternalFenceInfo ) const VULKAN_HPP_NOEXCEPT
10503 {
10504 std::size_t seed = 0;
10505 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFenceInfo.sType );
10506 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFenceInfo.pNext );
10507 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFenceInfo.handleType );
10508 return seed;
10509 }
10510 };
10511
10512 # if defined( VK_USE_PLATFORM_ANDROID_KHR )
10513 template <>
10514 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFormatResolveFeaturesANDROID>
10515 {
10516 std::size_t
10517 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFormatResolveFeaturesANDROID const & physicalDeviceExternalFormatResolveFeaturesANDROID ) const
10518 VULKAN_HPP_NOEXCEPT
10519 {
10520 std::size_t seed = 0;
10521 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFormatResolveFeaturesANDROID.sType );
10522 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFormatResolveFeaturesANDROID.pNext );
10523 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFormatResolveFeaturesANDROID.externalFormatResolve );
10524 return seed;
10525 }
10526 };
10527 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/
10528
10529 # if defined( VK_USE_PLATFORM_ANDROID_KHR )
10530 template <>
10531 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFormatResolvePropertiesANDROID>
10532 {
10533 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFormatResolvePropertiesANDROID const &
10534 physicalDeviceExternalFormatResolvePropertiesANDROID ) const VULKAN_HPP_NOEXCEPT
10535 {
10536 std::size_t seed = 0;
10537 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFormatResolvePropertiesANDROID.sType );
10538 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFormatResolvePropertiesANDROID.pNext );
10539 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFormatResolvePropertiesANDROID.nullColorAttachmentWithExternalFormatResolve );
10540 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFormatResolvePropertiesANDROID.externalFormatResolveChromaOffsetX );
10541 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFormatResolvePropertiesANDROID.externalFormatResolveChromaOffsetY );
10542 return seed;
10543 }
10544 };
10545 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/
10546
10547 template <>
10548 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalImageFormatInfo>
10549 {
10550 std::size_t
10551 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalImageFormatInfo const & physicalDeviceExternalImageFormatInfo ) const VULKAN_HPP_NOEXCEPT
10552 {
10553 std::size_t seed = 0;
10554 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalImageFormatInfo.sType );
10555 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalImageFormatInfo.pNext );
10556 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalImageFormatInfo.handleType );
10557 return seed;
10558 }
10559 };
10560
10561 template <>
10562 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryHostPropertiesEXT>
10563 {
10564 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryHostPropertiesEXT const & physicalDeviceExternalMemoryHostPropertiesEXT ) const
10565 VULKAN_HPP_NOEXCEPT
10566 {
10567 std::size_t seed = 0;
10568 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalMemoryHostPropertiesEXT.sType );
10569 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalMemoryHostPropertiesEXT.pNext );
10570 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalMemoryHostPropertiesEXT.minImportedHostPointerAlignment );
10571 return seed;
10572 }
10573 };
10574
10575 template <>
10576 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryRDMAFeaturesNV>
10577 {
10578 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryRDMAFeaturesNV const & physicalDeviceExternalMemoryRDMAFeaturesNV ) const
10579 VULKAN_HPP_NOEXCEPT
10580 {
10581 std::size_t seed = 0;
10582 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalMemoryRDMAFeaturesNV.sType );
10583 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalMemoryRDMAFeaturesNV.pNext );
10584 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalMemoryRDMAFeaturesNV.externalMemoryRDMA );
10585 return seed;
10586 }
10587 };
10588
10589 # if defined( VK_USE_PLATFORM_SCREEN_QNX )
10590 template <>
10591 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX>
10592 {
10593 std::size_t
10594 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX const & physicalDeviceExternalMemoryScreenBufferFeaturesQNX ) const
10595 VULKAN_HPP_NOEXCEPT
10596 {
10597 std::size_t seed = 0;
10598 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalMemoryScreenBufferFeaturesQNX.sType );
10599 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalMemoryScreenBufferFeaturesQNX.pNext );
10600 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalMemoryScreenBufferFeaturesQNX.screenBufferImport );
10601 return seed;
10602 }
10603 };
10604 # endif /*VK_USE_PLATFORM_SCREEN_QNX*/
10605
10606 template <>
10607 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo>
10608 {
10609 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo const & physicalDeviceExternalSemaphoreInfo ) const VULKAN_HPP_NOEXCEPT
10610 {
10611 std::size_t seed = 0;
10612 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalSemaphoreInfo.sType );
10613 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalSemaphoreInfo.pNext );
10614 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalSemaphoreInfo.handleType );
10615 return seed;
10616 }
10617 };
10618
10619 template <>
10620 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalTensorInfoARM>
10621 {
10622 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalTensorInfoARM const & physicalDeviceExternalTensorInfoARM ) const VULKAN_HPP_NOEXCEPT
10623 {
10624 std::size_t seed = 0;
10625 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalTensorInfoARM.sType );
10626 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalTensorInfoARM.pNext );
10627 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalTensorInfoARM.flags );
10628 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalTensorInfoARM.pDescription );
10629 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalTensorInfoARM.handleType );
10630 return seed;
10631 }
10632 };
10633
10634 template <>
10635 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFaultFeaturesEXT>
10636 {
10637 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFaultFeaturesEXT const & physicalDeviceFaultFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
10638 {
10639 std::size_t seed = 0;
10640 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFaultFeaturesEXT.sType );
10641 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFaultFeaturesEXT.pNext );
10642 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFaultFeaturesEXT.deviceFault );
10643 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFaultFeaturesEXT.deviceFaultVendorBinary );
10644 return seed;
10645 }
10646 };
10647
10648 template <>
10649 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2>
10650 {
10651 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 const & physicalDeviceFeatures2 ) const VULKAN_HPP_NOEXCEPT
10652 {
10653 std::size_t seed = 0;
10654 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures2.sType );
10655 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures2.pNext );
10656 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures2.features );
10657 return seed;
10658 }
10659 };
10660
10661 template <>
10662 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFloatControlsProperties>
10663 {
10664 std::size_t
10665 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFloatControlsProperties const & physicalDeviceFloatControlsProperties ) const VULKAN_HPP_NOEXCEPT
10666 {
10667 std::size_t seed = 0;
10668 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.sType );
10669 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.pNext );
10670 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.denormBehaviorIndependence );
10671 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.roundingModeIndependence );
10672 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderSignedZeroInfNanPreserveFloat16 );
10673 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderSignedZeroInfNanPreserveFloat32 );
10674 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderSignedZeroInfNanPreserveFloat64 );
10675 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderDenormPreserveFloat16 );
10676 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderDenormPreserveFloat32 );
10677 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderDenormPreserveFloat64 );
10678 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderDenormFlushToZeroFloat16 );
10679 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderDenormFlushToZeroFloat32 );
10680 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderDenormFlushToZeroFloat64 );
10681 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTEFloat16 );
10682 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTEFloat32 );
10683 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTEFloat64 );
10684 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTZFloat16 );
10685 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTZFloat32 );
10686 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTZFloat64 );
10687 return seed;
10688 }
10689 };
10690
10691 template <>
10692 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFormatPackFeaturesARM>
10693 {
10694 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFormatPackFeaturesARM const & physicalDeviceFormatPackFeaturesARM ) const VULKAN_HPP_NOEXCEPT
10695 {
10696 std::size_t seed = 0;
10697 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFormatPackFeaturesARM.sType );
10698 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFormatPackFeaturesARM.pNext );
10699 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFormatPackFeaturesARM.formatPack );
10700 return seed;
10701 }
10702 };
10703
10704 template <>
10705 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMap2FeaturesEXT>
10706 {
10707 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMap2FeaturesEXT const & physicalDeviceFragmentDensityMap2FeaturesEXT ) const
10708 VULKAN_HPP_NOEXCEPT
10709 {
10710 std::size_t seed = 0;
10711 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMap2FeaturesEXT.sType );
10712 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMap2FeaturesEXT.pNext );
10713 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMap2FeaturesEXT.fragmentDensityMapDeferred );
10714 return seed;
10715 }
10716 };
10717
10718 template <>
10719 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMap2PropertiesEXT>
10720 {
10721 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMap2PropertiesEXT const & physicalDeviceFragmentDensityMap2PropertiesEXT ) const
10722 VULKAN_HPP_NOEXCEPT
10723 {
10724 std::size_t seed = 0;
10725 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMap2PropertiesEXT.sType );
10726 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMap2PropertiesEXT.pNext );
10727 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMap2PropertiesEXT.subsampledLoads );
10728 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMap2PropertiesEXT.subsampledCoarseReconstructionEarlyAccess );
10729 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMap2PropertiesEXT.maxSubsampledArrayLayers );
10730 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMap2PropertiesEXT.maxDescriptorSetSubsampledSamplers );
10731 return seed;
10732 }
10733 };
10734
10735 template <>
10736 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapFeaturesEXT>
10737 {
10738 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapFeaturesEXT const & physicalDeviceFragmentDensityMapFeaturesEXT ) const
10739 VULKAN_HPP_NOEXCEPT
10740 {
10741 std::size_t seed = 0;
10742 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapFeaturesEXT.sType );
10743 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapFeaturesEXT.pNext );
10744 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapFeaturesEXT.fragmentDensityMap );
10745 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapFeaturesEXT.fragmentDensityMapDynamic );
10746 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapFeaturesEXT.fragmentDensityMapNonSubsampledImages );
10747 return seed;
10748 }
10749 };
10750
10751 template <>
10752 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE>
10753 {
10754 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE const &
10755 physicalDeviceFragmentDensityMapLayeredFeaturesVALVE ) const VULKAN_HPP_NOEXCEPT
10756 {
10757 std::size_t seed = 0;
10758 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapLayeredFeaturesVALVE.sType );
10759 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapLayeredFeaturesVALVE.pNext );
10760 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapLayeredFeaturesVALVE.fragmentDensityMapLayered );
10761 return seed;
10762 }
10763 };
10764
10765 template <>
10766 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE>
10767 {
10768 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE const &
10769 physicalDeviceFragmentDensityMapLayeredPropertiesVALVE ) const VULKAN_HPP_NOEXCEPT
10770 {
10771 std::size_t seed = 0;
10772 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapLayeredPropertiesVALVE.sType );
10773 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapLayeredPropertiesVALVE.pNext );
10774 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapLayeredPropertiesVALVE.maxFragmentDensityMapLayers );
10775 return seed;
10776 }
10777 };
10778
10779 template <>
10780 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT>
10781 {
10782 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT const & physicalDeviceFragmentDensityMapOffsetFeaturesEXT )
10783 const VULKAN_HPP_NOEXCEPT
10784 {
10785 std::size_t seed = 0;
10786 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetFeaturesEXT.sType );
10787 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetFeaturesEXT.pNext );
10788 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetFeaturesEXT.fragmentDensityMapOffset );
10789 return seed;
10790 }
10791 };
10792
10793 template <>
10794 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT>
10795 {
10796 std::size_t
10797 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT const & physicalDeviceFragmentDensityMapOffsetPropertiesEXT ) const
10798 VULKAN_HPP_NOEXCEPT
10799 {
10800 std::size_t seed = 0;
10801 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetPropertiesEXT.sType );
10802 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetPropertiesEXT.pNext );
10803 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetPropertiesEXT.fragmentDensityOffsetGranularity );
10804 return seed;
10805 }
10806 };
10807
10808 template <>
10809 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapPropertiesEXT>
10810 {
10811 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapPropertiesEXT const & physicalDeviceFragmentDensityMapPropertiesEXT ) const
10812 VULKAN_HPP_NOEXCEPT
10813 {
10814 std::size_t seed = 0;
10815 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapPropertiesEXT.sType );
10816 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapPropertiesEXT.pNext );
10817 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapPropertiesEXT.minFragmentDensityTexelSize );
10818 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapPropertiesEXT.maxFragmentDensityTexelSize );
10819 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapPropertiesEXT.fragmentDensityInvocations );
10820 return seed;
10821 }
10822 };
10823
10824 template <>
10825 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderBarycentricFeaturesKHR>
10826 {
10827 std::size_t
10828 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderBarycentricFeaturesKHR const & physicalDeviceFragmentShaderBarycentricFeaturesKHR ) const
10829 VULKAN_HPP_NOEXCEPT
10830 {
10831 std::size_t seed = 0;
10832 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderBarycentricFeaturesKHR.sType );
10833 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderBarycentricFeaturesKHR.pNext );
10834 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderBarycentricFeaturesKHR.fragmentShaderBarycentric );
10835 return seed;
10836 }
10837 };
10838
10839 template <>
10840 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderBarycentricPropertiesKHR>
10841 {
10842 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderBarycentricPropertiesKHR const &
10843 physicalDeviceFragmentShaderBarycentricPropertiesKHR ) const VULKAN_HPP_NOEXCEPT
10844 {
10845 std::size_t seed = 0;
10846 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderBarycentricPropertiesKHR.sType );
10847 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderBarycentricPropertiesKHR.pNext );
10848 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderBarycentricPropertiesKHR.triStripVertexOrderIndependentOfProvokingVertex );
10849 return seed;
10850 }
10851 };
10852
10853 template <>
10854 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderInterlockFeaturesEXT>
10855 {
10856 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderInterlockFeaturesEXT const & physicalDeviceFragmentShaderInterlockFeaturesEXT )
10857 const VULKAN_HPP_NOEXCEPT
10858 {
10859 std::size_t seed = 0;
10860 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderInterlockFeaturesEXT.sType );
10861 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderInterlockFeaturesEXT.pNext );
10862 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderInterlockFeaturesEXT.fragmentShaderSampleInterlock );
10863 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderInterlockFeaturesEXT.fragmentShaderPixelInterlock );
10864 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderInterlockFeaturesEXT.fragmentShaderShadingRateInterlock );
10865 return seed;
10866 }
10867 };
10868
10869 template <>
10870 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateEnumsFeaturesNV>
10871 {
10872 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateEnumsFeaturesNV const & physicalDeviceFragmentShadingRateEnumsFeaturesNV )
10873 const VULKAN_HPP_NOEXCEPT
10874 {
10875 std::size_t seed = 0;
10876 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateEnumsFeaturesNV.sType );
10877 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateEnumsFeaturesNV.pNext );
10878 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateEnumsFeaturesNV.fragmentShadingRateEnums );
10879 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateEnumsFeaturesNV.supersampleFragmentShadingRates );
10880 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateEnumsFeaturesNV.noInvocationFragmentShadingRates );
10881 return seed;
10882 }
10883 };
10884
10885 template <>
10886 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateEnumsPropertiesNV>
10887 {
10888 std::size_t
10889 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateEnumsPropertiesNV const & physicalDeviceFragmentShadingRateEnumsPropertiesNV ) const
10890 VULKAN_HPP_NOEXCEPT
10891 {
10892 std::size_t seed = 0;
10893 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateEnumsPropertiesNV.sType );
10894 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateEnumsPropertiesNV.pNext );
10895 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateEnumsPropertiesNV.maxFragmentShadingRateInvocationCount );
10896 return seed;
10897 }
10898 };
10899
10900 template <>
10901 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateFeaturesKHR>
10902 {
10903 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateFeaturesKHR const & physicalDeviceFragmentShadingRateFeaturesKHR ) const
10904 VULKAN_HPP_NOEXCEPT
10905 {
10906 std::size_t seed = 0;
10907 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateFeaturesKHR.sType );
10908 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateFeaturesKHR.pNext );
10909 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateFeaturesKHR.pipelineFragmentShadingRate );
10910 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateFeaturesKHR.primitiveFragmentShadingRate );
10911 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateFeaturesKHR.attachmentFragmentShadingRate );
10912 return seed;
10913 }
10914 };
10915
10916 template <>
10917 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR>
10918 {
10919 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR const & physicalDeviceFragmentShadingRateKHR ) const VULKAN_HPP_NOEXCEPT
10920 {
10921 std::size_t seed = 0;
10922 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateKHR.sType );
10923 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateKHR.pNext );
10924 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateKHR.sampleCounts );
10925 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateKHR.fragmentSize );
10926 return seed;
10927 }
10928 };
10929
10930 template <>
10931 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRatePropertiesKHR>
10932 {
10933 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRatePropertiesKHR const & physicalDeviceFragmentShadingRatePropertiesKHR ) const
10934 VULKAN_HPP_NOEXCEPT
10935 {
10936 std::size_t seed = 0;
10937 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.sType );
10938 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.pNext );
10939 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.minFragmentShadingRateAttachmentTexelSize );
10940 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentShadingRateAttachmentTexelSize );
10941 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentShadingRateAttachmentTexelSizeAspectRatio );
10942 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.primitiveFragmentShadingRateWithMultipleViewports );
10943 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.layeredShadingRateAttachments );
10944 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateNonTrivialCombinerOps );
10945 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentSize );
10946 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentSizeAspectRatio );
10947 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentShadingRateCoverageSamples );
10948 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentShadingRateRasterizationSamples );
10949 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithShaderDepthStencilWrites );
10950 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithSampleMask );
10951 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithShaderSampleMask );
10952 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithConservativeRasterization );
10953 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithFragmentShaderInterlock );
10954 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithCustomSampleLocations );
10955 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateStrictMultiplyCombiner );
10956 return seed;
10957 }
10958 };
10959
10960 template <>
10961 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFrameBoundaryFeaturesEXT>
10962 {
10963 std::size_t
10964 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFrameBoundaryFeaturesEXT const & physicalDeviceFrameBoundaryFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
10965 {
10966 std::size_t seed = 0;
10967 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFrameBoundaryFeaturesEXT.sType );
10968 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFrameBoundaryFeaturesEXT.pNext );
10969 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFrameBoundaryFeaturesEXT.frameBoundary );
10970 return seed;
10971 }
10972 };
10973
10974 template <>
10975 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceGlobalPriorityQueryFeatures>
10976 {
10977 std::size_t
10978 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceGlobalPriorityQueryFeatures const & physicalDeviceGlobalPriorityQueryFeatures ) const VULKAN_HPP_NOEXCEPT
10979 {
10980 std::size_t seed = 0;
10981 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGlobalPriorityQueryFeatures.sType );
10982 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGlobalPriorityQueryFeatures.pNext );
10983 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGlobalPriorityQueryFeatures.globalPriorityQuery );
10984 return seed;
10985 }
10986 };
10987
10988 template <>
10989 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT>
10990 {
10991 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT const & physicalDeviceGraphicsPipelineLibraryFeaturesEXT )
10992 const VULKAN_HPP_NOEXCEPT
10993 {
10994 std::size_t seed = 0;
10995 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGraphicsPipelineLibraryFeaturesEXT.sType );
10996 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGraphicsPipelineLibraryFeaturesEXT.pNext );
10997 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGraphicsPipelineLibraryFeaturesEXT.graphicsPipelineLibrary );
10998 return seed;
10999 }
11000 };
11001
11002 template <>
11003 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT>
11004 {
11005 std::size_t
11006 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT const & physicalDeviceGraphicsPipelineLibraryPropertiesEXT ) const
11007 VULKAN_HPP_NOEXCEPT
11008 {
11009 std::size_t seed = 0;
11010 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGraphicsPipelineLibraryPropertiesEXT.sType );
11011 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGraphicsPipelineLibraryPropertiesEXT.pNext );
11012 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGraphicsPipelineLibraryPropertiesEXT.graphicsPipelineLibraryFastLinking );
11013 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGraphicsPipelineLibraryPropertiesEXT.graphicsPipelineLibraryIndependentInterpolationDecoration );
11014 return seed;
11015 }
11016 };
11017
11018 template <>
11019 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties>
11020 {
11021 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties const & physicalDeviceGroupProperties ) const VULKAN_HPP_NOEXCEPT
11022 {
11023 std::size_t seed = 0;
11024 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGroupProperties.sType );
11025 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGroupProperties.pNext );
11026 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGroupProperties.physicalDeviceCount );
11027 for ( size_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; ++i )
11028 {
11029 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGroupProperties.physicalDevices[i] );
11030 }
11031 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGroupProperties.subsetAllocation );
11032 return seed;
11033 }
11034 };
11035
11036 template <>
11037 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceHdrVividFeaturesHUAWEI>
11038 {
11039 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceHdrVividFeaturesHUAWEI const & physicalDeviceHdrVividFeaturesHUAWEI ) const VULKAN_HPP_NOEXCEPT
11040 {
11041 std::size_t seed = 0;
11042 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHdrVividFeaturesHUAWEI.sType );
11043 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHdrVividFeaturesHUAWEI.pNext );
11044 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHdrVividFeaturesHUAWEI.hdrVivid );
11045 return seed;
11046 }
11047 };
11048
11049 template <>
11050 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceHostImageCopyFeatures>
11051 {
11052 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceHostImageCopyFeatures const & physicalDeviceHostImageCopyFeatures ) const VULKAN_HPP_NOEXCEPT
11053 {
11054 std::size_t seed = 0;
11055 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyFeatures.sType );
11056 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyFeatures.pNext );
11057 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyFeatures.hostImageCopy );
11058 return seed;
11059 }
11060 };
11061
11062 template <>
11063 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceHostImageCopyProperties>
11064 {
11065 std::size_t
11066 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceHostImageCopyProperties const & physicalDeviceHostImageCopyProperties ) const VULKAN_HPP_NOEXCEPT
11067 {
11068 std::size_t seed = 0;
11069 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyProperties.sType );
11070 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyProperties.pNext );
11071 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyProperties.copySrcLayoutCount );
11072 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyProperties.pCopySrcLayouts );
11073 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyProperties.copyDstLayoutCount );
11074 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyProperties.pCopyDstLayouts );
11075 for ( size_t i = 0; i < VK_UUID_SIZE; ++i )
11076 {
11077 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyProperties.optimalTilingLayoutUUID[i] );
11078 }
11079 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyProperties.identicalMemoryTypeRequirements );
11080 return seed;
11081 }
11082 };
11083
11084 template <>
11085 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceHostQueryResetFeatures>
11086 {
11087 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceHostQueryResetFeatures const & physicalDeviceHostQueryResetFeatures ) const VULKAN_HPP_NOEXCEPT
11088 {
11089 std::size_t seed = 0;
11090 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostQueryResetFeatures.sType );
11091 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostQueryResetFeatures.pNext );
11092 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostQueryResetFeatures.hostQueryReset );
11093 return seed;
11094 }
11095 };
11096
11097 template <>
11098 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceIDProperties>
11099 {
11100 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceIDProperties const & physicalDeviceIDProperties ) const VULKAN_HPP_NOEXCEPT
11101 {
11102 std::size_t seed = 0;
11103 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIDProperties.sType );
11104 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIDProperties.pNext );
11105 for ( size_t i = 0; i < VK_UUID_SIZE; ++i )
11106 {
11107 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIDProperties.deviceUUID[i] );
11108 }
11109 for ( size_t i = 0; i < VK_UUID_SIZE; ++i )
11110 {
11111 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIDProperties.driverUUID[i] );
11112 }
11113 for ( size_t i = 0; i < VK_LUID_SIZE; ++i )
11114 {
11115 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIDProperties.deviceLUID[i] );
11116 }
11117 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIDProperties.deviceNodeMask );
11118 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIDProperties.deviceLUIDValid );
11119 return seed;
11120 }
11121 };
11122
11123 template <>
11124 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImage2DViewOf3DFeaturesEXT>
11125 {
11126 std::size_t
11127 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImage2DViewOf3DFeaturesEXT const & physicalDeviceImage2DViewOf3DFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
11128 {
11129 std::size_t seed = 0;
11130 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImage2DViewOf3DFeaturesEXT.sType );
11131 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImage2DViewOf3DFeaturesEXT.pNext );
11132 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImage2DViewOf3DFeaturesEXT.image2DViewOf3D );
11133 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImage2DViewOf3DFeaturesEXT.sampler2DViewOf3D );
11134 return seed;
11135 }
11136 };
11137
11138 template <>
11139 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageAlignmentControlFeaturesMESA>
11140 {
11141 std::size_t operator()(
11142 VULKAN_HPP_NAMESPACE::PhysicalDeviceImageAlignmentControlFeaturesMESA const & physicalDeviceImageAlignmentControlFeaturesMESA ) const VULKAN_HPP_NOEXCEPT
11143 {
11144 std::size_t seed = 0;
11145 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageAlignmentControlFeaturesMESA.sType );
11146 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageAlignmentControlFeaturesMESA.pNext );
11147 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageAlignmentControlFeaturesMESA.imageAlignmentControl );
11148 return seed;
11149 }
11150 };
11151
11152 template <>
11153 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageAlignmentControlPropertiesMESA>
11154 {
11155 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageAlignmentControlPropertiesMESA const & physicalDeviceImageAlignmentControlPropertiesMESA )
11156 const VULKAN_HPP_NOEXCEPT
11157 {
11158 std::size_t seed = 0;
11159 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageAlignmentControlPropertiesMESA.sType );
11160 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageAlignmentControlPropertiesMESA.pNext );
11161 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageAlignmentControlPropertiesMESA.supportedImageAlignmentMask );
11162 return seed;
11163 }
11164 };
11165
11166 template <>
11167 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageCompressionControlFeaturesEXT>
11168 {
11169 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageCompressionControlFeaturesEXT const & physicalDeviceImageCompressionControlFeaturesEXT )
11170 const VULKAN_HPP_NOEXCEPT
11171 {
11172 std::size_t seed = 0;
11173 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageCompressionControlFeaturesEXT.sType );
11174 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageCompressionControlFeaturesEXT.pNext );
11175 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageCompressionControlFeaturesEXT.imageCompressionControl );
11176 return seed;
11177 }
11178 };
11179
11180 template <>
11181 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT>
11182 {
11183 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT const &
11184 physicalDeviceImageCompressionControlSwapchainFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
11185 {
11186 std::size_t seed = 0;
11187 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageCompressionControlSwapchainFeaturesEXT.sType );
11188 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageCompressionControlSwapchainFeaturesEXT.pNext );
11189 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageCompressionControlSwapchainFeaturesEXT.imageCompressionControlSwapchain );
11190 return seed;
11191 }
11192 };
11193
11194 template <>
11195 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageDrmFormatModifierInfoEXT>
11196 {
11197 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageDrmFormatModifierInfoEXT const & physicalDeviceImageDrmFormatModifierInfoEXT ) const
11198 VULKAN_HPP_NOEXCEPT
11199 {
11200 std::size_t seed = 0;
11201 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageDrmFormatModifierInfoEXT.sType );
11202 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageDrmFormatModifierInfoEXT.pNext );
11203 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageDrmFormatModifierInfoEXT.drmFormatModifier );
11204 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageDrmFormatModifierInfoEXT.sharingMode );
11205 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageDrmFormatModifierInfoEXT.queueFamilyIndexCount );
11206 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageDrmFormatModifierInfoEXT.pQueueFamilyIndices );
11207 return seed;
11208 }
11209 };
11210
11211 template <>
11212 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2>
11213 {
11214 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 const & physicalDeviceImageFormatInfo2 ) const VULKAN_HPP_NOEXCEPT
11215 {
11216 std::size_t seed = 0;
11217 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageFormatInfo2.sType );
11218 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageFormatInfo2.pNext );
11219 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageFormatInfo2.format );
11220 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageFormatInfo2.type );
11221 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageFormatInfo2.tiling );
11222 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageFormatInfo2.usage );
11223 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageFormatInfo2.flags );
11224 return seed;
11225 }
11226 };
11227
11228 template <>
11229 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessing2FeaturesQCOM>
11230 {
11231 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessing2FeaturesQCOM const & physicalDeviceImageProcessing2FeaturesQCOM ) const
11232 VULKAN_HPP_NOEXCEPT
11233 {
11234 std::size_t seed = 0;
11235 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessing2FeaturesQCOM.sType );
11236 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessing2FeaturesQCOM.pNext );
11237 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessing2FeaturesQCOM.textureBlockMatch2 );
11238 return seed;
11239 }
11240 };
11241
11242 template <>
11243 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessing2PropertiesQCOM>
11244 {
11245 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessing2PropertiesQCOM const & physicalDeviceImageProcessing2PropertiesQCOM ) const
11246 VULKAN_HPP_NOEXCEPT
11247 {
11248 std::size_t seed = 0;
11249 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessing2PropertiesQCOM.sType );
11250 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessing2PropertiesQCOM.pNext );
11251 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessing2PropertiesQCOM.maxBlockMatchWindow );
11252 return seed;
11253 }
11254 };
11255
11256 template <>
11257 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessingFeaturesQCOM>
11258 {
11259 std::size_t
11260 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessingFeaturesQCOM const & physicalDeviceImageProcessingFeaturesQCOM ) const VULKAN_HPP_NOEXCEPT
11261 {
11262 std::size_t seed = 0;
11263 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingFeaturesQCOM.sType );
11264 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingFeaturesQCOM.pNext );
11265 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingFeaturesQCOM.textureSampleWeighted );
11266 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingFeaturesQCOM.textureBoxFilter );
11267 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingFeaturesQCOM.textureBlockMatch );
11268 return seed;
11269 }
11270 };
11271
11272 template <>
11273 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessingPropertiesQCOM>
11274 {
11275 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessingPropertiesQCOM const & physicalDeviceImageProcessingPropertiesQCOM ) const
11276 VULKAN_HPP_NOEXCEPT
11277 {
11278 std::size_t seed = 0;
11279 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingPropertiesQCOM.sType );
11280 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingPropertiesQCOM.pNext );
11281 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingPropertiesQCOM.maxWeightFilterPhases );
11282 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingPropertiesQCOM.maxWeightFilterDimension );
11283 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingPropertiesQCOM.maxBlockMatchRegion );
11284 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingPropertiesQCOM.maxBoxFilterBlockSize );
11285 return seed;
11286 }
11287 };
11288
11289 template <>
11290 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageRobustnessFeatures>
11291 {
11292 std::size_t
11293 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageRobustnessFeatures const & physicalDeviceImageRobustnessFeatures ) const VULKAN_HPP_NOEXCEPT
11294 {
11295 std::size_t seed = 0;
11296 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageRobustnessFeatures.sType );
11297 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageRobustnessFeatures.pNext );
11298 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageRobustnessFeatures.robustImageAccess );
11299 return seed;
11300 }
11301 };
11302
11303 template <>
11304 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageSlicedViewOf3DFeaturesEXT>
11305 {
11306 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageSlicedViewOf3DFeaturesEXT const & physicalDeviceImageSlicedViewOf3DFeaturesEXT ) const
11307 VULKAN_HPP_NOEXCEPT
11308 {
11309 std::size_t seed = 0;
11310 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageSlicedViewOf3DFeaturesEXT.sType );
11311 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageSlicedViewOf3DFeaturesEXT.pNext );
11312 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageSlicedViewOf3DFeaturesEXT.imageSlicedViewOf3D );
11313 return seed;
11314 }
11315 };
11316
11317 template <>
11318 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageViewImageFormatInfoEXT>
11319 {
11320 std::size_t
11321 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageViewImageFormatInfoEXT const & physicalDeviceImageViewImageFormatInfoEXT ) const VULKAN_HPP_NOEXCEPT
11322 {
11323 std::size_t seed = 0;
11324 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageViewImageFormatInfoEXT.sType );
11325 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageViewImageFormatInfoEXT.pNext );
11326 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageViewImageFormatInfoEXT.imageViewType );
11327 return seed;
11328 }
11329 };
11330
11331 template <>
11332 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageViewMinLodFeaturesEXT>
11333 {
11334 std::size_t
11335 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageViewMinLodFeaturesEXT const & physicalDeviceImageViewMinLodFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
11336 {
11337 std::size_t seed = 0;
11338 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageViewMinLodFeaturesEXT.sType );
11339 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageViewMinLodFeaturesEXT.pNext );
11340 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageViewMinLodFeaturesEXT.minLod );
11341 return seed;
11342 }
11343 };
11344
11345 template <>
11346 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImagelessFramebufferFeatures>
11347 {
11348 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImagelessFramebufferFeatures const & physicalDeviceImagelessFramebufferFeatures ) const
11349 VULKAN_HPP_NOEXCEPT
11350 {
11351 std::size_t seed = 0;
11352 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImagelessFramebufferFeatures.sType );
11353 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImagelessFramebufferFeatures.pNext );
11354 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImagelessFramebufferFeatures.imagelessFramebuffer );
11355 return seed;
11356 }
11357 };
11358
11359 template <>
11360 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceIndexTypeUint8Features>
11361 {
11362 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceIndexTypeUint8Features const & physicalDeviceIndexTypeUint8Features ) const VULKAN_HPP_NOEXCEPT
11363 {
11364 std::size_t seed = 0;
11365 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIndexTypeUint8Features.sType );
11366 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIndexTypeUint8Features.pNext );
11367 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIndexTypeUint8Features.indexTypeUint8 );
11368 return seed;
11369 }
11370 };
11371
11372 template <>
11373 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceInheritedViewportScissorFeaturesNV>
11374 {
11375 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceInheritedViewportScissorFeaturesNV const & physicalDeviceInheritedViewportScissorFeaturesNV )
11376 const VULKAN_HPP_NOEXCEPT
11377 {
11378 std::size_t seed = 0;
11379 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInheritedViewportScissorFeaturesNV.sType );
11380 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInheritedViewportScissorFeaturesNV.pNext );
11381 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInheritedViewportScissorFeaturesNV.inheritedViewportScissor2D );
11382 return seed;
11383 }
11384 };
11385
11386 template <>
11387 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceInlineUniformBlockFeatures>
11388 {
11389 std::size_t
11390 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceInlineUniformBlockFeatures const & physicalDeviceInlineUniformBlockFeatures ) const VULKAN_HPP_NOEXCEPT
11391 {
11392 std::size_t seed = 0;
11393 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockFeatures.sType );
11394 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockFeatures.pNext );
11395 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockFeatures.inlineUniformBlock );
11396 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockFeatures.descriptorBindingInlineUniformBlockUpdateAfterBind );
11397 return seed;
11398 }
11399 };
11400
11401 template <>
11402 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceInlineUniformBlockProperties>
11403 {
11404 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceInlineUniformBlockProperties const & physicalDeviceInlineUniformBlockProperties ) const
11405 VULKAN_HPP_NOEXCEPT
11406 {
11407 std::size_t seed = 0;
11408 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockProperties.sType );
11409 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockProperties.pNext );
11410 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockProperties.maxInlineUniformBlockSize );
11411 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockProperties.maxPerStageDescriptorInlineUniformBlocks );
11412 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockProperties.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks );
11413 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockProperties.maxDescriptorSetInlineUniformBlocks );
11414 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockProperties.maxDescriptorSetUpdateAfterBindInlineUniformBlocks );
11415 return seed;
11416 }
11417 };
11418
11419 template <>
11420 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceInvocationMaskFeaturesHUAWEI>
11421 {
11422 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceInvocationMaskFeaturesHUAWEI const & physicalDeviceInvocationMaskFeaturesHUAWEI ) const
11423 VULKAN_HPP_NOEXCEPT
11424 {
11425 std::size_t seed = 0;
11426 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInvocationMaskFeaturesHUAWEI.sType );
11427 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInvocationMaskFeaturesHUAWEI.pNext );
11428 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInvocationMaskFeaturesHUAWEI.invocationMask );
11429 return seed;
11430 }
11431 };
11432
11433 template <>
11434 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredApiPropertiesKHR>
11435 {
11436 std::size_t
11437 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredApiPropertiesKHR const & physicalDeviceLayeredApiPropertiesKHR ) const VULKAN_HPP_NOEXCEPT
11438 {
11439 std::size_t seed = 0;
11440 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredApiPropertiesKHR.sType );
11441 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredApiPropertiesKHR.pNext );
11442 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredApiPropertiesKHR.vendorID );
11443 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredApiPropertiesKHR.deviceID );
11444 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredApiPropertiesKHR.layeredAPI );
11445 for ( size_t i = 0; i < VK_MAX_PHYSICAL_DEVICE_NAME_SIZE; ++i )
11446 {
11447 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredApiPropertiesKHR.deviceName[i] );
11448 }
11449 return seed;
11450 }
11451 };
11452
11453 template <>
11454 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredApiPropertiesListKHR>
11455 {
11456 std::size_t
11457 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredApiPropertiesListKHR const & physicalDeviceLayeredApiPropertiesListKHR ) const VULKAN_HPP_NOEXCEPT
11458 {
11459 std::size_t seed = 0;
11460 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredApiPropertiesListKHR.sType );
11461 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredApiPropertiesListKHR.pNext );
11462 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredApiPropertiesListKHR.layeredApiCount );
11463 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredApiPropertiesListKHR.pLayeredApis );
11464 return seed;
11465 }
11466 };
11467
11468 template <>
11469 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLimits>
11470 {
11471 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLimits const & physicalDeviceLimits ) const VULKAN_HPP_NOEXCEPT
11472 {
11473 std::size_t seed = 0;
11474 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxImageDimension1D );
11475 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxImageDimension2D );
11476 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxImageDimension3D );
11477 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxImageDimensionCube );
11478 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxImageArrayLayers );
11479 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTexelBufferElements );
11480 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxUniformBufferRange );
11481 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxStorageBufferRange );
11482 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxPushConstantsSize );
11483 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxMemoryAllocationCount );
11484 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxSamplerAllocationCount );
11485 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.bufferImageGranularity );
11486 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.sparseAddressSpaceSize );
11487 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxBoundDescriptorSets );
11488 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxPerStageDescriptorSamplers );
11489 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxPerStageDescriptorUniformBuffers );
11490 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxPerStageDescriptorStorageBuffers );
11491 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxPerStageDescriptorSampledImages );
11492 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxPerStageDescriptorStorageImages );
11493 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxPerStageDescriptorInputAttachments );
11494 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxPerStageResources );
11495 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDescriptorSetSamplers );
11496 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDescriptorSetUniformBuffers );
11497 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDescriptorSetUniformBuffersDynamic );
11498 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDescriptorSetStorageBuffers );
11499 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDescriptorSetStorageBuffersDynamic );
11500 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDescriptorSetSampledImages );
11501 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDescriptorSetStorageImages );
11502 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDescriptorSetInputAttachments );
11503 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxVertexInputAttributes );
11504 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxVertexInputBindings );
11505 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxVertexInputAttributeOffset );
11506 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxVertexInputBindingStride );
11507 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxVertexOutputComponents );
11508 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTessellationGenerationLevel );
11509 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTessellationPatchSize );
11510 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTessellationControlPerVertexInputComponents );
11511 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTessellationControlPerVertexOutputComponents );
11512 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTessellationControlPerPatchOutputComponents );
11513 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTessellationControlTotalOutputComponents );
11514 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTessellationEvaluationInputComponents );
11515 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTessellationEvaluationOutputComponents );
11516 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxGeometryShaderInvocations );
11517 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxGeometryInputComponents );
11518 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxGeometryOutputComponents );
11519 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxGeometryOutputVertices );
11520 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxGeometryTotalOutputComponents );
11521 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxFragmentInputComponents );
11522 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxFragmentOutputAttachments );
11523 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxFragmentDualSrcAttachments );
11524 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxFragmentCombinedOutputResources );
11525 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxComputeSharedMemorySize );
11526 for ( size_t i = 0; i < 3; ++i )
11527 {
11528 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxComputeWorkGroupCount[i] );
11529 }
11530 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxComputeWorkGroupInvocations );
11531 for ( size_t i = 0; i < 3; ++i )
11532 {
11533 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxComputeWorkGroupSize[i] );
11534 }
11535 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.subPixelPrecisionBits );
11536 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.subTexelPrecisionBits );
11537 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.mipmapPrecisionBits );
11538 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDrawIndexedIndexValue );
11539 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDrawIndirectCount );
11540 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxSamplerLodBias );
11541 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxSamplerAnisotropy );
11542 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxViewports );
11543 for ( size_t i = 0; i < 2; ++i )
11544 {
11545 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxViewportDimensions[i] );
11546 }
11547 for ( size_t i = 0; i < 2; ++i )
11548 {
11549 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.viewportBoundsRange[i] );
11550 }
11551 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.viewportSubPixelBits );
11552 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.minMemoryMapAlignment );
11553 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.minTexelBufferOffsetAlignment );
11554 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.minUniformBufferOffsetAlignment );
11555 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.minStorageBufferOffsetAlignment );
11556 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.minTexelOffset );
11557 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTexelOffset );
11558 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.minTexelGatherOffset );
11559 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTexelGatherOffset );
11560 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.minInterpolationOffset );
11561 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxInterpolationOffset );
11562 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.subPixelInterpolationOffsetBits );
11563 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxFramebufferWidth );
11564 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxFramebufferHeight );
11565 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxFramebufferLayers );
11566 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.framebufferColorSampleCounts );
11567 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.framebufferDepthSampleCounts );
11568 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.framebufferStencilSampleCounts );
11569 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.framebufferNoAttachmentsSampleCounts );
11570 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxColorAttachments );
11571 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.sampledImageColorSampleCounts );
11572 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.sampledImageIntegerSampleCounts );
11573 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.sampledImageDepthSampleCounts );
11574 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.sampledImageStencilSampleCounts );
11575 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.storageImageSampleCounts );
11576 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxSampleMaskWords );
11577 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.timestampComputeAndGraphics );
11578 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.timestampPeriod );
11579 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxClipDistances );
11580 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxCullDistances );
11581 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxCombinedClipAndCullDistances );
11582 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.discreteQueuePriorities );
11583 for ( size_t i = 0; i < 2; ++i )
11584 {
11585 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.pointSizeRange[i] );
11586 }
11587 for ( size_t i = 0; i < 2; ++i )
11588 {
11589 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.lineWidthRange[i] );
11590 }
11591 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.pointSizeGranularity );
11592 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.lineWidthGranularity );
11593 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.strictLines );
11594 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.standardSampleLocations );
11595 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.optimalBufferCopyOffsetAlignment );
11596 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.optimalBufferCopyRowPitchAlignment );
11597 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.nonCoherentAtomSize );
11598 return seed;
11599 }
11600 };
11601
11602 template <>
11603 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseProperties>
11604 {
11605 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseProperties const & physicalDeviceSparseProperties ) const VULKAN_HPP_NOEXCEPT
11606 {
11607 std::size_t seed = 0;
11608 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseProperties.residencyStandard2DBlockShape );
11609 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseProperties.residencyStandard2DMultisampleBlockShape );
11610 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseProperties.residencyStandard3DBlockShape );
11611 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseProperties.residencyAlignedMipSize );
11612 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseProperties.residencyNonResidentStrict );
11613 return seed;
11614 }
11615 };
11616
11617 template <>
11618 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties>
11619 {
11620 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties const & physicalDeviceProperties ) const VULKAN_HPP_NOEXCEPT
11621 {
11622 std::size_t seed = 0;
11623 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.apiVersion );
11624 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.driverVersion );
11625 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.vendorID );
11626 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.deviceID );
11627 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.deviceType );
11628 for ( size_t i = 0; i < VK_MAX_PHYSICAL_DEVICE_NAME_SIZE; ++i )
11629 {
11630 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.deviceName[i] );
11631 }
11632 for ( size_t i = 0; i < VK_UUID_SIZE; ++i )
11633 {
11634 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.pipelineCacheUUID[i] );
11635 }
11636 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.limits );
11637 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.sparseProperties );
11638 return seed;
11639 }
11640 };
11641
11642 template <>
11643 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2>
11644 {
11645 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 const & physicalDeviceProperties2 ) const VULKAN_HPP_NOEXCEPT
11646 {
11647 std::size_t seed = 0;
11648 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties2.sType );
11649 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties2.pNext );
11650 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties2.properties );
11651 return seed;
11652 }
11653 };
11654
11655 template <>
11656 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredApiVulkanPropertiesKHR>
11657 {
11658 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredApiVulkanPropertiesKHR const & physicalDeviceLayeredApiVulkanPropertiesKHR ) const
11659 VULKAN_HPP_NOEXCEPT
11660 {
11661 std::size_t seed = 0;
11662 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredApiVulkanPropertiesKHR.sType );
11663 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredApiVulkanPropertiesKHR.pNext );
11664 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredApiVulkanPropertiesKHR.properties );
11665 return seed;
11666 }
11667 };
11668
11669 template <>
11670 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredDriverPropertiesMSFT>
11671 {
11672 std::size_t
11673 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredDriverPropertiesMSFT const & physicalDeviceLayeredDriverPropertiesMSFT ) const VULKAN_HPP_NOEXCEPT
11674 {
11675 std::size_t seed = 0;
11676 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredDriverPropertiesMSFT.sType );
11677 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredDriverPropertiesMSFT.pNext );
11678 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredDriverPropertiesMSFT.underlyingAPI );
11679 return seed;
11680 }
11681 };
11682
11683 template <>
11684 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLegacyDitheringFeaturesEXT>
11685 {
11686 std::size_t
11687 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLegacyDitheringFeaturesEXT const & physicalDeviceLegacyDitheringFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
11688 {
11689 std::size_t seed = 0;
11690 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyDitheringFeaturesEXT.sType );
11691 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyDitheringFeaturesEXT.pNext );
11692 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyDitheringFeaturesEXT.legacyDithering );
11693 return seed;
11694 }
11695 };
11696
11697 template <>
11698 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLegacyVertexAttributesFeaturesEXT>
11699 {
11700 std::size_t operator()(
11701 VULKAN_HPP_NAMESPACE::PhysicalDeviceLegacyVertexAttributesFeaturesEXT const & physicalDeviceLegacyVertexAttributesFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
11702 {
11703 std::size_t seed = 0;
11704 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyVertexAttributesFeaturesEXT.sType );
11705 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyVertexAttributesFeaturesEXT.pNext );
11706 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyVertexAttributesFeaturesEXT.legacyVertexAttributes );
11707 return seed;
11708 }
11709 };
11710
11711 template <>
11712 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLegacyVertexAttributesPropertiesEXT>
11713 {
11714 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLegacyVertexAttributesPropertiesEXT const & physicalDeviceLegacyVertexAttributesPropertiesEXT )
11715 const VULKAN_HPP_NOEXCEPT
11716 {
11717 std::size_t seed = 0;
11718 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyVertexAttributesPropertiesEXT.sType );
11719 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyVertexAttributesPropertiesEXT.pNext );
11720 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyVertexAttributesPropertiesEXT.nativeUnalignedPerformance );
11721 return seed;
11722 }
11723 };
11724
11725 template <>
11726 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationFeatures>
11727 {
11728 std::size_t
11729 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationFeatures const & physicalDeviceLineRasterizationFeatures ) const VULKAN_HPP_NOEXCEPT
11730 {
11731 std::size_t seed = 0;
11732 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeatures.sType );
11733 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeatures.pNext );
11734 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeatures.rectangularLines );
11735 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeatures.bresenhamLines );
11736 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeatures.smoothLines );
11737 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeatures.stippledRectangularLines );
11738 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeatures.stippledBresenhamLines );
11739 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeatures.stippledSmoothLines );
11740 return seed;
11741 }
11742 };
11743
11744 template <>
11745 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationProperties>
11746 {
11747 std::size_t
11748 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationProperties const & physicalDeviceLineRasterizationProperties ) const VULKAN_HPP_NOEXCEPT
11749 {
11750 std::size_t seed = 0;
11751 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationProperties.sType );
11752 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationProperties.pNext );
11753 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationProperties.lineSubPixelPrecisionBits );
11754 return seed;
11755 }
11756 };
11757
11758 template <>
11759 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLinearColorAttachmentFeaturesNV>
11760 {
11761 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLinearColorAttachmentFeaturesNV const & physicalDeviceLinearColorAttachmentFeaturesNV ) const
11762 VULKAN_HPP_NOEXCEPT
11763 {
11764 std::size_t seed = 0;
11765 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLinearColorAttachmentFeaturesNV.sType );
11766 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLinearColorAttachmentFeaturesNV.pNext );
11767 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLinearColorAttachmentFeaturesNV.linearColorAttachment );
11768 return seed;
11769 }
11770 };
11771
11772 template <>
11773 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance10FeaturesKHR>
11774 {
11775 std::size_t
11776 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance10FeaturesKHR const & physicalDeviceMaintenance10FeaturesKHR ) const VULKAN_HPP_NOEXCEPT
11777 {
11778 std::size_t seed = 0;
11779 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance10FeaturesKHR.sType );
11780 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance10FeaturesKHR.pNext );
11781 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance10FeaturesKHR.maintenance10 );
11782 return seed;
11783 }
11784 };
11785
11786 template <>
11787 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance10PropertiesKHR>
11788 {
11789 std::size_t
11790 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance10PropertiesKHR const & physicalDeviceMaintenance10PropertiesKHR ) const VULKAN_HPP_NOEXCEPT
11791 {
11792 std::size_t seed = 0;
11793 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance10PropertiesKHR.sType );
11794 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance10PropertiesKHR.pNext );
11795 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance10PropertiesKHR.rgba4OpaqueBlackSwizzled );
11796 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance10PropertiesKHR.resolveSrgbFormatAppliesTransferFunction );
11797 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance10PropertiesKHR.resolveSrgbFormatSupportsTransferFunctionControl );
11798 return seed;
11799 }
11800 };
11801
11802 template <>
11803 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance3Properties>
11804 {
11805 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance3Properties const & physicalDeviceMaintenance3Properties ) const VULKAN_HPP_NOEXCEPT
11806 {
11807 std::size_t seed = 0;
11808 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance3Properties.sType );
11809 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance3Properties.pNext );
11810 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance3Properties.maxPerSetDescriptors );
11811 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance3Properties.maxMemoryAllocationSize );
11812 return seed;
11813 }
11814 };
11815
11816 template <>
11817 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance4Features>
11818 {
11819 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance4Features const & physicalDeviceMaintenance4Features ) const VULKAN_HPP_NOEXCEPT
11820 {
11821 std::size_t seed = 0;
11822 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance4Features.sType );
11823 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance4Features.pNext );
11824 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance4Features.maintenance4 );
11825 return seed;
11826 }
11827 };
11828
11829 template <>
11830 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance4Properties>
11831 {
11832 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance4Properties const & physicalDeviceMaintenance4Properties ) const VULKAN_HPP_NOEXCEPT
11833 {
11834 std::size_t seed = 0;
11835 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance4Properties.sType );
11836 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance4Properties.pNext );
11837 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance4Properties.maxBufferSize );
11838 return seed;
11839 }
11840 };
11841
11842 template <>
11843 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance5Features>
11844 {
11845 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance5Features const & physicalDeviceMaintenance5Features ) const VULKAN_HPP_NOEXCEPT
11846 {
11847 std::size_t seed = 0;
11848 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5Features.sType );
11849 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5Features.pNext );
11850 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5Features.maintenance5 );
11851 return seed;
11852 }
11853 };
11854
11855 template <>
11856 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance5Properties>
11857 {
11858 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance5Properties const & physicalDeviceMaintenance5Properties ) const VULKAN_HPP_NOEXCEPT
11859 {
11860 std::size_t seed = 0;
11861 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5Properties.sType );
11862 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5Properties.pNext );
11863 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5Properties.earlyFragmentMultisampleCoverageAfterSampleCounting );
11864 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5Properties.earlyFragmentSampleMaskTestBeforeSampleCounting );
11865 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5Properties.depthStencilSwizzleOneSupport );
11866 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5Properties.polygonModePointSize );
11867 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5Properties.nonStrictSinglePixelWideLinesUseParallelogram );
11868 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5Properties.nonStrictWideLinesUseParallelogram );
11869 return seed;
11870 }
11871 };
11872
11873 template <>
11874 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance6Features>
11875 {
11876 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance6Features const & physicalDeviceMaintenance6Features ) const VULKAN_HPP_NOEXCEPT
11877 {
11878 std::size_t seed = 0;
11879 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance6Features.sType );
11880 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance6Features.pNext );
11881 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance6Features.maintenance6 );
11882 return seed;
11883 }
11884 };
11885
11886 template <>
11887 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance6Properties>
11888 {
11889 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance6Properties const & physicalDeviceMaintenance6Properties ) const VULKAN_HPP_NOEXCEPT
11890 {
11891 std::size_t seed = 0;
11892 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance6Properties.sType );
11893 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance6Properties.pNext );
11894 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance6Properties.blockTexelViewCompatibleMultipleLayers );
11895 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance6Properties.maxCombinedImageSamplerDescriptorCount );
11896 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance6Properties.fragmentShadingRateClampCombinerInputs );
11897 return seed;
11898 }
11899 };
11900
11901 template <>
11902 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance7FeaturesKHR>
11903 {
11904 std::size_t
11905 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance7FeaturesKHR const & physicalDeviceMaintenance7FeaturesKHR ) const VULKAN_HPP_NOEXCEPT
11906 {
11907 std::size_t seed = 0;
11908 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance7FeaturesKHR.sType );
11909 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance7FeaturesKHR.pNext );
11910 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance7FeaturesKHR.maintenance7 );
11911 return seed;
11912 }
11913 };
11914
11915 template <>
11916 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance7PropertiesKHR>
11917 {
11918 std::size_t
11919 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance7PropertiesKHR const & physicalDeviceMaintenance7PropertiesKHR ) const VULKAN_HPP_NOEXCEPT
11920 {
11921 std::size_t seed = 0;
11922 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance7PropertiesKHR.sType );
11923 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance7PropertiesKHR.pNext );
11924 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance7PropertiesKHR.robustFragmentShadingRateAttachmentAccess );
11925 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance7PropertiesKHR.separateDepthStencilAttachmentAccess );
11926 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance7PropertiesKHR.maxDescriptorSetTotalUniformBuffersDynamic );
11927 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance7PropertiesKHR.maxDescriptorSetTotalStorageBuffersDynamic );
11928 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance7PropertiesKHR.maxDescriptorSetTotalBuffersDynamic );
11929 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance7PropertiesKHR.maxDescriptorSetUpdateAfterBindTotalUniformBuffersDynamic );
11930 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance7PropertiesKHR.maxDescriptorSetUpdateAfterBindTotalStorageBuffersDynamic );
11931 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance7PropertiesKHR.maxDescriptorSetUpdateAfterBindTotalBuffersDynamic );
11932 return seed;
11933 }
11934 };
11935
11936 template <>
11937 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance8FeaturesKHR>
11938 {
11939 std::size_t
11940 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance8FeaturesKHR const & physicalDeviceMaintenance8FeaturesKHR ) const VULKAN_HPP_NOEXCEPT
11941 {
11942 std::size_t seed = 0;
11943 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance8FeaturesKHR.sType );
11944 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance8FeaturesKHR.pNext );
11945 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance8FeaturesKHR.maintenance8 );
11946 return seed;
11947 }
11948 };
11949
11950 template <>
11951 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance9FeaturesKHR>
11952 {
11953 std::size_t
11954 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance9FeaturesKHR const & physicalDeviceMaintenance9FeaturesKHR ) const VULKAN_HPP_NOEXCEPT
11955 {
11956 std::size_t seed = 0;
11957 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance9FeaturesKHR.sType );
11958 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance9FeaturesKHR.pNext );
11959 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance9FeaturesKHR.maintenance9 );
11960 return seed;
11961 }
11962 };
11963
11964 template <>
11965 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance9PropertiesKHR>
11966 {
11967 std::size_t
11968 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance9PropertiesKHR const & physicalDeviceMaintenance9PropertiesKHR ) const VULKAN_HPP_NOEXCEPT
11969 {
11970 std::size_t seed = 0;
11971 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance9PropertiesKHR.sType );
11972 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance9PropertiesKHR.pNext );
11973 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance9PropertiesKHR.image2DViewOf3DSparse );
11974 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance9PropertiesKHR.defaultVertexAttributeValue );
11975 return seed;
11976 }
11977 };
11978
11979 template <>
11980 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMapMemoryPlacedFeaturesEXT>
11981 {
11982 std::size_t
11983 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMapMemoryPlacedFeaturesEXT const & physicalDeviceMapMemoryPlacedFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
11984 {
11985 std::size_t seed = 0;
11986 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMapMemoryPlacedFeaturesEXT.sType );
11987 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMapMemoryPlacedFeaturesEXT.pNext );
11988 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMapMemoryPlacedFeaturesEXT.memoryMapPlaced );
11989 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMapMemoryPlacedFeaturesEXT.memoryMapRangePlaced );
11990 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMapMemoryPlacedFeaturesEXT.memoryUnmapReserve );
11991 return seed;
11992 }
11993 };
11994
11995 template <>
11996 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMapMemoryPlacedPropertiesEXT>
11997 {
11998 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMapMemoryPlacedPropertiesEXT const & physicalDeviceMapMemoryPlacedPropertiesEXT ) const
11999 VULKAN_HPP_NOEXCEPT
12000 {
12001 std::size_t seed = 0;
12002 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMapMemoryPlacedPropertiesEXT.sType );
12003 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMapMemoryPlacedPropertiesEXT.pNext );
12004 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMapMemoryPlacedPropertiesEXT.minPlacedMemoryMapAlignment );
12005 return seed;
12006 }
12007 };
12008
12009 template <>
12010 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryBudgetPropertiesEXT>
12011 {
12012 std::size_t
12013 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryBudgetPropertiesEXT const & physicalDeviceMemoryBudgetPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
12014 {
12015 std::size_t seed = 0;
12016 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryBudgetPropertiesEXT.sType );
12017 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryBudgetPropertiesEXT.pNext );
12018 for ( size_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i )
12019 {
12020 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryBudgetPropertiesEXT.heapBudget[i] );
12021 }
12022 for ( size_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i )
12023 {
12024 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryBudgetPropertiesEXT.heapUsage[i] );
12025 }
12026 return seed;
12027 }
12028 };
12029
12030 template <>
12031 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryDecompressionFeaturesEXT>
12032 {
12033 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryDecompressionFeaturesEXT const & physicalDeviceMemoryDecompressionFeaturesEXT ) const
12034 VULKAN_HPP_NOEXCEPT
12035 {
12036 std::size_t seed = 0;
12037 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionFeaturesEXT.sType );
12038 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionFeaturesEXT.pNext );
12039 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionFeaturesEXT.memoryDecompression );
12040 return seed;
12041 }
12042 };
12043
12044 template <>
12045 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryDecompressionPropertiesEXT>
12046 {
12047 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryDecompressionPropertiesEXT const & physicalDeviceMemoryDecompressionPropertiesEXT ) const
12048 VULKAN_HPP_NOEXCEPT
12049 {
12050 std::size_t seed = 0;
12051 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionPropertiesEXT.sType );
12052 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionPropertiesEXT.pNext );
12053 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionPropertiesEXT.decompressionMethods );
12054 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionPropertiesEXT.maxDecompressionIndirectCount );
12055 return seed;
12056 }
12057 };
12058
12059 template <>
12060 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryPriorityFeaturesEXT>
12061 {
12062 std::size_t
12063 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryPriorityFeaturesEXT const & physicalDeviceMemoryPriorityFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
12064 {
12065 std::size_t seed = 0;
12066 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryPriorityFeaturesEXT.sType );
12067 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryPriorityFeaturesEXT.pNext );
12068 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryPriorityFeaturesEXT.memoryPriority );
12069 return seed;
12070 }
12071 };
12072
12073 template <>
12074 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties>
12075 {
12076 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties const & physicalDeviceMemoryProperties ) const VULKAN_HPP_NOEXCEPT
12077 {
12078 std::size_t seed = 0;
12079 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryProperties.memoryTypeCount );
12080 for ( size_t i = 0; i < VK_MAX_MEMORY_TYPES; ++i )
12081 {
12082 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryProperties.memoryTypes[i] );
12083 }
12084 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryProperties.memoryHeapCount );
12085 for ( size_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i )
12086 {
12087 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryProperties.memoryHeaps[i] );
12088 }
12089 return seed;
12090 }
12091 };
12092
12093 template <>
12094 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2>
12095 {
12096 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 const & physicalDeviceMemoryProperties2 ) const VULKAN_HPP_NOEXCEPT
12097 {
12098 std::size_t seed = 0;
12099 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryProperties2.sType );
12100 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryProperties2.pNext );
12101 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryProperties2.memoryProperties );
12102 return seed;
12103 }
12104 };
12105
12106 template <>
12107 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderFeaturesEXT>
12108 {
12109 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderFeaturesEXT const & physicalDeviceMeshShaderFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
12110 {
12111 std::size_t seed = 0;
12112 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesEXT.sType );
12113 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesEXT.pNext );
12114 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesEXT.taskShader );
12115 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesEXT.meshShader );
12116 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesEXT.multiviewMeshShader );
12117 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesEXT.primitiveFragmentShadingRateMeshShader );
12118 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesEXT.meshShaderQueries );
12119 return seed;
12120 }
12121 };
12122
12123 template <>
12124 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderFeaturesNV>
12125 {
12126 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderFeaturesNV const & physicalDeviceMeshShaderFeaturesNV ) const VULKAN_HPP_NOEXCEPT
12127 {
12128 std::size_t seed = 0;
12129 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesNV.sType );
12130 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesNV.pNext );
12131 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesNV.taskShader );
12132 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesNV.meshShader );
12133 return seed;
12134 }
12135 };
12136
12137 template <>
12138 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderPropertiesEXT>
12139 {
12140 std::size_t
12141 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderPropertiesEXT const & physicalDeviceMeshShaderPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
12142 {
12143 std::size_t seed = 0;
12144 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.sType );
12145 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.pNext );
12146 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxTaskWorkGroupTotalCount );
12147 for ( size_t i = 0; i < 3; ++i )
12148 {
12149 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxTaskWorkGroupCount[i] );
12150 }
12151 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxTaskWorkGroupInvocations );
12152 for ( size_t i = 0; i < 3; ++i )
12153 {
12154 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxTaskWorkGroupSize[i] );
12155 }
12156 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxTaskPayloadSize );
12157 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxTaskSharedMemorySize );
12158 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxTaskPayloadAndSharedMemorySize );
12159 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshWorkGroupTotalCount );
12160 for ( size_t i = 0; i < 3; ++i )
12161 {
12162 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshWorkGroupCount[i] );
12163 }
12164 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshWorkGroupInvocations );
12165 for ( size_t i = 0; i < 3; ++i )
12166 {
12167 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshWorkGroupSize[i] );
12168 }
12169 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshSharedMemorySize );
12170 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshPayloadAndSharedMemorySize );
12171 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshOutputMemorySize );
12172 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshPayloadAndOutputMemorySize );
12173 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshOutputComponents );
12174 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshOutputVertices );
12175 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshOutputPrimitives );
12176 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshOutputLayers );
12177 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshMultiviewViewCount );
12178 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.meshOutputPerVertexGranularity );
12179 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.meshOutputPerPrimitiveGranularity );
12180 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxPreferredTaskWorkGroupInvocations );
12181 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxPreferredMeshWorkGroupInvocations );
12182 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.prefersLocalInvocationVertexOutput );
12183 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.prefersLocalInvocationPrimitiveOutput );
12184 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.prefersCompactVertexOutput );
12185 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.prefersCompactPrimitiveOutput );
12186 return seed;
12187 }
12188 };
12189
12190 template <>
12191 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderPropertiesNV>
12192 {
12193 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderPropertiesNV const & physicalDeviceMeshShaderPropertiesNV ) const VULKAN_HPP_NOEXCEPT
12194 {
12195 std::size_t seed = 0;
12196 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.sType );
12197 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.pNext );
12198 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxDrawMeshTasksCount );
12199 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxTaskWorkGroupInvocations );
12200 for ( size_t i = 0; i < 3; ++i )
12201 {
12202 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxTaskWorkGroupSize[i] );
12203 }
12204 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxTaskTotalMemorySize );
12205 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxTaskOutputCount );
12206 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxMeshWorkGroupInvocations );
12207 for ( size_t i = 0; i < 3; ++i )
12208 {
12209 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxMeshWorkGroupSize[i] );
12210 }
12211 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxMeshTotalMemorySize );
12212 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxMeshOutputVertices );
12213 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxMeshOutputPrimitives );
12214 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxMeshMultiviewViewCount );
12215 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.meshOutputPerVertexGranularity );
12216 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.meshOutputPerPrimitiveGranularity );
12217 return seed;
12218 }
12219 };
12220
12221 template <>
12222 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiDrawFeaturesEXT>
12223 {
12224 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiDrawFeaturesEXT const & physicalDeviceMultiDrawFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
12225 {
12226 std::size_t seed = 0;
12227 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiDrawFeaturesEXT.sType );
12228 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiDrawFeaturesEXT.pNext );
12229 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiDrawFeaturesEXT.multiDraw );
12230 return seed;
12231 }
12232 };
12233
12234 template <>
12235 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiDrawPropertiesEXT>
12236 {
12237 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiDrawPropertiesEXT const & physicalDeviceMultiDrawPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
12238 {
12239 std::size_t seed = 0;
12240 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiDrawPropertiesEXT.sType );
12241 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiDrawPropertiesEXT.pNext );
12242 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiDrawPropertiesEXT.maxMultiDrawCount );
12243 return seed;
12244 }
12245 };
12246
12247 template <>
12248 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT>
12249 {
12250 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT const &
12251 physicalDeviceMultisampledRenderToSingleSampledFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
12252 {
12253 std::size_t seed = 0;
12254 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultisampledRenderToSingleSampledFeaturesEXT.sType );
12255 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultisampledRenderToSingleSampledFeaturesEXT.pNext );
12256 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultisampledRenderToSingleSampledFeaturesEXT.multisampledRenderToSingleSampled );
12257 return seed;
12258 }
12259 };
12260
12261 template <>
12262 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewFeatures>
12263 {
12264 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewFeatures const & physicalDeviceMultiviewFeatures ) const VULKAN_HPP_NOEXCEPT
12265 {
12266 std::size_t seed = 0;
12267 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewFeatures.sType );
12268 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewFeatures.pNext );
12269 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewFeatures.multiview );
12270 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewFeatures.multiviewGeometryShader );
12271 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewFeatures.multiviewTessellationShader );
12272 return seed;
12273 }
12274 };
12275
12276 template <>
12277 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX>
12278 {
12279 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const &
12280 physicalDeviceMultiviewPerViewAttributesPropertiesNVX ) const VULKAN_HPP_NOEXCEPT
12281 {
12282 std::size_t seed = 0;
12283 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewAttributesPropertiesNVX.sType );
12284 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewAttributesPropertiesNVX.pNext );
12285 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewAttributesPropertiesNVX.perViewPositionAllComponents );
12286 return seed;
12287 }
12288 };
12289
12290 template <>
12291 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM>
12292 {
12293 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM const &
12294 physicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM ) const VULKAN_HPP_NOEXCEPT
12295 {
12296 std::size_t seed = 0;
12297 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM.sType );
12298 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM.pNext );
12299 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM.multiviewPerViewRenderAreas );
12300 return seed;
12301 }
12302 };
12303
12304 template <>
12305 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM>
12306 {
12307 std::size_t
12308 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM const & physicalDeviceMultiviewPerViewViewportsFeaturesQCOM ) const
12309 VULKAN_HPP_NOEXCEPT
12310 {
12311 std::size_t seed = 0;
12312 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewViewportsFeaturesQCOM.sType );
12313 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewViewportsFeaturesQCOM.pNext );
12314 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewViewportsFeaturesQCOM.multiviewPerViewViewports );
12315 return seed;
12316 }
12317 };
12318
12319 template <>
12320 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewProperties>
12321 {
12322 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewProperties const & physicalDeviceMultiviewProperties ) const VULKAN_HPP_NOEXCEPT
12323 {
12324 std::size_t seed = 0;
12325 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewProperties.sType );
12326 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewProperties.pNext );
12327 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewProperties.maxMultiviewViewCount );
12328 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewProperties.maxMultiviewInstanceIndex );
12329 return seed;
12330 }
12331 };
12332
12333 template <>
12334 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMutableDescriptorTypeFeaturesEXT>
12335 {
12336 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMutableDescriptorTypeFeaturesEXT const & physicalDeviceMutableDescriptorTypeFeaturesEXT ) const
12337 VULKAN_HPP_NOEXCEPT
12338 {
12339 std::size_t seed = 0;
12340 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMutableDescriptorTypeFeaturesEXT.sType );
12341 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMutableDescriptorTypeFeaturesEXT.pNext );
12342 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMutableDescriptorTypeFeaturesEXT.mutableDescriptorType );
12343 return seed;
12344 }
12345 };
12346
12347 template <>
12348 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceNestedCommandBufferFeaturesEXT>
12349 {
12350 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceNestedCommandBufferFeaturesEXT const & physicalDeviceNestedCommandBufferFeaturesEXT ) const
12351 VULKAN_HPP_NOEXCEPT
12352 {
12353 std::size_t seed = 0;
12354 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNestedCommandBufferFeaturesEXT.sType );
12355 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNestedCommandBufferFeaturesEXT.pNext );
12356 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNestedCommandBufferFeaturesEXT.nestedCommandBuffer );
12357 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNestedCommandBufferFeaturesEXT.nestedCommandBufferRendering );
12358 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNestedCommandBufferFeaturesEXT.nestedCommandBufferSimultaneousUse );
12359 return seed;
12360 }
12361 };
12362
12363 template <>
12364 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceNestedCommandBufferPropertiesEXT>
12365 {
12366 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceNestedCommandBufferPropertiesEXT const & physicalDeviceNestedCommandBufferPropertiesEXT ) const
12367 VULKAN_HPP_NOEXCEPT
12368 {
12369 std::size_t seed = 0;
12370 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNestedCommandBufferPropertiesEXT.sType );
12371 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNestedCommandBufferPropertiesEXT.pNext );
12372 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNestedCommandBufferPropertiesEXT.maxCommandBufferNestingLevel );
12373 return seed;
12374 }
12375 };
12376
12377 template <>
12378 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceNonSeamlessCubeMapFeaturesEXT>
12379 {
12380 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceNonSeamlessCubeMapFeaturesEXT const & physicalDeviceNonSeamlessCubeMapFeaturesEXT ) const
12381 VULKAN_HPP_NOEXCEPT
12382 {
12383 std::size_t seed = 0;
12384 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNonSeamlessCubeMapFeaturesEXT.sType );
12385 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNonSeamlessCubeMapFeaturesEXT.pNext );
12386 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNonSeamlessCubeMapFeaturesEXT.nonSeamlessCubeMap );
12387 return seed;
12388 }
12389 };
12390
12391 template <>
12392 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceOpacityMicromapFeaturesEXT>
12393 {
12394 std::size_t
12395 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceOpacityMicromapFeaturesEXT const & physicalDeviceOpacityMicromapFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
12396 {
12397 std::size_t seed = 0;
12398 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapFeaturesEXT.sType );
12399 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapFeaturesEXT.pNext );
12400 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapFeaturesEXT.micromap );
12401 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapFeaturesEXT.micromapCaptureReplay );
12402 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapFeaturesEXT.micromapHostCommands );
12403 return seed;
12404 }
12405 };
12406
12407 template <>
12408 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceOpacityMicromapPropertiesEXT>
12409 {
12410 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceOpacityMicromapPropertiesEXT const & physicalDeviceOpacityMicromapPropertiesEXT ) const
12411 VULKAN_HPP_NOEXCEPT
12412 {
12413 std::size_t seed = 0;
12414 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapPropertiesEXT.sType );
12415 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapPropertiesEXT.pNext );
12416 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapPropertiesEXT.maxOpacity2StateSubdivisionLevel );
12417 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapPropertiesEXT.maxOpacity4StateSubdivisionLevel );
12418 return seed;
12419 }
12420 };
12421
12422 template <>
12423 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceOpticalFlowFeaturesNV>
12424 {
12425 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceOpticalFlowFeaturesNV const & physicalDeviceOpticalFlowFeaturesNV ) const VULKAN_HPP_NOEXCEPT
12426 {
12427 std::size_t seed = 0;
12428 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowFeaturesNV.sType );
12429 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowFeaturesNV.pNext );
12430 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowFeaturesNV.opticalFlow );
12431 return seed;
12432 }
12433 };
12434
12435 template <>
12436 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceOpticalFlowPropertiesNV>
12437 {
12438 std::size_t
12439 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceOpticalFlowPropertiesNV const & physicalDeviceOpticalFlowPropertiesNV ) const VULKAN_HPP_NOEXCEPT
12440 {
12441 std::size_t seed = 0;
12442 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.sType );
12443 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.pNext );
12444 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.supportedOutputGridSizes );
12445 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.supportedHintGridSizes );
12446 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.hintSupported );
12447 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.costSupported );
12448 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.bidirectionalFlowSupported );
12449 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.globalFlowSupported );
12450 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.minWidth );
12451 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.minHeight );
12452 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.maxWidth );
12453 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.maxHeight );
12454 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.maxNumRegionsOfInterest );
12455 return seed;
12456 }
12457 };
12458
12459 template <>
12460 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePCIBusInfoPropertiesEXT>
12461 {
12462 std::size_t
12463 operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePCIBusInfoPropertiesEXT const & physicalDevicePCIBusInfoPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
12464 {
12465 std::size_t seed = 0;
12466 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePCIBusInfoPropertiesEXT.sType );
12467 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePCIBusInfoPropertiesEXT.pNext );
12468 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePCIBusInfoPropertiesEXT.pciDomain );
12469 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePCIBusInfoPropertiesEXT.pciBus );
12470 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePCIBusInfoPropertiesEXT.pciDevice );
12471 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePCIBusInfoPropertiesEXT.pciFunction );
12472 return seed;
12473 }
12474 };
12475
12476 template <>
12477 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT>
12478 {
12479 std::size_t
12480 operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT const & physicalDevicePageableDeviceLocalMemoryFeaturesEXT ) const
12481 VULKAN_HPP_NOEXCEPT
12482 {
12483 std::size_t seed = 0;
12484 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePageableDeviceLocalMemoryFeaturesEXT.sType );
12485 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePageableDeviceLocalMemoryFeaturesEXT.pNext );
12486 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePageableDeviceLocalMemoryFeaturesEXT.pageableDeviceLocalMemory );
12487 return seed;
12488 }
12489 };
12490
12491 template <>
12492 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePartitionedAccelerationStructureFeaturesNV>
12493 {
12494 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePartitionedAccelerationStructureFeaturesNV const &
12495 physicalDevicePartitionedAccelerationStructureFeaturesNV ) const VULKAN_HPP_NOEXCEPT
12496 {
12497 std::size_t seed = 0;
12498 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePartitionedAccelerationStructureFeaturesNV.sType );
12499 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePartitionedAccelerationStructureFeaturesNV.pNext );
12500 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePartitionedAccelerationStructureFeaturesNV.partitionedAccelerationStructure );
12501 return seed;
12502 }
12503 };
12504
12505 template <>
12506 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePartitionedAccelerationStructurePropertiesNV>
12507 {
12508 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePartitionedAccelerationStructurePropertiesNV const &
12509 physicalDevicePartitionedAccelerationStructurePropertiesNV ) const VULKAN_HPP_NOEXCEPT
12510 {
12511 std::size_t seed = 0;
12512 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePartitionedAccelerationStructurePropertiesNV.sType );
12513 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePartitionedAccelerationStructurePropertiesNV.pNext );
12514 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePartitionedAccelerationStructurePropertiesNV.maxPartitionCount );
12515 return seed;
12516 }
12517 };
12518
12519 template <>
12520 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePerStageDescriptorSetFeaturesNV>
12521 {
12522 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePerStageDescriptorSetFeaturesNV const & physicalDevicePerStageDescriptorSetFeaturesNV ) const
12523 VULKAN_HPP_NOEXCEPT
12524 {
12525 std::size_t seed = 0;
12526 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerStageDescriptorSetFeaturesNV.sType );
12527 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerStageDescriptorSetFeaturesNV.pNext );
12528 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerStageDescriptorSetFeaturesNV.perStageDescriptorSet );
12529 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerStageDescriptorSetFeaturesNV.dynamicPipelineLayout );
12530 return seed;
12531 }
12532 };
12533
12534 template <>
12535 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceCountersByRegionFeaturesARM>
12536 {
12537 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceCountersByRegionFeaturesARM const &
12538 physicalDevicePerformanceCountersByRegionFeaturesARM ) const VULKAN_HPP_NOEXCEPT
12539 {
12540 std::size_t seed = 0;
12541 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceCountersByRegionFeaturesARM.sType );
12542 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceCountersByRegionFeaturesARM.pNext );
12543 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceCountersByRegionFeaturesARM.performanceCountersByRegion );
12544 return seed;
12545 }
12546 };
12547
12548 template <>
12549 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceCountersByRegionPropertiesARM>
12550 {
12551 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceCountersByRegionPropertiesARM const &
12552 physicalDevicePerformanceCountersByRegionPropertiesARM ) const VULKAN_HPP_NOEXCEPT
12553 {
12554 std::size_t seed = 0;
12555 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceCountersByRegionPropertiesARM.sType );
12556 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceCountersByRegionPropertiesARM.pNext );
12557 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceCountersByRegionPropertiesARM.maxPerRegionPerformanceCounters );
12558 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceCountersByRegionPropertiesARM.performanceCounterRegionSize );
12559 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceCountersByRegionPropertiesARM.rowStrideAlignment );
12560 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceCountersByRegionPropertiesARM.regionAlignment );
12561 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceCountersByRegionPropertiesARM.identityTransformOrder );
12562 return seed;
12563 }
12564 };
12565
12566 template <>
12567 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceQueryFeaturesKHR>
12568 {
12569 std::size_t
12570 operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceQueryFeaturesKHR const & physicalDevicePerformanceQueryFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
12571 {
12572 std::size_t seed = 0;
12573 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceQueryFeaturesKHR.sType );
12574 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceQueryFeaturesKHR.pNext );
12575 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceQueryFeaturesKHR.performanceCounterQueryPools );
12576 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceQueryFeaturesKHR.performanceCounterMultipleQueryPools );
12577 return seed;
12578 }
12579 };
12580
12581 template <>
12582 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceQueryPropertiesKHR>
12583 {
12584 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceQueryPropertiesKHR const & physicalDevicePerformanceQueryPropertiesKHR ) const
12585 VULKAN_HPP_NOEXCEPT
12586 {
12587 std::size_t seed = 0;
12588 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceQueryPropertiesKHR.sType );
12589 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceQueryPropertiesKHR.pNext );
12590 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceQueryPropertiesKHR.allowCommandBufferQueryCopies );
12591 return seed;
12592 }
12593 };
12594
12595 template <>
12596 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineBinaryFeaturesKHR>
12597 {
12598 std::size_t
12599 operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineBinaryFeaturesKHR const & physicalDevicePipelineBinaryFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
12600 {
12601 std::size_t seed = 0;
12602 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineBinaryFeaturesKHR.sType );
12603 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineBinaryFeaturesKHR.pNext );
12604 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineBinaryFeaturesKHR.pipelineBinaries );
12605 return seed;
12606 }
12607 };
12608
12609 template <>
12610 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineBinaryPropertiesKHR>
12611 {
12612 std::size_t
12613 operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineBinaryPropertiesKHR const & physicalDevicePipelineBinaryPropertiesKHR ) const VULKAN_HPP_NOEXCEPT
12614 {
12615 std::size_t seed = 0;
12616 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineBinaryPropertiesKHR.sType );
12617 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineBinaryPropertiesKHR.pNext );
12618 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineBinaryPropertiesKHR.pipelineBinaryInternalCache );
12619 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineBinaryPropertiesKHR.pipelineBinaryInternalCacheControl );
12620 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineBinaryPropertiesKHR.pipelineBinaryPrefersInternalCache );
12621 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineBinaryPropertiesKHR.pipelineBinaryPrecompiledInternalCache );
12622 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineBinaryPropertiesKHR.pipelineBinaryCompressedData );
12623 return seed;
12624 }
12625 };
12626
12627 template <>
12628 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC>
12629 {
12630 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC const &
12631 physicalDevicePipelineCacheIncrementalModeFeaturesSEC ) const VULKAN_HPP_NOEXCEPT
12632 {
12633 std::size_t seed = 0;
12634 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineCacheIncrementalModeFeaturesSEC.sType );
12635 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineCacheIncrementalModeFeaturesSEC.pNext );
12636 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineCacheIncrementalModeFeaturesSEC.pipelineCacheIncrementalMode );
12637 return seed;
12638 }
12639 };
12640
12641 template <>
12642 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineCreationCacheControlFeatures>
12643 {
12644 std::size_t
12645 operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineCreationCacheControlFeatures const & physicalDevicePipelineCreationCacheControlFeatures ) const
12646 VULKAN_HPP_NOEXCEPT
12647 {
12648 std::size_t seed = 0;
12649 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineCreationCacheControlFeatures.sType );
12650 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineCreationCacheControlFeatures.pNext );
12651 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineCreationCacheControlFeatures.pipelineCreationCacheControl );
12652 return seed;
12653 }
12654 };
12655
12656 template <>
12657 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR>
12658 {
12659 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR const &
12660 physicalDevicePipelineExecutablePropertiesFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
12661 {
12662 std::size_t seed = 0;
12663 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineExecutablePropertiesFeaturesKHR.sType );
12664 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineExecutablePropertiesFeaturesKHR.pNext );
12665 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineExecutablePropertiesFeaturesKHR.pipelineExecutableInfo );
12666 return seed;
12667 }
12668 };
12669
12670 template <>
12671 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT>
12672 {
12673 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT const &
12674 physicalDevicePipelineLibraryGroupHandlesFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
12675 {
12676 std::size_t seed = 0;
12677 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineLibraryGroupHandlesFeaturesEXT.sType );
12678 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineLibraryGroupHandlesFeaturesEXT.pNext );
12679 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineLibraryGroupHandlesFeaturesEXT.pipelineLibraryGroupHandles );
12680 return seed;
12681 }
12682 };
12683
12684 template <>
12685 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineOpacityMicromapFeaturesARM>
12686 {
12687 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineOpacityMicromapFeaturesARM const & physicalDevicePipelineOpacityMicromapFeaturesARM )
12688 const VULKAN_HPP_NOEXCEPT
12689 {
12690 std::size_t seed = 0;
12691 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineOpacityMicromapFeaturesARM.sType );
12692 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineOpacityMicromapFeaturesARM.pNext );
12693 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineOpacityMicromapFeaturesARM.pipelineOpacityMicromap );
12694 return seed;
12695 }
12696 };
12697
12698 template <>
12699 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelinePropertiesFeaturesEXT>
12700 {
12701 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelinePropertiesFeaturesEXT const & physicalDevicePipelinePropertiesFeaturesEXT ) const
12702 VULKAN_HPP_NOEXCEPT
12703 {
12704 std::size_t seed = 0;
12705 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelinePropertiesFeaturesEXT.sType );
12706 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelinePropertiesFeaturesEXT.pNext );
12707 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelinePropertiesFeaturesEXT.pipelinePropertiesIdentifier );
12708 return seed;
12709 }
12710 };
12711
12712 template <>
12713 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineProtectedAccessFeatures>
12714 {
12715 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineProtectedAccessFeatures const & physicalDevicePipelineProtectedAccessFeatures ) const
12716 VULKAN_HPP_NOEXCEPT
12717 {
12718 std::size_t seed = 0;
12719 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineProtectedAccessFeatures.sType );
12720 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineProtectedAccessFeatures.pNext );
12721 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineProtectedAccessFeatures.pipelineProtectedAccess );
12722 return seed;
12723 }
12724 };
12725
12726 template <>
12727 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineRobustnessFeatures>
12728 {
12729 std::size_t
12730 operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineRobustnessFeatures const & physicalDevicePipelineRobustnessFeatures ) const VULKAN_HPP_NOEXCEPT
12731 {
12732 std::size_t seed = 0;
12733 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineRobustnessFeatures.sType );
12734 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineRobustnessFeatures.pNext );
12735 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineRobustnessFeatures.pipelineRobustness );
12736 return seed;
12737 }
12738 };
12739
12740 template <>
12741 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineRobustnessProperties>
12742 {
12743 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineRobustnessProperties const & physicalDevicePipelineRobustnessProperties ) const
12744 VULKAN_HPP_NOEXCEPT
12745 {
12746 std::size_t seed = 0;
12747 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineRobustnessProperties.sType );
12748 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineRobustnessProperties.pNext );
12749 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineRobustnessProperties.defaultRobustnessStorageBuffers );
12750 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineRobustnessProperties.defaultRobustnessUniformBuffers );
12751 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineRobustnessProperties.defaultRobustnessVertexInputs );
12752 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineRobustnessProperties.defaultRobustnessImages );
12753 return seed;
12754 }
12755 };
12756
12757 template <>
12758 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePointClippingProperties>
12759 {
12760 std::size_t
12761 operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePointClippingProperties const & physicalDevicePointClippingProperties ) const VULKAN_HPP_NOEXCEPT
12762 {
12763 std::size_t seed = 0;
12764 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePointClippingProperties.sType );
12765 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePointClippingProperties.pNext );
12766 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePointClippingProperties.pointClippingBehavior );
12767 return seed;
12768 }
12769 };
12770
12771 # if defined( VK_ENABLE_BETA_EXTENSIONS )
12772 template <>
12773 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePortabilitySubsetFeaturesKHR>
12774 {
12775 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePortabilitySubsetFeaturesKHR const & physicalDevicePortabilitySubsetFeaturesKHR ) const
12776 VULKAN_HPP_NOEXCEPT
12777 {
12778 std::size_t seed = 0;
12779 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.sType );
12780 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.pNext );
12781 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.constantAlphaColorBlendFactors );
12782 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.events );
12783 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.imageViewFormatReinterpretation );
12784 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.imageViewFormatSwizzle );
12785 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.imageView2DOn3DImage );
12786 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.multisampleArrayImage );
12787 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.mutableComparisonSamplers );
12788 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.pointPolygons );
12789 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.samplerMipLodBias );
12790 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.separateStencilMaskRef );
12791 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.shaderSampleRateInterpolationFunctions );
12792 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.tessellationIsolines );
12793 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.tessellationPointMode );
12794 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.triangleFans );
12795 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.vertexAttributeAccessBeyondStride );
12796 return seed;
12797 }
12798 };
12799 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
12800
12801 # if defined( VK_ENABLE_BETA_EXTENSIONS )
12802 template <>
12803 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePortabilitySubsetPropertiesKHR>
12804 {
12805 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePortabilitySubsetPropertiesKHR const & physicalDevicePortabilitySubsetPropertiesKHR ) const
12806 VULKAN_HPP_NOEXCEPT
12807 {
12808 std::size_t seed = 0;
12809 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetPropertiesKHR.sType );
12810 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetPropertiesKHR.pNext );
12811 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetPropertiesKHR.minVertexInputBindingStrideAlignment );
12812 return seed;
12813 }
12814 };
12815 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
12816
12817 template <>
12818 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePresentBarrierFeaturesNV>
12819 {
12820 std::size_t
12821 operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePresentBarrierFeaturesNV const & physicalDevicePresentBarrierFeaturesNV ) const VULKAN_HPP_NOEXCEPT
12822 {
12823 std::size_t seed = 0;
12824 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentBarrierFeaturesNV.sType );
12825 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentBarrierFeaturesNV.pNext );
12826 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentBarrierFeaturesNV.presentBarrier );
12827 return seed;
12828 }
12829 };
12830
12831 template <>
12832 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePresentId2FeaturesKHR>
12833 {
12834 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePresentId2FeaturesKHR const & physicalDevicePresentId2FeaturesKHR ) const VULKAN_HPP_NOEXCEPT
12835 {
12836 std::size_t seed = 0;
12837 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentId2FeaturesKHR.sType );
12838 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentId2FeaturesKHR.pNext );
12839 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentId2FeaturesKHR.presentId2 );
12840 return seed;
12841 }
12842 };
12843
12844 template <>
12845 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePresentIdFeaturesKHR>
12846 {
12847 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePresentIdFeaturesKHR const & physicalDevicePresentIdFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
12848 {
12849 std::size_t seed = 0;
12850 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentIdFeaturesKHR.sType );
12851 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentIdFeaturesKHR.pNext );
12852 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentIdFeaturesKHR.presentId );
12853 return seed;
12854 }
12855 };
12856
12857 # if defined( VK_ENABLE_BETA_EXTENSIONS )
12858 template <>
12859 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePresentMeteringFeaturesNV>
12860 {
12861 std::size_t
12862 operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePresentMeteringFeaturesNV const & physicalDevicePresentMeteringFeaturesNV ) const VULKAN_HPP_NOEXCEPT
12863 {
12864 std::size_t seed = 0;
12865 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentMeteringFeaturesNV.sType );
12866 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentMeteringFeaturesNV.pNext );
12867 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentMeteringFeaturesNV.presentMetering );
12868 return seed;
12869 }
12870 };
12871 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
12872
12873 template <>
12874 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR>
12875 {
12876 std::size_t
12877 operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR const & physicalDevicePresentModeFifoLatestReadyFeaturesKHR ) const
12878 VULKAN_HPP_NOEXCEPT
12879 {
12880 std::size_t seed = 0;
12881 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentModeFifoLatestReadyFeaturesKHR.sType );
12882 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentModeFifoLatestReadyFeaturesKHR.pNext );
12883 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentModeFifoLatestReadyFeaturesKHR.presentModeFifoLatestReady );
12884 return seed;
12885 }
12886 };
12887
12888 template <>
12889 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePresentWait2FeaturesKHR>
12890 {
12891 std::size_t
12892 operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePresentWait2FeaturesKHR const & physicalDevicePresentWait2FeaturesKHR ) const VULKAN_HPP_NOEXCEPT
12893 {
12894 std::size_t seed = 0;
12895 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentWait2FeaturesKHR.sType );
12896 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentWait2FeaturesKHR.pNext );
12897 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentWait2FeaturesKHR.presentWait2 );
12898 return seed;
12899 }
12900 };
12901
12902 template <>
12903 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePresentWaitFeaturesKHR>
12904 {
12905 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePresentWaitFeaturesKHR const & physicalDevicePresentWaitFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
12906 {
12907 std::size_t seed = 0;
12908 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentWaitFeaturesKHR.sType );
12909 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentWaitFeaturesKHR.pNext );
12910 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentWaitFeaturesKHR.presentWait );
12911 return seed;
12912 }
12913 };
12914
12915 # if defined( VK_USE_PLATFORM_OHOS )
12916 template <>
12917 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePresentationPropertiesOHOS>
12918 {
12919 std::size_t
12920 operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePresentationPropertiesOHOS const & physicalDevicePresentationPropertiesOHOS ) const VULKAN_HPP_NOEXCEPT
12921 {
12922 std::size_t seed = 0;
12923 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentationPropertiesOHOS.sType );
12924 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentationPropertiesOHOS.pNext );
12925 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentationPropertiesOHOS.sharedImage );
12926 return seed;
12927 }
12928 };
12929 # endif /*VK_USE_PLATFORM_OHOS*/
12930
12931 template <>
12932 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT>
12933 {
12934 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT const &
12935 physicalDevicePrimitiveTopologyListRestartFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
12936 {
12937 std::size_t seed = 0;
12938 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrimitiveTopologyListRestartFeaturesEXT.sType );
12939 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrimitiveTopologyListRestartFeaturesEXT.pNext );
12940 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrimitiveTopologyListRestartFeaturesEXT.primitiveTopologyListRestart );
12941 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrimitiveTopologyListRestartFeaturesEXT.primitiveTopologyPatchListRestart );
12942 return seed;
12943 }
12944 };
12945
12946 template <>
12947 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT>
12948 {
12949 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT const & physicalDevicePrimitivesGeneratedQueryFeaturesEXT )
12950 const VULKAN_HPP_NOEXCEPT
12951 {
12952 std::size_t seed = 0;
12953 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrimitivesGeneratedQueryFeaturesEXT.sType );
12954 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrimitivesGeneratedQueryFeaturesEXT.pNext );
12955 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrimitivesGeneratedQueryFeaturesEXT.primitivesGeneratedQuery );
12956 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrimitivesGeneratedQueryFeaturesEXT.primitivesGeneratedQueryWithRasterizerDiscard );
12957 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrimitivesGeneratedQueryFeaturesEXT.primitivesGeneratedQueryWithNonZeroStreams );
12958 return seed;
12959 }
12960 };
12961
12962 template <>
12963 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePrivateDataFeatures>
12964 {
12965 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePrivateDataFeatures const & physicalDevicePrivateDataFeatures ) const VULKAN_HPP_NOEXCEPT
12966 {
12967 std::size_t seed = 0;
12968 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrivateDataFeatures.sType );
12969 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrivateDataFeatures.pNext );
12970 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrivateDataFeatures.privateData );
12971 return seed;
12972 }
12973 };
12974
12975 template <>
12976 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceProtectedMemoryFeatures>
12977 {
12978 std::size_t
12979 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProtectedMemoryFeatures const & physicalDeviceProtectedMemoryFeatures ) const VULKAN_HPP_NOEXCEPT
12980 {
12981 std::size_t seed = 0;
12982 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProtectedMemoryFeatures.sType );
12983 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProtectedMemoryFeatures.pNext );
12984 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProtectedMemoryFeatures.protectedMemory );
12985 return seed;
12986 }
12987 };
12988
12989 template <>
12990 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceProtectedMemoryProperties>
12991 {
12992 std::size_t
12993 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProtectedMemoryProperties const & physicalDeviceProtectedMemoryProperties ) const VULKAN_HPP_NOEXCEPT
12994 {
12995 std::size_t seed = 0;
12996 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProtectedMemoryProperties.sType );
12997 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProtectedMemoryProperties.pNext );
12998 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProtectedMemoryProperties.protectedNoFault );
12999 return seed;
13000 }
13001 };
13002
13003 template <>
13004 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceProvokingVertexFeaturesEXT>
13005 {
13006 std::size_t
13007 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProvokingVertexFeaturesEXT const & physicalDeviceProvokingVertexFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
13008 {
13009 std::size_t seed = 0;
13010 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProvokingVertexFeaturesEXT.sType );
13011 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProvokingVertexFeaturesEXT.pNext );
13012 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProvokingVertexFeaturesEXT.provokingVertexLast );
13013 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProvokingVertexFeaturesEXT.transformFeedbackPreservesProvokingVertex );
13014 return seed;
13015 }
13016 };
13017
13018 template <>
13019 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceProvokingVertexPropertiesEXT>
13020 {
13021 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProvokingVertexPropertiesEXT const & physicalDeviceProvokingVertexPropertiesEXT ) const
13022 VULKAN_HPP_NOEXCEPT
13023 {
13024 std::size_t seed = 0;
13025 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProvokingVertexPropertiesEXT.sType );
13026 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProvokingVertexPropertiesEXT.pNext );
13027 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProvokingVertexPropertiesEXT.provokingVertexModePerPipeline );
13028 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProvokingVertexPropertiesEXT.transformFeedbackPreservesTriangleFanProvokingVertex );
13029 return seed;
13030 }
13031 };
13032
13033 template <>
13034 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePushDescriptorProperties>
13035 {
13036 std::size_t
13037 operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePushDescriptorProperties const & physicalDevicePushDescriptorProperties ) const VULKAN_HPP_NOEXCEPT
13038 {
13039 std::size_t seed = 0;
13040 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePushDescriptorProperties.sType );
13041 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePushDescriptorProperties.pNext );
13042 VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePushDescriptorProperties.maxPushDescriptors );
13043 return seed;
13044 }
13045 };
13046
13047 template <>
13048 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM>
13049 {
13050 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM const &
13051 physicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM ) const VULKAN_HPP_NOEXCEPT
13052 {
13053 std::size_t seed = 0;
13054 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM.sType );
13055 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM.pNext );
13056 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM.queueFamilyIndex );
13057 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM.engineType );
13058 return seed;
13059 }
13060 };
13061
13062 template <>
13063 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRGBA10X6FormatsFeaturesEXT>
13064 {
13065 std::size_t
13066 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRGBA10X6FormatsFeaturesEXT const & physicalDeviceRGBA10X6FormatsFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
13067 {
13068 std::size_t seed = 0;
13069 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRGBA10X6FormatsFeaturesEXT.sType );
13070 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRGBA10X6FormatsFeaturesEXT.pNext );
13071 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRGBA10X6FormatsFeaturesEXT.formatRgba10x6WithoutYCbCrSampler );
13072 return seed;
13073 }
13074 };
13075
13076 template <>
13077 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT>
13078 {
13079 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT const &
13080 physicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
13081 {
13082 std::size_t seed = 0;
13083 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT.sType );
13084 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT.pNext );
13085 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT.rasterizationOrderColorAttachmentAccess );
13086 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT.rasterizationOrderDepthAttachmentAccess );
13087 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT.rasterizationOrderStencilAttachmentAccess );
13088 return seed;
13089 }
13090 };
13091
13092 template <>
13093 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRawAccessChainsFeaturesNV>
13094 {
13095 std::size_t
13096 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRawAccessChainsFeaturesNV const & physicalDeviceRawAccessChainsFeaturesNV ) const VULKAN_HPP_NOEXCEPT
13097 {
13098 std::size_t seed = 0;
13099 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRawAccessChainsFeaturesNV.sType );
13100 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRawAccessChainsFeaturesNV.pNext );
13101 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRawAccessChainsFeaturesNV.shaderRawAccessChains );
13102 return seed;
13103 }
13104 };
13105
13106 template <>
13107 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayQueryFeaturesKHR>
13108 {
13109 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayQueryFeaturesKHR const & physicalDeviceRayQueryFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
13110 {
13111 std::size_t seed = 0;
13112 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayQueryFeaturesKHR.sType );
13113 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayQueryFeaturesKHR.pNext );
13114 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayQueryFeaturesKHR.rayQuery );
13115 return seed;
13116 }
13117 };
13118
13119 template <>
13120 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderFeaturesEXT>
13121 {
13122 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderFeaturesEXT const &
13123 physicalDeviceRayTracingInvocationReorderFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
13124 {
13125 std::size_t seed = 0;
13126 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderFeaturesEXT.sType );
13127 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderFeaturesEXT.pNext );
13128 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderFeaturesEXT.rayTracingInvocationReorder );
13129 return seed;
13130 }
13131 };
13132
13133 template <>
13134 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderFeaturesNV>
13135 {
13136 std::size_t
13137 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderFeaturesNV const & physicalDeviceRayTracingInvocationReorderFeaturesNV ) const
13138 VULKAN_HPP_NOEXCEPT
13139 {
13140 std::size_t seed = 0;
13141 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderFeaturesNV.sType );
13142 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderFeaturesNV.pNext );
13143 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderFeaturesNV.rayTracingInvocationReorder );
13144 return seed;
13145 }
13146 };
13147
13148 template <>
13149 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderPropertiesEXT>
13150 {
13151 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderPropertiesEXT const &
13152 physicalDeviceRayTracingInvocationReorderPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
13153 {
13154 std::size_t seed = 0;
13155 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderPropertiesEXT.sType );
13156 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderPropertiesEXT.pNext );
13157 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderPropertiesEXT.rayTracingInvocationReorderReorderingHint );
13158 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderPropertiesEXT.maxShaderBindingTableRecordIndex );
13159 return seed;
13160 }
13161 };
13162
13163 template <>
13164 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderPropertiesNV>
13165 {
13166 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderPropertiesNV const &
13167 physicalDeviceRayTracingInvocationReorderPropertiesNV ) const VULKAN_HPP_NOEXCEPT
13168 {
13169 std::size_t seed = 0;
13170 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderPropertiesNV.sType );
13171 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderPropertiesNV.pNext );
13172 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderPropertiesNV.rayTracingInvocationReorderReorderingHint );
13173 return seed;
13174 }
13175 };
13176
13177 template <>
13178 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV>
13179 {
13180 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV const &
13181 physicalDeviceRayTracingLinearSweptSpheresFeaturesNV ) const VULKAN_HPP_NOEXCEPT
13182 {
13183 std::size_t seed = 0;
13184 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingLinearSweptSpheresFeaturesNV.sType );
13185 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingLinearSweptSpheresFeaturesNV.pNext );
13186 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingLinearSweptSpheresFeaturesNV.spheres );
13187 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingLinearSweptSpheresFeaturesNV.linearSweptSpheres );
13188 return seed;
13189 }
13190 };
13191
13192 template <>
13193 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingMaintenance1FeaturesKHR>
13194 {
13195 std::size_t operator()(
13196 VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingMaintenance1FeaturesKHR const & physicalDeviceRayTracingMaintenance1FeaturesKHR ) const VULKAN_HPP_NOEXCEPT
13197 {
13198 std::size_t seed = 0;
13199 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingMaintenance1FeaturesKHR.sType );
13200 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingMaintenance1FeaturesKHR.pNext );
13201 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingMaintenance1FeaturesKHR.rayTracingMaintenance1 );
13202 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingMaintenance1FeaturesKHR.rayTracingPipelineTraceRaysIndirect2 );
13203 return seed;
13204 }
13205 };
13206
13207 template <>
13208 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingMotionBlurFeaturesNV>
13209 {
13210 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingMotionBlurFeaturesNV const & physicalDeviceRayTracingMotionBlurFeaturesNV ) const
13211 VULKAN_HPP_NOEXCEPT
13212 {
13213 std::size_t seed = 0;
13214 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingMotionBlurFeaturesNV.sType );
13215 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingMotionBlurFeaturesNV.pNext );
13216 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingMotionBlurFeaturesNV.rayTracingMotionBlur );
13217 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingMotionBlurFeaturesNV.rayTracingMotionBlurPipelineTraceRaysIndirect );
13218 return seed;
13219 }
13220 };
13221
13222 template <>
13223 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPipelineFeaturesKHR>
13224 {
13225 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPipelineFeaturesKHR const & physicalDeviceRayTracingPipelineFeaturesKHR ) const
13226 VULKAN_HPP_NOEXCEPT
13227 {
13228 std::size_t seed = 0;
13229 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelineFeaturesKHR.sType );
13230 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelineFeaturesKHR.pNext );
13231 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelineFeaturesKHR.rayTracingPipeline );
13232 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelineFeaturesKHR.rayTracingPipelineShaderGroupHandleCaptureReplay );
13233 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelineFeaturesKHR.rayTracingPipelineShaderGroupHandleCaptureReplayMixed );
13234 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelineFeaturesKHR.rayTracingPipelineTraceRaysIndirect );
13235 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelineFeaturesKHR.rayTraversalPrimitiveCulling );
13236 return seed;
13237 }
13238 };
13239
13240 template <>
13241 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPipelinePropertiesKHR>
13242 {
13243 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPipelinePropertiesKHR const & physicalDeviceRayTracingPipelinePropertiesKHR ) const
13244 VULKAN_HPP_NOEXCEPT
13245 {
13246 std::size_t seed = 0;
13247 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.sType );
13248 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.pNext );
13249 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.shaderGroupHandleSize );
13250 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.maxRayRecursionDepth );
13251 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.maxShaderGroupStride );
13252 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.shaderGroupBaseAlignment );
13253 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.shaderGroupHandleCaptureReplaySize );
13254 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.maxRayDispatchInvocationCount );
13255 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.shaderGroupHandleAlignment );
13256 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.maxRayHitAttributeSize );
13257 return seed;
13258 }
13259 };
13260
13261 template <>
13262 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPositionFetchFeaturesKHR>
13263 {
13264 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPositionFetchFeaturesKHR const & physicalDeviceRayTracingPositionFetchFeaturesKHR )
13265 const VULKAN_HPP_NOEXCEPT
13266 {
13267 std::size_t seed = 0;
13268 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPositionFetchFeaturesKHR.sType );
13269 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPositionFetchFeaturesKHR.pNext );
13270 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPositionFetchFeaturesKHR.rayTracingPositionFetch );
13271 return seed;
13272 }
13273 };
13274
13275 template <>
13276 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPropertiesNV>
13277 {
13278 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPropertiesNV const & physicalDeviceRayTracingPropertiesNV ) const VULKAN_HPP_NOEXCEPT
13279 {
13280 std::size_t seed = 0;
13281 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.sType );
13282 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.pNext );
13283 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.shaderGroupHandleSize );
13284 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.maxRecursionDepth );
13285 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.maxShaderGroupStride );
13286 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.shaderGroupBaseAlignment );
13287 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.maxGeometryCount );
13288 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.maxInstanceCount );
13289 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.maxTriangleCount );
13290 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.maxDescriptorSetAccelerationStructures );
13291 return seed;
13292 }
13293 };
13294
13295 template <>
13296 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingValidationFeaturesNV>
13297 {
13298 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingValidationFeaturesNV const & physicalDeviceRayTracingValidationFeaturesNV ) const
13299 VULKAN_HPP_NOEXCEPT
13300 {
13301 std::size_t seed = 0;
13302 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingValidationFeaturesNV.sType );
13303 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingValidationFeaturesNV.pNext );
13304 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingValidationFeaturesNV.rayTracingValidation );
13305 return seed;
13306 }
13307 };
13308
13309 template <>
13310 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRelaxedLineRasterizationFeaturesIMG>
13311 {
13312 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRelaxedLineRasterizationFeaturesIMG const & physicalDeviceRelaxedLineRasterizationFeaturesIMG )
13313 const VULKAN_HPP_NOEXCEPT
13314 {
13315 std::size_t seed = 0;
13316 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRelaxedLineRasterizationFeaturesIMG.sType );
13317 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRelaxedLineRasterizationFeaturesIMG.pNext );
13318 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRelaxedLineRasterizationFeaturesIMG.relaxedLineRasterization );
13319 return seed;
13320 }
13321 };
13322
13323 template <>
13324 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRenderPassStripedFeaturesARM>
13325 {
13326 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRenderPassStripedFeaturesARM const & physicalDeviceRenderPassStripedFeaturesARM ) const
13327 VULKAN_HPP_NOEXCEPT
13328 {
13329 std::size_t seed = 0;
13330 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRenderPassStripedFeaturesARM.sType );
13331 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRenderPassStripedFeaturesARM.pNext );
13332 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRenderPassStripedFeaturesARM.renderPassStriped );
13333 return seed;
13334 }
13335 };
13336
13337 template <>
13338 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRenderPassStripedPropertiesARM>
13339 {
13340 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRenderPassStripedPropertiesARM const & physicalDeviceRenderPassStripedPropertiesARM ) const
13341 VULKAN_HPP_NOEXCEPT
13342 {
13343 std::size_t seed = 0;
13344 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRenderPassStripedPropertiesARM.sType );
13345 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRenderPassStripedPropertiesARM.pNext );
13346 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRenderPassStripedPropertiesARM.renderPassStripeGranularity );
13347 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRenderPassStripedPropertiesARM.maxRenderPassStripes );
13348 return seed;
13349 }
13350 };
13351
13352 template <>
13353 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRepresentativeFragmentTestFeaturesNV>
13354 {
13355 std::size_t
13356 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRepresentativeFragmentTestFeaturesNV const & physicalDeviceRepresentativeFragmentTestFeaturesNV ) const
13357 VULKAN_HPP_NOEXCEPT
13358 {
13359 std::size_t seed = 0;
13360 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRepresentativeFragmentTestFeaturesNV.sType );
13361 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRepresentativeFragmentTestFeaturesNV.pNext );
13362 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRepresentativeFragmentTestFeaturesNV.representativeFragmentTest );
13363 return seed;
13364 }
13365 };
13366
13367 template <>
13368 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2FeaturesKHR>
13369 {
13370 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2FeaturesKHR const & physicalDeviceRobustness2FeaturesKHR ) const VULKAN_HPP_NOEXCEPT
13371 {
13372 std::size_t seed = 0;
13373 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2FeaturesKHR.sType );
13374 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2FeaturesKHR.pNext );
13375 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2FeaturesKHR.robustBufferAccess2 );
13376 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2FeaturesKHR.robustImageAccess2 );
13377 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2FeaturesKHR.nullDescriptor );
13378 return seed;
13379 }
13380 };
13381
13382 template <>
13383 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2PropertiesKHR>
13384 {
13385 std::size_t
13386 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2PropertiesKHR const & physicalDeviceRobustness2PropertiesKHR ) const VULKAN_HPP_NOEXCEPT
13387 {
13388 std::size_t seed = 0;
13389 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2PropertiesKHR.sType );
13390 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2PropertiesKHR.pNext );
13391 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2PropertiesKHR.robustStorageBufferAccessSizeAlignment );
13392 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2PropertiesKHR.robustUniformBufferAccessSizeAlignment );
13393 return seed;
13394 }
13395 };
13396
13397 template <>
13398 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSampleLocationsPropertiesEXT>
13399 {
13400 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSampleLocationsPropertiesEXT const & physicalDeviceSampleLocationsPropertiesEXT ) const
13401 VULKAN_HPP_NOEXCEPT
13402 {
13403 std::size_t seed = 0;
13404 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSampleLocationsPropertiesEXT.sType );
13405 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSampleLocationsPropertiesEXT.pNext );
13406 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSampleLocationsPropertiesEXT.sampleLocationSampleCounts );
13407 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSampleLocationsPropertiesEXT.maxSampleLocationGridSize );
13408 for ( size_t i = 0; i < 2; ++i )
13409 {
13410 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSampleLocationsPropertiesEXT.sampleLocationCoordinateRange[i] );
13411 }
13412 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSampleLocationsPropertiesEXT.sampleLocationSubPixelBits );
13413 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSampleLocationsPropertiesEXT.variableSampleLocations );
13414 return seed;
13415 }
13416 };
13417
13418 template <>
13419 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSamplerFilterMinmaxProperties>
13420 {
13421 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSamplerFilterMinmaxProperties const & physicalDeviceSamplerFilterMinmaxProperties ) const
13422 VULKAN_HPP_NOEXCEPT
13423 {
13424 std::size_t seed = 0;
13425 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSamplerFilterMinmaxProperties.sType );
13426 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSamplerFilterMinmaxProperties.pNext );
13427 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSamplerFilterMinmaxProperties.filterMinmaxSingleComponentFormats );
13428 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSamplerFilterMinmaxProperties.filterMinmaxImageComponentMapping );
13429 return seed;
13430 }
13431 };
13432
13433 template <>
13434 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSamplerYcbcrConversionFeatures>
13435 {
13436 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSamplerYcbcrConversionFeatures const & physicalDeviceSamplerYcbcrConversionFeatures ) const
13437 VULKAN_HPP_NOEXCEPT
13438 {
13439 std::size_t seed = 0;
13440 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSamplerYcbcrConversionFeatures.sType );
13441 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSamplerYcbcrConversionFeatures.pNext );
13442 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSamplerYcbcrConversionFeatures.samplerYcbcrConversion );
13443 return seed;
13444 }
13445 };
13446
13447 template <>
13448 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceScalarBlockLayoutFeatures>
13449 {
13450 std::size_t
13451 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceScalarBlockLayoutFeatures const & physicalDeviceScalarBlockLayoutFeatures ) const VULKAN_HPP_NOEXCEPT
13452 {
13453 std::size_t seed = 0;
13454 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceScalarBlockLayoutFeatures.sType );
13455 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceScalarBlockLayoutFeatures.pNext );
13456 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceScalarBlockLayoutFeatures.scalarBlockLayout );
13457 return seed;
13458 }
13459 };
13460
13461 template <>
13462 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSchedulingControlsFeaturesARM>
13463 {
13464 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSchedulingControlsFeaturesARM const & physicalDeviceSchedulingControlsFeaturesARM ) const
13465 VULKAN_HPP_NOEXCEPT
13466 {
13467 std::size_t seed = 0;
13468 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSchedulingControlsFeaturesARM.sType );
13469 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSchedulingControlsFeaturesARM.pNext );
13470 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSchedulingControlsFeaturesARM.schedulingControls );
13471 return seed;
13472 }
13473 };
13474
13475 template <>
13476 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSchedulingControlsPropertiesARM>
13477 {
13478 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSchedulingControlsPropertiesARM const & physicalDeviceSchedulingControlsPropertiesARM ) const
13479 VULKAN_HPP_NOEXCEPT
13480 {
13481 std::size_t seed = 0;
13482 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSchedulingControlsPropertiesARM.sType );
13483 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSchedulingControlsPropertiesARM.pNext );
13484 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSchedulingControlsPropertiesARM.schedulingControlsFlags );
13485 return seed;
13486 }
13487 };
13488
13489 template <>
13490 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSeparateDepthStencilLayoutsFeatures>
13491 {
13492 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSeparateDepthStencilLayoutsFeatures const & physicalDeviceSeparateDepthStencilLayoutsFeatures )
13493 const VULKAN_HPP_NOEXCEPT
13494 {
13495 std::size_t seed = 0;
13496 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSeparateDepthStencilLayoutsFeatures.sType );
13497 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSeparateDepthStencilLayoutsFeatures.pNext );
13498 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSeparateDepthStencilLayoutsFeatures.separateDepthStencilLayouts );
13499 return seed;
13500 }
13501 };
13502
13503 template <>
13504 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShader64BitIndexingFeaturesEXT>
13505 {
13506 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShader64BitIndexingFeaturesEXT const & physicalDeviceShader64BitIndexingFeaturesEXT ) const
13507 VULKAN_HPP_NOEXCEPT
13508 {
13509 std::size_t seed = 0;
13510 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShader64BitIndexingFeaturesEXT.sType );
13511 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShader64BitIndexingFeaturesEXT.pNext );
13512 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShader64BitIndexingFeaturesEXT.shader64BitIndexing );
13513 return seed;
13514 }
13515 };
13516
13517 template <>
13518 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV>
13519 {
13520 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV const & physicalDeviceShaderAtomicFloat16VectorFeaturesNV )
13521 const VULKAN_HPP_NOEXCEPT
13522 {
13523 std::size_t seed = 0;
13524 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat16VectorFeaturesNV.sType );
13525 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat16VectorFeaturesNV.pNext );
13526 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat16VectorFeaturesNV.shaderFloat16VectorAtomics );
13527 return seed;
13528 }
13529 };
13530
13531 template <>
13532 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloat2FeaturesEXT>
13533 {
13534 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloat2FeaturesEXT const & physicalDeviceShaderAtomicFloat2FeaturesEXT ) const
13535 VULKAN_HPP_NOEXCEPT
13536 {
13537 std::size_t seed = 0;
13538 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.sType );
13539 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.pNext );
13540 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderBufferFloat16Atomics );
13541 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderBufferFloat16AtomicAdd );
13542 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderBufferFloat16AtomicMinMax );
13543 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderBufferFloat32AtomicMinMax );
13544 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderBufferFloat64AtomicMinMax );
13545 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderSharedFloat16Atomics );
13546 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderSharedFloat16AtomicAdd );
13547 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderSharedFloat16AtomicMinMax );
13548 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderSharedFloat32AtomicMinMax );
13549 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderSharedFloat64AtomicMinMax );
13550 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderImageFloat32AtomicMinMax );
13551 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.sparseImageFloat32AtomicMinMax );
13552 return seed;
13553 }
13554 };
13555
13556 template <>
13557 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloatFeaturesEXT>
13558 {
13559 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloatFeaturesEXT const & physicalDeviceShaderAtomicFloatFeaturesEXT ) const
13560 VULKAN_HPP_NOEXCEPT
13561 {
13562 std::size_t seed = 0;
13563 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.sType );
13564 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.pNext );
13565 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderBufferFloat32Atomics );
13566 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderBufferFloat32AtomicAdd );
13567 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderBufferFloat64Atomics );
13568 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderBufferFloat64AtomicAdd );
13569 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderSharedFloat32Atomics );
13570 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderSharedFloat32AtomicAdd );
13571 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderSharedFloat64Atomics );
13572 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderSharedFloat64AtomicAdd );
13573 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderImageFloat32Atomics );
13574 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderImageFloat32AtomicAdd );
13575 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.sparseImageFloat32Atomics );
13576 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.sparseImageFloat32AtomicAdd );
13577 return seed;
13578 }
13579 };
13580
13581 template <>
13582 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicInt64Features>
13583 {
13584 std::size_t
13585 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicInt64Features const & physicalDeviceShaderAtomicInt64Features ) const VULKAN_HPP_NOEXCEPT
13586 {
13587 std::size_t seed = 0;
13588 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicInt64Features.sType );
13589 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicInt64Features.pNext );
13590 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicInt64Features.shaderBufferInt64Atomics );
13591 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicInt64Features.shaderSharedInt64Atomics );
13592 return seed;
13593 }
13594 };
13595
13596 template <>
13597 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderBfloat16FeaturesKHR>
13598 {
13599 std::size_t
13600 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderBfloat16FeaturesKHR const & physicalDeviceShaderBfloat16FeaturesKHR ) const VULKAN_HPP_NOEXCEPT
13601 {
13602 std::size_t seed = 0;
13603 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderBfloat16FeaturesKHR.sType );
13604 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderBfloat16FeaturesKHR.pNext );
13605 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderBfloat16FeaturesKHR.shaderBFloat16Type );
13606 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderBfloat16FeaturesKHR.shaderBFloat16DotProduct );
13607 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderBfloat16FeaturesKHR.shaderBFloat16CooperativeMatrix );
13608 return seed;
13609 }
13610 };
13611
13612 template <>
13613 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderClockFeaturesKHR>
13614 {
13615 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderClockFeaturesKHR const & physicalDeviceShaderClockFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
13616 {
13617 std::size_t seed = 0;
13618 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderClockFeaturesKHR.sType );
13619 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderClockFeaturesKHR.pNext );
13620 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderClockFeaturesKHR.shaderSubgroupClock );
13621 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderClockFeaturesKHR.shaderDeviceClock );
13622 return seed;
13623 }
13624 };
13625
13626 template <>
13627 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCoreBuiltinsFeaturesARM>
13628 {
13629 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCoreBuiltinsFeaturesARM const & physicalDeviceShaderCoreBuiltinsFeaturesARM ) const
13630 VULKAN_HPP_NOEXCEPT
13631 {
13632 std::size_t seed = 0;
13633 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreBuiltinsFeaturesARM.sType );
13634 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreBuiltinsFeaturesARM.pNext );
13635 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreBuiltinsFeaturesARM.shaderCoreBuiltins );
13636 return seed;
13637 }
13638 };
13639
13640 template <>
13641 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCoreBuiltinsPropertiesARM>
13642 {
13643 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCoreBuiltinsPropertiesARM const & physicalDeviceShaderCoreBuiltinsPropertiesARM ) const
13644 VULKAN_HPP_NOEXCEPT
13645 {
13646 std::size_t seed = 0;
13647 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreBuiltinsPropertiesARM.sType );
13648 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreBuiltinsPropertiesARM.pNext );
13649 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreBuiltinsPropertiesARM.shaderCoreMask );
13650 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreBuiltinsPropertiesARM.shaderCoreCount );
13651 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreBuiltinsPropertiesARM.shaderWarpsPerCore );
13652 return seed;
13653 }
13654 };
13655
13656 template <>
13657 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCoreProperties2AMD>
13658 {
13659 std::size_t
13660 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCoreProperties2AMD const & physicalDeviceShaderCoreProperties2AMD ) const VULKAN_HPP_NOEXCEPT
13661 {
13662 std::size_t seed = 0;
13663 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreProperties2AMD.sType );
13664 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreProperties2AMD.pNext );
13665 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreProperties2AMD.shaderCoreFeatures );
13666 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreProperties2AMD.activeComputeUnitCount );
13667 return seed;
13668 }
13669 };
13670
13671 template <>
13672 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCorePropertiesAMD>
13673 {
13674 std::size_t
13675 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCorePropertiesAMD const & physicalDeviceShaderCorePropertiesAMD ) const VULKAN_HPP_NOEXCEPT
13676 {
13677 std::size_t seed = 0;
13678 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.sType );
13679 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.pNext );
13680 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.shaderEngineCount );
13681 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.shaderArraysPerEngineCount );
13682 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.computeUnitsPerShaderArray );
13683 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.simdPerComputeUnit );
13684 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.wavefrontsPerSimd );
13685 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.wavefrontSize );
13686 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.sgprsPerSimd );
13687 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.minSgprAllocation );
13688 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.maxSgprAllocation );
13689 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.sgprAllocationGranularity );
13690 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.vgprsPerSimd );
13691 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.minVgprAllocation );
13692 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.maxVgprAllocation );
13693 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.vgprAllocationGranularity );
13694 return seed;
13695 }
13696 };
13697
13698 template <>
13699 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCorePropertiesARM>
13700 {
13701 std::size_t
13702 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCorePropertiesARM const & physicalDeviceShaderCorePropertiesARM ) const VULKAN_HPP_NOEXCEPT
13703 {
13704 std::size_t seed = 0;
13705 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesARM.sType );
13706 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesARM.pNext );
13707 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesARM.pixelRate );
13708 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesARM.texelRate );
13709 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesARM.fmaRate );
13710 return seed;
13711 }
13712 };
13713
13714 template <>
13715 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderDemoteToHelperInvocationFeatures>
13716 {
13717 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderDemoteToHelperInvocationFeatures const &
13718 physicalDeviceShaderDemoteToHelperInvocationFeatures ) const VULKAN_HPP_NOEXCEPT
13719 {
13720 std::size_t seed = 0;
13721 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderDemoteToHelperInvocationFeatures.sType );
13722 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderDemoteToHelperInvocationFeatures.pNext );
13723 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderDemoteToHelperInvocationFeatures.shaderDemoteToHelperInvocation );
13724 return seed;
13725 }
13726 };
13727
13728 template <>
13729 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderDrawParametersFeatures>
13730 {
13731 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderDrawParametersFeatures const & physicalDeviceShaderDrawParametersFeatures ) const
13732 VULKAN_HPP_NOEXCEPT
13733 {
13734 std::size_t seed = 0;
13735 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderDrawParametersFeatures.sType );
13736 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderDrawParametersFeatures.pNext );
13737 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderDrawParametersFeatures.shaderDrawParameters );
13738 return seed;
13739 }
13740 };
13741
13742 template <>
13743 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD>
13744 {
13745 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD const &
13746 physicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD ) const VULKAN_HPP_NOEXCEPT
13747 {
13748 std::size_t seed = 0;
13749 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD.sType );
13750 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD.pNext );
13751 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD.shaderEarlyAndLateFragmentTests );
13752 return seed;
13753 }
13754 };
13755
13756 # if defined( VK_ENABLE_BETA_EXTENSIONS )
13757 template <>
13758 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderEnqueueFeaturesAMDX>
13759 {
13760 std::size_t
13761 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderEnqueueFeaturesAMDX const & physicalDeviceShaderEnqueueFeaturesAMDX ) const VULKAN_HPP_NOEXCEPT
13762 {
13763 std::size_t seed = 0;
13764 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueueFeaturesAMDX.sType );
13765 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueueFeaturesAMDX.pNext );
13766 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueueFeaturesAMDX.shaderEnqueue );
13767 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueueFeaturesAMDX.shaderMeshEnqueue );
13768 return seed;
13769 }
13770 };
13771 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
13772
13773 # if defined( VK_ENABLE_BETA_EXTENSIONS )
13774 template <>
13775 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderEnqueuePropertiesAMDX>
13776 {
13777 std::size_t
13778 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderEnqueuePropertiesAMDX const & physicalDeviceShaderEnqueuePropertiesAMDX ) const VULKAN_HPP_NOEXCEPT
13779 {
13780 std::size_t seed = 0;
13781 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueuePropertiesAMDX.sType );
13782 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueuePropertiesAMDX.pNext );
13783 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueuePropertiesAMDX.maxExecutionGraphDepth );
13784 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueuePropertiesAMDX.maxExecutionGraphShaderOutputNodes );
13785 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueuePropertiesAMDX.maxExecutionGraphShaderPayloadSize );
13786 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueuePropertiesAMDX.maxExecutionGraphShaderPayloadCount );
13787 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueuePropertiesAMDX.executionGraphDispatchAddressAlignment );
13788 for ( size_t i = 0; i < 3; ++i )
13789 {
13790 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueuePropertiesAMDX.maxExecutionGraphWorkgroupCount[i] );
13791 }
13792 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueuePropertiesAMDX.maxExecutionGraphWorkgroups );
13793 return seed;
13794 }
13795 };
13796 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
13797
13798 template <>
13799 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderExpectAssumeFeatures>
13800 {
13801 std::size_t
13802 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderExpectAssumeFeatures const & physicalDeviceShaderExpectAssumeFeatures ) const VULKAN_HPP_NOEXCEPT
13803 {
13804 std::size_t seed = 0;
13805 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderExpectAssumeFeatures.sType );
13806 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderExpectAssumeFeatures.pNext );
13807 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderExpectAssumeFeatures.shaderExpectAssume );
13808 return seed;
13809 }
13810 };
13811
13812 template <>
13813 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFloat16Int8Features>
13814 {
13815 std::size_t
13816 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFloat16Int8Features const & physicalDeviceShaderFloat16Int8Features ) const VULKAN_HPP_NOEXCEPT
13817 {
13818 std::size_t seed = 0;
13819 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFloat16Int8Features.sType );
13820 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFloat16Int8Features.pNext );
13821 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFloat16Int8Features.shaderFloat16 );
13822 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFloat16Int8Features.shaderInt8 );
13823 return seed;
13824 }
13825 };
13826
13827 template <>
13828 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFloat8FeaturesEXT>
13829 {
13830 std::size_t
13831 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFloat8FeaturesEXT const & physicalDeviceShaderFloat8FeaturesEXT ) const VULKAN_HPP_NOEXCEPT
13832 {
13833 std::size_t seed = 0;
13834 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFloat8FeaturesEXT.sType );
13835 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFloat8FeaturesEXT.pNext );
13836 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFloat8FeaturesEXT.shaderFloat8 );
13837 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFloat8FeaturesEXT.shaderFloat8CooperativeMatrix );
13838 return seed;
13839 }
13840 };
13841
13842 template <>
13843 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFloatControls2Features>
13844 {
13845 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFloatControls2Features const & physicalDeviceShaderFloatControls2Features ) const
13846 VULKAN_HPP_NOEXCEPT
13847 {
13848 std::size_t seed = 0;
13849 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFloatControls2Features.sType );
13850 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFloatControls2Features.pNext );
13851 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFloatControls2Features.shaderFloatControls2 );
13852 return seed;
13853 }
13854 };
13855
13856 template <>
13857 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFmaFeaturesKHR>
13858 {
13859 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFmaFeaturesKHR const & physicalDeviceShaderFmaFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
13860 {
13861 std::size_t seed = 0;
13862 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFmaFeaturesKHR.sType );
13863 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFmaFeaturesKHR.pNext );
13864 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFmaFeaturesKHR.shaderFmaFloat16 );
13865 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFmaFeaturesKHR.shaderFmaFloat32 );
13866 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFmaFeaturesKHR.shaderFmaFloat64 );
13867 return seed;
13868 }
13869 };
13870
13871 template <>
13872 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderImageAtomicInt64FeaturesEXT>
13873 {
13874 std::size_t operator()(
13875 VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderImageAtomicInt64FeaturesEXT const & physicalDeviceShaderImageAtomicInt64FeaturesEXT ) const VULKAN_HPP_NOEXCEPT
13876 {
13877 std::size_t seed = 0;
13878 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderImageAtomicInt64FeaturesEXT.sType );
13879 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderImageAtomicInt64FeaturesEXT.pNext );
13880 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderImageAtomicInt64FeaturesEXT.shaderImageInt64Atomics );
13881 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderImageAtomicInt64FeaturesEXT.sparseImageInt64Atomics );
13882 return seed;
13883 }
13884 };
13885
13886 template <>
13887 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderImageFootprintFeaturesNV>
13888 {
13889 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderImageFootprintFeaturesNV const & physicalDeviceShaderImageFootprintFeaturesNV ) const
13890 VULKAN_HPP_NOEXCEPT
13891 {
13892 std::size_t seed = 0;
13893 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderImageFootprintFeaturesNV.sType );
13894 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderImageFootprintFeaturesNV.pNext );
13895 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderImageFootprintFeaturesNV.imageFootprint );
13896 return seed;
13897 }
13898 };
13899
13900 template <>
13901 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerDotProductFeatures>
13902 {
13903 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerDotProductFeatures const & physicalDeviceShaderIntegerDotProductFeatures ) const
13904 VULKAN_HPP_NOEXCEPT
13905 {
13906 std::size_t seed = 0;
13907 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductFeatures.sType );
13908 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductFeatures.pNext );
13909 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductFeatures.shaderIntegerDotProduct );
13910 return seed;
13911 }
13912 };
13913
13914 template <>
13915 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerDotProductProperties>
13916 {
13917 std::size_t operator()(
13918 VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerDotProductProperties const & physicalDeviceShaderIntegerDotProductProperties ) const VULKAN_HPP_NOEXCEPT
13919 {
13920 std::size_t seed = 0;
13921 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.sType );
13922 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.pNext );
13923 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct8BitUnsignedAccelerated );
13924 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct8BitSignedAccelerated );
13925 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct8BitMixedSignednessAccelerated );
13926 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct4x8BitPackedUnsignedAccelerated );
13927 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct4x8BitPackedSignedAccelerated );
13928 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct4x8BitPackedMixedSignednessAccelerated );
13929 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct16BitUnsignedAccelerated );
13930 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct16BitSignedAccelerated );
13931 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct16BitMixedSignednessAccelerated );
13932 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct32BitUnsignedAccelerated );
13933 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct32BitSignedAccelerated );
13934 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct32BitMixedSignednessAccelerated );
13935 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct64BitUnsignedAccelerated );
13936 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct64BitSignedAccelerated );
13937 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct64BitMixedSignednessAccelerated );
13938 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating8BitUnsignedAccelerated );
13939 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating8BitSignedAccelerated );
13940 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated );
13941 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated );
13942 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated );
13943 VULKAN_HPP_HASH_COMBINE( seed,
13944 physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated );
13945 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating16BitUnsignedAccelerated );
13946 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating16BitSignedAccelerated );
13947 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated );
13948 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating32BitUnsignedAccelerated );
13949 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating32BitSignedAccelerated );
13950 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated );
13951 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating64BitUnsignedAccelerated );
13952 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating64BitSignedAccelerated );
13953 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated );
13954 return seed;
13955 }
13956 };
13957
13958 template <>
13959 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL>
13960 {
13961 std::size_t
13962 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const & physicalDeviceShaderIntegerFunctions2FeaturesINTEL ) const
13963 VULKAN_HPP_NOEXCEPT
13964 {
13965 std::size_t seed = 0;
13966 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerFunctions2FeaturesINTEL.sType );
13967 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerFunctions2FeaturesINTEL.pNext );
13968 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerFunctions2FeaturesINTEL.shaderIntegerFunctions2 );
13969 return seed;
13970 }
13971 };
13972
13973 template <>
13974 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR>
13975 {
13976 std::size_t
13977 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR const & physicalDeviceShaderMaximalReconvergenceFeaturesKHR ) const
13978 VULKAN_HPP_NOEXCEPT
13979 {
13980 std::size_t seed = 0;
13981 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderMaximalReconvergenceFeaturesKHR.sType );
13982 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderMaximalReconvergenceFeaturesKHR.pNext );
13983 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderMaximalReconvergenceFeaturesKHR.shaderMaximalReconvergence );
13984 return seed;
13985 }
13986 };
13987
13988 template <>
13989 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderModuleIdentifierFeaturesEXT>
13990 {
13991 std::size_t operator()(
13992 VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderModuleIdentifierFeaturesEXT const & physicalDeviceShaderModuleIdentifierFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
13993 {
13994 std::size_t seed = 0;
13995 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderModuleIdentifierFeaturesEXT.sType );
13996 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderModuleIdentifierFeaturesEXT.pNext );
13997 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderModuleIdentifierFeaturesEXT.shaderModuleIdentifier );
13998 return seed;
13999 }
14000 };
14001
14002 template <>
14003 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderModuleIdentifierPropertiesEXT>
14004 {
14005 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderModuleIdentifierPropertiesEXT const & physicalDeviceShaderModuleIdentifierPropertiesEXT )
14006 const VULKAN_HPP_NOEXCEPT
14007 {
14008 std::size_t seed = 0;
14009 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderModuleIdentifierPropertiesEXT.sType );
14010 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderModuleIdentifierPropertiesEXT.pNext );
14011 for ( size_t i = 0; i < VK_UUID_SIZE; ++i )
14012 {
14013 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderModuleIdentifierPropertiesEXT.shaderModuleIdentifierAlgorithmUUID[i] );
14014 }
14015 return seed;
14016 }
14017 };
14018
14019 template <>
14020 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderObjectFeaturesEXT>
14021 {
14022 std::size_t
14023 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderObjectFeaturesEXT const & physicalDeviceShaderObjectFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
14024 {
14025 std::size_t seed = 0;
14026 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderObjectFeaturesEXT.sType );
14027 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderObjectFeaturesEXT.pNext );
14028 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderObjectFeaturesEXT.shaderObject );
14029 return seed;
14030 }
14031 };
14032
14033 template <>
14034 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderObjectPropertiesEXT>
14035 {
14036 std::size_t
14037 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderObjectPropertiesEXT const & physicalDeviceShaderObjectPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
14038 {
14039 std::size_t seed = 0;
14040 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderObjectPropertiesEXT.sType );
14041 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderObjectPropertiesEXT.pNext );
14042 for ( size_t i = 0; i < VK_UUID_SIZE; ++i )
14043 {
14044 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderObjectPropertiesEXT.shaderBinaryUUID[i] );
14045 }
14046 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderObjectPropertiesEXT.shaderBinaryVersion );
14047 return seed;
14048 }
14049 };
14050
14051 template <>
14052 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderQuadControlFeaturesKHR>
14053 {
14054 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderQuadControlFeaturesKHR const & physicalDeviceShaderQuadControlFeaturesKHR ) const
14055 VULKAN_HPP_NOEXCEPT
14056 {
14057 std::size_t seed = 0;
14058 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderQuadControlFeaturesKHR.sType );
14059 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderQuadControlFeaturesKHR.pNext );
14060 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderQuadControlFeaturesKHR.shaderQuadControl );
14061 return seed;
14062 }
14063 };
14064
14065 template <>
14066 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR>
14067 {
14068 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR const &
14069 physicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
14070 {
14071 std::size_t seed = 0;
14072 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR.sType );
14073 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR.pNext );
14074 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR.shaderRelaxedExtendedInstruction );
14075 return seed;
14076 }
14077 };
14078
14079 template <>
14080 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderReplicatedCompositesFeaturesEXT>
14081 {
14082 std::size_t
14083 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderReplicatedCompositesFeaturesEXT const & physicalDeviceShaderReplicatedCompositesFeaturesEXT ) const
14084 VULKAN_HPP_NOEXCEPT
14085 {
14086 std::size_t seed = 0;
14087 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderReplicatedCompositesFeaturesEXT.sType );
14088 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderReplicatedCompositesFeaturesEXT.pNext );
14089 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderReplicatedCompositesFeaturesEXT.shaderReplicatedComposites );
14090 return seed;
14091 }
14092 };
14093
14094 template <>
14095 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSMBuiltinsFeaturesNV>
14096 {
14097 std::size_t
14098 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSMBuiltinsFeaturesNV const & physicalDeviceShaderSMBuiltinsFeaturesNV ) const VULKAN_HPP_NOEXCEPT
14099 {
14100 std::size_t seed = 0;
14101 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSMBuiltinsFeaturesNV.sType );
14102 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSMBuiltinsFeaturesNV.pNext );
14103 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSMBuiltinsFeaturesNV.shaderSMBuiltins );
14104 return seed;
14105 }
14106 };
14107
14108 template <>
14109 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSMBuiltinsPropertiesNV>
14110 {
14111 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSMBuiltinsPropertiesNV const & physicalDeviceShaderSMBuiltinsPropertiesNV ) const
14112 VULKAN_HPP_NOEXCEPT
14113 {
14114 std::size_t seed = 0;
14115 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSMBuiltinsPropertiesNV.sType );
14116 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSMBuiltinsPropertiesNV.pNext );
14117 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSMBuiltinsPropertiesNV.shaderSMCount );
14118 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSMBuiltinsPropertiesNV.shaderWarpsPerSM );
14119 return seed;
14120 }
14121 };
14122
14123 template <>
14124 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupExtendedTypesFeatures>
14125 {
14126 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupExtendedTypesFeatures const & physicalDeviceShaderSubgroupExtendedTypesFeatures )
14127 const VULKAN_HPP_NOEXCEPT
14128 {
14129 std::size_t seed = 0;
14130 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupExtendedTypesFeatures.sType );
14131 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupExtendedTypesFeatures.pNext );
14132 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupExtendedTypesFeatures.shaderSubgroupExtendedTypes );
14133 return seed;
14134 }
14135 };
14136
14137 template <>
14138 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupRotateFeatures>
14139 {
14140 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupRotateFeatures const & physicalDeviceShaderSubgroupRotateFeatures ) const
14141 VULKAN_HPP_NOEXCEPT
14142 {
14143 std::size_t seed = 0;
14144 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupRotateFeatures.sType );
14145 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupRotateFeatures.pNext );
14146 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupRotateFeatures.shaderSubgroupRotate );
14147 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupRotateFeatures.shaderSubgroupRotateClustered );
14148 return seed;
14149 }
14150 };
14151
14152 template <>
14153 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR>
14154 {
14155 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR const &
14156 physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
14157 {
14158 std::size_t seed = 0;
14159 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR.sType );
14160 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR.pNext );
14161 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR.shaderSubgroupUniformControlFlow );
14162 return seed;
14163 }
14164 };
14165
14166 template <>
14167 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderTerminateInvocationFeatures>
14168 {
14169 std::size_t operator()(
14170 VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderTerminateInvocationFeatures const & physicalDeviceShaderTerminateInvocationFeatures ) const VULKAN_HPP_NOEXCEPT
14171 {
14172 std::size_t seed = 0;
14173 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTerminateInvocationFeatures.sType );
14174 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTerminateInvocationFeatures.pNext );
14175 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTerminateInvocationFeatures.shaderTerminateInvocation );
14176 return seed;
14177 }
14178 };
14179
14180 template <>
14181 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderTileImageFeaturesEXT>
14182 {
14183 std::size_t
14184 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderTileImageFeaturesEXT const & physicalDeviceShaderTileImageFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
14185 {
14186 std::size_t seed = 0;
14187 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImageFeaturesEXT.sType );
14188 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImageFeaturesEXT.pNext );
14189 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImageFeaturesEXT.shaderTileImageColorReadAccess );
14190 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImageFeaturesEXT.shaderTileImageDepthReadAccess );
14191 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImageFeaturesEXT.shaderTileImageStencilReadAccess );
14192 return seed;
14193 }
14194 };
14195
14196 template <>
14197 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderTileImagePropertiesEXT>
14198 {
14199 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderTileImagePropertiesEXT const & physicalDeviceShaderTileImagePropertiesEXT ) const
14200 VULKAN_HPP_NOEXCEPT
14201 {
14202 std::size_t seed = 0;
14203 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImagePropertiesEXT.sType );
14204 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImagePropertiesEXT.pNext );
14205 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImagePropertiesEXT.shaderTileImageCoherentReadAccelerated );
14206 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImagePropertiesEXT.shaderTileImageReadSampleFromPixelRateInvocation );
14207 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImagePropertiesEXT.shaderTileImageReadFromHelperInvocation );
14208 return seed;
14209 }
14210 };
14211
14212 template <>
14213 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT>
14214 {
14215 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT const &
14216 physicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
14217 {
14218 std::size_t seed = 0;
14219 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT.sType );
14220 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT.pNext );
14221 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT.shaderUniformBufferUnsizedArray );
14222 return seed;
14223 }
14224 };
14225
14226 template <>
14227 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderUntypedPointersFeaturesKHR>
14228 {
14229 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderUntypedPointersFeaturesKHR const & physicalDeviceShaderUntypedPointersFeaturesKHR ) const
14230 VULKAN_HPP_NOEXCEPT
14231 {
14232 std::size_t seed = 0;
14233 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderUntypedPointersFeaturesKHR.sType );
14234 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderUntypedPointersFeaturesKHR.pNext );
14235 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderUntypedPointersFeaturesKHR.shaderUntypedPointers );
14236 return seed;
14237 }
14238 };
14239
14240 template <>
14241 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShadingRateImageFeaturesNV>
14242 {
14243 std::size_t
14244 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShadingRateImageFeaturesNV const & physicalDeviceShadingRateImageFeaturesNV ) const VULKAN_HPP_NOEXCEPT
14245 {
14246 std::size_t seed = 0;
14247 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShadingRateImageFeaturesNV.sType );
14248 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShadingRateImageFeaturesNV.pNext );
14249 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShadingRateImageFeaturesNV.shadingRateImage );
14250 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShadingRateImageFeaturesNV.shadingRateCoarseSampleOrder );
14251 return seed;
14252 }
14253 };
14254
14255 template <>
14256 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShadingRateImagePropertiesNV>
14257 {
14258 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShadingRateImagePropertiesNV const & physicalDeviceShadingRateImagePropertiesNV ) const
14259 VULKAN_HPP_NOEXCEPT
14260 {
14261 std::size_t seed = 0;
14262 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShadingRateImagePropertiesNV.sType );
14263 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShadingRateImagePropertiesNV.pNext );
14264 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShadingRateImagePropertiesNV.shadingRateTexelSize );
14265 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShadingRateImagePropertiesNV.shadingRatePaletteSize );
14266 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShadingRateImagePropertiesNV.shadingRateMaxCoarseSamples );
14267 return seed;
14268 }
14269 };
14270
14271 template <>
14272 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2>
14273 {
14274 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 const & physicalDeviceSparseImageFormatInfo2 ) const VULKAN_HPP_NOEXCEPT
14275 {
14276 std::size_t seed = 0;
14277 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseImageFormatInfo2.sType );
14278 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseImageFormatInfo2.pNext );
14279 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseImageFormatInfo2.format );
14280 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseImageFormatInfo2.type );
14281 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseImageFormatInfo2.samples );
14282 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseImageFormatInfo2.usage );
14283 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseImageFormatInfo2.tiling );
14284 return seed;
14285 }
14286 };
14287
14288 template <>
14289 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupProperties>
14290 {
14291 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupProperties const & physicalDeviceSubgroupProperties ) const VULKAN_HPP_NOEXCEPT
14292 {
14293 std::size_t seed = 0;
14294 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupProperties.sType );
14295 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupProperties.pNext );
14296 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupProperties.subgroupSize );
14297 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupProperties.supportedStages );
14298 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupProperties.supportedOperations );
14299 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupProperties.quadOperationsInAllStages );
14300 return seed;
14301 }
14302 };
14303
14304 template <>
14305 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupSizeControlFeatures>
14306 {
14307 std::size_t
14308 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupSizeControlFeatures const & physicalDeviceSubgroupSizeControlFeatures ) const VULKAN_HPP_NOEXCEPT
14309 {
14310 std::size_t seed = 0;
14311 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlFeatures.sType );
14312 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlFeatures.pNext );
14313 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlFeatures.subgroupSizeControl );
14314 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlFeatures.computeFullSubgroups );
14315 return seed;
14316 }
14317 };
14318
14319 template <>
14320 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupSizeControlProperties>
14321 {
14322 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupSizeControlProperties const & physicalDeviceSubgroupSizeControlProperties ) const
14323 VULKAN_HPP_NOEXCEPT
14324 {
14325 std::size_t seed = 0;
14326 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlProperties.sType );
14327 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlProperties.pNext );
14328 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlProperties.minSubgroupSize );
14329 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlProperties.maxSubgroupSize );
14330 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlProperties.maxComputeWorkgroupSubgroups );
14331 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlProperties.requiredSubgroupSizeStages );
14332 return seed;
14333 }
14334 };
14335
14336 template <>
14337 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassMergeFeedbackFeaturesEXT>
14338 {
14339 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassMergeFeedbackFeaturesEXT const & physicalDeviceSubpassMergeFeedbackFeaturesEXT ) const
14340 VULKAN_HPP_NOEXCEPT
14341 {
14342 std::size_t seed = 0;
14343 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubpassMergeFeedbackFeaturesEXT.sType );
14344 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubpassMergeFeedbackFeaturesEXT.pNext );
14345 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubpassMergeFeedbackFeaturesEXT.subpassMergeFeedback );
14346 return seed;
14347 }
14348 };
14349
14350 template <>
14351 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassShadingFeaturesHUAWEI>
14352 {
14353 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassShadingFeaturesHUAWEI const & physicalDeviceSubpassShadingFeaturesHUAWEI ) const
14354 VULKAN_HPP_NOEXCEPT
14355 {
14356 std::size_t seed = 0;
14357 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubpassShadingFeaturesHUAWEI.sType );
14358 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubpassShadingFeaturesHUAWEI.pNext );
14359 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubpassShadingFeaturesHUAWEI.subpassShading );
14360 return seed;
14361 }
14362 };
14363
14364 template <>
14365 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassShadingPropertiesHUAWEI>
14366 {
14367 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassShadingPropertiesHUAWEI const & physicalDeviceSubpassShadingPropertiesHUAWEI ) const
14368 VULKAN_HPP_NOEXCEPT
14369 {
14370 std::size_t seed = 0;
14371 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubpassShadingPropertiesHUAWEI.sType );
14372 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubpassShadingPropertiesHUAWEI.pNext );
14373 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubpassShadingPropertiesHUAWEI.maxSubpassShadingWorkgroupSizeAspectRatio );
14374 return seed;
14375 }
14376 };
14377
14378 template <>
14379 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR>
14380 {
14381 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR const & physicalDeviceSurfaceInfo2KHR ) const VULKAN_HPP_NOEXCEPT
14382 {
14383 std::size_t seed = 0;
14384 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSurfaceInfo2KHR.sType );
14385 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSurfaceInfo2KHR.pNext );
14386 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSurfaceInfo2KHR.surface );
14387 return seed;
14388 }
14389 };
14390
14391 template <>
14392 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSwapchainMaintenance1FeaturesKHR>
14393 {
14394 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSwapchainMaintenance1FeaturesKHR const & physicalDeviceSwapchainMaintenance1FeaturesKHR ) const
14395 VULKAN_HPP_NOEXCEPT
14396 {
14397 std::size_t seed = 0;
14398 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSwapchainMaintenance1FeaturesKHR.sType );
14399 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSwapchainMaintenance1FeaturesKHR.pNext );
14400 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSwapchainMaintenance1FeaturesKHR.swapchainMaintenance1 );
14401 return seed;
14402 }
14403 };
14404
14405 template <>
14406 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSynchronization2Features>
14407 {
14408 std::size_t
14409 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSynchronization2Features const & physicalDeviceSynchronization2Features ) const VULKAN_HPP_NOEXCEPT
14410 {
14411 std::size_t seed = 0;
14412 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSynchronization2Features.sType );
14413 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSynchronization2Features.pNext );
14414 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSynchronization2Features.synchronization2 );
14415 return seed;
14416 }
14417 };
14418
14419 template <>
14420 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTensorFeaturesARM>
14421 {
14422 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTensorFeaturesARM const & physicalDeviceTensorFeaturesARM ) const VULKAN_HPP_NOEXCEPT
14423 {
14424 std::size_t seed = 0;
14425 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTensorFeaturesARM.sType );
14426 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTensorFeaturesARM.pNext );
14427 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTensorFeaturesARM.tensorNonPacked );
14428 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTensorFeaturesARM.shaderTensorAccess );
14429 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTensorFeaturesARM.shaderStorageTensorArrayDynamicIndexing );
14430 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTensorFeaturesARM.shaderStorageTensorArrayNonUniformIndexing );
14431 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTensorFeaturesARM.descriptorBindingStorageTensorUpdateAfterBind );
14432 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTensorFeaturesARM.tensors );
14433 return seed;
14434 }
14435 };
14436
14437 template <>
14438 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTensorPropertiesARM>
14439 {
14440 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTensorPropertiesARM const & physicalDeviceTensorPropertiesARM ) const VULKAN_HPP_NOEXCEPT
14441 {
14442 std::size_t seed = 0;
14443 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTensorPropertiesARM.sType );
14444 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTensorPropertiesARM.pNext );
14445 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTensorPropertiesARM.maxTensorDimensionCount );
14446 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTensorPropertiesARM.maxTensorElements );
14447 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTensorPropertiesARM.maxPerDimensionTensorElements );
14448 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTensorPropertiesARM.maxTensorStride );
14449 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTensorPropertiesARM.maxTensorSize );
14450 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTensorPropertiesARM.maxTensorShaderAccessArrayLength );
14451 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTensorPropertiesARM.maxTensorShaderAccessSize );
14452 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTensorPropertiesARM.maxDescriptorSetStorageTensors );
14453 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTensorPropertiesARM.maxPerStageDescriptorSetStorageTensors );
14454 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTensorPropertiesARM.maxDescriptorSetUpdateAfterBindStorageTensors );
14455 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTensorPropertiesARM.maxPerStageDescriptorUpdateAfterBindStorageTensors );
14456 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTensorPropertiesARM.shaderStorageTensorArrayNonUniformIndexingNative );
14457 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTensorPropertiesARM.shaderTensorSupportedStages );
14458 return seed;
14459 }
14460 };
14461
14462 template <>
14463 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTexelBufferAlignmentFeaturesEXT>
14464 {
14465 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTexelBufferAlignmentFeaturesEXT const & physicalDeviceTexelBufferAlignmentFeaturesEXT ) const
14466 VULKAN_HPP_NOEXCEPT
14467 {
14468 std::size_t seed = 0;
14469 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTexelBufferAlignmentFeaturesEXT.sType );
14470 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTexelBufferAlignmentFeaturesEXT.pNext );
14471 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTexelBufferAlignmentFeaturesEXT.texelBufferAlignment );
14472 return seed;
14473 }
14474 };
14475
14476 template <>
14477 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTexelBufferAlignmentProperties>
14478 {
14479 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTexelBufferAlignmentProperties const & physicalDeviceTexelBufferAlignmentProperties ) const
14480 VULKAN_HPP_NOEXCEPT
14481 {
14482 std::size_t seed = 0;
14483 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTexelBufferAlignmentProperties.sType );
14484 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTexelBufferAlignmentProperties.pNext );
14485 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTexelBufferAlignmentProperties.storageTexelBufferOffsetAlignmentBytes );
14486 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTexelBufferAlignmentProperties.storageTexelBufferOffsetSingleTexelAlignment );
14487 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTexelBufferAlignmentProperties.uniformTexelBufferOffsetAlignmentBytes );
14488 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTexelBufferAlignmentProperties.uniformTexelBufferOffsetSingleTexelAlignment );
14489 return seed;
14490 }
14491 };
14492
14493 template <>
14494 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTextureCompressionASTCHDRFeatures>
14495 {
14496 std::size_t operator()(
14497 VULKAN_HPP_NAMESPACE::PhysicalDeviceTextureCompressionASTCHDRFeatures const & physicalDeviceTextureCompressionASTCHDRFeatures ) const VULKAN_HPP_NOEXCEPT
14498 {
14499 std::size_t seed = 0;
14500 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTextureCompressionASTCHDRFeatures.sType );
14501 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTextureCompressionASTCHDRFeatures.pNext );
14502 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTextureCompressionASTCHDRFeatures.textureCompressionASTC_HDR );
14503 return seed;
14504 }
14505 };
14506
14507 template <>
14508 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTileMemoryHeapFeaturesQCOM>
14509 {
14510 std::size_t
14511 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTileMemoryHeapFeaturesQCOM const & physicalDeviceTileMemoryHeapFeaturesQCOM ) const VULKAN_HPP_NOEXCEPT
14512 {
14513 std::size_t seed = 0;
14514 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileMemoryHeapFeaturesQCOM.sType );
14515 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileMemoryHeapFeaturesQCOM.pNext );
14516 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileMemoryHeapFeaturesQCOM.tileMemoryHeap );
14517 return seed;
14518 }
14519 };
14520
14521 template <>
14522 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTileMemoryHeapPropertiesQCOM>
14523 {
14524 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTileMemoryHeapPropertiesQCOM const & physicalDeviceTileMemoryHeapPropertiesQCOM ) const
14525 VULKAN_HPP_NOEXCEPT
14526 {
14527 std::size_t seed = 0;
14528 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileMemoryHeapPropertiesQCOM.sType );
14529 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileMemoryHeapPropertiesQCOM.pNext );
14530 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileMemoryHeapPropertiesQCOM.queueSubmitBoundary );
14531 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileMemoryHeapPropertiesQCOM.tileBufferTransfers );
14532 return seed;
14533 }
14534 };
14535
14536 template <>
14537 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTilePropertiesFeaturesQCOM>
14538 {
14539 std::size_t
14540 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTilePropertiesFeaturesQCOM const & physicalDeviceTilePropertiesFeaturesQCOM ) const VULKAN_HPP_NOEXCEPT
14541 {
14542 std::size_t seed = 0;
14543 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTilePropertiesFeaturesQCOM.sType );
14544 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTilePropertiesFeaturesQCOM.pNext );
14545 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTilePropertiesFeaturesQCOM.tileProperties );
14546 return seed;
14547 }
14548 };
14549
14550 template <>
14551 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTileShadingFeaturesQCOM>
14552 {
14553 std::size_t
14554 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTileShadingFeaturesQCOM const & physicalDeviceTileShadingFeaturesQCOM ) const VULKAN_HPP_NOEXCEPT
14555 {
14556 std::size_t seed = 0;
14557 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingFeaturesQCOM.sType );
14558 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingFeaturesQCOM.pNext );
14559 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingFeaturesQCOM.tileShading );
14560 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingFeaturesQCOM.tileShadingFragmentStage );
14561 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingFeaturesQCOM.tileShadingColorAttachments );
14562 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingFeaturesQCOM.tileShadingDepthAttachments );
14563 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingFeaturesQCOM.tileShadingStencilAttachments );
14564 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingFeaturesQCOM.tileShadingInputAttachments );
14565 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingFeaturesQCOM.tileShadingSampledAttachments );
14566 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingFeaturesQCOM.tileShadingPerTileDraw );
14567 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingFeaturesQCOM.tileShadingPerTileDispatch );
14568 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingFeaturesQCOM.tileShadingDispatchTile );
14569 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingFeaturesQCOM.tileShadingApron );
14570 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingFeaturesQCOM.tileShadingAnisotropicApron );
14571 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingFeaturesQCOM.tileShadingAtomicOps );
14572 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingFeaturesQCOM.tileShadingImageProcessing );
14573 return seed;
14574 }
14575 };
14576
14577 template <>
14578 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTileShadingPropertiesQCOM>
14579 {
14580 std::size_t
14581 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTileShadingPropertiesQCOM const & physicalDeviceTileShadingPropertiesQCOM ) const VULKAN_HPP_NOEXCEPT
14582 {
14583 std::size_t seed = 0;
14584 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingPropertiesQCOM.sType );
14585 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingPropertiesQCOM.pNext );
14586 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingPropertiesQCOM.maxApronSize );
14587 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingPropertiesQCOM.preferNonCoherent );
14588 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingPropertiesQCOM.tileGranularity );
14589 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingPropertiesQCOM.maxTileShadingRate );
14590 return seed;
14591 }
14592 };
14593
14594 template <>
14595 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTimelineSemaphoreFeatures>
14596 {
14597 std::size_t
14598 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTimelineSemaphoreFeatures const & physicalDeviceTimelineSemaphoreFeatures ) const VULKAN_HPP_NOEXCEPT
14599 {
14600 std::size_t seed = 0;
14601 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTimelineSemaphoreFeatures.sType );
14602 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTimelineSemaphoreFeatures.pNext );
14603 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTimelineSemaphoreFeatures.timelineSemaphore );
14604 return seed;
14605 }
14606 };
14607
14608 template <>
14609 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTimelineSemaphoreProperties>
14610 {
14611 std::size_t
14612 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTimelineSemaphoreProperties const & physicalDeviceTimelineSemaphoreProperties ) const VULKAN_HPP_NOEXCEPT
14613 {
14614 std::size_t seed = 0;
14615 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTimelineSemaphoreProperties.sType );
14616 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTimelineSemaphoreProperties.pNext );
14617 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTimelineSemaphoreProperties.maxTimelineSemaphoreValueDifference );
14618 return seed;
14619 }
14620 };
14621
14622 template <>
14623 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties>
14624 {
14625 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties const & physicalDeviceToolProperties ) const VULKAN_HPP_NOEXCEPT
14626 {
14627 std::size_t seed = 0;
14628 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceToolProperties.sType );
14629 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceToolProperties.pNext );
14630 for ( size_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i )
14631 {
14632 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceToolProperties.name[i] );
14633 }
14634 for ( size_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i )
14635 {
14636 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceToolProperties.version[i] );
14637 }
14638 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceToolProperties.purposes );
14639 for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i )
14640 {
14641 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceToolProperties.description[i] );
14642 }
14643 for ( size_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i )
14644 {
14645 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceToolProperties.layer[i] );
14646 }
14647 return seed;
14648 }
14649 };
14650
14651 template <>
14652 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTransformFeedbackFeaturesEXT>
14653 {
14654 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTransformFeedbackFeaturesEXT const & physicalDeviceTransformFeedbackFeaturesEXT ) const
14655 VULKAN_HPP_NOEXCEPT
14656 {
14657 std::size_t seed = 0;
14658 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackFeaturesEXT.sType );
14659 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackFeaturesEXT.pNext );
14660 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackFeaturesEXT.transformFeedback );
14661 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackFeaturesEXT.geometryStreams );
14662 return seed;
14663 }
14664 };
14665
14666 template <>
14667 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTransformFeedbackPropertiesEXT>
14668 {
14669 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTransformFeedbackPropertiesEXT const & physicalDeviceTransformFeedbackPropertiesEXT ) const
14670 VULKAN_HPP_NOEXCEPT
14671 {
14672 std::size_t seed = 0;
14673 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.sType );
14674 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.pNext );
14675 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackStreams );
14676 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackBuffers );
14677 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackBufferSize );
14678 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackStreamDataSize );
14679 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackBufferDataSize );
14680 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackBufferDataStride );
14681 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.transformFeedbackQueries );
14682 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.transformFeedbackStreamsLinesTriangles );
14683 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.transformFeedbackRasterizationStreamSelect );
14684 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.transformFeedbackDraw );
14685 return seed;
14686 }
14687 };
14688
14689 template <>
14690 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceUnifiedImageLayoutsFeaturesKHR>
14691 {
14692 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceUnifiedImageLayoutsFeaturesKHR const & physicalDeviceUnifiedImageLayoutsFeaturesKHR ) const
14693 VULKAN_HPP_NOEXCEPT
14694 {
14695 std::size_t seed = 0;
14696 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceUnifiedImageLayoutsFeaturesKHR.sType );
14697 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceUnifiedImageLayoutsFeaturesKHR.pNext );
14698 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceUnifiedImageLayoutsFeaturesKHR.unifiedImageLayouts );
14699 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceUnifiedImageLayoutsFeaturesKHR.unifiedImageLayoutsVideo );
14700 return seed;
14701 }
14702 };
14703
14704 template <>
14705 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceUniformBufferStandardLayoutFeatures>
14706 {
14707 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceUniformBufferStandardLayoutFeatures const & physicalDeviceUniformBufferStandardLayoutFeatures )
14708 const VULKAN_HPP_NOEXCEPT
14709 {
14710 std::size_t seed = 0;
14711 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceUniformBufferStandardLayoutFeatures.sType );
14712 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceUniformBufferStandardLayoutFeatures.pNext );
14713 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceUniformBufferStandardLayoutFeatures.uniformBufferStandardLayout );
14714 return seed;
14715 }
14716 };
14717
14718 template <>
14719 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVariablePointersFeatures>
14720 {
14721 std::size_t
14722 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVariablePointersFeatures const & physicalDeviceVariablePointersFeatures ) const VULKAN_HPP_NOEXCEPT
14723 {
14724 std::size_t seed = 0;
14725 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVariablePointersFeatures.sType );
14726 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVariablePointersFeatures.pNext );
14727 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVariablePointersFeatures.variablePointersStorageBuffer );
14728 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVariablePointersFeatures.variablePointers );
14729 return seed;
14730 }
14731 };
14732
14733 template <>
14734 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorFeatures>
14735 {
14736 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorFeatures const & physicalDeviceVertexAttributeDivisorFeatures ) const
14737 VULKAN_HPP_NOEXCEPT
14738 {
14739 std::size_t seed = 0;
14740 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorFeatures.sType );
14741 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorFeatures.pNext );
14742 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorFeatures.vertexAttributeInstanceRateDivisor );
14743 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorFeatures.vertexAttributeInstanceRateZeroDivisor );
14744 return seed;
14745 }
14746 };
14747
14748 template <>
14749 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorProperties>
14750 {
14751 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorProperties const & physicalDeviceVertexAttributeDivisorProperties ) const
14752 VULKAN_HPP_NOEXCEPT
14753 {
14754 std::size_t seed = 0;
14755 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorProperties.sType );
14756 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorProperties.pNext );
14757 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorProperties.maxVertexAttribDivisor );
14758 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorProperties.supportsNonZeroFirstInstance );
14759 return seed;
14760 }
14761 };
14762
14763 template <>
14764 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorPropertiesEXT>
14765 {
14766 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorPropertiesEXT const & physicalDeviceVertexAttributeDivisorPropertiesEXT )
14767 const VULKAN_HPP_NOEXCEPT
14768 {
14769 std::size_t seed = 0;
14770 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorPropertiesEXT.sType );
14771 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorPropertiesEXT.pNext );
14772 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorPropertiesEXT.maxVertexAttribDivisor );
14773 return seed;
14774 }
14775 };
14776
14777 template <>
14778 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeRobustnessFeaturesEXT>
14779 {
14780 std::size_t
14781 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeRobustnessFeaturesEXT const & physicalDeviceVertexAttributeRobustnessFeaturesEXT ) const
14782 VULKAN_HPP_NOEXCEPT
14783 {
14784 std::size_t seed = 0;
14785 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeRobustnessFeaturesEXT.sType );
14786 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeRobustnessFeaturesEXT.pNext );
14787 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeRobustnessFeaturesEXT.vertexAttributeRobustness );
14788 return seed;
14789 }
14790 };
14791
14792 template <>
14793 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexInputDynamicStateFeaturesEXT>
14794 {
14795 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexInputDynamicStateFeaturesEXT const & physicalDeviceVertexInputDynamicStateFeaturesEXT )
14796 const VULKAN_HPP_NOEXCEPT
14797 {
14798 std::size_t seed = 0;
14799 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexInputDynamicStateFeaturesEXT.sType );
14800 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexInputDynamicStateFeaturesEXT.pNext );
14801 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexInputDynamicStateFeaturesEXT.vertexInputDynamicState );
14802 return seed;
14803 }
14804 };
14805
14806 template <>
14807 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoDecodeVP9FeaturesKHR>
14808 {
14809 std::size_t
14810 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoDecodeVP9FeaturesKHR const & physicalDeviceVideoDecodeVP9FeaturesKHR ) const VULKAN_HPP_NOEXCEPT
14811 {
14812 std::size_t seed = 0;
14813 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoDecodeVP9FeaturesKHR.sType );
14814 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoDecodeVP9FeaturesKHR.pNext );
14815 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoDecodeVP9FeaturesKHR.videoDecodeVP9 );
14816 return seed;
14817 }
14818 };
14819
14820 template <>
14821 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeAV1FeaturesKHR>
14822 {
14823 std::size_t
14824 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeAV1FeaturesKHR const & physicalDeviceVideoEncodeAV1FeaturesKHR ) const VULKAN_HPP_NOEXCEPT
14825 {
14826 std::size_t seed = 0;
14827 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoEncodeAV1FeaturesKHR.sType );
14828 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoEncodeAV1FeaturesKHR.pNext );
14829 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoEncodeAV1FeaturesKHR.videoEncodeAV1 );
14830 return seed;
14831 }
14832 };
14833
14834 template <>
14835 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR>
14836 {
14837 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR const & physicalDeviceVideoEncodeIntraRefreshFeaturesKHR )
14838 const VULKAN_HPP_NOEXCEPT
14839 {
14840 std::size_t seed = 0;
14841 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoEncodeIntraRefreshFeaturesKHR.sType );
14842 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoEncodeIntraRefreshFeaturesKHR.pNext );
14843 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoEncodeIntraRefreshFeaturesKHR.videoEncodeIntraRefresh );
14844 return seed;
14845 }
14846 };
14847
14848 template <>
14849 struct hash<VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR>
14850 {
14851 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR const & videoProfileInfoKHR ) const VULKAN_HPP_NOEXCEPT
14852 {
14853 std::size_t seed = 0;
14854 VULKAN_HPP_HASH_COMBINE( seed, videoProfileInfoKHR.sType );
14855 VULKAN_HPP_HASH_COMBINE( seed, videoProfileInfoKHR.pNext );
14856 VULKAN_HPP_HASH_COMBINE( seed, videoProfileInfoKHR.videoCodecOperation );
14857 VULKAN_HPP_HASH_COMBINE( seed, videoProfileInfoKHR.chromaSubsampling );
14858 VULKAN_HPP_HASH_COMBINE( seed, videoProfileInfoKHR.lumaBitDepth );
14859 VULKAN_HPP_HASH_COMBINE( seed, videoProfileInfoKHR.chromaBitDepth );
14860 return seed;
14861 }
14862 };
14863
14864 template <>
14865 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeQualityLevelInfoKHR>
14866 {
14867 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeQualityLevelInfoKHR const & physicalDeviceVideoEncodeQualityLevelInfoKHR ) const
14868 VULKAN_HPP_NOEXCEPT
14869 {
14870 std::size_t seed = 0;
14871 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoEncodeQualityLevelInfoKHR.sType );
14872 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoEncodeQualityLevelInfoKHR.pNext );
14873 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoEncodeQualityLevelInfoKHR.pVideoProfile );
14874 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoEncodeQualityLevelInfoKHR.qualityLevel );
14875 return seed;
14876 }
14877 };
14878
14879 template <>
14880 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR>
14881 {
14882 std::size_t
14883 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR const & physicalDeviceVideoEncodeQuantizationMapFeaturesKHR ) const
14884 VULKAN_HPP_NOEXCEPT
14885 {
14886 std::size_t seed = 0;
14887 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoEncodeQuantizationMapFeaturesKHR.sType );
14888 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoEncodeQuantizationMapFeaturesKHR.pNext );
14889 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoEncodeQuantizationMapFeaturesKHR.videoEncodeQuantizationMap );
14890 return seed;
14891 }
14892 };
14893
14894 template <>
14895 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE>
14896 {
14897 std::size_t
14898 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE const & physicalDeviceVideoEncodeRgbConversionFeaturesVALVE ) const
14899 VULKAN_HPP_NOEXCEPT
14900 {
14901 std::size_t seed = 0;
14902 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoEncodeRgbConversionFeaturesVALVE.sType );
14903 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoEncodeRgbConversionFeaturesVALVE.pNext );
14904 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoEncodeRgbConversionFeaturesVALVE.videoEncodeRgbConversion );
14905 return seed;
14906 }
14907 };
14908
14909 template <>
14910 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR>
14911 {
14912 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR const & physicalDeviceVideoFormatInfoKHR ) const VULKAN_HPP_NOEXCEPT
14913 {
14914 std::size_t seed = 0;
14915 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoFormatInfoKHR.sType );
14916 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoFormatInfoKHR.pNext );
14917 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoFormatInfoKHR.imageUsage );
14918 return seed;
14919 }
14920 };
14921
14922 template <>
14923 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoMaintenance1FeaturesKHR>
14924 {
14925 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoMaintenance1FeaturesKHR const & physicalDeviceVideoMaintenance1FeaturesKHR ) const
14926 VULKAN_HPP_NOEXCEPT
14927 {
14928 std::size_t seed = 0;
14929 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoMaintenance1FeaturesKHR.sType );
14930 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoMaintenance1FeaturesKHR.pNext );
14931 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoMaintenance1FeaturesKHR.videoMaintenance1 );
14932 return seed;
14933 }
14934 };
14935
14936 template <>
14937 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoMaintenance2FeaturesKHR>
14938 {
14939 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoMaintenance2FeaturesKHR const & physicalDeviceVideoMaintenance2FeaturesKHR ) const
14940 VULKAN_HPP_NOEXCEPT
14941 {
14942 std::size_t seed = 0;
14943 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoMaintenance2FeaturesKHR.sType );
14944 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoMaintenance2FeaturesKHR.pNext );
14945 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoMaintenance2FeaturesKHR.videoMaintenance2 );
14946 return seed;
14947 }
14948 };
14949
14950 template <>
14951 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan11Features>
14952 {
14953 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan11Features const & physicalDeviceVulkan11Features ) const VULKAN_HPP_NOEXCEPT
14954 {
14955 std::size_t seed = 0;
14956 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.sType );
14957 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.pNext );
14958 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.storageBuffer16BitAccess );
14959 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.uniformAndStorageBuffer16BitAccess );
14960 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.storagePushConstant16 );
14961 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.storageInputOutput16 );
14962 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.multiview );
14963 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.multiviewGeometryShader );
14964 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.multiviewTessellationShader );
14965 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.variablePointersStorageBuffer );
14966 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.variablePointers );
14967 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.protectedMemory );
14968 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.samplerYcbcrConversion );
14969 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.shaderDrawParameters );
14970 return seed;
14971 }
14972 };
14973
14974 template <>
14975 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan11Properties>
14976 {
14977 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan11Properties const & physicalDeviceVulkan11Properties ) const VULKAN_HPP_NOEXCEPT
14978 {
14979 std::size_t seed = 0;
14980 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.sType );
14981 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.pNext );
14982 for ( size_t i = 0; i < VK_UUID_SIZE; ++i )
14983 {
14984 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.deviceUUID[i] );
14985 }
14986 for ( size_t i = 0; i < VK_UUID_SIZE; ++i )
14987 {
14988 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.driverUUID[i] );
14989 }
14990 for ( size_t i = 0; i < VK_LUID_SIZE; ++i )
14991 {
14992 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.deviceLUID[i] );
14993 }
14994 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.deviceNodeMask );
14995 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.deviceLUIDValid );
14996 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.subgroupSize );
14997 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.subgroupSupportedStages );
14998 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.subgroupSupportedOperations );
14999 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.subgroupQuadOperationsInAllStages );
15000 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.pointClippingBehavior );
15001 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.maxMultiviewViewCount );
15002 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.maxMultiviewInstanceIndex );
15003 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.protectedNoFault );
15004 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.maxPerSetDescriptors );
15005 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.maxMemoryAllocationSize );
15006 return seed;
15007 }
15008 };
15009
15010 template <>
15011 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan12Features>
15012 {
15013 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan12Features const & physicalDeviceVulkan12Features ) const VULKAN_HPP_NOEXCEPT
15014 {
15015 std::size_t seed = 0;
15016 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.sType );
15017 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.pNext );
15018 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.samplerMirrorClampToEdge );
15019 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.drawIndirectCount );
15020 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.storageBuffer8BitAccess );
15021 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.uniformAndStorageBuffer8BitAccess );
15022 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.storagePushConstant8 );
15023 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderBufferInt64Atomics );
15024 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderSharedInt64Atomics );
15025 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderFloat16 );
15026 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderInt8 );
15027 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorIndexing );
15028 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderInputAttachmentArrayDynamicIndexing );
15029 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderUniformTexelBufferArrayDynamicIndexing );
15030 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderStorageTexelBufferArrayDynamicIndexing );
15031 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderUniformBufferArrayNonUniformIndexing );
15032 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderSampledImageArrayNonUniformIndexing );
15033 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderStorageBufferArrayNonUniformIndexing );
15034 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderStorageImageArrayNonUniformIndexing );
15035 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderInputAttachmentArrayNonUniformIndexing );
15036 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderUniformTexelBufferArrayNonUniformIndexing );
15037 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderStorageTexelBufferArrayNonUniformIndexing );
15038 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorBindingUniformBufferUpdateAfterBind );
15039 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorBindingSampledImageUpdateAfterBind );
15040 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorBindingStorageImageUpdateAfterBind );
15041 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorBindingStorageBufferUpdateAfterBind );
15042 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorBindingUniformTexelBufferUpdateAfterBind );
15043 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorBindingStorageTexelBufferUpdateAfterBind );
15044 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorBindingUpdateUnusedWhilePending );
15045 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorBindingPartiallyBound );
15046 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorBindingVariableDescriptorCount );
15047 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.runtimeDescriptorArray );
15048 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.samplerFilterMinmax );
15049 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.scalarBlockLayout );
15050 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.imagelessFramebuffer );
15051 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.uniformBufferStandardLayout );
15052 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderSubgroupExtendedTypes );
15053 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.separateDepthStencilLayouts );
15054 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.hostQueryReset );
15055 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.timelineSemaphore );
15056 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.bufferDeviceAddress );
15057 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.bufferDeviceAddressCaptureReplay );
15058 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.bufferDeviceAddressMultiDevice );
15059 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.vulkanMemoryModel );
15060 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.vulkanMemoryModelDeviceScope );
15061 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.vulkanMemoryModelAvailabilityVisibilityChains );
15062 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderOutputViewportIndex );
15063 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderOutputLayer );
15064 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.subgroupBroadcastDynamicId );
15065 return seed;
15066 }
15067 };
15068
15069 template <>
15070 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan12Properties>
15071 {
15072 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan12Properties const & physicalDeviceVulkan12Properties ) const VULKAN_HPP_NOEXCEPT
15073 {
15074 std::size_t seed = 0;
15075 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.sType );
15076 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.pNext );
15077 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.driverID );
15078 for ( size_t i = 0; i < VK_MAX_DRIVER_NAME_SIZE; ++i )
15079 {
15080 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.driverName[i] );
15081 }
15082 for ( size_t i = 0; i < VK_MAX_DRIVER_INFO_SIZE; ++i )
15083 {
15084 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.driverInfo[i] );
15085 }
15086 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.conformanceVersion );
15087 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.denormBehaviorIndependence );
15088 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.roundingModeIndependence );
15089 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderSignedZeroInfNanPreserveFloat16 );
15090 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderSignedZeroInfNanPreserveFloat32 );
15091 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderSignedZeroInfNanPreserveFloat64 );
15092 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderDenormPreserveFloat16 );
15093 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderDenormPreserveFloat32 );
15094 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderDenormPreserveFloat64 );
15095 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderDenormFlushToZeroFloat16 );
15096 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderDenormFlushToZeroFloat32 );
15097 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderDenormFlushToZeroFloat64 );
15098 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTEFloat16 );
15099 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTEFloat32 );
15100 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTEFloat64 );
15101 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTZFloat16 );
15102 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTZFloat32 );
15103 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTZFloat64 );
15104 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxUpdateAfterBindDescriptorsInAllPools );
15105 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderUniformBufferArrayNonUniformIndexingNative );
15106 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderSampledImageArrayNonUniformIndexingNative );
15107 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderStorageBufferArrayNonUniformIndexingNative );
15108 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderStorageImageArrayNonUniformIndexingNative );
15109 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderInputAttachmentArrayNonUniformIndexingNative );
15110 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.robustBufferAccessUpdateAfterBind );
15111 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.quadDivergentImplicitLod );
15112 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindSamplers );
15113 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindUniformBuffers );
15114 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindStorageBuffers );
15115 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindSampledImages );
15116 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindStorageImages );
15117 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindInputAttachments );
15118 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxPerStageUpdateAfterBindResources );
15119 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindSamplers );
15120 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindUniformBuffers );
15121 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic );
15122 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindStorageBuffers );
15123 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic );
15124 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindSampledImages );
15125 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindStorageImages );
15126 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindInputAttachments );
15127 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.supportedDepthResolveModes );
15128 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.supportedStencilResolveModes );
15129 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.independentResolveNone );
15130 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.independentResolve );
15131 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.filterMinmaxSingleComponentFormats );
15132 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.filterMinmaxImageComponentMapping );
15133 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxTimelineSemaphoreValueDifference );
15134 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.framebufferIntegerColorSampleCounts );
15135 return seed;
15136 }
15137 };
15138
15139 template <>
15140 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan13Features>
15141 {
15142 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan13Features const & physicalDeviceVulkan13Features ) const VULKAN_HPP_NOEXCEPT
15143 {
15144 std::size_t seed = 0;
15145 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.sType );
15146 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.pNext );
15147 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.robustImageAccess );
15148 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.inlineUniformBlock );
15149 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.descriptorBindingInlineUniformBlockUpdateAfterBind );
15150 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.pipelineCreationCacheControl );
15151 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.privateData );
15152 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.shaderDemoteToHelperInvocation );
15153 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.shaderTerminateInvocation );
15154 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.subgroupSizeControl );
15155 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.computeFullSubgroups );
15156 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.synchronization2 );
15157 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.textureCompressionASTC_HDR );
15158 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.shaderZeroInitializeWorkgroupMemory );
15159 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.dynamicRendering );
15160 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.shaderIntegerDotProduct );
15161 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.maintenance4 );
15162 return seed;
15163 }
15164 };
15165
15166 template <>
15167 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan13Properties>
15168 {
15169 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan13Properties const & physicalDeviceVulkan13Properties ) const VULKAN_HPP_NOEXCEPT
15170 {
15171 std::size_t seed = 0;
15172 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.sType );
15173 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.pNext );
15174 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.minSubgroupSize );
15175 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.maxSubgroupSize );
15176 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.maxComputeWorkgroupSubgroups );
15177 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.requiredSubgroupSizeStages );
15178 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.maxInlineUniformBlockSize );
15179 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.maxPerStageDescriptorInlineUniformBlocks );
15180 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks );
15181 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.maxDescriptorSetInlineUniformBlocks );
15182 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.maxDescriptorSetUpdateAfterBindInlineUniformBlocks );
15183 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.maxInlineUniformTotalSize );
15184 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct8BitUnsignedAccelerated );
15185 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct8BitSignedAccelerated );
15186 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct8BitMixedSignednessAccelerated );
15187 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct4x8BitPackedUnsignedAccelerated );
15188 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct4x8BitPackedSignedAccelerated );
15189 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct4x8BitPackedMixedSignednessAccelerated );
15190 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct16BitUnsignedAccelerated );
15191 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct16BitSignedAccelerated );
15192 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct16BitMixedSignednessAccelerated );
15193 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct32BitUnsignedAccelerated );
15194 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct32BitSignedAccelerated );
15195 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct32BitMixedSignednessAccelerated );
15196 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct64BitUnsignedAccelerated );
15197 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct64BitSignedAccelerated );
15198 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct64BitMixedSignednessAccelerated );
15199 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating8BitUnsignedAccelerated );
15200 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating8BitSignedAccelerated );
15201 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated );
15202 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated );
15203 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated );
15204 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated );
15205 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating16BitUnsignedAccelerated );
15206 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating16BitSignedAccelerated );
15207 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated );
15208 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating32BitUnsignedAccelerated );
15209 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating32BitSignedAccelerated );
15210 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated );
15211 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating64BitUnsignedAccelerated );
15212 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating64BitSignedAccelerated );
15213 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated );
15214 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.storageTexelBufferOffsetAlignmentBytes );
15215 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.storageTexelBufferOffsetSingleTexelAlignment );
15216 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.uniformTexelBufferOffsetAlignmentBytes );
15217 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.uniformTexelBufferOffsetSingleTexelAlignment );
15218 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.maxBufferSize );
15219 return seed;
15220 }
15221 };
15222
15223 template <>
15224 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan14Features>
15225 {
15226 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan14Features const & physicalDeviceVulkan14Features ) const VULKAN_HPP_NOEXCEPT
15227 {
15228 std::size_t seed = 0;
15229 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.sType );
15230 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.pNext );
15231 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.globalPriorityQuery );
15232 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.shaderSubgroupRotate );
15233 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.shaderSubgroupRotateClustered );
15234 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.shaderFloatControls2 );
15235 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.shaderExpectAssume );
15236 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.rectangularLines );
15237 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.bresenhamLines );
15238 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.smoothLines );
15239 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.stippledRectangularLines );
15240 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.stippledBresenhamLines );
15241 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.stippledSmoothLines );
15242 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.vertexAttributeInstanceRateDivisor );
15243 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.vertexAttributeInstanceRateZeroDivisor );
15244 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.indexTypeUint8 );
15245 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.dynamicRenderingLocalRead );
15246 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.maintenance5 );
15247 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.maintenance6 );
15248 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.pipelineProtectedAccess );
15249 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.pipelineRobustness );
15250 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.hostImageCopy );
15251 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.pushDescriptor );
15252 return seed;
15253 }
15254 };
15255
15256 template <>
15257 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan14Properties>
15258 {
15259 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan14Properties const & physicalDeviceVulkan14Properties ) const VULKAN_HPP_NOEXCEPT
15260 {
15261 std::size_t seed = 0;
15262 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.sType );
15263 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.pNext );
15264 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.lineSubPixelPrecisionBits );
15265 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.maxVertexAttribDivisor );
15266 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.supportsNonZeroFirstInstance );
15267 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.maxPushDescriptors );
15268 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.dynamicRenderingLocalReadDepthStencilAttachments );
15269 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.dynamicRenderingLocalReadMultisampledAttachments );
15270 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.earlyFragmentMultisampleCoverageAfterSampleCounting );
15271 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.earlyFragmentSampleMaskTestBeforeSampleCounting );
15272 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.depthStencilSwizzleOneSupport );
15273 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.polygonModePointSize );
15274 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.nonStrictSinglePixelWideLinesUseParallelogram );
15275 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.nonStrictWideLinesUseParallelogram );
15276 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.blockTexelViewCompatibleMultipleLayers );
15277 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.maxCombinedImageSamplerDescriptorCount );
15278 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.fragmentShadingRateClampCombinerInputs );
15279 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.defaultRobustnessStorageBuffers );
15280 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.defaultRobustnessUniformBuffers );
15281 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.defaultRobustnessVertexInputs );
15282 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.defaultRobustnessImages );
15283 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.copySrcLayoutCount );
15284 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.pCopySrcLayouts );
15285 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.copyDstLayoutCount );
15286 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.pCopyDstLayouts );
15287 for ( size_t i = 0; i < VK_UUID_SIZE; ++i )
15288 {
15289 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.optimalTilingLayoutUUID[i] );
15290 }
15291 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.identicalMemoryTypeRequirements );
15292 return seed;
15293 }
15294 };
15295
15296 template <>
15297 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkanMemoryModelFeatures>
15298 {
15299 std::size_t
15300 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkanMemoryModelFeatures const & physicalDeviceVulkanMemoryModelFeatures ) const VULKAN_HPP_NOEXCEPT
15301 {
15302 std::size_t seed = 0;
15303 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkanMemoryModelFeatures.sType );
15304 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkanMemoryModelFeatures.pNext );
15305 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkanMemoryModelFeatures.vulkanMemoryModel );
15306 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkanMemoryModelFeatures.vulkanMemoryModelDeviceScope );
15307 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkanMemoryModelFeatures.vulkanMemoryModelAvailabilityVisibilityChains );
15308 return seed;
15309 }
15310 };
15311
15312 template <>
15313 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR>
15314 {
15315 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR const &
15316 physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
15317 {
15318 std::size_t seed = 0;
15319 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.sType );
15320 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.pNext );
15321 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.workgroupMemoryExplicitLayout );
15322 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.workgroupMemoryExplicitLayoutScalarBlockLayout );
15323 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.workgroupMemoryExplicitLayout8BitAccess );
15324 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.workgroupMemoryExplicitLayout16BitAccess );
15325 return seed;
15326 }
15327 };
15328
15329 template <>
15330 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT>
15331 {
15332 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT const & physicalDeviceYcbcr2Plane444FormatsFeaturesEXT ) const
15333 VULKAN_HPP_NOEXCEPT
15334 {
15335 std::size_t seed = 0;
15336 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceYcbcr2Plane444FormatsFeaturesEXT.sType );
15337 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceYcbcr2Plane444FormatsFeaturesEXT.pNext );
15338 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceYcbcr2Plane444FormatsFeaturesEXT.ycbcr2plane444Formats );
15339 return seed;
15340 }
15341 };
15342
15343 template <>
15344 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcrDegammaFeaturesQCOM>
15345 {
15346 std::size_t
15347 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcrDegammaFeaturesQCOM const & physicalDeviceYcbcrDegammaFeaturesQCOM ) const VULKAN_HPP_NOEXCEPT
15348 {
15349 std::size_t seed = 0;
15350 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceYcbcrDegammaFeaturesQCOM.sType );
15351 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceYcbcrDegammaFeaturesQCOM.pNext );
15352 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceYcbcrDegammaFeaturesQCOM.ycbcrDegamma );
15353 return seed;
15354 }
15355 };
15356
15357 template <>
15358 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcrImageArraysFeaturesEXT>
15359 {
15360 std::size_t
15361 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcrImageArraysFeaturesEXT const & physicalDeviceYcbcrImageArraysFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
15362 {
15363 std::size_t seed = 0;
15364 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceYcbcrImageArraysFeaturesEXT.sType );
15365 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceYcbcrImageArraysFeaturesEXT.pNext );
15366 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceYcbcrImageArraysFeaturesEXT.ycbcrImageArrays );
15367 return seed;
15368 }
15369 };
15370
15371 template <>
15372 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT>
15373 {
15374 std::size_t
15375 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT const & physicalDeviceZeroInitializeDeviceMemoryFeaturesEXT ) const
15376 VULKAN_HPP_NOEXCEPT
15377 {
15378 std::size_t seed = 0;
15379 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceZeroInitializeDeviceMemoryFeaturesEXT.sType );
15380 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceZeroInitializeDeviceMemoryFeaturesEXT.pNext );
15381 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceZeroInitializeDeviceMemoryFeaturesEXT.zeroInitializeDeviceMemory );
15382 return seed;
15383 }
15384 };
15385
15386 template <>
15387 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures>
15388 {
15389 std::size_t
15390 operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures const & physicalDeviceZeroInitializeWorkgroupMemoryFeatures ) const
15391 VULKAN_HPP_NOEXCEPT
15392 {
15393 std::size_t seed = 0;
15394 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceZeroInitializeWorkgroupMemoryFeatures.sType );
15395 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceZeroInitializeWorkgroupMemoryFeatures.pNext );
15396 VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceZeroInitializeWorkgroupMemoryFeatures.shaderZeroInitializeWorkgroupMemory );
15397 return seed;
15398 }
15399 };
15400
15401 template <>
15402 struct hash<VULKAN_HPP_NAMESPACE::PipelineBinaryKeyKHR>
15403 {
15404 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineBinaryKeyKHR const & pipelineBinaryKeyKHR ) const VULKAN_HPP_NOEXCEPT
15405 {
15406 std::size_t seed = 0;
15407 VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryKeyKHR.sType );
15408 VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryKeyKHR.pNext );
15409 VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryKeyKHR.keySize );
15410 for ( size_t i = 0; i < VK_MAX_PIPELINE_BINARY_KEY_SIZE_KHR; ++i )
15411 {
15412 VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryKeyKHR.key[i] );
15413 }
15414 return seed;
15415 }
15416 };
15417
15418 template <>
15419 struct hash<VULKAN_HPP_NAMESPACE::PipelineBinaryDataKHR>
15420 {
15421 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineBinaryDataKHR const & pipelineBinaryDataKHR ) const VULKAN_HPP_NOEXCEPT
15422 {
15423 std::size_t seed = 0;
15424 VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryDataKHR.dataSize );
15425 VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryDataKHR.pData );
15426 return seed;
15427 }
15428 };
15429
15430 template <>
15431 struct hash<VULKAN_HPP_NAMESPACE::PipelineBinaryKeysAndDataKHR>
15432 {
15433 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineBinaryKeysAndDataKHR const & pipelineBinaryKeysAndDataKHR ) const VULKAN_HPP_NOEXCEPT
15434 {
15435 std::size_t seed = 0;
15436 VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryKeysAndDataKHR.binaryCount );
15437 VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryKeysAndDataKHR.pPipelineBinaryKeys );
15438 VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryKeysAndDataKHR.pPipelineBinaryData );
15439 return seed;
15440 }
15441 };
15442
15443 template <>
15444 struct hash<VULKAN_HPP_NAMESPACE::PipelineCreateInfoKHR>
15445 {
15446 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCreateInfoKHR const & pipelineCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
15447 {
15448 std::size_t seed = 0;
15449 VULKAN_HPP_HASH_COMBINE( seed, pipelineCreateInfoKHR.sType );
15450 VULKAN_HPP_HASH_COMBINE( seed, pipelineCreateInfoKHR.pNext );
15451 return seed;
15452 }
15453 };
15454
15455 template <>
15456 struct hash<VULKAN_HPP_NAMESPACE::PipelineBinaryCreateInfoKHR>
15457 {
15458 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineBinaryCreateInfoKHR const & pipelineBinaryCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
15459 {
15460 std::size_t seed = 0;
15461 VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryCreateInfoKHR.sType );
15462 VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryCreateInfoKHR.pNext );
15463 VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryCreateInfoKHR.pKeysAndDataInfo );
15464 VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryCreateInfoKHR.pipeline );
15465 VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryCreateInfoKHR.pPipelineCreateInfo );
15466 return seed;
15467 }
15468 };
15469
15470 template <>
15471 struct hash<VULKAN_HPP_NAMESPACE::PipelineBinaryDataInfoKHR>
15472 {
15473 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineBinaryDataInfoKHR const & pipelineBinaryDataInfoKHR ) const VULKAN_HPP_NOEXCEPT
15474 {
15475 std::size_t seed = 0;
15476 VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryDataInfoKHR.sType );
15477 VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryDataInfoKHR.pNext );
15478 VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryDataInfoKHR.pipelineBinary );
15479 return seed;
15480 }
15481 };
15482
15483 template <>
15484 struct hash<VULKAN_HPP_NAMESPACE::PipelineBinaryHandlesInfoKHR>
15485 {
15486 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineBinaryHandlesInfoKHR const & pipelineBinaryHandlesInfoKHR ) const VULKAN_HPP_NOEXCEPT
15487 {
15488 std::size_t seed = 0;
15489 VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryHandlesInfoKHR.sType );
15490 VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryHandlesInfoKHR.pNext );
15491 VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryHandlesInfoKHR.pipelineBinaryCount );
15492 VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryHandlesInfoKHR.pPipelineBinaries );
15493 return seed;
15494 }
15495 };
15496
15497 template <>
15498 struct hash<VULKAN_HPP_NAMESPACE::PipelineBinaryInfoKHR>
15499 {
15500 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineBinaryInfoKHR const & pipelineBinaryInfoKHR ) const VULKAN_HPP_NOEXCEPT
15501 {
15502 std::size_t seed = 0;
15503 VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryInfoKHR.sType );
15504 VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryInfoKHR.pNext );
15505 VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryInfoKHR.binaryCount );
15506 VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryInfoKHR.pPipelineBinaries );
15507 return seed;
15508 }
15509 };
15510
15511 template <>
15512 struct hash<VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo>
15513 {
15514 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo const & pipelineCacheCreateInfo ) const VULKAN_HPP_NOEXCEPT
15515 {
15516 std::size_t seed = 0;
15517 VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheCreateInfo.sType );
15518 VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheCreateInfo.pNext );
15519 VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheCreateInfo.flags );
15520 VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheCreateInfo.initialDataSize );
15521 VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheCreateInfo.pInitialData );
15522 return seed;
15523 }
15524 };
15525
15526 template <>
15527 struct hash<VULKAN_HPP_NAMESPACE::PipelineCacheHeaderVersionDataGraphQCOM>
15528 {
15529 std::size_t
15530 operator()( VULKAN_HPP_NAMESPACE::PipelineCacheHeaderVersionDataGraphQCOM const & pipelineCacheHeaderVersionDataGraphQCOM ) const VULKAN_HPP_NOEXCEPT
15531 {
15532 std::size_t seed = 0;
15533 VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheHeaderVersionDataGraphQCOM.headerSize );
15534 VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheHeaderVersionDataGraphQCOM.headerVersion );
15535 VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheHeaderVersionDataGraphQCOM.cacheType );
15536 VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheHeaderVersionDataGraphQCOM.cacheVersion );
15537 for ( size_t i = 0; i < VK_DATA_GRAPH_MODEL_TOOLCHAIN_VERSION_LENGTH_QCOM; ++i )
15538 {
15539 VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheHeaderVersionDataGraphQCOM.toolchainVersion[i] );
15540 }
15541 return seed;
15542 }
15543 };
15544
15545 template <>
15546 struct hash<VULKAN_HPP_NAMESPACE::PipelineCacheHeaderVersionOne>
15547 {
15548 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCacheHeaderVersionOne const & pipelineCacheHeaderVersionOne ) const VULKAN_HPP_NOEXCEPT
15549 {
15550 std::size_t seed = 0;
15551 VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheHeaderVersionOne.headerSize );
15552 VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheHeaderVersionOne.headerVersion );
15553 VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheHeaderVersionOne.vendorID );
15554 VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheHeaderVersionOne.deviceID );
15555 for ( size_t i = 0; i < VK_UUID_SIZE; ++i )
15556 {
15557 VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheHeaderVersionOne.pipelineCacheUUID[i] );
15558 }
15559 return seed;
15560 }
15561 };
15562
15563 template <>
15564 struct hash<VULKAN_HPP_NAMESPACE::PipelineColorBlendAdvancedStateCreateInfoEXT>
15565 {
15566 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineColorBlendAdvancedStateCreateInfoEXT const & pipelineColorBlendAdvancedStateCreateInfoEXT ) const
15567 VULKAN_HPP_NOEXCEPT
15568 {
15569 std::size_t seed = 0;
15570 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAdvancedStateCreateInfoEXT.sType );
15571 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAdvancedStateCreateInfoEXT.pNext );
15572 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAdvancedStateCreateInfoEXT.srcPremultiplied );
15573 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAdvancedStateCreateInfoEXT.dstPremultiplied );
15574 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAdvancedStateCreateInfoEXT.blendOverlap );
15575 return seed;
15576 }
15577 };
15578
15579 template <>
15580 struct hash<VULKAN_HPP_NAMESPACE::PipelineColorWriteCreateInfoEXT>
15581 {
15582 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineColorWriteCreateInfoEXT const & pipelineColorWriteCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
15583 {
15584 std::size_t seed = 0;
15585 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorWriteCreateInfoEXT.sType );
15586 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorWriteCreateInfoEXT.pNext );
15587 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorWriteCreateInfoEXT.attachmentCount );
15588 VULKAN_HPP_HASH_COMBINE( seed, pipelineColorWriteCreateInfoEXT.pColorWriteEnables );
15589 return seed;
15590 }
15591 };
15592
15593 template <>
15594 struct hash<VULKAN_HPP_NAMESPACE::PipelineCompilerControlCreateInfoAMD>
15595 {
15596 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCompilerControlCreateInfoAMD const & pipelineCompilerControlCreateInfoAMD ) const VULKAN_HPP_NOEXCEPT
15597 {
15598 std::size_t seed = 0;
15599 VULKAN_HPP_HASH_COMBINE( seed, pipelineCompilerControlCreateInfoAMD.sType );
15600 VULKAN_HPP_HASH_COMBINE( seed, pipelineCompilerControlCreateInfoAMD.pNext );
15601 VULKAN_HPP_HASH_COMBINE( seed, pipelineCompilerControlCreateInfoAMD.compilerControlFlags );
15602 return seed;
15603 }
15604 };
15605
15606 template <>
15607 struct hash<VULKAN_HPP_NAMESPACE::PipelineCoverageModulationStateCreateInfoNV>
15608 {
15609 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCoverageModulationStateCreateInfoNV const & pipelineCoverageModulationStateCreateInfoNV ) const
15610 VULKAN_HPP_NOEXCEPT
15611 {
15612 std::size_t seed = 0;
15613 VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageModulationStateCreateInfoNV.sType );
15614 VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageModulationStateCreateInfoNV.pNext );
15615 VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageModulationStateCreateInfoNV.flags );
15616 VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageModulationStateCreateInfoNV.coverageModulationMode );
15617 VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageModulationStateCreateInfoNV.coverageModulationTableEnable );
15618 VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageModulationStateCreateInfoNV.coverageModulationTableCount );
15619 VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageModulationStateCreateInfoNV.pCoverageModulationTable );
15620 return seed;
15621 }
15622 };
15623
15624 template <>
15625 struct hash<VULKAN_HPP_NAMESPACE::PipelineCoverageReductionStateCreateInfoNV>
15626 {
15627 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCoverageReductionStateCreateInfoNV const & pipelineCoverageReductionStateCreateInfoNV ) const
15628 VULKAN_HPP_NOEXCEPT
15629 {
15630 std::size_t seed = 0;
15631 VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageReductionStateCreateInfoNV.sType );
15632 VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageReductionStateCreateInfoNV.pNext );
15633 VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageReductionStateCreateInfoNV.flags );
15634 VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageReductionStateCreateInfoNV.coverageReductionMode );
15635 return seed;
15636 }
15637 };
15638
15639 template <>
15640 struct hash<VULKAN_HPP_NAMESPACE::PipelineCoverageToColorStateCreateInfoNV>
15641 {
15642 std::size_t
15643 operator()( VULKAN_HPP_NAMESPACE::PipelineCoverageToColorStateCreateInfoNV const & pipelineCoverageToColorStateCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
15644 {
15645 std::size_t seed = 0;
15646 VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageToColorStateCreateInfoNV.sType );
15647 VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageToColorStateCreateInfoNV.pNext );
15648 VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageToColorStateCreateInfoNV.flags );
15649 VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageToColorStateCreateInfoNV.coverageToColorEnable );
15650 VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageToColorStateCreateInfoNV.coverageToColorLocation );
15651 return seed;
15652 }
15653 };
15654
15655 template <>
15656 struct hash<VULKAN_HPP_NAMESPACE::PipelineCreateFlags2CreateInfo>
15657 {
15658 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCreateFlags2CreateInfo const & pipelineCreateFlags2CreateInfo ) const VULKAN_HPP_NOEXCEPT
15659 {
15660 std::size_t seed = 0;
15661 VULKAN_HPP_HASH_COMBINE( seed, pipelineCreateFlags2CreateInfo.sType );
15662 VULKAN_HPP_HASH_COMBINE( seed, pipelineCreateFlags2CreateInfo.pNext );
15663 VULKAN_HPP_HASH_COMBINE( seed, pipelineCreateFlags2CreateInfo.flags );
15664 return seed;
15665 }
15666 };
15667
15668 template <>
15669 struct hash<VULKAN_HPP_NAMESPACE::PipelineCreationFeedback>
15670 {
15671 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCreationFeedback const & pipelineCreationFeedback ) const VULKAN_HPP_NOEXCEPT
15672 {
15673 std::size_t seed = 0;
15674 VULKAN_HPP_HASH_COMBINE( seed, pipelineCreationFeedback.flags );
15675 VULKAN_HPP_HASH_COMBINE( seed, pipelineCreationFeedback.duration );
15676 return seed;
15677 }
15678 };
15679
15680 template <>
15681 struct hash<VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackCreateInfo>
15682 {
15683 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackCreateInfo const & pipelineCreationFeedbackCreateInfo ) const VULKAN_HPP_NOEXCEPT
15684 {
15685 std::size_t seed = 0;
15686 VULKAN_HPP_HASH_COMBINE( seed, pipelineCreationFeedbackCreateInfo.sType );
15687 VULKAN_HPP_HASH_COMBINE( seed, pipelineCreationFeedbackCreateInfo.pNext );
15688 VULKAN_HPP_HASH_COMBINE( seed, pipelineCreationFeedbackCreateInfo.pPipelineCreationFeedback );
15689 VULKAN_HPP_HASH_COMBINE( seed, pipelineCreationFeedbackCreateInfo.pipelineStageCreationFeedbackCount );
15690 VULKAN_HPP_HASH_COMBINE( seed, pipelineCreationFeedbackCreateInfo.pPipelineStageCreationFeedbacks );
15691 return seed;
15692 }
15693 };
15694
15695 template <>
15696 struct hash<VULKAN_HPP_NAMESPACE::PipelineDiscardRectangleStateCreateInfoEXT>
15697 {
15698 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineDiscardRectangleStateCreateInfoEXT const & pipelineDiscardRectangleStateCreateInfoEXT ) const
15699 VULKAN_HPP_NOEXCEPT
15700 {
15701 std::size_t seed = 0;
15702 VULKAN_HPP_HASH_COMBINE( seed, pipelineDiscardRectangleStateCreateInfoEXT.sType );
15703 VULKAN_HPP_HASH_COMBINE( seed, pipelineDiscardRectangleStateCreateInfoEXT.pNext );
15704 VULKAN_HPP_HASH_COMBINE( seed, pipelineDiscardRectangleStateCreateInfoEXT.flags );
15705 VULKAN_HPP_HASH_COMBINE( seed, pipelineDiscardRectangleStateCreateInfoEXT.discardRectangleMode );
15706 VULKAN_HPP_HASH_COMBINE( seed, pipelineDiscardRectangleStateCreateInfoEXT.discardRectangleCount );
15707 VULKAN_HPP_HASH_COMBINE( seed, pipelineDiscardRectangleStateCreateInfoEXT.pDiscardRectangles );
15708 return seed;
15709 }
15710 };
15711
15712 template <>
15713 struct hash<VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR>
15714 {
15715 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR const & pipelineExecutableInfoKHR ) const VULKAN_HPP_NOEXCEPT
15716 {
15717 std::size_t seed = 0;
15718 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInfoKHR.sType );
15719 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInfoKHR.pNext );
15720 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInfoKHR.pipeline );
15721 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInfoKHR.executableIndex );
15722 return seed;
15723 }
15724 };
15725
15726 template <>
15727 struct hash<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR>
15728 {
15729 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR const & pipelineExecutableInternalRepresentationKHR ) const
15730 VULKAN_HPP_NOEXCEPT
15731 {
15732 std::size_t seed = 0;
15733 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInternalRepresentationKHR.sType );
15734 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInternalRepresentationKHR.pNext );
15735 for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i )
15736 {
15737 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInternalRepresentationKHR.name[i] );
15738 }
15739 for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i )
15740 {
15741 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInternalRepresentationKHR.description[i] );
15742 }
15743 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInternalRepresentationKHR.isText );
15744 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInternalRepresentationKHR.dataSize );
15745 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInternalRepresentationKHR.pData );
15746 return seed;
15747 }
15748 };
15749
15750 template <>
15751 struct hash<VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR>
15752 {
15753 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR const & pipelineExecutablePropertiesKHR ) const VULKAN_HPP_NOEXCEPT
15754 {
15755 std::size_t seed = 0;
15756 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutablePropertiesKHR.sType );
15757 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutablePropertiesKHR.pNext );
15758 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutablePropertiesKHR.stages );
15759 for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i )
15760 {
15761 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutablePropertiesKHR.name[i] );
15762 }
15763 for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i )
15764 {
15765 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutablePropertiesKHR.description[i] );
15766 }
15767 VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutablePropertiesKHR.subgroupSize );
15768 return seed;
15769 }
15770 };
15771
15772 template <>
15773 struct hash<VULKAN_HPP_NAMESPACE::PipelineFragmentDensityMapLayeredCreateInfoVALVE>
15774 {
15775 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineFragmentDensityMapLayeredCreateInfoVALVE const & pipelineFragmentDensityMapLayeredCreateInfoVALVE )
15776 const VULKAN_HPP_NOEXCEPT
15777 {
15778 std::size_t seed = 0;
15779 VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentDensityMapLayeredCreateInfoVALVE.sType );
15780 VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentDensityMapLayeredCreateInfoVALVE.pNext );
15781 VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentDensityMapLayeredCreateInfoVALVE.maxFragmentDensityMapLayers );
15782 return seed;
15783 }
15784 };
15785
15786 template <>
15787 struct hash<VULKAN_HPP_NAMESPACE::PipelineFragmentShadingRateEnumStateCreateInfoNV>
15788 {
15789 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineFragmentShadingRateEnumStateCreateInfoNV const & pipelineFragmentShadingRateEnumStateCreateInfoNV )
15790 const VULKAN_HPP_NOEXCEPT
15791 {
15792 std::size_t seed = 0;
15793 VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentShadingRateEnumStateCreateInfoNV.sType );
15794 VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentShadingRateEnumStateCreateInfoNV.pNext );
15795 VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentShadingRateEnumStateCreateInfoNV.shadingRateType );
15796 VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentShadingRateEnumStateCreateInfoNV.shadingRate );
15797 for ( size_t i = 0; i < 2; ++i )
15798 {
15799 VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentShadingRateEnumStateCreateInfoNV.combinerOps[i] );
15800 }
15801 return seed;
15802 }
15803 };
15804
15805 template <>
15806 struct hash<VULKAN_HPP_NAMESPACE::PipelineFragmentShadingRateStateCreateInfoKHR>
15807 {
15808 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineFragmentShadingRateStateCreateInfoKHR const & pipelineFragmentShadingRateStateCreateInfoKHR ) const
15809 VULKAN_HPP_NOEXCEPT
15810 {
15811 std::size_t seed = 0;
15812 VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentShadingRateStateCreateInfoKHR.sType );
15813 VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentShadingRateStateCreateInfoKHR.pNext );
15814 VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentShadingRateStateCreateInfoKHR.fragmentSize );
15815 for ( size_t i = 0; i < 2; ++i )
15816 {
15817 VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentShadingRateStateCreateInfoKHR.combinerOps[i] );
15818 }
15819 return seed;
15820 }
15821 };
15822
15823 template <>
15824 struct hash<VULKAN_HPP_NAMESPACE::PipelineIndirectDeviceAddressInfoNV>
15825 {
15826 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineIndirectDeviceAddressInfoNV const & pipelineIndirectDeviceAddressInfoNV ) const VULKAN_HPP_NOEXCEPT
15827 {
15828 std::size_t seed = 0;
15829 VULKAN_HPP_HASH_COMBINE( seed, pipelineIndirectDeviceAddressInfoNV.sType );
15830 VULKAN_HPP_HASH_COMBINE( seed, pipelineIndirectDeviceAddressInfoNV.pNext );
15831 VULKAN_HPP_HASH_COMBINE( seed, pipelineIndirectDeviceAddressInfoNV.pipelineBindPoint );
15832 VULKAN_HPP_HASH_COMBINE( seed, pipelineIndirectDeviceAddressInfoNV.pipeline );
15833 return seed;
15834 }
15835 };
15836
15837 template <>
15838 struct hash<VULKAN_HPP_NAMESPACE::PipelineInfoKHR>
15839 {
15840 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineInfoKHR const & pipelineInfoKHR ) const VULKAN_HPP_NOEXCEPT
15841 {
15842 std::size_t seed = 0;
15843 VULKAN_HPP_HASH_COMBINE( seed, pipelineInfoKHR.sType );
15844 VULKAN_HPP_HASH_COMBINE( seed, pipelineInfoKHR.pNext );
15845 VULKAN_HPP_HASH_COMBINE( seed, pipelineInfoKHR.pipeline );
15846 return seed;
15847 }
15848 };
15849
15850 template <>
15851 struct hash<VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo>
15852 {
15853 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo const & pipelineLayoutCreateInfo ) const VULKAN_HPP_NOEXCEPT
15854 {
15855 std::size_t seed = 0;
15856 VULKAN_HPP_HASH_COMBINE( seed, pipelineLayoutCreateInfo.sType );
15857 VULKAN_HPP_HASH_COMBINE( seed, pipelineLayoutCreateInfo.pNext );
15858 VULKAN_HPP_HASH_COMBINE( seed, pipelineLayoutCreateInfo.flags );
15859 VULKAN_HPP_HASH_COMBINE( seed, pipelineLayoutCreateInfo.setLayoutCount );
15860 VULKAN_HPP_HASH_COMBINE( seed, pipelineLayoutCreateInfo.pSetLayouts );
15861 VULKAN_HPP_HASH_COMBINE( seed, pipelineLayoutCreateInfo.pushConstantRangeCount );
15862 VULKAN_HPP_HASH_COMBINE( seed, pipelineLayoutCreateInfo.pPushConstantRanges );
15863 return seed;
15864 }
15865 };
15866
15867 template <>
15868 struct hash<VULKAN_HPP_NAMESPACE::PipelinePropertiesIdentifierEXT>
15869 {
15870 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelinePropertiesIdentifierEXT const & pipelinePropertiesIdentifierEXT ) const VULKAN_HPP_NOEXCEPT
15871 {
15872 std::size_t seed = 0;
15873 VULKAN_HPP_HASH_COMBINE( seed, pipelinePropertiesIdentifierEXT.sType );
15874 VULKAN_HPP_HASH_COMBINE( seed, pipelinePropertiesIdentifierEXT.pNext );
15875 for ( size_t i = 0; i < VK_UUID_SIZE; ++i )
15876 {
15877 VULKAN_HPP_HASH_COMBINE( seed, pipelinePropertiesIdentifierEXT.pipelineIdentifier[i] );
15878 }
15879 return seed;
15880 }
15881 };
15882
15883 template <>
15884 struct hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationConservativeStateCreateInfoEXT>
15885 {
15886 std::size_t
15887 operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationConservativeStateCreateInfoEXT const & pipelineRasterizationConservativeStateCreateInfoEXT ) const
15888 VULKAN_HPP_NOEXCEPT
15889 {
15890 std::size_t seed = 0;
15891 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationConservativeStateCreateInfoEXT.sType );
15892 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationConservativeStateCreateInfoEXT.pNext );
15893 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationConservativeStateCreateInfoEXT.flags );
15894 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationConservativeStateCreateInfoEXT.conservativeRasterizationMode );
15895 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationConservativeStateCreateInfoEXT.extraPrimitiveOverestimationSize );
15896 return seed;
15897 }
15898 };
15899
15900 template <>
15901 struct hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationDepthClipStateCreateInfoEXT>
15902 {
15903 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationDepthClipStateCreateInfoEXT const & pipelineRasterizationDepthClipStateCreateInfoEXT )
15904 const VULKAN_HPP_NOEXCEPT
15905 {
15906 std::size_t seed = 0;
15907 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationDepthClipStateCreateInfoEXT.sType );
15908 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationDepthClipStateCreateInfoEXT.pNext );
15909 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationDepthClipStateCreateInfoEXT.flags );
15910 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationDepthClipStateCreateInfoEXT.depthClipEnable );
15911 return seed;
15912 }
15913 };
15914
15915 template <>
15916 struct hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationLineStateCreateInfo>
15917 {
15918 std::size_t
15919 operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationLineStateCreateInfo const & pipelineRasterizationLineStateCreateInfo ) const VULKAN_HPP_NOEXCEPT
15920 {
15921 std::size_t seed = 0;
15922 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfo.sType );
15923 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfo.pNext );
15924 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfo.lineRasterizationMode );
15925 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfo.stippledLineEnable );
15926 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfo.lineStippleFactor );
15927 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfo.lineStipplePattern );
15928 return seed;
15929 }
15930 };
15931
15932 template <>
15933 struct hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationProvokingVertexStateCreateInfoEXT>
15934 {
15935 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationProvokingVertexStateCreateInfoEXT const &
15936 pipelineRasterizationProvokingVertexStateCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
15937 {
15938 std::size_t seed = 0;
15939 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationProvokingVertexStateCreateInfoEXT.sType );
15940 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationProvokingVertexStateCreateInfoEXT.pNext );
15941 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationProvokingVertexStateCreateInfoEXT.provokingVertexMode );
15942 return seed;
15943 }
15944 };
15945
15946 template <>
15947 struct hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationStateRasterizationOrderAMD>
15948 {
15949 std::size_t operator()(
15950 VULKAN_HPP_NAMESPACE::PipelineRasterizationStateRasterizationOrderAMD const & pipelineRasterizationStateRasterizationOrderAMD ) const VULKAN_HPP_NOEXCEPT
15951 {
15952 std::size_t seed = 0;
15953 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateRasterizationOrderAMD.sType );
15954 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateRasterizationOrderAMD.pNext );
15955 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateRasterizationOrderAMD.rasterizationOrder );
15956 return seed;
15957 }
15958 };
15959
15960 template <>
15961 struct hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationStateStreamCreateInfoEXT>
15962 {
15963 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationStateStreamCreateInfoEXT const & pipelineRasterizationStateStreamCreateInfoEXT ) const
15964 VULKAN_HPP_NOEXCEPT
15965 {
15966 std::size_t seed = 0;
15967 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateStreamCreateInfoEXT.sType );
15968 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateStreamCreateInfoEXT.pNext );
15969 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateStreamCreateInfoEXT.flags );
15970 VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateStreamCreateInfoEXT.rasterizationStream );
15971 return seed;
15972 }
15973 };
15974
15975 template <>
15976 struct hash<VULKAN_HPP_NAMESPACE::PipelineRenderingCreateInfo>
15977 {
15978 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRenderingCreateInfo const & pipelineRenderingCreateInfo ) const VULKAN_HPP_NOEXCEPT
15979 {
15980 std::size_t seed = 0;
15981 VULKAN_HPP_HASH_COMBINE( seed, pipelineRenderingCreateInfo.sType );
15982 VULKAN_HPP_HASH_COMBINE( seed, pipelineRenderingCreateInfo.pNext );
15983 VULKAN_HPP_HASH_COMBINE( seed, pipelineRenderingCreateInfo.viewMask );
15984 VULKAN_HPP_HASH_COMBINE( seed, pipelineRenderingCreateInfo.colorAttachmentCount );
15985 VULKAN_HPP_HASH_COMBINE( seed, pipelineRenderingCreateInfo.pColorAttachmentFormats );
15986 VULKAN_HPP_HASH_COMBINE( seed, pipelineRenderingCreateInfo.depthAttachmentFormat );
15987 VULKAN_HPP_HASH_COMBINE( seed, pipelineRenderingCreateInfo.stencilAttachmentFormat );
15988 return seed;
15989 }
15990 };
15991
15992 template <>
15993 struct hash<VULKAN_HPP_NAMESPACE::PipelineRepresentativeFragmentTestStateCreateInfoNV>
15994 {
15995 std::size_t
15996 operator()( VULKAN_HPP_NAMESPACE::PipelineRepresentativeFragmentTestStateCreateInfoNV const & pipelineRepresentativeFragmentTestStateCreateInfoNV ) const
15997 VULKAN_HPP_NOEXCEPT
15998 {
15999 std::size_t seed = 0;
16000 VULKAN_HPP_HASH_COMBINE( seed, pipelineRepresentativeFragmentTestStateCreateInfoNV.sType );
16001 VULKAN_HPP_HASH_COMBINE( seed, pipelineRepresentativeFragmentTestStateCreateInfoNV.pNext );
16002 VULKAN_HPP_HASH_COMBINE( seed, pipelineRepresentativeFragmentTestStateCreateInfoNV.representativeFragmentTestEnable );
16003 return seed;
16004 }
16005 };
16006
16007 template <>
16008 struct hash<VULKAN_HPP_NAMESPACE::PipelineRobustnessCreateInfo>
16009 {
16010 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRobustnessCreateInfo const & pipelineRobustnessCreateInfo ) const VULKAN_HPP_NOEXCEPT
16011 {
16012 std::size_t seed = 0;
16013 VULKAN_HPP_HASH_COMBINE( seed, pipelineRobustnessCreateInfo.sType );
16014 VULKAN_HPP_HASH_COMBINE( seed, pipelineRobustnessCreateInfo.pNext );
16015 VULKAN_HPP_HASH_COMBINE( seed, pipelineRobustnessCreateInfo.storageBuffers );
16016 VULKAN_HPP_HASH_COMBINE( seed, pipelineRobustnessCreateInfo.uniformBuffers );
16017 VULKAN_HPP_HASH_COMBINE( seed, pipelineRobustnessCreateInfo.vertexInputs );
16018 VULKAN_HPP_HASH_COMBINE( seed, pipelineRobustnessCreateInfo.images );
16019 return seed;
16020 }
16021 };
16022
16023 template <>
16024 struct hash<VULKAN_HPP_NAMESPACE::PipelineSampleLocationsStateCreateInfoEXT>
16025 {
16026 std::size_t
16027 operator()( VULKAN_HPP_NAMESPACE::PipelineSampleLocationsStateCreateInfoEXT const & pipelineSampleLocationsStateCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
16028 {
16029 std::size_t seed = 0;
16030 VULKAN_HPP_HASH_COMBINE( seed, pipelineSampleLocationsStateCreateInfoEXT.sType );
16031 VULKAN_HPP_HASH_COMBINE( seed, pipelineSampleLocationsStateCreateInfoEXT.pNext );
16032 VULKAN_HPP_HASH_COMBINE( seed, pipelineSampleLocationsStateCreateInfoEXT.sampleLocationsEnable );
16033 VULKAN_HPP_HASH_COMBINE( seed, pipelineSampleLocationsStateCreateInfoEXT.sampleLocationsInfo );
16034 return seed;
16035 }
16036 };
16037
16038 template <>
16039 struct hash<VULKAN_HPP_NAMESPACE::PipelineShaderStageModuleIdentifierCreateInfoEXT>
16040 {
16041 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineShaderStageModuleIdentifierCreateInfoEXT const & pipelineShaderStageModuleIdentifierCreateInfoEXT )
16042 const VULKAN_HPP_NOEXCEPT
16043 {
16044 std::size_t seed = 0;
16045 VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageModuleIdentifierCreateInfoEXT.sType );
16046 VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageModuleIdentifierCreateInfoEXT.pNext );
16047 VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageModuleIdentifierCreateInfoEXT.identifierSize );
16048 VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageModuleIdentifierCreateInfoEXT.pIdentifier );
16049 return seed;
16050 }
16051 };
16052
16053 # if defined( VK_ENABLE_BETA_EXTENSIONS )
16054 template <>
16055 struct hash<VULKAN_HPP_NAMESPACE::PipelineShaderStageNodeCreateInfoAMDX>
16056 {
16057 std::size_t
16058 operator()( VULKAN_HPP_NAMESPACE::PipelineShaderStageNodeCreateInfoAMDX const & pipelineShaderStageNodeCreateInfoAMDX ) const VULKAN_HPP_NOEXCEPT
16059 {
16060 std::size_t seed = 0;
16061 VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageNodeCreateInfoAMDX.sType );
16062 VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageNodeCreateInfoAMDX.pNext );
16063 for ( const char * p = pipelineShaderStageNodeCreateInfoAMDX.pName; *p != '\0'; ++p )
16064 {
16065 VULKAN_HPP_HASH_COMBINE( seed, *p );
16066 }
16067 VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageNodeCreateInfoAMDX.index );
16068 return seed;
16069 }
16070 };
16071 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
16072
16073 template <>
16074 struct hash<VULKAN_HPP_NAMESPACE::PipelineShaderStageRequiredSubgroupSizeCreateInfo>
16075 {
16076 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineShaderStageRequiredSubgroupSizeCreateInfo const & pipelineShaderStageRequiredSubgroupSizeCreateInfo )
16077 const VULKAN_HPP_NOEXCEPT
16078 {
16079 std::size_t seed = 0;
16080 VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageRequiredSubgroupSizeCreateInfo.sType );
16081 VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageRequiredSubgroupSizeCreateInfo.pNext );
16082 VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageRequiredSubgroupSizeCreateInfo.requiredSubgroupSize );
16083 return seed;
16084 }
16085 };
16086
16087 template <>
16088 struct hash<VULKAN_HPP_NAMESPACE::PipelineTessellationDomainOriginStateCreateInfo>
16089 {
16090 std::size_t operator()(
16091 VULKAN_HPP_NAMESPACE::PipelineTessellationDomainOriginStateCreateInfo const & pipelineTessellationDomainOriginStateCreateInfo ) const VULKAN_HPP_NOEXCEPT
16092 {
16093 std::size_t seed = 0;
16094 VULKAN_HPP_HASH_COMBINE( seed, pipelineTessellationDomainOriginStateCreateInfo.sType );
16095 VULKAN_HPP_HASH_COMBINE( seed, pipelineTessellationDomainOriginStateCreateInfo.pNext );
16096 VULKAN_HPP_HASH_COMBINE( seed, pipelineTessellationDomainOriginStateCreateInfo.domainOrigin );
16097 return seed;
16098 }
16099 };
16100
16101 template <>
16102 struct hash<VULKAN_HPP_NAMESPACE::VertexInputBindingDivisorDescription>
16103 {
16104 std::size_t operator()( VULKAN_HPP_NAMESPACE::VertexInputBindingDivisorDescription const & vertexInputBindingDivisorDescription ) const VULKAN_HPP_NOEXCEPT
16105 {
16106 std::size_t seed = 0;
16107 VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDivisorDescription.binding );
16108 VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDivisorDescription.divisor );
16109 return seed;
16110 }
16111 };
16112
16113 template <>
16114 struct hash<VULKAN_HPP_NAMESPACE::PipelineVertexInputDivisorStateCreateInfo>
16115 {
16116 std::size_t
16117 operator()( VULKAN_HPP_NAMESPACE::PipelineVertexInputDivisorStateCreateInfo const & pipelineVertexInputDivisorStateCreateInfo ) const VULKAN_HPP_NOEXCEPT
16118 {
16119 std::size_t seed = 0;
16120 VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputDivisorStateCreateInfo.sType );
16121 VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputDivisorStateCreateInfo.pNext );
16122 VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputDivisorStateCreateInfo.vertexBindingDivisorCount );
16123 VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputDivisorStateCreateInfo.pVertexBindingDivisors );
16124 return seed;
16125 }
16126 };
16127
16128 template <>
16129 struct hash<VULKAN_HPP_NAMESPACE::PipelineViewportCoarseSampleOrderStateCreateInfoNV>
16130 {
16131 std::size_t
16132 operator()( VULKAN_HPP_NAMESPACE::PipelineViewportCoarseSampleOrderStateCreateInfoNV const & pipelineViewportCoarseSampleOrderStateCreateInfoNV ) const
16133 VULKAN_HPP_NOEXCEPT
16134 {
16135 std::size_t seed = 0;
16136 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportCoarseSampleOrderStateCreateInfoNV.sType );
16137 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportCoarseSampleOrderStateCreateInfoNV.pNext );
16138 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportCoarseSampleOrderStateCreateInfoNV.sampleOrderType );
16139 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportCoarseSampleOrderStateCreateInfoNV.customSampleOrderCount );
16140 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportCoarseSampleOrderStateCreateInfoNV.pCustomSampleOrders );
16141 return seed;
16142 }
16143 };
16144
16145 template <>
16146 struct hash<VULKAN_HPP_NAMESPACE::PipelineViewportDepthClampControlCreateInfoEXT>
16147 {
16148 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineViewportDepthClampControlCreateInfoEXT const & pipelineViewportDepthClampControlCreateInfoEXT ) const
16149 VULKAN_HPP_NOEXCEPT
16150 {
16151 std::size_t seed = 0;
16152 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportDepthClampControlCreateInfoEXT.sType );
16153 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportDepthClampControlCreateInfoEXT.pNext );
16154 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportDepthClampControlCreateInfoEXT.depthClampMode );
16155 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportDepthClampControlCreateInfoEXT.pDepthClampRange );
16156 return seed;
16157 }
16158 };
16159
16160 template <>
16161 struct hash<VULKAN_HPP_NAMESPACE::PipelineViewportDepthClipControlCreateInfoEXT>
16162 {
16163 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineViewportDepthClipControlCreateInfoEXT const & pipelineViewportDepthClipControlCreateInfoEXT ) const
16164 VULKAN_HPP_NOEXCEPT
16165 {
16166 std::size_t seed = 0;
16167 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportDepthClipControlCreateInfoEXT.sType );
16168 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportDepthClipControlCreateInfoEXT.pNext );
16169 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportDepthClipControlCreateInfoEXT.negativeOneToOne );
16170 return seed;
16171 }
16172 };
16173
16174 template <>
16175 struct hash<VULKAN_HPP_NAMESPACE::PipelineViewportExclusiveScissorStateCreateInfoNV>
16176 {
16177 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineViewportExclusiveScissorStateCreateInfoNV const & pipelineViewportExclusiveScissorStateCreateInfoNV )
16178 const VULKAN_HPP_NOEXCEPT
16179 {
16180 std::size_t seed = 0;
16181 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportExclusiveScissorStateCreateInfoNV.sType );
16182 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportExclusiveScissorStateCreateInfoNV.pNext );
16183 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportExclusiveScissorStateCreateInfoNV.exclusiveScissorCount );
16184 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportExclusiveScissorStateCreateInfoNV.pExclusiveScissors );
16185 return seed;
16186 }
16187 };
16188
16189 template <>
16190 struct hash<VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV>
16191 {
16192 std::size_t operator()( VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV const & shadingRatePaletteNV ) const VULKAN_HPP_NOEXCEPT
16193 {
16194 std::size_t seed = 0;
16195 VULKAN_HPP_HASH_COMBINE( seed, shadingRatePaletteNV.shadingRatePaletteEntryCount );
16196 VULKAN_HPP_HASH_COMBINE( seed, shadingRatePaletteNV.pShadingRatePaletteEntries );
16197 return seed;
16198 }
16199 };
16200
16201 template <>
16202 struct hash<VULKAN_HPP_NAMESPACE::PipelineViewportShadingRateImageStateCreateInfoNV>
16203 {
16204 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineViewportShadingRateImageStateCreateInfoNV const & pipelineViewportShadingRateImageStateCreateInfoNV )
16205 const VULKAN_HPP_NOEXCEPT
16206 {
16207 std::size_t seed = 0;
16208 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportShadingRateImageStateCreateInfoNV.sType );
16209 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportShadingRateImageStateCreateInfoNV.pNext );
16210 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportShadingRateImageStateCreateInfoNV.shadingRateImageEnable );
16211 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportShadingRateImageStateCreateInfoNV.viewportCount );
16212 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportShadingRateImageStateCreateInfoNV.pShadingRatePalettes );
16213 return seed;
16214 }
16215 };
16216
16217 template <>
16218 struct hash<VULKAN_HPP_NAMESPACE::ViewportSwizzleNV>
16219 {
16220 std::size_t operator()( VULKAN_HPP_NAMESPACE::ViewportSwizzleNV const & viewportSwizzleNV ) const VULKAN_HPP_NOEXCEPT
16221 {
16222 std::size_t seed = 0;
16223 VULKAN_HPP_HASH_COMBINE( seed, viewportSwizzleNV.x );
16224 VULKAN_HPP_HASH_COMBINE( seed, viewportSwizzleNV.y );
16225 VULKAN_HPP_HASH_COMBINE( seed, viewportSwizzleNV.z );
16226 VULKAN_HPP_HASH_COMBINE( seed, viewportSwizzleNV.w );
16227 return seed;
16228 }
16229 };
16230
16231 template <>
16232 struct hash<VULKAN_HPP_NAMESPACE::PipelineViewportSwizzleStateCreateInfoNV>
16233 {
16234 std::size_t
16235 operator()( VULKAN_HPP_NAMESPACE::PipelineViewportSwizzleStateCreateInfoNV const & pipelineViewportSwizzleStateCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
16236 {
16237 std::size_t seed = 0;
16238 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportSwizzleStateCreateInfoNV.sType );
16239 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportSwizzleStateCreateInfoNV.pNext );
16240 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportSwizzleStateCreateInfoNV.flags );
16241 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportSwizzleStateCreateInfoNV.viewportCount );
16242 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportSwizzleStateCreateInfoNV.pViewportSwizzles );
16243 return seed;
16244 }
16245 };
16246
16247 template <>
16248 struct hash<VULKAN_HPP_NAMESPACE::ViewportWScalingNV>
16249 {
16250 std::size_t operator()( VULKAN_HPP_NAMESPACE::ViewportWScalingNV const & viewportWScalingNV ) const VULKAN_HPP_NOEXCEPT
16251 {
16252 std::size_t seed = 0;
16253 VULKAN_HPP_HASH_COMBINE( seed, viewportWScalingNV.xcoeff );
16254 VULKAN_HPP_HASH_COMBINE( seed, viewportWScalingNV.ycoeff );
16255 return seed;
16256 }
16257 };
16258
16259 template <>
16260 struct hash<VULKAN_HPP_NAMESPACE::PipelineViewportWScalingStateCreateInfoNV>
16261 {
16262 std::size_t
16263 operator()( VULKAN_HPP_NAMESPACE::PipelineViewportWScalingStateCreateInfoNV const & pipelineViewportWScalingStateCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
16264 {
16265 std::size_t seed = 0;
16266 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportWScalingStateCreateInfoNV.sType );
16267 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportWScalingStateCreateInfoNV.pNext );
16268 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportWScalingStateCreateInfoNV.viewportWScalingEnable );
16269 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportWScalingStateCreateInfoNV.viewportCount );
16270 VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportWScalingStateCreateInfoNV.pViewportWScalings );
16271 return seed;
16272 }
16273 };
16274
16275 # if defined( VK_USE_PLATFORM_GGP )
16276 template <>
16277 struct hash<VULKAN_HPP_NAMESPACE::PresentFrameTokenGGP>
16278 {
16279 std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentFrameTokenGGP const & presentFrameTokenGGP ) const VULKAN_HPP_NOEXCEPT
16280 {
16281 std::size_t seed = 0;
16282 VULKAN_HPP_HASH_COMBINE( seed, presentFrameTokenGGP.sType );
16283 VULKAN_HPP_HASH_COMBINE( seed, presentFrameTokenGGP.pNext );
16284 VULKAN_HPP_HASH_COMBINE( seed, presentFrameTokenGGP.frameToken );
16285 return seed;
16286 }
16287 };
16288 # endif /*VK_USE_PLATFORM_GGP*/
16289
16290 template <>
16291 struct hash<VULKAN_HPP_NAMESPACE::PresentId2KHR>
16292 {
16293 std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentId2KHR const & presentId2KHR ) const VULKAN_HPP_NOEXCEPT
16294 {
16295 std::size_t seed = 0;
16296 VULKAN_HPP_HASH_COMBINE( seed, presentId2KHR.sType );
16297 VULKAN_HPP_HASH_COMBINE( seed, presentId2KHR.pNext );
16298 VULKAN_HPP_HASH_COMBINE( seed, presentId2KHR.swapchainCount );
16299 VULKAN_HPP_HASH_COMBINE( seed, presentId2KHR.pPresentIds );
16300 return seed;
16301 }
16302 };
16303
16304 template <>
16305 struct hash<VULKAN_HPP_NAMESPACE::PresentIdKHR>
16306 {
16307 std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentIdKHR const & presentIdKHR ) const VULKAN_HPP_NOEXCEPT
16308 {
16309 std::size_t seed = 0;
16310 VULKAN_HPP_HASH_COMBINE( seed, presentIdKHR.sType );
16311 VULKAN_HPP_HASH_COMBINE( seed, presentIdKHR.pNext );
16312 VULKAN_HPP_HASH_COMBINE( seed, presentIdKHR.swapchainCount );
16313 VULKAN_HPP_HASH_COMBINE( seed, presentIdKHR.pPresentIds );
16314 return seed;
16315 }
16316 };
16317
16318 template <>
16319 struct hash<VULKAN_HPP_NAMESPACE::PresentInfoKHR>
16320 {
16321 std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentInfoKHR const & presentInfoKHR ) const VULKAN_HPP_NOEXCEPT
16322 {
16323 std::size_t seed = 0;
16324 VULKAN_HPP_HASH_COMBINE( seed, presentInfoKHR.sType );
16325 VULKAN_HPP_HASH_COMBINE( seed, presentInfoKHR.pNext );
16326 VULKAN_HPP_HASH_COMBINE( seed, presentInfoKHR.waitSemaphoreCount );
16327 VULKAN_HPP_HASH_COMBINE( seed, presentInfoKHR.pWaitSemaphores );
16328 VULKAN_HPP_HASH_COMBINE( seed, presentInfoKHR.swapchainCount );
16329 VULKAN_HPP_HASH_COMBINE( seed, presentInfoKHR.pSwapchains );
16330 VULKAN_HPP_HASH_COMBINE( seed, presentInfoKHR.pImageIndices );
16331 VULKAN_HPP_HASH_COMBINE( seed, presentInfoKHR.pResults );
16332 return seed;
16333 }
16334 };
16335
16336 template <>
16337 struct hash<VULKAN_HPP_NAMESPACE::RectLayerKHR>
16338 {
16339 std::size_t operator()( VULKAN_HPP_NAMESPACE::RectLayerKHR const & rectLayerKHR ) const VULKAN_HPP_NOEXCEPT
16340 {
16341 std::size_t seed = 0;
16342 VULKAN_HPP_HASH_COMBINE( seed, rectLayerKHR.offset );
16343 VULKAN_HPP_HASH_COMBINE( seed, rectLayerKHR.extent );
16344 VULKAN_HPP_HASH_COMBINE( seed, rectLayerKHR.layer );
16345 return seed;
16346 }
16347 };
16348
16349 template <>
16350 struct hash<VULKAN_HPP_NAMESPACE::PresentRegionKHR>
16351 {
16352 std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentRegionKHR const & presentRegionKHR ) const VULKAN_HPP_NOEXCEPT
16353 {
16354 std::size_t seed = 0;
16355 VULKAN_HPP_HASH_COMBINE( seed, presentRegionKHR.rectangleCount );
16356 VULKAN_HPP_HASH_COMBINE( seed, presentRegionKHR.pRectangles );
16357 return seed;
16358 }
16359 };
16360
16361 template <>
16362 struct hash<VULKAN_HPP_NAMESPACE::PresentRegionsKHR>
16363 {
16364 std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentRegionsKHR const & presentRegionsKHR ) const VULKAN_HPP_NOEXCEPT
16365 {
16366 std::size_t seed = 0;
16367 VULKAN_HPP_HASH_COMBINE( seed, presentRegionsKHR.sType );
16368 VULKAN_HPP_HASH_COMBINE( seed, presentRegionsKHR.pNext );
16369 VULKAN_HPP_HASH_COMBINE( seed, presentRegionsKHR.swapchainCount );
16370 VULKAN_HPP_HASH_COMBINE( seed, presentRegionsKHR.pRegions );
16371 return seed;
16372 }
16373 };
16374
16375 template <>
16376 struct hash<VULKAN_HPP_NAMESPACE::PresentTimeGOOGLE>
16377 {
16378 std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentTimeGOOGLE const & presentTimeGOOGLE ) const VULKAN_HPP_NOEXCEPT
16379 {
16380 std::size_t seed = 0;
16381 VULKAN_HPP_HASH_COMBINE( seed, presentTimeGOOGLE.presentID );
16382 VULKAN_HPP_HASH_COMBINE( seed, presentTimeGOOGLE.desiredPresentTime );
16383 return seed;
16384 }
16385 };
16386
16387 template <>
16388 struct hash<VULKAN_HPP_NAMESPACE::PresentTimesInfoGOOGLE>
16389 {
16390 std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentTimesInfoGOOGLE const & presentTimesInfoGOOGLE ) const VULKAN_HPP_NOEXCEPT
16391 {
16392 std::size_t seed = 0;
16393 VULKAN_HPP_HASH_COMBINE( seed, presentTimesInfoGOOGLE.sType );
16394 VULKAN_HPP_HASH_COMBINE( seed, presentTimesInfoGOOGLE.pNext );
16395 VULKAN_HPP_HASH_COMBINE( seed, presentTimesInfoGOOGLE.swapchainCount );
16396 VULKAN_HPP_HASH_COMBINE( seed, presentTimesInfoGOOGLE.pTimes );
16397 return seed;
16398 }
16399 };
16400
16401 template <>
16402 struct hash<VULKAN_HPP_NAMESPACE::PresentWait2InfoKHR>
16403 {
16404 std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentWait2InfoKHR const & presentWait2InfoKHR ) const VULKAN_HPP_NOEXCEPT
16405 {
16406 std::size_t seed = 0;
16407 VULKAN_HPP_HASH_COMBINE( seed, presentWait2InfoKHR.sType );
16408 VULKAN_HPP_HASH_COMBINE( seed, presentWait2InfoKHR.pNext );
16409 VULKAN_HPP_HASH_COMBINE( seed, presentWait2InfoKHR.presentId );
16410 VULKAN_HPP_HASH_COMBINE( seed, presentWait2InfoKHR.timeout );
16411 return seed;
16412 }
16413 };
16414
16415 template <>
16416 struct hash<VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo>
16417 {
16418 std::size_t operator()( VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo const & privateDataSlotCreateInfo ) const VULKAN_HPP_NOEXCEPT
16419 {
16420 std::size_t seed = 0;
16421 VULKAN_HPP_HASH_COMBINE( seed, privateDataSlotCreateInfo.sType );
16422 VULKAN_HPP_HASH_COMBINE( seed, privateDataSlotCreateInfo.pNext );
16423 VULKAN_HPP_HASH_COMBINE( seed, privateDataSlotCreateInfo.flags );
16424 return seed;
16425 }
16426 };
16427
16428 template <>
16429 struct hash<VULKAN_HPP_NAMESPACE::ProtectedSubmitInfo>
16430 {
16431 std::size_t operator()( VULKAN_HPP_NAMESPACE::ProtectedSubmitInfo const & protectedSubmitInfo ) const VULKAN_HPP_NOEXCEPT
16432 {
16433 std::size_t seed = 0;
16434 VULKAN_HPP_HASH_COMBINE( seed, protectedSubmitInfo.sType );
16435 VULKAN_HPP_HASH_COMBINE( seed, protectedSubmitInfo.pNext );
16436 VULKAN_HPP_HASH_COMBINE( seed, protectedSubmitInfo.protectedSubmit );
16437 return seed;
16438 }
16439 };
16440
16441 template <>
16442 struct hash<VULKAN_HPP_NAMESPACE::PushConstantsInfo>
16443 {
16444 std::size_t operator()( VULKAN_HPP_NAMESPACE::PushConstantsInfo const & pushConstantsInfo ) const VULKAN_HPP_NOEXCEPT
16445 {
16446 std::size_t seed = 0;
16447 VULKAN_HPP_HASH_COMBINE( seed, pushConstantsInfo.sType );
16448 VULKAN_HPP_HASH_COMBINE( seed, pushConstantsInfo.pNext );
16449 VULKAN_HPP_HASH_COMBINE( seed, pushConstantsInfo.layout );
16450 VULKAN_HPP_HASH_COMBINE( seed, pushConstantsInfo.stageFlags );
16451 VULKAN_HPP_HASH_COMBINE( seed, pushConstantsInfo.offset );
16452 VULKAN_HPP_HASH_COMBINE( seed, pushConstantsInfo.size );
16453 VULKAN_HPP_HASH_COMBINE( seed, pushConstantsInfo.pValues );
16454 return seed;
16455 }
16456 };
16457
16458 template <>
16459 struct hash<VULKAN_HPP_NAMESPACE::WriteDescriptorSet>
16460 {
16461 std::size_t operator()( VULKAN_HPP_NAMESPACE::WriteDescriptorSet const & writeDescriptorSet ) const VULKAN_HPP_NOEXCEPT
16462 {
16463 std::size_t seed = 0;
16464 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.sType );
16465 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.pNext );
16466 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.dstSet );
16467 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.dstBinding );
16468 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.dstArrayElement );
16469 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.descriptorCount );
16470 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.descriptorType );
16471 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.pImageInfo );
16472 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.pBufferInfo );
16473 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.pTexelBufferView );
16474 return seed;
16475 }
16476 };
16477
16478 template <>
16479 struct hash<VULKAN_HPP_NAMESPACE::PushDescriptorSetInfo>
16480 {
16481 std::size_t operator()( VULKAN_HPP_NAMESPACE::PushDescriptorSetInfo const & pushDescriptorSetInfo ) const VULKAN_HPP_NOEXCEPT
16482 {
16483 std::size_t seed = 0;
16484 VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetInfo.sType );
16485 VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetInfo.pNext );
16486 VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetInfo.stageFlags );
16487 VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetInfo.layout );
16488 VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetInfo.set );
16489 VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetInfo.descriptorWriteCount );
16490 VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetInfo.pDescriptorWrites );
16491 return seed;
16492 }
16493 };
16494
16495 template <>
16496 struct hash<VULKAN_HPP_NAMESPACE::PushDescriptorSetWithTemplateInfo>
16497 {
16498 std::size_t operator()( VULKAN_HPP_NAMESPACE::PushDescriptorSetWithTemplateInfo const & pushDescriptorSetWithTemplateInfo ) const VULKAN_HPP_NOEXCEPT
16499 {
16500 std::size_t seed = 0;
16501 VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetWithTemplateInfo.sType );
16502 VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetWithTemplateInfo.pNext );
16503 VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetWithTemplateInfo.descriptorUpdateTemplate );
16504 VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetWithTemplateInfo.layout );
16505 VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetWithTemplateInfo.set );
16506 VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetWithTemplateInfo.pData );
16507 return seed;
16508 }
16509 };
16510
16511 template <>
16512 struct hash<VULKAN_HPP_NAMESPACE::QueryLowLatencySupportNV>
16513 {
16514 std::size_t operator()( VULKAN_HPP_NAMESPACE::QueryLowLatencySupportNV const & queryLowLatencySupportNV ) const VULKAN_HPP_NOEXCEPT
16515 {
16516 std::size_t seed = 0;
16517 VULKAN_HPP_HASH_COMBINE( seed, queryLowLatencySupportNV.sType );
16518 VULKAN_HPP_HASH_COMBINE( seed, queryLowLatencySupportNV.pNext );
16519 VULKAN_HPP_HASH_COMBINE( seed, queryLowLatencySupportNV.pQueriedLowLatencyData );
16520 return seed;
16521 }
16522 };
16523
16524 template <>
16525 struct hash<VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo>
16526 {
16527 std::size_t operator()( VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo const & queryPoolCreateInfo ) const VULKAN_HPP_NOEXCEPT
16528 {
16529 std::size_t seed = 0;
16530 VULKAN_HPP_HASH_COMBINE( seed, queryPoolCreateInfo.sType );
16531 VULKAN_HPP_HASH_COMBINE( seed, queryPoolCreateInfo.pNext );
16532 VULKAN_HPP_HASH_COMBINE( seed, queryPoolCreateInfo.flags );
16533 VULKAN_HPP_HASH_COMBINE( seed, queryPoolCreateInfo.queryType );
16534 VULKAN_HPP_HASH_COMBINE( seed, queryPoolCreateInfo.queryCount );
16535 VULKAN_HPP_HASH_COMBINE( seed, queryPoolCreateInfo.pipelineStatistics );
16536 return seed;
16537 }
16538 };
16539
16540 template <>
16541 struct hash<VULKAN_HPP_NAMESPACE::QueryPoolPerformanceCreateInfoKHR>
16542 {
16543 std::size_t operator()( VULKAN_HPP_NAMESPACE::QueryPoolPerformanceCreateInfoKHR const & queryPoolPerformanceCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
16544 {
16545 std::size_t seed = 0;
16546 VULKAN_HPP_HASH_COMBINE( seed, queryPoolPerformanceCreateInfoKHR.sType );
16547 VULKAN_HPP_HASH_COMBINE( seed, queryPoolPerformanceCreateInfoKHR.pNext );
16548 VULKAN_HPP_HASH_COMBINE( seed, queryPoolPerformanceCreateInfoKHR.queueFamilyIndex );
16549 VULKAN_HPP_HASH_COMBINE( seed, queryPoolPerformanceCreateInfoKHR.counterIndexCount );
16550 VULKAN_HPP_HASH_COMBINE( seed, queryPoolPerformanceCreateInfoKHR.pCounterIndices );
16551 return seed;
16552 }
16553 };
16554
16555 template <>
16556 struct hash<VULKAN_HPP_NAMESPACE::QueryPoolPerformanceQueryCreateInfoINTEL>
16557 {
16558 std::size_t
16559 operator()( VULKAN_HPP_NAMESPACE::QueryPoolPerformanceQueryCreateInfoINTEL const & queryPoolPerformanceQueryCreateInfoINTEL ) const VULKAN_HPP_NOEXCEPT
16560 {
16561 std::size_t seed = 0;
16562 VULKAN_HPP_HASH_COMBINE( seed, queryPoolPerformanceQueryCreateInfoINTEL.sType );
16563 VULKAN_HPP_HASH_COMBINE( seed, queryPoolPerformanceQueryCreateInfoINTEL.pNext );
16564 VULKAN_HPP_HASH_COMBINE( seed, queryPoolPerformanceQueryCreateInfoINTEL.performanceCountersSampling );
16565 return seed;
16566 }
16567 };
16568
16569 template <>
16570 struct hash<VULKAN_HPP_NAMESPACE::QueryPoolVideoEncodeFeedbackCreateInfoKHR>
16571 {
16572 std::size_t
16573 operator()( VULKAN_HPP_NAMESPACE::QueryPoolVideoEncodeFeedbackCreateInfoKHR const & queryPoolVideoEncodeFeedbackCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
16574 {
16575 std::size_t seed = 0;
16576 VULKAN_HPP_HASH_COMBINE( seed, queryPoolVideoEncodeFeedbackCreateInfoKHR.sType );
16577 VULKAN_HPP_HASH_COMBINE( seed, queryPoolVideoEncodeFeedbackCreateInfoKHR.pNext );
16578 VULKAN_HPP_HASH_COMBINE( seed, queryPoolVideoEncodeFeedbackCreateInfoKHR.encodeFeedbackFlags );
16579 return seed;
16580 }
16581 };
16582
16583 template <>
16584 struct hash<VULKAN_HPP_NAMESPACE::QueueFamilyCheckpointProperties2NV>
16585 {
16586 std::size_t operator()( VULKAN_HPP_NAMESPACE::QueueFamilyCheckpointProperties2NV const & queueFamilyCheckpointProperties2NV ) const VULKAN_HPP_NOEXCEPT
16587 {
16588 std::size_t seed = 0;
16589 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyCheckpointProperties2NV.sType );
16590 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyCheckpointProperties2NV.pNext );
16591 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyCheckpointProperties2NV.checkpointExecutionStageMask );
16592 return seed;
16593 }
16594 };
16595
16596 template <>
16597 struct hash<VULKAN_HPP_NAMESPACE::QueueFamilyCheckpointPropertiesNV>
16598 {
16599 std::size_t operator()( VULKAN_HPP_NAMESPACE::QueueFamilyCheckpointPropertiesNV const & queueFamilyCheckpointPropertiesNV ) const VULKAN_HPP_NOEXCEPT
16600 {
16601 std::size_t seed = 0;
16602 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyCheckpointPropertiesNV.sType );
16603 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyCheckpointPropertiesNV.pNext );
16604 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyCheckpointPropertiesNV.checkpointExecutionStageMask );
16605 return seed;
16606 }
16607 };
16608
16609 template <>
16610 struct hash<VULKAN_HPP_NAMESPACE::QueueFamilyDataGraphProcessingEnginePropertiesARM>
16611 {
16612 std::size_t operator()( VULKAN_HPP_NAMESPACE::QueueFamilyDataGraphProcessingEnginePropertiesARM const & queueFamilyDataGraphProcessingEnginePropertiesARM )
16613 const VULKAN_HPP_NOEXCEPT
16614 {
16615 std::size_t seed = 0;
16616 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyDataGraphProcessingEnginePropertiesARM.sType );
16617 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyDataGraphProcessingEnginePropertiesARM.pNext );
16618 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyDataGraphProcessingEnginePropertiesARM.foreignSemaphoreHandleTypes );
16619 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyDataGraphProcessingEnginePropertiesARM.foreignMemoryHandleTypes );
16620 return seed;
16621 }
16622 };
16623
16624 template <>
16625 struct hash<VULKAN_HPP_NAMESPACE::QueueFamilyDataGraphPropertiesARM>
16626 {
16627 std::size_t operator()( VULKAN_HPP_NAMESPACE::QueueFamilyDataGraphPropertiesARM const & queueFamilyDataGraphPropertiesARM ) const VULKAN_HPP_NOEXCEPT
16628 {
16629 std::size_t seed = 0;
16630 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyDataGraphPropertiesARM.sType );
16631 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyDataGraphPropertiesARM.pNext );
16632 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyDataGraphPropertiesARM.engine );
16633 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyDataGraphPropertiesARM.operation );
16634 return seed;
16635 }
16636 };
16637
16638 template <>
16639 struct hash<VULKAN_HPP_NAMESPACE::QueueFamilyGlobalPriorityProperties>
16640 {
16641 std::size_t operator()( VULKAN_HPP_NAMESPACE::QueueFamilyGlobalPriorityProperties const & queueFamilyGlobalPriorityProperties ) const VULKAN_HPP_NOEXCEPT
16642 {
16643 std::size_t seed = 0;
16644 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyGlobalPriorityProperties.sType );
16645 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyGlobalPriorityProperties.pNext );
16646 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyGlobalPriorityProperties.priorityCount );
16647 for ( size_t i = 0; i < VK_MAX_GLOBAL_PRIORITY_SIZE; ++i )
16648 {
16649 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyGlobalPriorityProperties.priorities[i] );
16650 }
16651 return seed;
16652 }
16653 };
16654
16655 template <>
16656 struct hash<VULKAN_HPP_NAMESPACE::QueueFamilyOwnershipTransferPropertiesKHR>
16657 {
16658 std::size_t
16659 operator()( VULKAN_HPP_NAMESPACE::QueueFamilyOwnershipTransferPropertiesKHR const & queueFamilyOwnershipTransferPropertiesKHR ) const VULKAN_HPP_NOEXCEPT
16660 {
16661 std::size_t seed = 0;
16662 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyOwnershipTransferPropertiesKHR.sType );
16663 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyOwnershipTransferPropertiesKHR.pNext );
16664 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyOwnershipTransferPropertiesKHR.optimalImageTransferToQueueFamilies );
16665 return seed;
16666 }
16667 };
16668
16669 template <>
16670 struct hash<VULKAN_HPP_NAMESPACE::QueueFamilyProperties>
16671 {
16672 std::size_t operator()( VULKAN_HPP_NAMESPACE::QueueFamilyProperties const & queueFamilyProperties ) const VULKAN_HPP_NOEXCEPT
16673 {
16674 std::size_t seed = 0;
16675 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyProperties.queueFlags );
16676 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyProperties.queueCount );
16677 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyProperties.timestampValidBits );
16678 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyProperties.minImageTransferGranularity );
16679 return seed;
16680 }
16681 };
16682
16683 template <>
16684 struct hash<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>
16685 {
16686 std::size_t operator()( VULKAN_HPP_NAMESPACE::QueueFamilyProperties2 const & queueFamilyProperties2 ) const VULKAN_HPP_NOEXCEPT
16687 {
16688 std::size_t seed = 0;
16689 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyProperties2.sType );
16690 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyProperties2.pNext );
16691 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyProperties2.queueFamilyProperties );
16692 return seed;
16693 }
16694 };
16695
16696 template <>
16697 struct hash<VULKAN_HPP_NAMESPACE::QueueFamilyQueryResultStatusPropertiesKHR>
16698 {
16699 std::size_t
16700 operator()( VULKAN_HPP_NAMESPACE::QueueFamilyQueryResultStatusPropertiesKHR const & queueFamilyQueryResultStatusPropertiesKHR ) const VULKAN_HPP_NOEXCEPT
16701 {
16702 std::size_t seed = 0;
16703 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyQueryResultStatusPropertiesKHR.sType );
16704 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyQueryResultStatusPropertiesKHR.pNext );
16705 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyQueryResultStatusPropertiesKHR.queryResultStatusSupport );
16706 return seed;
16707 }
16708 };
16709
16710 template <>
16711 struct hash<VULKAN_HPP_NAMESPACE::QueueFamilyVideoPropertiesKHR>
16712 {
16713 std::size_t operator()( VULKAN_HPP_NAMESPACE::QueueFamilyVideoPropertiesKHR const & queueFamilyVideoPropertiesKHR ) const VULKAN_HPP_NOEXCEPT
16714 {
16715 std::size_t seed = 0;
16716 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyVideoPropertiesKHR.sType );
16717 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyVideoPropertiesKHR.pNext );
16718 VULKAN_HPP_HASH_COMBINE( seed, queueFamilyVideoPropertiesKHR.videoCodecOperations );
16719 return seed;
16720 }
16721 };
16722
16723 template <>
16724 struct hash<VULKAN_HPP_NAMESPACE::RayTracingPipelineClusterAccelerationStructureCreateInfoNV>
16725 {
16726 std::size_t operator()( VULKAN_HPP_NAMESPACE::RayTracingPipelineClusterAccelerationStructureCreateInfoNV const &
16727 rayTracingPipelineClusterAccelerationStructureCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
16728 {
16729 std::size_t seed = 0;
16730 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineClusterAccelerationStructureCreateInfoNV.sType );
16731 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineClusterAccelerationStructureCreateInfoNV.pNext );
16732 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineClusterAccelerationStructureCreateInfoNV.allowClusterAccelerationStructure );
16733 return seed;
16734 }
16735 };
16736
16737 template <>
16738 struct hash<VULKAN_HPP_NAMESPACE::RayTracingShaderGroupCreateInfoKHR>
16739 {
16740 std::size_t operator()( VULKAN_HPP_NAMESPACE::RayTracingShaderGroupCreateInfoKHR const & rayTracingShaderGroupCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
16741 {
16742 std::size_t seed = 0;
16743 VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoKHR.sType );
16744 VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoKHR.pNext );
16745 VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoKHR.type );
16746 VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoKHR.generalShader );
16747 VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoKHR.closestHitShader );
16748 VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoKHR.anyHitShader );
16749 VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoKHR.intersectionShader );
16750 VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoKHR.pShaderGroupCaptureReplayHandle );
16751 return seed;
16752 }
16753 };
16754
16755 template <>
16756 struct hash<VULKAN_HPP_NAMESPACE::RayTracingPipelineInterfaceCreateInfoKHR>
16757 {
16758 std::size_t
16759 operator()( VULKAN_HPP_NAMESPACE::RayTracingPipelineInterfaceCreateInfoKHR const & rayTracingPipelineInterfaceCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
16760 {
16761 std::size_t seed = 0;
16762 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineInterfaceCreateInfoKHR.sType );
16763 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineInterfaceCreateInfoKHR.pNext );
16764 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineInterfaceCreateInfoKHR.maxPipelineRayPayloadSize );
16765 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineInterfaceCreateInfoKHR.maxPipelineRayHitAttributeSize );
16766 return seed;
16767 }
16768 };
16769
16770 template <>
16771 struct hash<VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR>
16772 {
16773 std::size_t operator()( VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR const & rayTracingPipelineCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
16774 {
16775 std::size_t seed = 0;
16776 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.sType );
16777 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.pNext );
16778 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.flags );
16779 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.stageCount );
16780 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.pStages );
16781 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.groupCount );
16782 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.pGroups );
16783 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.maxPipelineRayRecursionDepth );
16784 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.pLibraryInfo );
16785 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.pLibraryInterface );
16786 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.pDynamicState );
16787 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.layout );
16788 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.basePipelineHandle );
16789 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.basePipelineIndex );
16790 return seed;
16791 }
16792 };
16793
16794 template <>
16795 struct hash<VULKAN_HPP_NAMESPACE::RayTracingShaderGroupCreateInfoNV>
16796 {
16797 std::size_t operator()( VULKAN_HPP_NAMESPACE::RayTracingShaderGroupCreateInfoNV const & rayTracingShaderGroupCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
16798 {
16799 std::size_t seed = 0;
16800 VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoNV.sType );
16801 VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoNV.pNext );
16802 VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoNV.type );
16803 VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoNV.generalShader );
16804 VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoNV.closestHitShader );
16805 VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoNV.anyHitShader );
16806 VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoNV.intersectionShader );
16807 return seed;
16808 }
16809 };
16810
16811 template <>
16812 struct hash<VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV>
16813 {
16814 std::size_t operator()( VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV const & rayTracingPipelineCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
16815 {
16816 std::size_t seed = 0;
16817 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.sType );
16818 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.pNext );
16819 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.flags );
16820 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.stageCount );
16821 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.pStages );
16822 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.groupCount );
16823 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.pGroups );
16824 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.maxRecursionDepth );
16825 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.layout );
16826 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.basePipelineHandle );
16827 VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.basePipelineIndex );
16828 return seed;
16829 }
16830 };
16831
16832 template <>
16833 struct hash<VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE>
16834 {
16835 std::size_t operator()( VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE const & refreshCycleDurationGOOGLE ) const VULKAN_HPP_NOEXCEPT
16836 {
16837 std::size_t seed = 0;
16838 VULKAN_HPP_HASH_COMBINE( seed, refreshCycleDurationGOOGLE.refreshDuration );
16839 return seed;
16840 }
16841 };
16842
16843 template <>
16844 struct hash<VULKAN_HPP_NAMESPACE::ReleaseCapturedPipelineDataInfoKHR>
16845 {
16846 std::size_t operator()( VULKAN_HPP_NAMESPACE::ReleaseCapturedPipelineDataInfoKHR const & releaseCapturedPipelineDataInfoKHR ) const VULKAN_HPP_NOEXCEPT
16847 {
16848 std::size_t seed = 0;
16849 VULKAN_HPP_HASH_COMBINE( seed, releaseCapturedPipelineDataInfoKHR.sType );
16850 VULKAN_HPP_HASH_COMBINE( seed, releaseCapturedPipelineDataInfoKHR.pNext );
16851 VULKAN_HPP_HASH_COMBINE( seed, releaseCapturedPipelineDataInfoKHR.pipeline );
16852 return seed;
16853 }
16854 };
16855
16856 template <>
16857 struct hash<VULKAN_HPP_NAMESPACE::ReleaseSwapchainImagesInfoKHR>
16858 {
16859 std::size_t operator()( VULKAN_HPP_NAMESPACE::ReleaseSwapchainImagesInfoKHR const & releaseSwapchainImagesInfoKHR ) const VULKAN_HPP_NOEXCEPT
16860 {
16861 std::size_t seed = 0;
16862 VULKAN_HPP_HASH_COMBINE( seed, releaseSwapchainImagesInfoKHR.sType );
16863 VULKAN_HPP_HASH_COMBINE( seed, releaseSwapchainImagesInfoKHR.pNext );
16864 VULKAN_HPP_HASH_COMBINE( seed, releaseSwapchainImagesInfoKHR.swapchain );
16865 VULKAN_HPP_HASH_COMBINE( seed, releaseSwapchainImagesInfoKHR.imageIndexCount );
16866 VULKAN_HPP_HASH_COMBINE( seed, releaseSwapchainImagesInfoKHR.pImageIndices );
16867 return seed;
16868 }
16869 };
16870
16871 template <>
16872 struct hash<VULKAN_HPP_NAMESPACE::RenderPassAttachmentBeginInfo>
16873 {
16874 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassAttachmentBeginInfo const & renderPassAttachmentBeginInfo ) const VULKAN_HPP_NOEXCEPT
16875 {
16876 std::size_t seed = 0;
16877 VULKAN_HPP_HASH_COMBINE( seed, renderPassAttachmentBeginInfo.sType );
16878 VULKAN_HPP_HASH_COMBINE( seed, renderPassAttachmentBeginInfo.pNext );
16879 VULKAN_HPP_HASH_COMBINE( seed, renderPassAttachmentBeginInfo.attachmentCount );
16880 VULKAN_HPP_HASH_COMBINE( seed, renderPassAttachmentBeginInfo.pAttachments );
16881 return seed;
16882 }
16883 };
16884
16885 template <>
16886 struct hash<VULKAN_HPP_NAMESPACE::RenderPassBeginInfo>
16887 {
16888 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassBeginInfo const & renderPassBeginInfo ) const VULKAN_HPP_NOEXCEPT
16889 {
16890 std::size_t seed = 0;
16891 VULKAN_HPP_HASH_COMBINE( seed, renderPassBeginInfo.sType );
16892 VULKAN_HPP_HASH_COMBINE( seed, renderPassBeginInfo.pNext );
16893 VULKAN_HPP_HASH_COMBINE( seed, renderPassBeginInfo.renderPass );
16894 VULKAN_HPP_HASH_COMBINE( seed, renderPassBeginInfo.framebuffer );
16895 VULKAN_HPP_HASH_COMBINE( seed, renderPassBeginInfo.renderArea );
16896 VULKAN_HPP_HASH_COMBINE( seed, renderPassBeginInfo.clearValueCount );
16897 VULKAN_HPP_HASH_COMBINE( seed, renderPassBeginInfo.pClearValues );
16898 return seed;
16899 }
16900 };
16901
16902 template <>
16903 struct hash<VULKAN_HPP_NAMESPACE::SubpassDescription>
16904 {
16905 std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassDescription const & subpassDescription ) const VULKAN_HPP_NOEXCEPT
16906 {
16907 std::size_t seed = 0;
16908 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.flags );
16909 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.pipelineBindPoint );
16910 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.inputAttachmentCount );
16911 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.pInputAttachments );
16912 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.colorAttachmentCount );
16913 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.pColorAttachments );
16914 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.pResolveAttachments );
16915 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.pDepthStencilAttachment );
16916 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.preserveAttachmentCount );
16917 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.pPreserveAttachments );
16918 return seed;
16919 }
16920 };
16921
16922 template <>
16923 struct hash<VULKAN_HPP_NAMESPACE::SubpassDependency>
16924 {
16925 std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassDependency const & subpassDependency ) const VULKAN_HPP_NOEXCEPT
16926 {
16927 std::size_t seed = 0;
16928 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency.srcSubpass );
16929 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency.dstSubpass );
16930 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency.srcStageMask );
16931 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency.dstStageMask );
16932 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency.srcAccessMask );
16933 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency.dstAccessMask );
16934 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency.dependencyFlags );
16935 return seed;
16936 }
16937 };
16938
16939 template <>
16940 struct hash<VULKAN_HPP_NAMESPACE::RenderPassCreateInfo>
16941 {
16942 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassCreateInfo const & renderPassCreateInfo ) const VULKAN_HPP_NOEXCEPT
16943 {
16944 std::size_t seed = 0;
16945 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo.sType );
16946 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo.pNext );
16947 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo.flags );
16948 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo.attachmentCount );
16949 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo.pAttachments );
16950 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo.subpassCount );
16951 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo.pSubpasses );
16952 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo.dependencyCount );
16953 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo.pDependencies );
16954 return seed;
16955 }
16956 };
16957
16958 template <>
16959 struct hash<VULKAN_HPP_NAMESPACE::SubpassDescription2>
16960 {
16961 std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassDescription2 const & subpassDescription2 ) const VULKAN_HPP_NOEXCEPT
16962 {
16963 std::size_t seed = 0;
16964 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.sType );
16965 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.pNext );
16966 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.flags );
16967 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.pipelineBindPoint );
16968 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.viewMask );
16969 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.inputAttachmentCount );
16970 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.pInputAttachments );
16971 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.colorAttachmentCount );
16972 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.pColorAttachments );
16973 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.pResolveAttachments );
16974 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.pDepthStencilAttachment );
16975 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.preserveAttachmentCount );
16976 VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.pPreserveAttachments );
16977 return seed;
16978 }
16979 };
16980
16981 template <>
16982 struct hash<VULKAN_HPP_NAMESPACE::SubpassDependency2>
16983 {
16984 std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassDependency2 const & subpassDependency2 ) const VULKAN_HPP_NOEXCEPT
16985 {
16986 std::size_t seed = 0;
16987 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.sType );
16988 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.pNext );
16989 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.srcSubpass );
16990 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.dstSubpass );
16991 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.srcStageMask );
16992 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.dstStageMask );
16993 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.srcAccessMask );
16994 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.dstAccessMask );
16995 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.dependencyFlags );
16996 VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.viewOffset );
16997 return seed;
16998 }
16999 };
17000
17001 template <>
17002 struct hash<VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2>
17003 {
17004 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 const & renderPassCreateInfo2 ) const VULKAN_HPP_NOEXCEPT
17005 {
17006 std::size_t seed = 0;
17007 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.sType );
17008 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.pNext );
17009 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.flags );
17010 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.attachmentCount );
17011 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.pAttachments );
17012 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.subpassCount );
17013 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.pSubpasses );
17014 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.dependencyCount );
17015 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.pDependencies );
17016 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.correlatedViewMaskCount );
17017 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.pCorrelatedViewMasks );
17018 return seed;
17019 }
17020 };
17021
17022 template <>
17023 struct hash<VULKAN_HPP_NAMESPACE::RenderPassCreationControlEXT>
17024 {
17025 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassCreationControlEXT const & renderPassCreationControlEXT ) const VULKAN_HPP_NOEXCEPT
17026 {
17027 std::size_t seed = 0;
17028 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreationControlEXT.sType );
17029 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreationControlEXT.pNext );
17030 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreationControlEXT.disallowMerging );
17031 return seed;
17032 }
17033 };
17034
17035 template <>
17036 struct hash<VULKAN_HPP_NAMESPACE::RenderPassCreationFeedbackInfoEXT>
17037 {
17038 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassCreationFeedbackInfoEXT const & renderPassCreationFeedbackInfoEXT ) const VULKAN_HPP_NOEXCEPT
17039 {
17040 std::size_t seed = 0;
17041 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreationFeedbackInfoEXT.postMergeSubpassCount );
17042 return seed;
17043 }
17044 };
17045
17046 template <>
17047 struct hash<VULKAN_HPP_NAMESPACE::RenderPassCreationFeedbackCreateInfoEXT>
17048 {
17049 std::size_t
17050 operator()( VULKAN_HPP_NAMESPACE::RenderPassCreationFeedbackCreateInfoEXT const & renderPassCreationFeedbackCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
17051 {
17052 std::size_t seed = 0;
17053 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreationFeedbackCreateInfoEXT.sType );
17054 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreationFeedbackCreateInfoEXT.pNext );
17055 VULKAN_HPP_HASH_COMBINE( seed, renderPassCreationFeedbackCreateInfoEXT.pRenderPassFeedback );
17056 return seed;
17057 }
17058 };
17059
17060 template <>
17061 struct hash<VULKAN_HPP_NAMESPACE::RenderPassFragmentDensityMapCreateInfoEXT>
17062 {
17063 std::size_t
17064 operator()( VULKAN_HPP_NAMESPACE::RenderPassFragmentDensityMapCreateInfoEXT const & renderPassFragmentDensityMapCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
17065 {
17066 std::size_t seed = 0;
17067 VULKAN_HPP_HASH_COMBINE( seed, renderPassFragmentDensityMapCreateInfoEXT.sType );
17068 VULKAN_HPP_HASH_COMBINE( seed, renderPassFragmentDensityMapCreateInfoEXT.pNext );
17069 VULKAN_HPP_HASH_COMBINE( seed, renderPassFragmentDensityMapCreateInfoEXT.fragmentDensityMapAttachment );
17070 return seed;
17071 }
17072 };
17073
17074 template <>
17075 struct hash<VULKAN_HPP_NAMESPACE::RenderPassFragmentDensityMapOffsetEndInfoEXT>
17076 {
17077 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassFragmentDensityMapOffsetEndInfoEXT const & renderPassFragmentDensityMapOffsetEndInfoEXT ) const
17078 VULKAN_HPP_NOEXCEPT
17079 {
17080 std::size_t seed = 0;
17081 VULKAN_HPP_HASH_COMBINE( seed, renderPassFragmentDensityMapOffsetEndInfoEXT.sType );
17082 VULKAN_HPP_HASH_COMBINE( seed, renderPassFragmentDensityMapOffsetEndInfoEXT.pNext );
17083 VULKAN_HPP_HASH_COMBINE( seed, renderPassFragmentDensityMapOffsetEndInfoEXT.fragmentDensityOffsetCount );
17084 VULKAN_HPP_HASH_COMBINE( seed, renderPassFragmentDensityMapOffsetEndInfoEXT.pFragmentDensityOffsets );
17085 return seed;
17086 }
17087 };
17088
17089 template <>
17090 struct hash<VULKAN_HPP_NAMESPACE::RenderPassInputAttachmentAspectCreateInfo>
17091 {
17092 std::size_t
17093 operator()( VULKAN_HPP_NAMESPACE::RenderPassInputAttachmentAspectCreateInfo const & renderPassInputAttachmentAspectCreateInfo ) const VULKAN_HPP_NOEXCEPT
17094 {
17095 std::size_t seed = 0;
17096 VULKAN_HPP_HASH_COMBINE( seed, renderPassInputAttachmentAspectCreateInfo.sType );
17097 VULKAN_HPP_HASH_COMBINE( seed, renderPassInputAttachmentAspectCreateInfo.pNext );
17098 VULKAN_HPP_HASH_COMBINE( seed, renderPassInputAttachmentAspectCreateInfo.aspectReferenceCount );
17099 VULKAN_HPP_HASH_COMBINE( seed, renderPassInputAttachmentAspectCreateInfo.pAspectReferences );
17100 return seed;
17101 }
17102 };
17103
17104 template <>
17105 struct hash<VULKAN_HPP_NAMESPACE::RenderPassMultiviewCreateInfo>
17106 {
17107 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassMultiviewCreateInfo const & renderPassMultiviewCreateInfo ) const VULKAN_HPP_NOEXCEPT
17108 {
17109 std::size_t seed = 0;
17110 VULKAN_HPP_HASH_COMBINE( seed, renderPassMultiviewCreateInfo.sType );
17111 VULKAN_HPP_HASH_COMBINE( seed, renderPassMultiviewCreateInfo.pNext );
17112 VULKAN_HPP_HASH_COMBINE( seed, renderPassMultiviewCreateInfo.subpassCount );
17113 VULKAN_HPP_HASH_COMBINE( seed, renderPassMultiviewCreateInfo.pViewMasks );
17114 VULKAN_HPP_HASH_COMBINE( seed, renderPassMultiviewCreateInfo.dependencyCount );
17115 VULKAN_HPP_HASH_COMBINE( seed, renderPassMultiviewCreateInfo.pViewOffsets );
17116 VULKAN_HPP_HASH_COMBINE( seed, renderPassMultiviewCreateInfo.correlationMaskCount );
17117 VULKAN_HPP_HASH_COMBINE( seed, renderPassMultiviewCreateInfo.pCorrelationMasks );
17118 return seed;
17119 }
17120 };
17121
17122 template <>
17123 struct hash<VULKAN_HPP_NAMESPACE::RenderPassPerformanceCountersByRegionBeginInfoARM>
17124 {
17125 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassPerformanceCountersByRegionBeginInfoARM const & renderPassPerformanceCountersByRegionBeginInfoARM )
17126 const VULKAN_HPP_NOEXCEPT
17127 {
17128 std::size_t seed = 0;
17129 VULKAN_HPP_HASH_COMBINE( seed, renderPassPerformanceCountersByRegionBeginInfoARM.sType );
17130 VULKAN_HPP_HASH_COMBINE( seed, renderPassPerformanceCountersByRegionBeginInfoARM.pNext );
17131 VULKAN_HPP_HASH_COMBINE( seed, renderPassPerformanceCountersByRegionBeginInfoARM.counterAddressCount );
17132 VULKAN_HPP_HASH_COMBINE( seed, renderPassPerformanceCountersByRegionBeginInfoARM.pCounterAddresses );
17133 VULKAN_HPP_HASH_COMBINE( seed, renderPassPerformanceCountersByRegionBeginInfoARM.serializeRegions );
17134 VULKAN_HPP_HASH_COMBINE( seed, renderPassPerformanceCountersByRegionBeginInfoARM.counterIndexCount );
17135 VULKAN_HPP_HASH_COMBINE( seed, renderPassPerformanceCountersByRegionBeginInfoARM.pCounterIndices );
17136 return seed;
17137 }
17138 };
17139
17140 template <>
17141 struct hash<VULKAN_HPP_NAMESPACE::SubpassSampleLocationsEXT>
17142 {
17143 std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassSampleLocationsEXT const & subpassSampleLocationsEXT ) const VULKAN_HPP_NOEXCEPT
17144 {
17145 std::size_t seed = 0;
17146 VULKAN_HPP_HASH_COMBINE( seed, subpassSampleLocationsEXT.subpassIndex );
17147 VULKAN_HPP_HASH_COMBINE( seed, subpassSampleLocationsEXT.sampleLocationsInfo );
17148 return seed;
17149 }
17150 };
17151
17152 template <>
17153 struct hash<VULKAN_HPP_NAMESPACE::RenderPassSampleLocationsBeginInfoEXT>
17154 {
17155 std::size_t
17156 operator()( VULKAN_HPP_NAMESPACE::RenderPassSampleLocationsBeginInfoEXT const & renderPassSampleLocationsBeginInfoEXT ) const VULKAN_HPP_NOEXCEPT
17157 {
17158 std::size_t seed = 0;
17159 VULKAN_HPP_HASH_COMBINE( seed, renderPassSampleLocationsBeginInfoEXT.sType );
17160 VULKAN_HPP_HASH_COMBINE( seed, renderPassSampleLocationsBeginInfoEXT.pNext );
17161 VULKAN_HPP_HASH_COMBINE( seed, renderPassSampleLocationsBeginInfoEXT.attachmentInitialSampleLocationsCount );
17162 VULKAN_HPP_HASH_COMBINE( seed, renderPassSampleLocationsBeginInfoEXT.pAttachmentInitialSampleLocations );
17163 VULKAN_HPP_HASH_COMBINE( seed, renderPassSampleLocationsBeginInfoEXT.postSubpassSampleLocationsCount );
17164 VULKAN_HPP_HASH_COMBINE( seed, renderPassSampleLocationsBeginInfoEXT.pPostSubpassSampleLocations );
17165 return seed;
17166 }
17167 };
17168
17169 template <>
17170 struct hash<VULKAN_HPP_NAMESPACE::RenderPassStripeInfoARM>
17171 {
17172 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassStripeInfoARM const & renderPassStripeInfoARM ) const VULKAN_HPP_NOEXCEPT
17173 {
17174 std::size_t seed = 0;
17175 VULKAN_HPP_HASH_COMBINE( seed, renderPassStripeInfoARM.sType );
17176 VULKAN_HPP_HASH_COMBINE( seed, renderPassStripeInfoARM.pNext );
17177 VULKAN_HPP_HASH_COMBINE( seed, renderPassStripeInfoARM.stripeArea );
17178 return seed;
17179 }
17180 };
17181
17182 template <>
17183 struct hash<VULKAN_HPP_NAMESPACE::RenderPassStripeBeginInfoARM>
17184 {
17185 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassStripeBeginInfoARM const & renderPassStripeBeginInfoARM ) const VULKAN_HPP_NOEXCEPT
17186 {
17187 std::size_t seed = 0;
17188 VULKAN_HPP_HASH_COMBINE( seed, renderPassStripeBeginInfoARM.sType );
17189 VULKAN_HPP_HASH_COMBINE( seed, renderPassStripeBeginInfoARM.pNext );
17190 VULKAN_HPP_HASH_COMBINE( seed, renderPassStripeBeginInfoARM.stripeInfoCount );
17191 VULKAN_HPP_HASH_COMBINE( seed, renderPassStripeBeginInfoARM.pStripeInfos );
17192 return seed;
17193 }
17194 };
17195
17196 template <>
17197 struct hash<VULKAN_HPP_NAMESPACE::SemaphoreSubmitInfo>
17198 {
17199 std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreSubmitInfo const & semaphoreSubmitInfo ) const VULKAN_HPP_NOEXCEPT
17200 {
17201 std::size_t seed = 0;
17202 VULKAN_HPP_HASH_COMBINE( seed, semaphoreSubmitInfo.sType );
17203 VULKAN_HPP_HASH_COMBINE( seed, semaphoreSubmitInfo.pNext );
17204 VULKAN_HPP_HASH_COMBINE( seed, semaphoreSubmitInfo.semaphore );
17205 VULKAN_HPP_HASH_COMBINE( seed, semaphoreSubmitInfo.value );
17206 VULKAN_HPP_HASH_COMBINE( seed, semaphoreSubmitInfo.stageMask );
17207 VULKAN_HPP_HASH_COMBINE( seed, semaphoreSubmitInfo.deviceIndex );
17208 return seed;
17209 }
17210 };
17211
17212 template <>
17213 struct hash<VULKAN_HPP_NAMESPACE::RenderPassStripeSubmitInfoARM>
17214 {
17215 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassStripeSubmitInfoARM const & renderPassStripeSubmitInfoARM ) const VULKAN_HPP_NOEXCEPT
17216 {
17217 std::size_t seed = 0;
17218 VULKAN_HPP_HASH_COMBINE( seed, renderPassStripeSubmitInfoARM.sType );
17219 VULKAN_HPP_HASH_COMBINE( seed, renderPassStripeSubmitInfoARM.pNext );
17220 VULKAN_HPP_HASH_COMBINE( seed, renderPassStripeSubmitInfoARM.stripeSemaphoreInfoCount );
17221 VULKAN_HPP_HASH_COMBINE( seed, renderPassStripeSubmitInfoARM.pStripeSemaphoreInfos );
17222 return seed;
17223 }
17224 };
17225
17226 template <>
17227 struct hash<VULKAN_HPP_NAMESPACE::RenderPassSubpassFeedbackInfoEXT>
17228 {
17229 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassSubpassFeedbackInfoEXT const & renderPassSubpassFeedbackInfoEXT ) const VULKAN_HPP_NOEXCEPT
17230 {
17231 std::size_t seed = 0;
17232 VULKAN_HPP_HASH_COMBINE( seed, renderPassSubpassFeedbackInfoEXT.subpassMergeStatus );
17233 for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i )
17234 {
17235 VULKAN_HPP_HASH_COMBINE( seed, renderPassSubpassFeedbackInfoEXT.description[i] );
17236 }
17237 VULKAN_HPP_HASH_COMBINE( seed, renderPassSubpassFeedbackInfoEXT.postMergeIndex );
17238 return seed;
17239 }
17240 };
17241
17242 template <>
17243 struct hash<VULKAN_HPP_NAMESPACE::RenderPassSubpassFeedbackCreateInfoEXT>
17244 {
17245 std::size_t
17246 operator()( VULKAN_HPP_NAMESPACE::RenderPassSubpassFeedbackCreateInfoEXT const & renderPassSubpassFeedbackCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
17247 {
17248 std::size_t seed = 0;
17249 VULKAN_HPP_HASH_COMBINE( seed, renderPassSubpassFeedbackCreateInfoEXT.sType );
17250 VULKAN_HPP_HASH_COMBINE( seed, renderPassSubpassFeedbackCreateInfoEXT.pNext );
17251 VULKAN_HPP_HASH_COMBINE( seed, renderPassSubpassFeedbackCreateInfoEXT.pSubpassFeedback );
17252 return seed;
17253 }
17254 };
17255
17256 template <>
17257 struct hash<VULKAN_HPP_NAMESPACE::RenderPassTileShadingCreateInfoQCOM>
17258 {
17259 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassTileShadingCreateInfoQCOM const & renderPassTileShadingCreateInfoQCOM ) const VULKAN_HPP_NOEXCEPT
17260 {
17261 std::size_t seed = 0;
17262 VULKAN_HPP_HASH_COMBINE( seed, renderPassTileShadingCreateInfoQCOM.sType );
17263 VULKAN_HPP_HASH_COMBINE( seed, renderPassTileShadingCreateInfoQCOM.pNext );
17264 VULKAN_HPP_HASH_COMBINE( seed, renderPassTileShadingCreateInfoQCOM.flags );
17265 VULKAN_HPP_HASH_COMBINE( seed, renderPassTileShadingCreateInfoQCOM.tileApronSize );
17266 return seed;
17267 }
17268 };
17269
17270 template <>
17271 struct hash<VULKAN_HPP_NAMESPACE::RenderPassTransformBeginInfoQCOM>
17272 {
17273 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassTransformBeginInfoQCOM const & renderPassTransformBeginInfoQCOM ) const VULKAN_HPP_NOEXCEPT
17274 {
17275 std::size_t seed = 0;
17276 VULKAN_HPP_HASH_COMBINE( seed, renderPassTransformBeginInfoQCOM.sType );
17277 VULKAN_HPP_HASH_COMBINE( seed, renderPassTransformBeginInfoQCOM.pNext );
17278 VULKAN_HPP_HASH_COMBINE( seed, renderPassTransformBeginInfoQCOM.transform );
17279 return seed;
17280 }
17281 };
17282
17283 template <>
17284 struct hash<VULKAN_HPP_NAMESPACE::RenderingAreaInfo>
17285 {
17286 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderingAreaInfo const & renderingAreaInfo ) const VULKAN_HPP_NOEXCEPT
17287 {
17288 std::size_t seed = 0;
17289 VULKAN_HPP_HASH_COMBINE( seed, renderingAreaInfo.sType );
17290 VULKAN_HPP_HASH_COMBINE( seed, renderingAreaInfo.pNext );
17291 VULKAN_HPP_HASH_COMBINE( seed, renderingAreaInfo.viewMask );
17292 VULKAN_HPP_HASH_COMBINE( seed, renderingAreaInfo.colorAttachmentCount );
17293 VULKAN_HPP_HASH_COMBINE( seed, renderingAreaInfo.pColorAttachmentFormats );
17294 VULKAN_HPP_HASH_COMBINE( seed, renderingAreaInfo.depthAttachmentFormat );
17295 VULKAN_HPP_HASH_COMBINE( seed, renderingAreaInfo.stencilAttachmentFormat );
17296 return seed;
17297 }
17298 };
17299
17300 template <>
17301 struct hash<VULKAN_HPP_NAMESPACE::RenderingAttachmentFlagsInfoKHR>
17302 {
17303 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderingAttachmentFlagsInfoKHR const & renderingAttachmentFlagsInfoKHR ) const VULKAN_HPP_NOEXCEPT
17304 {
17305 std::size_t seed = 0;
17306 VULKAN_HPP_HASH_COMBINE( seed, renderingAttachmentFlagsInfoKHR.sType );
17307 VULKAN_HPP_HASH_COMBINE( seed, renderingAttachmentFlagsInfoKHR.pNext );
17308 VULKAN_HPP_HASH_COMBINE( seed, renderingAttachmentFlagsInfoKHR.flags );
17309 return seed;
17310 }
17311 };
17312
17313 template <>
17314 struct hash<VULKAN_HPP_NAMESPACE::RenderingAttachmentLocationInfo>
17315 {
17316 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderingAttachmentLocationInfo const & renderingAttachmentLocationInfo ) const VULKAN_HPP_NOEXCEPT
17317 {
17318 std::size_t seed = 0;
17319 VULKAN_HPP_HASH_COMBINE( seed, renderingAttachmentLocationInfo.sType );
17320 VULKAN_HPP_HASH_COMBINE( seed, renderingAttachmentLocationInfo.pNext );
17321 VULKAN_HPP_HASH_COMBINE( seed, renderingAttachmentLocationInfo.colorAttachmentCount );
17322 VULKAN_HPP_HASH_COMBINE( seed, renderingAttachmentLocationInfo.pColorAttachmentLocations );
17323 return seed;
17324 }
17325 };
17326
17327 template <>
17328 struct hash<VULKAN_HPP_NAMESPACE::RenderingEndInfoKHR>
17329 {
17330 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderingEndInfoKHR const & renderingEndInfoKHR ) const VULKAN_HPP_NOEXCEPT
17331 {
17332 std::size_t seed = 0;
17333 VULKAN_HPP_HASH_COMBINE( seed, renderingEndInfoKHR.sType );
17334 VULKAN_HPP_HASH_COMBINE( seed, renderingEndInfoKHR.pNext );
17335 return seed;
17336 }
17337 };
17338
17339 template <>
17340 struct hash<VULKAN_HPP_NAMESPACE::RenderingFragmentDensityMapAttachmentInfoEXT>
17341 {
17342 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderingFragmentDensityMapAttachmentInfoEXT const & renderingFragmentDensityMapAttachmentInfoEXT ) const
17343 VULKAN_HPP_NOEXCEPT
17344 {
17345 std::size_t seed = 0;
17346 VULKAN_HPP_HASH_COMBINE( seed, renderingFragmentDensityMapAttachmentInfoEXT.sType );
17347 VULKAN_HPP_HASH_COMBINE( seed, renderingFragmentDensityMapAttachmentInfoEXT.pNext );
17348 VULKAN_HPP_HASH_COMBINE( seed, renderingFragmentDensityMapAttachmentInfoEXT.imageView );
17349 VULKAN_HPP_HASH_COMBINE( seed, renderingFragmentDensityMapAttachmentInfoEXT.imageLayout );
17350 return seed;
17351 }
17352 };
17353
17354 template <>
17355 struct hash<VULKAN_HPP_NAMESPACE::RenderingFragmentShadingRateAttachmentInfoKHR>
17356 {
17357 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderingFragmentShadingRateAttachmentInfoKHR const & renderingFragmentShadingRateAttachmentInfoKHR ) const
17358 VULKAN_HPP_NOEXCEPT
17359 {
17360 std::size_t seed = 0;
17361 VULKAN_HPP_HASH_COMBINE( seed, renderingFragmentShadingRateAttachmentInfoKHR.sType );
17362 VULKAN_HPP_HASH_COMBINE( seed, renderingFragmentShadingRateAttachmentInfoKHR.pNext );
17363 VULKAN_HPP_HASH_COMBINE( seed, renderingFragmentShadingRateAttachmentInfoKHR.imageView );
17364 VULKAN_HPP_HASH_COMBINE( seed, renderingFragmentShadingRateAttachmentInfoKHR.imageLayout );
17365 VULKAN_HPP_HASH_COMBINE( seed, renderingFragmentShadingRateAttachmentInfoKHR.shadingRateAttachmentTexelSize );
17366 return seed;
17367 }
17368 };
17369
17370 template <>
17371 struct hash<VULKAN_HPP_NAMESPACE::RenderingInfo>
17372 {
17373 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderingInfo const & renderingInfo ) const VULKAN_HPP_NOEXCEPT
17374 {
17375 std::size_t seed = 0;
17376 VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.sType );
17377 VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.pNext );
17378 VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.flags );
17379 VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.renderArea );
17380 VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.layerCount );
17381 VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.viewMask );
17382 VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.colorAttachmentCount );
17383 VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.pColorAttachments );
17384 VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.pDepthAttachment );
17385 VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.pStencilAttachment );
17386 return seed;
17387 }
17388 };
17389
17390 template <>
17391 struct hash<VULKAN_HPP_NAMESPACE::RenderingInputAttachmentIndexInfo>
17392 {
17393 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderingInputAttachmentIndexInfo const & renderingInputAttachmentIndexInfo ) const VULKAN_HPP_NOEXCEPT
17394 {
17395 std::size_t seed = 0;
17396 VULKAN_HPP_HASH_COMBINE( seed, renderingInputAttachmentIndexInfo.sType );
17397 VULKAN_HPP_HASH_COMBINE( seed, renderingInputAttachmentIndexInfo.pNext );
17398 VULKAN_HPP_HASH_COMBINE( seed, renderingInputAttachmentIndexInfo.colorAttachmentCount );
17399 VULKAN_HPP_HASH_COMBINE( seed, renderingInputAttachmentIndexInfo.pColorAttachmentInputIndices );
17400 VULKAN_HPP_HASH_COMBINE( seed, renderingInputAttachmentIndexInfo.pDepthInputAttachmentIndex );
17401 VULKAN_HPP_HASH_COMBINE( seed, renderingInputAttachmentIndexInfo.pStencilInputAttachmentIndex );
17402 return seed;
17403 }
17404 };
17405
17406 template <>
17407 struct hash<VULKAN_HPP_NAMESPACE::ResolveImageInfo2>
17408 {
17409 std::size_t operator()( VULKAN_HPP_NAMESPACE::ResolveImageInfo2 const & resolveImageInfo2 ) const VULKAN_HPP_NOEXCEPT
17410 {
17411 std::size_t seed = 0;
17412 VULKAN_HPP_HASH_COMBINE( seed, resolveImageInfo2.sType );
17413 VULKAN_HPP_HASH_COMBINE( seed, resolveImageInfo2.pNext );
17414 VULKAN_HPP_HASH_COMBINE( seed, resolveImageInfo2.srcImage );
17415 VULKAN_HPP_HASH_COMBINE( seed, resolveImageInfo2.srcImageLayout );
17416 VULKAN_HPP_HASH_COMBINE( seed, resolveImageInfo2.dstImage );
17417 VULKAN_HPP_HASH_COMBINE( seed, resolveImageInfo2.dstImageLayout );
17418 VULKAN_HPP_HASH_COMBINE( seed, resolveImageInfo2.regionCount );
17419 VULKAN_HPP_HASH_COMBINE( seed, resolveImageInfo2.pRegions );
17420 return seed;
17421 }
17422 };
17423
17424 template <>
17425 struct hash<VULKAN_HPP_NAMESPACE::ResolveImageModeInfoKHR>
17426 {
17427 std::size_t operator()( VULKAN_HPP_NAMESPACE::ResolveImageModeInfoKHR const & resolveImageModeInfoKHR ) const VULKAN_HPP_NOEXCEPT
17428 {
17429 std::size_t seed = 0;
17430 VULKAN_HPP_HASH_COMBINE( seed, resolveImageModeInfoKHR.sType );
17431 VULKAN_HPP_HASH_COMBINE( seed, resolveImageModeInfoKHR.pNext );
17432 VULKAN_HPP_HASH_COMBINE( seed, resolveImageModeInfoKHR.flags );
17433 VULKAN_HPP_HASH_COMBINE( seed, resolveImageModeInfoKHR.resolveMode );
17434 VULKAN_HPP_HASH_COMBINE( seed, resolveImageModeInfoKHR.stencilResolveMode );
17435 return seed;
17436 }
17437 };
17438
17439 template <>
17440 struct hash<VULKAN_HPP_NAMESPACE::SamplerBlockMatchWindowCreateInfoQCOM>
17441 {
17442 std::size_t
17443 operator()( VULKAN_HPP_NAMESPACE::SamplerBlockMatchWindowCreateInfoQCOM const & samplerBlockMatchWindowCreateInfoQCOM ) const VULKAN_HPP_NOEXCEPT
17444 {
17445 std::size_t seed = 0;
17446 VULKAN_HPP_HASH_COMBINE( seed, samplerBlockMatchWindowCreateInfoQCOM.sType );
17447 VULKAN_HPP_HASH_COMBINE( seed, samplerBlockMatchWindowCreateInfoQCOM.pNext );
17448 VULKAN_HPP_HASH_COMBINE( seed, samplerBlockMatchWindowCreateInfoQCOM.windowExtent );
17449 VULKAN_HPP_HASH_COMBINE( seed, samplerBlockMatchWindowCreateInfoQCOM.windowCompareMode );
17450 return seed;
17451 }
17452 };
17453
17454 template <>
17455 struct hash<VULKAN_HPP_NAMESPACE::SamplerBorderColorComponentMappingCreateInfoEXT>
17456 {
17457 std::size_t operator()(
17458 VULKAN_HPP_NAMESPACE::SamplerBorderColorComponentMappingCreateInfoEXT const & samplerBorderColorComponentMappingCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
17459 {
17460 std::size_t seed = 0;
17461 VULKAN_HPP_HASH_COMBINE( seed, samplerBorderColorComponentMappingCreateInfoEXT.sType );
17462 VULKAN_HPP_HASH_COMBINE( seed, samplerBorderColorComponentMappingCreateInfoEXT.pNext );
17463 VULKAN_HPP_HASH_COMBINE( seed, samplerBorderColorComponentMappingCreateInfoEXT.components );
17464 VULKAN_HPP_HASH_COMBINE( seed, samplerBorderColorComponentMappingCreateInfoEXT.srgb );
17465 return seed;
17466 }
17467 };
17468
17469 template <>
17470 struct hash<VULKAN_HPP_NAMESPACE::SamplerCaptureDescriptorDataInfoEXT>
17471 {
17472 std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerCaptureDescriptorDataInfoEXT const & samplerCaptureDescriptorDataInfoEXT ) const VULKAN_HPP_NOEXCEPT
17473 {
17474 std::size_t seed = 0;
17475 VULKAN_HPP_HASH_COMBINE( seed, samplerCaptureDescriptorDataInfoEXT.sType );
17476 VULKAN_HPP_HASH_COMBINE( seed, samplerCaptureDescriptorDataInfoEXT.pNext );
17477 VULKAN_HPP_HASH_COMBINE( seed, samplerCaptureDescriptorDataInfoEXT.sampler );
17478 return seed;
17479 }
17480 };
17481
17482 template <>
17483 struct hash<VULKAN_HPP_NAMESPACE::SamplerCreateInfo>
17484 {
17485 std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerCreateInfo const & samplerCreateInfo ) const VULKAN_HPP_NOEXCEPT
17486 {
17487 std::size_t seed = 0;
17488 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.sType );
17489 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.pNext );
17490 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.flags );
17491 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.magFilter );
17492 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.minFilter );
17493 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.mipmapMode );
17494 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.addressModeU );
17495 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.addressModeV );
17496 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.addressModeW );
17497 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.mipLodBias );
17498 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.anisotropyEnable );
17499 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.maxAnisotropy );
17500 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.compareEnable );
17501 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.compareOp );
17502 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.minLod );
17503 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.maxLod );
17504 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.borderColor );
17505 VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.unnormalizedCoordinates );
17506 return seed;
17507 }
17508 };
17509
17510 template <>
17511 struct hash<VULKAN_HPP_NAMESPACE::SamplerCubicWeightsCreateInfoQCOM>
17512 {
17513 std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerCubicWeightsCreateInfoQCOM const & samplerCubicWeightsCreateInfoQCOM ) const VULKAN_HPP_NOEXCEPT
17514 {
17515 std::size_t seed = 0;
17516 VULKAN_HPP_HASH_COMBINE( seed, samplerCubicWeightsCreateInfoQCOM.sType );
17517 VULKAN_HPP_HASH_COMBINE( seed, samplerCubicWeightsCreateInfoQCOM.pNext );
17518 VULKAN_HPP_HASH_COMBINE( seed, samplerCubicWeightsCreateInfoQCOM.cubicWeights );
17519 return seed;
17520 }
17521 };
17522
17523 template <>
17524 struct hash<VULKAN_HPP_NAMESPACE::SamplerReductionModeCreateInfo>
17525 {
17526 std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerReductionModeCreateInfo const & samplerReductionModeCreateInfo ) const VULKAN_HPP_NOEXCEPT
17527 {
17528 std::size_t seed = 0;
17529 VULKAN_HPP_HASH_COMBINE( seed, samplerReductionModeCreateInfo.sType );
17530 VULKAN_HPP_HASH_COMBINE( seed, samplerReductionModeCreateInfo.pNext );
17531 VULKAN_HPP_HASH_COMBINE( seed, samplerReductionModeCreateInfo.reductionMode );
17532 return seed;
17533 }
17534 };
17535
17536 template <>
17537 struct hash<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo>
17538 {
17539 std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo const & samplerYcbcrConversionCreateInfo ) const VULKAN_HPP_NOEXCEPT
17540 {
17541 std::size_t seed = 0;
17542 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.sType );
17543 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.pNext );
17544 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.format );
17545 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.ycbcrModel );
17546 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.ycbcrRange );
17547 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.components );
17548 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.xChromaOffset );
17549 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.yChromaOffset );
17550 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.chromaFilter );
17551 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.forceExplicitReconstruction );
17552 return seed;
17553 }
17554 };
17555
17556 template <>
17557 struct hash<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionImageFormatProperties>
17558 {
17559 std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionImageFormatProperties const & samplerYcbcrConversionImageFormatProperties ) const
17560 VULKAN_HPP_NOEXCEPT
17561 {
17562 std::size_t seed = 0;
17563 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionImageFormatProperties.sType );
17564 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionImageFormatProperties.pNext );
17565 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionImageFormatProperties.combinedImageSamplerDescriptorCount );
17566 return seed;
17567 }
17568 };
17569
17570 template <>
17571 struct hash<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionInfo>
17572 {
17573 std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionInfo const & samplerYcbcrConversionInfo ) const VULKAN_HPP_NOEXCEPT
17574 {
17575 std::size_t seed = 0;
17576 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionInfo.sType );
17577 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionInfo.pNext );
17578 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionInfo.conversion );
17579 return seed;
17580 }
17581 };
17582
17583 template <>
17584 struct hash<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM>
17585 {
17586 std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM const & samplerYcbcrConversionYcbcrDegammaCreateInfoQCOM )
17587 const VULKAN_HPP_NOEXCEPT
17588 {
17589 std::size_t seed = 0;
17590 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionYcbcrDegammaCreateInfoQCOM.sType );
17591 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionYcbcrDegammaCreateInfoQCOM.pNext );
17592 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionYcbcrDegammaCreateInfoQCOM.enableYDegamma );
17593 VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionYcbcrDegammaCreateInfoQCOM.enableCbCrDegamma );
17594 return seed;
17595 }
17596 };
17597
17598 # if defined( VK_USE_PLATFORM_SCREEN_QNX )
17599 template <>
17600 struct hash<VULKAN_HPP_NAMESPACE::ScreenBufferFormatPropertiesQNX>
17601 {
17602 std::size_t operator()( VULKAN_HPP_NAMESPACE::ScreenBufferFormatPropertiesQNX const & screenBufferFormatPropertiesQNX ) const VULKAN_HPP_NOEXCEPT
17603 {
17604 std::size_t seed = 0;
17605 VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.sType );
17606 VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.pNext );
17607 VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.format );
17608 VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.externalFormat );
17609 VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.screenUsage );
17610 VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.formatFeatures );
17611 VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.samplerYcbcrConversionComponents );
17612 VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.suggestedYcbcrModel );
17613 VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.suggestedYcbcrRange );
17614 VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.suggestedXChromaOffset );
17615 VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.suggestedYChromaOffset );
17616 return seed;
17617 }
17618 };
17619 # endif /*VK_USE_PLATFORM_SCREEN_QNX*/
17620
17621 # if defined( VK_USE_PLATFORM_SCREEN_QNX )
17622 template <>
17623 struct hash<VULKAN_HPP_NAMESPACE::ScreenBufferPropertiesQNX>
17624 {
17625 std::size_t operator()( VULKAN_HPP_NAMESPACE::ScreenBufferPropertiesQNX const & screenBufferPropertiesQNX ) const VULKAN_HPP_NOEXCEPT
17626 {
17627 std::size_t seed = 0;
17628 VULKAN_HPP_HASH_COMBINE( seed, screenBufferPropertiesQNX.sType );
17629 VULKAN_HPP_HASH_COMBINE( seed, screenBufferPropertiesQNX.pNext );
17630 VULKAN_HPP_HASH_COMBINE( seed, screenBufferPropertiesQNX.allocationSize );
17631 VULKAN_HPP_HASH_COMBINE( seed, screenBufferPropertiesQNX.memoryTypeBits );
17632 return seed;
17633 }
17634 };
17635 # endif /*VK_USE_PLATFORM_SCREEN_QNX*/
17636
17637 # if defined( VK_USE_PLATFORM_SCREEN_QNX )
17638 template <>
17639 struct hash<VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX>
17640 {
17641 std::size_t operator()( VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX const & screenSurfaceCreateInfoQNX ) const VULKAN_HPP_NOEXCEPT
17642 {
17643 std::size_t seed = 0;
17644 VULKAN_HPP_HASH_COMBINE( seed, screenSurfaceCreateInfoQNX.sType );
17645 VULKAN_HPP_HASH_COMBINE( seed, screenSurfaceCreateInfoQNX.pNext );
17646 VULKAN_HPP_HASH_COMBINE( seed, screenSurfaceCreateInfoQNX.flags );
17647 VULKAN_HPP_HASH_COMBINE( seed, screenSurfaceCreateInfoQNX.context );
17648 VULKAN_HPP_HASH_COMBINE( seed, screenSurfaceCreateInfoQNX.window );
17649 return seed;
17650 }
17651 };
17652 # endif /*VK_USE_PLATFORM_SCREEN_QNX*/
17653
17654 template <>
17655 struct hash<VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo>
17656 {
17657 std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo const & semaphoreCreateInfo ) const VULKAN_HPP_NOEXCEPT
17658 {
17659 std::size_t seed = 0;
17660 VULKAN_HPP_HASH_COMBINE( seed, semaphoreCreateInfo.sType );
17661 VULKAN_HPP_HASH_COMBINE( seed, semaphoreCreateInfo.pNext );
17662 VULKAN_HPP_HASH_COMBINE( seed, semaphoreCreateInfo.flags );
17663 return seed;
17664 }
17665 };
17666
17667 template <>
17668 struct hash<VULKAN_HPP_NAMESPACE::SemaphoreGetFdInfoKHR>
17669 {
17670 std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreGetFdInfoKHR const & semaphoreGetFdInfoKHR ) const VULKAN_HPP_NOEXCEPT
17671 {
17672 std::size_t seed = 0;
17673 VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetFdInfoKHR.sType );
17674 VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetFdInfoKHR.pNext );
17675 VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetFdInfoKHR.semaphore );
17676 VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetFdInfoKHR.handleType );
17677 return seed;
17678 }
17679 };
17680
17681 # if defined( VK_USE_PLATFORM_WIN32_KHR )
17682 template <>
17683 struct hash<VULKAN_HPP_NAMESPACE::SemaphoreGetWin32HandleInfoKHR>
17684 {
17685 std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreGetWin32HandleInfoKHR const & semaphoreGetWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT
17686 {
17687 std::size_t seed = 0;
17688 VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetWin32HandleInfoKHR.sType );
17689 VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetWin32HandleInfoKHR.pNext );
17690 VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetWin32HandleInfoKHR.semaphore );
17691 VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetWin32HandleInfoKHR.handleType );
17692 return seed;
17693 }
17694 };
17695 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
17696
17697 # if defined( VK_USE_PLATFORM_FUCHSIA )
17698 template <>
17699 struct hash<VULKAN_HPP_NAMESPACE::SemaphoreGetZirconHandleInfoFUCHSIA>
17700 {
17701 std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreGetZirconHandleInfoFUCHSIA const & semaphoreGetZirconHandleInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT
17702 {
17703 std::size_t seed = 0;
17704 VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetZirconHandleInfoFUCHSIA.sType );
17705 VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetZirconHandleInfoFUCHSIA.pNext );
17706 VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetZirconHandleInfoFUCHSIA.semaphore );
17707 VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetZirconHandleInfoFUCHSIA.handleType );
17708 return seed;
17709 }
17710 };
17711 # endif /*VK_USE_PLATFORM_FUCHSIA*/
17712
17713 template <>
17714 struct hash<VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo>
17715 {
17716 std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo const & semaphoreSignalInfo ) const VULKAN_HPP_NOEXCEPT
17717 {
17718 std::size_t seed = 0;
17719 VULKAN_HPP_HASH_COMBINE( seed, semaphoreSignalInfo.sType );
17720 VULKAN_HPP_HASH_COMBINE( seed, semaphoreSignalInfo.pNext );
17721 VULKAN_HPP_HASH_COMBINE( seed, semaphoreSignalInfo.semaphore );
17722 VULKAN_HPP_HASH_COMBINE( seed, semaphoreSignalInfo.value );
17723 return seed;
17724 }
17725 };
17726
17727 template <>
17728 struct hash<VULKAN_HPP_NAMESPACE::SemaphoreTypeCreateInfo>
17729 {
17730 std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreTypeCreateInfo const & semaphoreTypeCreateInfo ) const VULKAN_HPP_NOEXCEPT
17731 {
17732 std::size_t seed = 0;
17733 VULKAN_HPP_HASH_COMBINE( seed, semaphoreTypeCreateInfo.sType );
17734 VULKAN_HPP_HASH_COMBINE( seed, semaphoreTypeCreateInfo.pNext );
17735 VULKAN_HPP_HASH_COMBINE( seed, semaphoreTypeCreateInfo.semaphoreType );
17736 VULKAN_HPP_HASH_COMBINE( seed, semaphoreTypeCreateInfo.initialValue );
17737 return seed;
17738 }
17739 };
17740
17741 template <>
17742 struct hash<VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo>
17743 {
17744 std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo const & semaphoreWaitInfo ) const VULKAN_HPP_NOEXCEPT
17745 {
17746 std::size_t seed = 0;
17747 VULKAN_HPP_HASH_COMBINE( seed, semaphoreWaitInfo.sType );
17748 VULKAN_HPP_HASH_COMBINE( seed, semaphoreWaitInfo.pNext );
17749 VULKAN_HPP_HASH_COMBINE( seed, semaphoreWaitInfo.flags );
17750 VULKAN_HPP_HASH_COMBINE( seed, semaphoreWaitInfo.semaphoreCount );
17751 VULKAN_HPP_HASH_COMBINE( seed, semaphoreWaitInfo.pSemaphores );
17752 VULKAN_HPP_HASH_COMBINE( seed, semaphoreWaitInfo.pValues );
17753 return seed;
17754 }
17755 };
17756
17757 template <>
17758 struct hash<VULKAN_HPP_NAMESPACE::SetDescriptorBufferOffsetsInfoEXT>
17759 {
17760 std::size_t operator()( VULKAN_HPP_NAMESPACE::SetDescriptorBufferOffsetsInfoEXT const & setDescriptorBufferOffsetsInfoEXT ) const VULKAN_HPP_NOEXCEPT
17761 {
17762 std::size_t seed = 0;
17763 VULKAN_HPP_HASH_COMBINE( seed, setDescriptorBufferOffsetsInfoEXT.sType );
17764 VULKAN_HPP_HASH_COMBINE( seed, setDescriptorBufferOffsetsInfoEXT.pNext );
17765 VULKAN_HPP_HASH_COMBINE( seed, setDescriptorBufferOffsetsInfoEXT.stageFlags );
17766 VULKAN_HPP_HASH_COMBINE( seed, setDescriptorBufferOffsetsInfoEXT.layout );
17767 VULKAN_HPP_HASH_COMBINE( seed, setDescriptorBufferOffsetsInfoEXT.firstSet );
17768 VULKAN_HPP_HASH_COMBINE( seed, setDescriptorBufferOffsetsInfoEXT.setCount );
17769 VULKAN_HPP_HASH_COMBINE( seed, setDescriptorBufferOffsetsInfoEXT.pBufferIndices );
17770 VULKAN_HPP_HASH_COMBINE( seed, setDescriptorBufferOffsetsInfoEXT.pOffsets );
17771 return seed;
17772 }
17773 };
17774
17775 template <>
17776 struct hash<VULKAN_HPP_NAMESPACE::SetLatencyMarkerInfoNV>
17777 {
17778 std::size_t operator()( VULKAN_HPP_NAMESPACE::SetLatencyMarkerInfoNV const & setLatencyMarkerInfoNV ) const VULKAN_HPP_NOEXCEPT
17779 {
17780 std::size_t seed = 0;
17781 VULKAN_HPP_HASH_COMBINE( seed, setLatencyMarkerInfoNV.sType );
17782 VULKAN_HPP_HASH_COMBINE( seed, setLatencyMarkerInfoNV.pNext );
17783 VULKAN_HPP_HASH_COMBINE( seed, setLatencyMarkerInfoNV.presentID );
17784 VULKAN_HPP_HASH_COMBINE( seed, setLatencyMarkerInfoNV.marker );
17785 return seed;
17786 }
17787 };
17788
17789 # if defined( VK_ENABLE_BETA_EXTENSIONS )
17790 template <>
17791 struct hash<VULKAN_HPP_NAMESPACE::SetPresentConfigNV>
17792 {
17793 std::size_t operator()( VULKAN_HPP_NAMESPACE::SetPresentConfigNV const & setPresentConfigNV ) const VULKAN_HPP_NOEXCEPT
17794 {
17795 std::size_t seed = 0;
17796 VULKAN_HPP_HASH_COMBINE( seed, setPresentConfigNV.sType );
17797 VULKAN_HPP_HASH_COMBINE( seed, setPresentConfigNV.pNext );
17798 VULKAN_HPP_HASH_COMBINE( seed, setPresentConfigNV.numFramesPerBatch );
17799 VULKAN_HPP_HASH_COMBINE( seed, setPresentConfigNV.presentConfigFeedback );
17800 return seed;
17801 }
17802 };
17803 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
17804
17805 template <>
17806 struct hash<VULKAN_HPP_NAMESPACE::SetStateFlagsIndirectCommandNV>
17807 {
17808 std::size_t operator()( VULKAN_HPP_NAMESPACE::SetStateFlagsIndirectCommandNV const & setStateFlagsIndirectCommandNV ) const VULKAN_HPP_NOEXCEPT
17809 {
17810 std::size_t seed = 0;
17811 VULKAN_HPP_HASH_COMBINE( seed, setStateFlagsIndirectCommandNV.data );
17812 return seed;
17813 }
17814 };
17815
17816 template <>
17817 struct hash<VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT>
17818 {
17819 std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT const & shaderCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
17820 {
17821 std::size_t seed = 0;
17822 VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.sType );
17823 VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.pNext );
17824 VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.flags );
17825 VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.stage );
17826 VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.nextStage );
17827 VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.codeType );
17828 VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.codeSize );
17829 VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.pCode );
17830 for ( const char * p = shaderCreateInfoEXT.pName; *p != '\0'; ++p )
17831 {
17832 VULKAN_HPP_HASH_COMBINE( seed, *p );
17833 }
17834 VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.setLayoutCount );
17835 VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.pSetLayouts );
17836 VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.pushConstantRangeCount );
17837 VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.pPushConstantRanges );
17838 VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.pSpecializationInfo );
17839 return seed;
17840 }
17841 };
17842
17843 template <>
17844 struct hash<VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo>
17845 {
17846 std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo const & shaderModuleCreateInfo ) const VULKAN_HPP_NOEXCEPT
17847 {
17848 std::size_t seed = 0;
17849 VULKAN_HPP_HASH_COMBINE( seed, shaderModuleCreateInfo.sType );
17850 VULKAN_HPP_HASH_COMBINE( seed, shaderModuleCreateInfo.pNext );
17851 VULKAN_HPP_HASH_COMBINE( seed, shaderModuleCreateInfo.flags );
17852 VULKAN_HPP_HASH_COMBINE( seed, shaderModuleCreateInfo.codeSize );
17853 VULKAN_HPP_HASH_COMBINE( seed, shaderModuleCreateInfo.pCode );
17854 return seed;
17855 }
17856 };
17857
17858 template <>
17859 struct hash<VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT>
17860 {
17861 std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT const & shaderModuleIdentifierEXT ) const VULKAN_HPP_NOEXCEPT
17862 {
17863 std::size_t seed = 0;
17864 VULKAN_HPP_HASH_COMBINE( seed, shaderModuleIdentifierEXT.sType );
17865 VULKAN_HPP_HASH_COMBINE( seed, shaderModuleIdentifierEXT.pNext );
17866 VULKAN_HPP_HASH_COMBINE( seed, shaderModuleIdentifierEXT.identifierSize );
17867 for ( size_t i = 0; i < VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT; ++i )
17868 {
17869 VULKAN_HPP_HASH_COMBINE( seed, shaderModuleIdentifierEXT.identifier[i] );
17870 }
17871 return seed;
17872 }
17873 };
17874
17875 template <>
17876 struct hash<VULKAN_HPP_NAMESPACE::ShaderModuleValidationCacheCreateInfoEXT>
17877 {
17878 std::size_t
17879 operator()( VULKAN_HPP_NAMESPACE::ShaderModuleValidationCacheCreateInfoEXT const & shaderModuleValidationCacheCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
17880 {
17881 std::size_t seed = 0;
17882 VULKAN_HPP_HASH_COMBINE( seed, shaderModuleValidationCacheCreateInfoEXT.sType );
17883 VULKAN_HPP_HASH_COMBINE( seed, shaderModuleValidationCacheCreateInfoEXT.pNext );
17884 VULKAN_HPP_HASH_COMBINE( seed, shaderModuleValidationCacheCreateInfoEXT.validationCache );
17885 return seed;
17886 }
17887 };
17888
17889 template <>
17890 struct hash<VULKAN_HPP_NAMESPACE::ShaderResourceUsageAMD>
17891 {
17892 std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderResourceUsageAMD const & shaderResourceUsageAMD ) const VULKAN_HPP_NOEXCEPT
17893 {
17894 std::size_t seed = 0;
17895 VULKAN_HPP_HASH_COMBINE( seed, shaderResourceUsageAMD.numUsedVgprs );
17896 VULKAN_HPP_HASH_COMBINE( seed, shaderResourceUsageAMD.numUsedSgprs );
17897 VULKAN_HPP_HASH_COMBINE( seed, shaderResourceUsageAMD.ldsSizePerLocalWorkGroup );
17898 VULKAN_HPP_HASH_COMBINE( seed, shaderResourceUsageAMD.ldsUsageSizeInBytes );
17899 VULKAN_HPP_HASH_COMBINE( seed, shaderResourceUsageAMD.scratchMemUsageInBytes );
17900 return seed;
17901 }
17902 };
17903
17904 template <>
17905 struct hash<VULKAN_HPP_NAMESPACE::ShaderStatisticsInfoAMD>
17906 {
17907 std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderStatisticsInfoAMD const & shaderStatisticsInfoAMD ) const VULKAN_HPP_NOEXCEPT
17908 {
17909 std::size_t seed = 0;
17910 VULKAN_HPP_HASH_COMBINE( seed, shaderStatisticsInfoAMD.shaderStageMask );
17911 VULKAN_HPP_HASH_COMBINE( seed, shaderStatisticsInfoAMD.resourceUsage );
17912 VULKAN_HPP_HASH_COMBINE( seed, shaderStatisticsInfoAMD.numPhysicalVgprs );
17913 VULKAN_HPP_HASH_COMBINE( seed, shaderStatisticsInfoAMD.numPhysicalSgprs );
17914 VULKAN_HPP_HASH_COMBINE( seed, shaderStatisticsInfoAMD.numAvailableVgprs );
17915 VULKAN_HPP_HASH_COMBINE( seed, shaderStatisticsInfoAMD.numAvailableSgprs );
17916 for ( size_t i = 0; i < 3; ++i )
17917 {
17918 VULKAN_HPP_HASH_COMBINE( seed, shaderStatisticsInfoAMD.computeWorkGroupSize[i] );
17919 }
17920 return seed;
17921 }
17922 };
17923
17924 template <>
17925 struct hash<VULKAN_HPP_NAMESPACE::SharedPresentSurfaceCapabilitiesKHR>
17926 {
17927 std::size_t operator()( VULKAN_HPP_NAMESPACE::SharedPresentSurfaceCapabilitiesKHR const & sharedPresentSurfaceCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT
17928 {
17929 std::size_t seed = 0;
17930 VULKAN_HPP_HASH_COMBINE( seed, sharedPresentSurfaceCapabilitiesKHR.sType );
17931 VULKAN_HPP_HASH_COMBINE( seed, sharedPresentSurfaceCapabilitiesKHR.pNext );
17932 VULKAN_HPP_HASH_COMBINE( seed, sharedPresentSurfaceCapabilitiesKHR.sharedPresentSupportedUsageFlags );
17933 return seed;
17934 }
17935 };
17936
17937 template <>
17938 struct hash<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties>
17939 {
17940 std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageFormatProperties const & sparseImageFormatProperties ) const VULKAN_HPP_NOEXCEPT
17941 {
17942 std::size_t seed = 0;
17943 VULKAN_HPP_HASH_COMBINE( seed, sparseImageFormatProperties.aspectMask );
17944 VULKAN_HPP_HASH_COMBINE( seed, sparseImageFormatProperties.imageGranularity );
17945 VULKAN_HPP_HASH_COMBINE( seed, sparseImageFormatProperties.flags );
17946 return seed;
17947 }
17948 };
17949
17950 template <>
17951 struct hash<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>
17952 {
17953 std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2 const & sparseImageFormatProperties2 ) const VULKAN_HPP_NOEXCEPT
17954 {
17955 std::size_t seed = 0;
17956 VULKAN_HPP_HASH_COMBINE( seed, sparseImageFormatProperties2.sType );
17957 VULKAN_HPP_HASH_COMBINE( seed, sparseImageFormatProperties2.pNext );
17958 VULKAN_HPP_HASH_COMBINE( seed, sparseImageFormatProperties2.properties );
17959 return seed;
17960 }
17961 };
17962
17963 template <>
17964 struct hash<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements>
17965 {
17966 std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements const & sparseImageMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
17967 {
17968 std::size_t seed = 0;
17969 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryRequirements.formatProperties );
17970 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryRequirements.imageMipTailFirstLod );
17971 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryRequirements.imageMipTailSize );
17972 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryRequirements.imageMipTailOffset );
17973 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryRequirements.imageMipTailStride );
17974 return seed;
17975 }
17976 };
17977
17978 template <>
17979 struct hash<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>
17980 {
17981 std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 const & sparseImageMemoryRequirements2 ) const VULKAN_HPP_NOEXCEPT
17982 {
17983 std::size_t seed = 0;
17984 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryRequirements2.sType );
17985 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryRequirements2.pNext );
17986 VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryRequirements2.memoryRequirements );
17987 return seed;
17988 }
17989 };
17990
17991 # if defined( VK_USE_PLATFORM_GGP )
17992 template <>
17993 struct hash<VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP>
17994 {
17995 std::size_t operator()( VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP const & streamDescriptorSurfaceCreateInfoGGP ) const VULKAN_HPP_NOEXCEPT
17996 {
17997 std::size_t seed = 0;
17998 VULKAN_HPP_HASH_COMBINE( seed, streamDescriptorSurfaceCreateInfoGGP.sType );
17999 VULKAN_HPP_HASH_COMBINE( seed, streamDescriptorSurfaceCreateInfoGGP.pNext );
18000 VULKAN_HPP_HASH_COMBINE( seed, streamDescriptorSurfaceCreateInfoGGP.flags );
18001 VULKAN_HPP_HASH_COMBINE( seed, streamDescriptorSurfaceCreateInfoGGP.streamDescriptor );
18002 return seed;
18003 }
18004 };
18005 # endif /*VK_USE_PLATFORM_GGP*/
18006
18007 template <>
18008 struct hash<VULKAN_HPP_NAMESPACE::SubmitInfo>
18009 {
18010 std::size_t operator()( VULKAN_HPP_NAMESPACE::SubmitInfo const & submitInfo ) const VULKAN_HPP_NOEXCEPT
18011 {
18012 std::size_t seed = 0;
18013 VULKAN_HPP_HASH_COMBINE( seed, submitInfo.sType );
18014 VULKAN_HPP_HASH_COMBINE( seed, submitInfo.pNext );
18015 VULKAN_HPP_HASH_COMBINE( seed, submitInfo.waitSemaphoreCount );
18016 VULKAN_HPP_HASH_COMBINE( seed, submitInfo.pWaitSemaphores );
18017 VULKAN_HPP_HASH_COMBINE( seed, submitInfo.pWaitDstStageMask );
18018 VULKAN_HPP_HASH_COMBINE( seed, submitInfo.commandBufferCount );
18019 VULKAN_HPP_HASH_COMBINE( seed, submitInfo.pCommandBuffers );
18020 VULKAN_HPP_HASH_COMBINE( seed, submitInfo.signalSemaphoreCount );
18021 VULKAN_HPP_HASH_COMBINE( seed, submitInfo.pSignalSemaphores );
18022 return seed;
18023 }
18024 };
18025
18026 template <>
18027 struct hash<VULKAN_HPP_NAMESPACE::SubmitInfo2>
18028 {
18029 std::size_t operator()( VULKAN_HPP_NAMESPACE::SubmitInfo2 const & submitInfo2 ) const VULKAN_HPP_NOEXCEPT
18030 {
18031 std::size_t seed = 0;
18032 VULKAN_HPP_HASH_COMBINE( seed, submitInfo2.sType );
18033 VULKAN_HPP_HASH_COMBINE( seed, submitInfo2.pNext );
18034 VULKAN_HPP_HASH_COMBINE( seed, submitInfo2.flags );
18035 VULKAN_HPP_HASH_COMBINE( seed, submitInfo2.waitSemaphoreInfoCount );
18036 VULKAN_HPP_HASH_COMBINE( seed, submitInfo2.pWaitSemaphoreInfos );
18037 VULKAN_HPP_HASH_COMBINE( seed, submitInfo2.commandBufferInfoCount );
18038 VULKAN_HPP_HASH_COMBINE( seed, submitInfo2.pCommandBufferInfos );
18039 VULKAN_HPP_HASH_COMBINE( seed, submitInfo2.signalSemaphoreInfoCount );
18040 VULKAN_HPP_HASH_COMBINE( seed, submitInfo2.pSignalSemaphoreInfos );
18041 return seed;
18042 }
18043 };
18044
18045 template <>
18046 struct hash<VULKAN_HPP_NAMESPACE::SubpassBeginInfo>
18047 {
18048 std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassBeginInfo const & subpassBeginInfo ) const VULKAN_HPP_NOEXCEPT
18049 {
18050 std::size_t seed = 0;
18051 VULKAN_HPP_HASH_COMBINE( seed, subpassBeginInfo.sType );
18052 VULKAN_HPP_HASH_COMBINE( seed, subpassBeginInfo.pNext );
18053 VULKAN_HPP_HASH_COMBINE( seed, subpassBeginInfo.contents );
18054 return seed;
18055 }
18056 };
18057
18058 template <>
18059 struct hash<VULKAN_HPP_NAMESPACE::SubpassDescriptionDepthStencilResolve>
18060 {
18061 std::size_t
18062 operator()( VULKAN_HPP_NAMESPACE::SubpassDescriptionDepthStencilResolve const & subpassDescriptionDepthStencilResolve ) const VULKAN_HPP_NOEXCEPT
18063 {
18064 std::size_t seed = 0;
18065 VULKAN_HPP_HASH_COMBINE( seed, subpassDescriptionDepthStencilResolve.sType );
18066 VULKAN_HPP_HASH_COMBINE( seed, subpassDescriptionDepthStencilResolve.pNext );
18067 VULKAN_HPP_HASH_COMBINE( seed, subpassDescriptionDepthStencilResolve.depthResolveMode );
18068 VULKAN_HPP_HASH_COMBINE( seed, subpassDescriptionDepthStencilResolve.stencilResolveMode );
18069 VULKAN_HPP_HASH_COMBINE( seed, subpassDescriptionDepthStencilResolve.pDepthStencilResolveAttachment );
18070 return seed;
18071 }
18072 };
18073
18074 template <>
18075 struct hash<VULKAN_HPP_NAMESPACE::SubpassEndInfo>
18076 {
18077 std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassEndInfo const & subpassEndInfo ) const VULKAN_HPP_NOEXCEPT
18078 {
18079 std::size_t seed = 0;
18080 VULKAN_HPP_HASH_COMBINE( seed, subpassEndInfo.sType );
18081 VULKAN_HPP_HASH_COMBINE( seed, subpassEndInfo.pNext );
18082 return seed;
18083 }
18084 };
18085
18086 template <>
18087 struct hash<VULKAN_HPP_NAMESPACE::SubpassResolvePerformanceQueryEXT>
18088 {
18089 std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassResolvePerformanceQueryEXT const & subpassResolvePerformanceQueryEXT ) const VULKAN_HPP_NOEXCEPT
18090 {
18091 std::size_t seed = 0;
18092 VULKAN_HPP_HASH_COMBINE( seed, subpassResolvePerformanceQueryEXT.sType );
18093 VULKAN_HPP_HASH_COMBINE( seed, subpassResolvePerformanceQueryEXT.pNext );
18094 VULKAN_HPP_HASH_COMBINE( seed, subpassResolvePerformanceQueryEXT.optimal );
18095 return seed;
18096 }
18097 };
18098
18099 template <>
18100 struct hash<VULKAN_HPP_NAMESPACE::SubpassShadingPipelineCreateInfoHUAWEI>
18101 {
18102 std::size_t
18103 operator()( VULKAN_HPP_NAMESPACE::SubpassShadingPipelineCreateInfoHUAWEI const & subpassShadingPipelineCreateInfoHUAWEI ) const VULKAN_HPP_NOEXCEPT
18104 {
18105 std::size_t seed = 0;
18106 VULKAN_HPP_HASH_COMBINE( seed, subpassShadingPipelineCreateInfoHUAWEI.sType );
18107 VULKAN_HPP_HASH_COMBINE( seed, subpassShadingPipelineCreateInfoHUAWEI.pNext );
18108 VULKAN_HPP_HASH_COMBINE( seed, subpassShadingPipelineCreateInfoHUAWEI.renderPass );
18109 VULKAN_HPP_HASH_COMBINE( seed, subpassShadingPipelineCreateInfoHUAWEI.subpass );
18110 return seed;
18111 }
18112 };
18113
18114 template <>
18115 struct hash<VULKAN_HPP_NAMESPACE::SubresourceHostMemcpySize>
18116 {
18117 std::size_t operator()( VULKAN_HPP_NAMESPACE::SubresourceHostMemcpySize const & subresourceHostMemcpySize ) const VULKAN_HPP_NOEXCEPT
18118 {
18119 std::size_t seed = 0;
18120 VULKAN_HPP_HASH_COMBINE( seed, subresourceHostMemcpySize.sType );
18121 VULKAN_HPP_HASH_COMBINE( seed, subresourceHostMemcpySize.pNext );
18122 VULKAN_HPP_HASH_COMBINE( seed, subresourceHostMemcpySize.size );
18123 return seed;
18124 }
18125 };
18126
18127 template <>
18128 struct hash<VULKAN_HPP_NAMESPACE::SubresourceLayout2>
18129 {
18130 std::size_t operator()( VULKAN_HPP_NAMESPACE::SubresourceLayout2 const & subresourceLayout2 ) const VULKAN_HPP_NOEXCEPT
18131 {
18132 std::size_t seed = 0;
18133 VULKAN_HPP_HASH_COMBINE( seed, subresourceLayout2.sType );
18134 VULKAN_HPP_HASH_COMBINE( seed, subresourceLayout2.pNext );
18135 VULKAN_HPP_HASH_COMBINE( seed, subresourceLayout2.subresourceLayout );
18136 return seed;
18137 }
18138 };
18139
18140 template <>
18141 struct hash<VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT>
18142 {
18143 std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT const & surfaceCapabilities2EXT ) const VULKAN_HPP_NOEXCEPT
18144 {
18145 std::size_t seed = 0;
18146 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.sType );
18147 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.pNext );
18148 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.minImageCount );
18149 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.maxImageCount );
18150 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.currentExtent );
18151 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.minImageExtent );
18152 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.maxImageExtent );
18153 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.maxImageArrayLayers );
18154 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.supportedTransforms );
18155 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.currentTransform );
18156 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.supportedCompositeAlpha );
18157 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.supportedUsageFlags );
18158 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.supportedSurfaceCounters );
18159 return seed;
18160 }
18161 };
18162
18163 template <>
18164 struct hash<VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR>
18165 {
18166 std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR const & surfaceCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT
18167 {
18168 std::size_t seed = 0;
18169 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.minImageCount );
18170 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.maxImageCount );
18171 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.currentExtent );
18172 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.minImageExtent );
18173 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.maxImageExtent );
18174 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.maxImageArrayLayers );
18175 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.supportedTransforms );
18176 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.currentTransform );
18177 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.supportedCompositeAlpha );
18178 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.supportedUsageFlags );
18179 return seed;
18180 }
18181 };
18182
18183 template <>
18184 struct hash<VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR>
18185 {
18186 std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR const & surfaceCapabilities2KHR ) const VULKAN_HPP_NOEXCEPT
18187 {
18188 std::size_t seed = 0;
18189 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2KHR.sType );
18190 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2KHR.pNext );
18191 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2KHR.surfaceCapabilities );
18192 return seed;
18193 }
18194 };
18195
18196 # if defined( VK_USE_PLATFORM_WIN32_KHR )
18197 template <>
18198 struct hash<VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesFullScreenExclusiveEXT>
18199 {
18200 std::size_t
18201 operator()( VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesFullScreenExclusiveEXT const & surfaceCapabilitiesFullScreenExclusiveEXT ) const VULKAN_HPP_NOEXCEPT
18202 {
18203 std::size_t seed = 0;
18204 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesFullScreenExclusiveEXT.sType );
18205 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesFullScreenExclusiveEXT.pNext );
18206 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesFullScreenExclusiveEXT.fullScreenExclusiveSupported );
18207 return seed;
18208 }
18209 };
18210 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
18211
18212 template <>
18213 struct hash<VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesPresentBarrierNV>
18214 {
18215 std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesPresentBarrierNV const & surfaceCapabilitiesPresentBarrierNV ) const VULKAN_HPP_NOEXCEPT
18216 {
18217 std::size_t seed = 0;
18218 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesPresentBarrierNV.sType );
18219 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesPresentBarrierNV.pNext );
18220 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesPresentBarrierNV.presentBarrierSupported );
18221 return seed;
18222 }
18223 };
18224
18225 template <>
18226 struct hash<VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesPresentId2KHR>
18227 {
18228 std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesPresentId2KHR const & surfaceCapabilitiesPresentId2KHR ) const VULKAN_HPP_NOEXCEPT
18229 {
18230 std::size_t seed = 0;
18231 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesPresentId2KHR.sType );
18232 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesPresentId2KHR.pNext );
18233 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesPresentId2KHR.presentId2Supported );
18234 return seed;
18235 }
18236 };
18237
18238 template <>
18239 struct hash<VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesPresentWait2KHR>
18240 {
18241 std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesPresentWait2KHR const & surfaceCapabilitiesPresentWait2KHR ) const VULKAN_HPP_NOEXCEPT
18242 {
18243 std::size_t seed = 0;
18244 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesPresentWait2KHR.sType );
18245 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesPresentWait2KHR.pNext );
18246 VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesPresentWait2KHR.presentWait2Supported );
18247 return seed;
18248 }
18249 };
18250
18251 # if defined( VK_USE_PLATFORM_OHOS )
18252 template <>
18253 struct hash<VULKAN_HPP_NAMESPACE::SurfaceCreateInfoOHOS>
18254 {
18255 std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceCreateInfoOHOS const & surfaceCreateInfoOHOS ) const VULKAN_HPP_NOEXCEPT
18256 {
18257 std::size_t seed = 0;
18258 VULKAN_HPP_HASH_COMBINE( seed, surfaceCreateInfoOHOS.sType );
18259 VULKAN_HPP_HASH_COMBINE( seed, surfaceCreateInfoOHOS.pNext );
18260 VULKAN_HPP_HASH_COMBINE( seed, surfaceCreateInfoOHOS.flags );
18261 VULKAN_HPP_HASH_COMBINE( seed, surfaceCreateInfoOHOS.window );
18262 return seed;
18263 }
18264 };
18265 # endif /*VK_USE_PLATFORM_OHOS*/
18266
18267 template <>
18268 struct hash<VULKAN_HPP_NAMESPACE::SurfaceFormatKHR>
18269 {
18270 std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceFormatKHR const & surfaceFormatKHR ) const VULKAN_HPP_NOEXCEPT
18271 {
18272 std::size_t seed = 0;
18273 VULKAN_HPP_HASH_COMBINE( seed, surfaceFormatKHR.format );
18274 VULKAN_HPP_HASH_COMBINE( seed, surfaceFormatKHR.colorSpace );
18275 return seed;
18276 }
18277 };
18278
18279 template <>
18280 struct hash<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR>
18281 {
18282 std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR const & surfaceFormat2KHR ) const VULKAN_HPP_NOEXCEPT
18283 {
18284 std::size_t seed = 0;
18285 VULKAN_HPP_HASH_COMBINE( seed, surfaceFormat2KHR.sType );
18286 VULKAN_HPP_HASH_COMBINE( seed, surfaceFormat2KHR.pNext );
18287 VULKAN_HPP_HASH_COMBINE( seed, surfaceFormat2KHR.surfaceFormat );
18288 return seed;
18289 }
18290 };
18291
18292 # if defined( VK_USE_PLATFORM_WIN32_KHR )
18293 template <>
18294 struct hash<VULKAN_HPP_NAMESPACE::SurfaceFullScreenExclusiveInfoEXT>
18295 {
18296 std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceFullScreenExclusiveInfoEXT const & surfaceFullScreenExclusiveInfoEXT ) const VULKAN_HPP_NOEXCEPT
18297 {
18298 std::size_t seed = 0;
18299 VULKAN_HPP_HASH_COMBINE( seed, surfaceFullScreenExclusiveInfoEXT.sType );
18300 VULKAN_HPP_HASH_COMBINE( seed, surfaceFullScreenExclusiveInfoEXT.pNext );
18301 VULKAN_HPP_HASH_COMBINE( seed, surfaceFullScreenExclusiveInfoEXT.fullScreenExclusive );
18302 return seed;
18303 }
18304 };
18305 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
18306
18307 # if defined( VK_USE_PLATFORM_WIN32_KHR )
18308 template <>
18309 struct hash<VULKAN_HPP_NAMESPACE::SurfaceFullScreenExclusiveWin32InfoEXT>
18310 {
18311 std::size_t
18312 operator()( VULKAN_HPP_NAMESPACE::SurfaceFullScreenExclusiveWin32InfoEXT const & surfaceFullScreenExclusiveWin32InfoEXT ) const VULKAN_HPP_NOEXCEPT
18313 {
18314 std::size_t seed = 0;
18315 VULKAN_HPP_HASH_COMBINE( seed, surfaceFullScreenExclusiveWin32InfoEXT.sType );
18316 VULKAN_HPP_HASH_COMBINE( seed, surfaceFullScreenExclusiveWin32InfoEXT.pNext );
18317 VULKAN_HPP_HASH_COMBINE( seed, surfaceFullScreenExclusiveWin32InfoEXT.hmonitor );
18318 return seed;
18319 }
18320 };
18321 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
18322
18323 template <>
18324 struct hash<VULKAN_HPP_NAMESPACE::SurfacePresentModeCompatibilityKHR>
18325 {
18326 std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfacePresentModeCompatibilityKHR const & surfacePresentModeCompatibilityKHR ) const VULKAN_HPP_NOEXCEPT
18327 {
18328 std::size_t seed = 0;
18329 VULKAN_HPP_HASH_COMBINE( seed, surfacePresentModeCompatibilityKHR.sType );
18330 VULKAN_HPP_HASH_COMBINE( seed, surfacePresentModeCompatibilityKHR.pNext );
18331 VULKAN_HPP_HASH_COMBINE( seed, surfacePresentModeCompatibilityKHR.presentModeCount );
18332 VULKAN_HPP_HASH_COMBINE( seed, surfacePresentModeCompatibilityKHR.pPresentModes );
18333 return seed;
18334 }
18335 };
18336
18337 template <>
18338 struct hash<VULKAN_HPP_NAMESPACE::SurfacePresentModeKHR>
18339 {
18340 std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfacePresentModeKHR const & surfacePresentModeKHR ) const VULKAN_HPP_NOEXCEPT
18341 {
18342 std::size_t seed = 0;
18343 VULKAN_HPP_HASH_COMBINE( seed, surfacePresentModeKHR.sType );
18344 VULKAN_HPP_HASH_COMBINE( seed, surfacePresentModeKHR.pNext );
18345 VULKAN_HPP_HASH_COMBINE( seed, surfacePresentModeKHR.presentMode );
18346 return seed;
18347 }
18348 };
18349
18350 template <>
18351 struct hash<VULKAN_HPP_NAMESPACE::SurfacePresentScalingCapabilitiesKHR>
18352 {
18353 std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfacePresentScalingCapabilitiesKHR const & surfacePresentScalingCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT
18354 {
18355 std::size_t seed = 0;
18356 VULKAN_HPP_HASH_COMBINE( seed, surfacePresentScalingCapabilitiesKHR.sType );
18357 VULKAN_HPP_HASH_COMBINE( seed, surfacePresentScalingCapabilitiesKHR.pNext );
18358 VULKAN_HPP_HASH_COMBINE( seed, surfacePresentScalingCapabilitiesKHR.supportedPresentScaling );
18359 VULKAN_HPP_HASH_COMBINE( seed, surfacePresentScalingCapabilitiesKHR.supportedPresentGravityX );
18360 VULKAN_HPP_HASH_COMBINE( seed, surfacePresentScalingCapabilitiesKHR.supportedPresentGravityY );
18361 VULKAN_HPP_HASH_COMBINE( seed, surfacePresentScalingCapabilitiesKHR.minScaledImageExtent );
18362 VULKAN_HPP_HASH_COMBINE( seed, surfacePresentScalingCapabilitiesKHR.maxScaledImageExtent );
18363 return seed;
18364 }
18365 };
18366
18367 template <>
18368 struct hash<VULKAN_HPP_NAMESPACE::SurfaceProtectedCapabilitiesKHR>
18369 {
18370 std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceProtectedCapabilitiesKHR const & surfaceProtectedCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT
18371 {
18372 std::size_t seed = 0;
18373 VULKAN_HPP_HASH_COMBINE( seed, surfaceProtectedCapabilitiesKHR.sType );
18374 VULKAN_HPP_HASH_COMBINE( seed, surfaceProtectedCapabilitiesKHR.pNext );
18375 VULKAN_HPP_HASH_COMBINE( seed, surfaceProtectedCapabilitiesKHR.supportsProtected );
18376 return seed;
18377 }
18378 };
18379
18380 template <>
18381 struct hash<VULKAN_HPP_NAMESPACE::SwapchainCounterCreateInfoEXT>
18382 {
18383 std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainCounterCreateInfoEXT const & swapchainCounterCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
18384 {
18385 std::size_t seed = 0;
18386 VULKAN_HPP_HASH_COMBINE( seed, swapchainCounterCreateInfoEXT.sType );
18387 VULKAN_HPP_HASH_COMBINE( seed, swapchainCounterCreateInfoEXT.pNext );
18388 VULKAN_HPP_HASH_COMBINE( seed, swapchainCounterCreateInfoEXT.surfaceCounters );
18389 return seed;
18390 }
18391 };
18392
18393 template <>
18394 struct hash<VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR>
18395 {
18396 std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR const & swapchainCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
18397 {
18398 std::size_t seed = 0;
18399 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.sType );
18400 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.pNext );
18401 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.flags );
18402 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.surface );
18403 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.minImageCount );
18404 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.imageFormat );
18405 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.imageColorSpace );
18406 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.imageExtent );
18407 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.imageArrayLayers );
18408 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.imageUsage );
18409 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.imageSharingMode );
18410 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.queueFamilyIndexCount );
18411 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.pQueueFamilyIndices );
18412 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.preTransform );
18413 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.compositeAlpha );
18414 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.presentMode );
18415 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.clipped );
18416 VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.oldSwapchain );
18417 return seed;
18418 }
18419 };
18420
18421 template <>
18422 struct hash<VULKAN_HPP_NAMESPACE::SwapchainDisplayNativeHdrCreateInfoAMD>
18423 {
18424 std::size_t
18425 operator()( VULKAN_HPP_NAMESPACE::SwapchainDisplayNativeHdrCreateInfoAMD const & swapchainDisplayNativeHdrCreateInfoAMD ) const VULKAN_HPP_NOEXCEPT
18426 {
18427 std::size_t seed = 0;
18428 VULKAN_HPP_HASH_COMBINE( seed, swapchainDisplayNativeHdrCreateInfoAMD.sType );
18429 VULKAN_HPP_HASH_COMBINE( seed, swapchainDisplayNativeHdrCreateInfoAMD.pNext );
18430 VULKAN_HPP_HASH_COMBINE( seed, swapchainDisplayNativeHdrCreateInfoAMD.localDimmingEnable );
18431 return seed;
18432 }
18433 };
18434
18435 # if defined( VK_USE_PLATFORM_OHOS )
18436 template <>
18437 struct hash<VULKAN_HPP_NAMESPACE::SwapchainImageCreateInfoOHOS>
18438 {
18439 std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainImageCreateInfoOHOS const & swapchainImageCreateInfoOHOS ) const VULKAN_HPP_NOEXCEPT
18440 {
18441 std::size_t seed = 0;
18442 VULKAN_HPP_HASH_COMBINE( seed, swapchainImageCreateInfoOHOS.sType );
18443 VULKAN_HPP_HASH_COMBINE( seed, swapchainImageCreateInfoOHOS.pNext );
18444 VULKAN_HPP_HASH_COMBINE( seed, swapchainImageCreateInfoOHOS.usage );
18445 return seed;
18446 }
18447 };
18448 # endif /*VK_USE_PLATFORM_OHOS*/
18449
18450 template <>
18451 struct hash<VULKAN_HPP_NAMESPACE::SwapchainLatencyCreateInfoNV>
18452 {
18453 std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainLatencyCreateInfoNV const & swapchainLatencyCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
18454 {
18455 std::size_t seed = 0;
18456 VULKAN_HPP_HASH_COMBINE( seed, swapchainLatencyCreateInfoNV.sType );
18457 VULKAN_HPP_HASH_COMBINE( seed, swapchainLatencyCreateInfoNV.pNext );
18458 VULKAN_HPP_HASH_COMBINE( seed, swapchainLatencyCreateInfoNV.latencyModeEnable );
18459 return seed;
18460 }
18461 };
18462
18463 template <>
18464 struct hash<VULKAN_HPP_NAMESPACE::SwapchainPresentBarrierCreateInfoNV>
18465 {
18466 std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainPresentBarrierCreateInfoNV const & swapchainPresentBarrierCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
18467 {
18468 std::size_t seed = 0;
18469 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentBarrierCreateInfoNV.sType );
18470 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentBarrierCreateInfoNV.pNext );
18471 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentBarrierCreateInfoNV.presentBarrierEnable );
18472 return seed;
18473 }
18474 };
18475
18476 template <>
18477 struct hash<VULKAN_HPP_NAMESPACE::SwapchainPresentFenceInfoKHR>
18478 {
18479 std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainPresentFenceInfoKHR const & swapchainPresentFenceInfoKHR ) const VULKAN_HPP_NOEXCEPT
18480 {
18481 std::size_t seed = 0;
18482 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentFenceInfoKHR.sType );
18483 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentFenceInfoKHR.pNext );
18484 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentFenceInfoKHR.swapchainCount );
18485 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentFenceInfoKHR.pFences );
18486 return seed;
18487 }
18488 };
18489
18490 template <>
18491 struct hash<VULKAN_HPP_NAMESPACE::SwapchainPresentModeInfoKHR>
18492 {
18493 std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainPresentModeInfoKHR const & swapchainPresentModeInfoKHR ) const VULKAN_HPP_NOEXCEPT
18494 {
18495 std::size_t seed = 0;
18496 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentModeInfoKHR.sType );
18497 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentModeInfoKHR.pNext );
18498 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentModeInfoKHR.swapchainCount );
18499 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentModeInfoKHR.pPresentModes );
18500 return seed;
18501 }
18502 };
18503
18504 template <>
18505 struct hash<VULKAN_HPP_NAMESPACE::SwapchainPresentModesCreateInfoKHR>
18506 {
18507 std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainPresentModesCreateInfoKHR const & swapchainPresentModesCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
18508 {
18509 std::size_t seed = 0;
18510 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentModesCreateInfoKHR.sType );
18511 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentModesCreateInfoKHR.pNext );
18512 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentModesCreateInfoKHR.presentModeCount );
18513 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentModesCreateInfoKHR.pPresentModes );
18514 return seed;
18515 }
18516 };
18517
18518 template <>
18519 struct hash<VULKAN_HPP_NAMESPACE::SwapchainPresentScalingCreateInfoKHR>
18520 {
18521 std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainPresentScalingCreateInfoKHR const & swapchainPresentScalingCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
18522 {
18523 std::size_t seed = 0;
18524 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentScalingCreateInfoKHR.sType );
18525 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentScalingCreateInfoKHR.pNext );
18526 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentScalingCreateInfoKHR.scalingBehavior );
18527 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentScalingCreateInfoKHR.presentGravityX );
18528 VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentScalingCreateInfoKHR.presentGravityY );
18529 return seed;
18530 }
18531 };
18532
18533 template <>
18534 struct hash<VULKAN_HPP_NAMESPACE::TensorCaptureDescriptorDataInfoARM>
18535 {
18536 std::size_t operator()( VULKAN_HPP_NAMESPACE::TensorCaptureDescriptorDataInfoARM const & tensorCaptureDescriptorDataInfoARM ) const VULKAN_HPP_NOEXCEPT
18537 {
18538 std::size_t seed = 0;
18539 VULKAN_HPP_HASH_COMBINE( seed, tensorCaptureDescriptorDataInfoARM.sType );
18540 VULKAN_HPP_HASH_COMBINE( seed, tensorCaptureDescriptorDataInfoARM.pNext );
18541 VULKAN_HPP_HASH_COMBINE( seed, tensorCaptureDescriptorDataInfoARM.tensor );
18542 return seed;
18543 }
18544 };
18545
18546 template <>
18547 struct hash<VULKAN_HPP_NAMESPACE::TensorMemoryBarrierARM>
18548 {
18549 std::size_t operator()( VULKAN_HPP_NAMESPACE::TensorMemoryBarrierARM const & tensorMemoryBarrierARM ) const VULKAN_HPP_NOEXCEPT
18550 {
18551 std::size_t seed = 0;
18552 VULKAN_HPP_HASH_COMBINE( seed, tensorMemoryBarrierARM.sType );
18553 VULKAN_HPP_HASH_COMBINE( seed, tensorMemoryBarrierARM.pNext );
18554 VULKAN_HPP_HASH_COMBINE( seed, tensorMemoryBarrierARM.srcStageMask );
18555 VULKAN_HPP_HASH_COMBINE( seed, tensorMemoryBarrierARM.srcAccessMask );
18556 VULKAN_HPP_HASH_COMBINE( seed, tensorMemoryBarrierARM.dstStageMask );
18557 VULKAN_HPP_HASH_COMBINE( seed, tensorMemoryBarrierARM.dstAccessMask );
18558 VULKAN_HPP_HASH_COMBINE( seed, tensorMemoryBarrierARM.srcQueueFamilyIndex );
18559 VULKAN_HPP_HASH_COMBINE( seed, tensorMemoryBarrierARM.dstQueueFamilyIndex );
18560 VULKAN_HPP_HASH_COMBINE( seed, tensorMemoryBarrierARM.tensor );
18561 return seed;
18562 }
18563 };
18564
18565 template <>
18566 struct hash<VULKAN_HPP_NAMESPACE::TensorDependencyInfoARM>
18567 {
18568 std::size_t operator()( VULKAN_HPP_NAMESPACE::TensorDependencyInfoARM const & tensorDependencyInfoARM ) const VULKAN_HPP_NOEXCEPT
18569 {
18570 std::size_t seed = 0;
18571 VULKAN_HPP_HASH_COMBINE( seed, tensorDependencyInfoARM.sType );
18572 VULKAN_HPP_HASH_COMBINE( seed, tensorDependencyInfoARM.pNext );
18573 VULKAN_HPP_HASH_COMBINE( seed, tensorDependencyInfoARM.tensorMemoryBarrierCount );
18574 VULKAN_HPP_HASH_COMBINE( seed, tensorDependencyInfoARM.pTensorMemoryBarriers );
18575 return seed;
18576 }
18577 };
18578
18579 template <>
18580 struct hash<VULKAN_HPP_NAMESPACE::TensorFormatPropertiesARM>
18581 {
18582 std::size_t operator()( VULKAN_HPP_NAMESPACE::TensorFormatPropertiesARM const & tensorFormatPropertiesARM ) const VULKAN_HPP_NOEXCEPT
18583 {
18584 std::size_t seed = 0;
18585 VULKAN_HPP_HASH_COMBINE( seed, tensorFormatPropertiesARM.sType );
18586 VULKAN_HPP_HASH_COMBINE( seed, tensorFormatPropertiesARM.pNext );
18587 VULKAN_HPP_HASH_COMBINE( seed, tensorFormatPropertiesARM.optimalTilingTensorFeatures );
18588 VULKAN_HPP_HASH_COMBINE( seed, tensorFormatPropertiesARM.linearTilingTensorFeatures );
18589 return seed;
18590 }
18591 };
18592
18593 template <>
18594 struct hash<VULKAN_HPP_NAMESPACE::TensorMemoryRequirementsInfoARM>
18595 {
18596 std::size_t operator()( VULKAN_HPP_NAMESPACE::TensorMemoryRequirementsInfoARM const & tensorMemoryRequirementsInfoARM ) const VULKAN_HPP_NOEXCEPT
18597 {
18598 std::size_t seed = 0;
18599 VULKAN_HPP_HASH_COMBINE( seed, tensorMemoryRequirementsInfoARM.sType );
18600 VULKAN_HPP_HASH_COMBINE( seed, tensorMemoryRequirementsInfoARM.pNext );
18601 VULKAN_HPP_HASH_COMBINE( seed, tensorMemoryRequirementsInfoARM.tensor );
18602 return seed;
18603 }
18604 };
18605
18606 template <>
18607 struct hash<VULKAN_HPP_NAMESPACE::TensorViewCaptureDescriptorDataInfoARM>
18608 {
18609 std::size_t
18610 operator()( VULKAN_HPP_NAMESPACE::TensorViewCaptureDescriptorDataInfoARM const & tensorViewCaptureDescriptorDataInfoARM ) const VULKAN_HPP_NOEXCEPT
18611 {
18612 std::size_t seed = 0;
18613 VULKAN_HPP_HASH_COMBINE( seed, tensorViewCaptureDescriptorDataInfoARM.sType );
18614 VULKAN_HPP_HASH_COMBINE( seed, tensorViewCaptureDescriptorDataInfoARM.pNext );
18615 VULKAN_HPP_HASH_COMBINE( seed, tensorViewCaptureDescriptorDataInfoARM.tensorView );
18616 return seed;
18617 }
18618 };
18619
18620 template <>
18621 struct hash<VULKAN_HPP_NAMESPACE::TensorViewCreateInfoARM>
18622 {
18623 std::size_t operator()( VULKAN_HPP_NAMESPACE::TensorViewCreateInfoARM const & tensorViewCreateInfoARM ) const VULKAN_HPP_NOEXCEPT
18624 {
18625 std::size_t seed = 0;
18626 VULKAN_HPP_HASH_COMBINE( seed, tensorViewCreateInfoARM.sType );
18627 VULKAN_HPP_HASH_COMBINE( seed, tensorViewCreateInfoARM.pNext );
18628 VULKAN_HPP_HASH_COMBINE( seed, tensorViewCreateInfoARM.flags );
18629 VULKAN_HPP_HASH_COMBINE( seed, tensorViewCreateInfoARM.tensor );
18630 VULKAN_HPP_HASH_COMBINE( seed, tensorViewCreateInfoARM.format );
18631 return seed;
18632 }
18633 };
18634
18635 template <>
18636 struct hash<VULKAN_HPP_NAMESPACE::TextureLODGatherFormatPropertiesAMD>
18637 {
18638 std::size_t operator()( VULKAN_HPP_NAMESPACE::TextureLODGatherFormatPropertiesAMD const & textureLODGatherFormatPropertiesAMD ) const VULKAN_HPP_NOEXCEPT
18639 {
18640 std::size_t seed = 0;
18641 VULKAN_HPP_HASH_COMBINE( seed, textureLODGatherFormatPropertiesAMD.sType );
18642 VULKAN_HPP_HASH_COMBINE( seed, textureLODGatherFormatPropertiesAMD.pNext );
18643 VULKAN_HPP_HASH_COMBINE( seed, textureLODGatherFormatPropertiesAMD.supportsTextureGatherLODBiasAMD );
18644 return seed;
18645 }
18646 };
18647
18648 template <>
18649 struct hash<VULKAN_HPP_NAMESPACE::TileMemoryBindInfoQCOM>
18650 {
18651 std::size_t operator()( VULKAN_HPP_NAMESPACE::TileMemoryBindInfoQCOM const & tileMemoryBindInfoQCOM ) const VULKAN_HPP_NOEXCEPT
18652 {
18653 std::size_t seed = 0;
18654 VULKAN_HPP_HASH_COMBINE( seed, tileMemoryBindInfoQCOM.sType );
18655 VULKAN_HPP_HASH_COMBINE( seed, tileMemoryBindInfoQCOM.pNext );
18656 VULKAN_HPP_HASH_COMBINE( seed, tileMemoryBindInfoQCOM.memory );
18657 return seed;
18658 }
18659 };
18660
18661 template <>
18662 struct hash<VULKAN_HPP_NAMESPACE::TileMemoryRequirementsQCOM>
18663 {
18664 std::size_t operator()( VULKAN_HPP_NAMESPACE::TileMemoryRequirementsQCOM const & tileMemoryRequirementsQCOM ) const VULKAN_HPP_NOEXCEPT
18665 {
18666 std::size_t seed = 0;
18667 VULKAN_HPP_HASH_COMBINE( seed, tileMemoryRequirementsQCOM.sType );
18668 VULKAN_HPP_HASH_COMBINE( seed, tileMemoryRequirementsQCOM.pNext );
18669 VULKAN_HPP_HASH_COMBINE( seed, tileMemoryRequirementsQCOM.size );
18670 VULKAN_HPP_HASH_COMBINE( seed, tileMemoryRequirementsQCOM.alignment );
18671 return seed;
18672 }
18673 };
18674
18675 template <>
18676 struct hash<VULKAN_HPP_NAMESPACE::TileMemorySizeInfoQCOM>
18677 {
18678 std::size_t operator()( VULKAN_HPP_NAMESPACE::TileMemorySizeInfoQCOM const & tileMemorySizeInfoQCOM ) const VULKAN_HPP_NOEXCEPT
18679 {
18680 std::size_t seed = 0;
18681 VULKAN_HPP_HASH_COMBINE( seed, tileMemorySizeInfoQCOM.sType );
18682 VULKAN_HPP_HASH_COMBINE( seed, tileMemorySizeInfoQCOM.pNext );
18683 VULKAN_HPP_HASH_COMBINE( seed, tileMemorySizeInfoQCOM.size );
18684 return seed;
18685 }
18686 };
18687
18688 template <>
18689 struct hash<VULKAN_HPP_NAMESPACE::TilePropertiesQCOM>
18690 {
18691 std::size_t operator()( VULKAN_HPP_NAMESPACE::TilePropertiesQCOM const & tilePropertiesQCOM ) const VULKAN_HPP_NOEXCEPT
18692 {
18693 std::size_t seed = 0;
18694 VULKAN_HPP_HASH_COMBINE( seed, tilePropertiesQCOM.sType );
18695 VULKAN_HPP_HASH_COMBINE( seed, tilePropertiesQCOM.pNext );
18696 VULKAN_HPP_HASH_COMBINE( seed, tilePropertiesQCOM.tileSize );
18697 VULKAN_HPP_HASH_COMBINE( seed, tilePropertiesQCOM.apronSize );
18698 VULKAN_HPP_HASH_COMBINE( seed, tilePropertiesQCOM.origin );
18699 return seed;
18700 }
18701 };
18702
18703 template <>
18704 struct hash<VULKAN_HPP_NAMESPACE::TimelineSemaphoreSubmitInfo>
18705 {
18706 std::size_t operator()( VULKAN_HPP_NAMESPACE::TimelineSemaphoreSubmitInfo const & timelineSemaphoreSubmitInfo ) const VULKAN_HPP_NOEXCEPT
18707 {
18708 std::size_t seed = 0;
18709 VULKAN_HPP_HASH_COMBINE( seed, timelineSemaphoreSubmitInfo.sType );
18710 VULKAN_HPP_HASH_COMBINE( seed, timelineSemaphoreSubmitInfo.pNext );
18711 VULKAN_HPP_HASH_COMBINE( seed, timelineSemaphoreSubmitInfo.waitSemaphoreValueCount );
18712 VULKAN_HPP_HASH_COMBINE( seed, timelineSemaphoreSubmitInfo.pWaitSemaphoreValues );
18713 VULKAN_HPP_HASH_COMBINE( seed, timelineSemaphoreSubmitInfo.signalSemaphoreValueCount );
18714 VULKAN_HPP_HASH_COMBINE( seed, timelineSemaphoreSubmitInfo.pSignalSemaphoreValues );
18715 return seed;
18716 }
18717 };
18718
18719 template <>
18720 struct hash<VULKAN_HPP_NAMESPACE::TraceRaysIndirectCommand2KHR>
18721 {
18722 std::size_t operator()( VULKAN_HPP_NAMESPACE::TraceRaysIndirectCommand2KHR const & traceRaysIndirectCommand2KHR ) const VULKAN_HPP_NOEXCEPT
18723 {
18724 std::size_t seed = 0;
18725 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.raygenShaderRecordAddress );
18726 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.raygenShaderRecordSize );
18727 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.missShaderBindingTableAddress );
18728 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.missShaderBindingTableSize );
18729 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.missShaderBindingTableStride );
18730 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.hitShaderBindingTableAddress );
18731 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.hitShaderBindingTableSize );
18732 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.hitShaderBindingTableStride );
18733 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.callableShaderBindingTableAddress );
18734 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.callableShaderBindingTableSize );
18735 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.callableShaderBindingTableStride );
18736 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.width );
18737 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.height );
18738 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.depth );
18739 return seed;
18740 }
18741 };
18742
18743 template <>
18744 struct hash<VULKAN_HPP_NAMESPACE::TraceRaysIndirectCommandKHR>
18745 {
18746 std::size_t operator()( VULKAN_HPP_NAMESPACE::TraceRaysIndirectCommandKHR const & traceRaysIndirectCommandKHR ) const VULKAN_HPP_NOEXCEPT
18747 {
18748 std::size_t seed = 0;
18749 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommandKHR.width );
18750 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommandKHR.height );
18751 VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommandKHR.depth );
18752 return seed;
18753 }
18754 };
18755
18756 template <>
18757 struct hash<VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT>
18758 {
18759 std::size_t operator()( VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT const & validationCacheCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
18760 {
18761 std::size_t seed = 0;
18762 VULKAN_HPP_HASH_COMBINE( seed, validationCacheCreateInfoEXT.sType );
18763 VULKAN_HPP_HASH_COMBINE( seed, validationCacheCreateInfoEXT.pNext );
18764 VULKAN_HPP_HASH_COMBINE( seed, validationCacheCreateInfoEXT.flags );
18765 VULKAN_HPP_HASH_COMBINE( seed, validationCacheCreateInfoEXT.initialDataSize );
18766 VULKAN_HPP_HASH_COMBINE( seed, validationCacheCreateInfoEXT.pInitialData );
18767 return seed;
18768 }
18769 };
18770
18771 template <>
18772 struct hash<VULKAN_HPP_NAMESPACE::ValidationFeaturesEXT>
18773 {
18774 std::size_t operator()( VULKAN_HPP_NAMESPACE::ValidationFeaturesEXT const & validationFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
18775 {
18776 std::size_t seed = 0;
18777 VULKAN_HPP_HASH_COMBINE( seed, validationFeaturesEXT.sType );
18778 VULKAN_HPP_HASH_COMBINE( seed, validationFeaturesEXT.pNext );
18779 VULKAN_HPP_HASH_COMBINE( seed, validationFeaturesEXT.enabledValidationFeatureCount );
18780 VULKAN_HPP_HASH_COMBINE( seed, validationFeaturesEXT.pEnabledValidationFeatures );
18781 VULKAN_HPP_HASH_COMBINE( seed, validationFeaturesEXT.disabledValidationFeatureCount );
18782 VULKAN_HPP_HASH_COMBINE( seed, validationFeaturesEXT.pDisabledValidationFeatures );
18783 return seed;
18784 }
18785 };
18786
18787 template <>
18788 struct hash<VULKAN_HPP_NAMESPACE::ValidationFlagsEXT>
18789 {
18790 std::size_t operator()( VULKAN_HPP_NAMESPACE::ValidationFlagsEXT const & validationFlagsEXT ) const VULKAN_HPP_NOEXCEPT
18791 {
18792 std::size_t seed = 0;
18793 VULKAN_HPP_HASH_COMBINE( seed, validationFlagsEXT.sType );
18794 VULKAN_HPP_HASH_COMBINE( seed, validationFlagsEXT.pNext );
18795 VULKAN_HPP_HASH_COMBINE( seed, validationFlagsEXT.disabledValidationCheckCount );
18796 VULKAN_HPP_HASH_COMBINE( seed, validationFlagsEXT.pDisabledValidationChecks );
18797 return seed;
18798 }
18799 };
18800
18801 template <>
18802 struct hash<VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT>
18803 {
18804 std::size_t operator()( VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT const & vertexInputAttributeDescription2EXT ) const VULKAN_HPP_NOEXCEPT
18805 {
18806 std::size_t seed = 0;
18807 VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription2EXT.sType );
18808 VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription2EXT.pNext );
18809 VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription2EXT.location );
18810 VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription2EXT.binding );
18811 VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription2EXT.format );
18812 VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription2EXT.offset );
18813 return seed;
18814 }
18815 };
18816
18817 template <>
18818 struct hash<VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT>
18819 {
18820 std::size_t operator()( VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT const & vertexInputBindingDescription2EXT ) const VULKAN_HPP_NOEXCEPT
18821 {
18822 std::size_t seed = 0;
18823 VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDescription2EXT.sType );
18824 VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDescription2EXT.pNext );
18825 VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDescription2EXT.binding );
18826 VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDescription2EXT.stride );
18827 VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDescription2EXT.inputRate );
18828 VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDescription2EXT.divisor );
18829 return seed;
18830 }
18831 };
18832
18833 # if defined( VK_USE_PLATFORM_VI_NN )
18834 template <>
18835 struct hash<VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN>
18836 {
18837 std::size_t operator()( VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN const & viSurfaceCreateInfoNN ) const VULKAN_HPP_NOEXCEPT
18838 {
18839 std::size_t seed = 0;
18840 VULKAN_HPP_HASH_COMBINE( seed, viSurfaceCreateInfoNN.sType );
18841 VULKAN_HPP_HASH_COMBINE( seed, viSurfaceCreateInfoNN.pNext );
18842 VULKAN_HPP_HASH_COMBINE( seed, viSurfaceCreateInfoNN.flags );
18843 VULKAN_HPP_HASH_COMBINE( seed, viSurfaceCreateInfoNN.window );
18844 return seed;
18845 }
18846 };
18847 # endif /*VK_USE_PLATFORM_VI_NN*/
18848
18849 template <>
18850 struct hash<VULKAN_HPP_NAMESPACE::VideoPictureResourceInfoKHR>
18851 {
18852 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoPictureResourceInfoKHR const & videoPictureResourceInfoKHR ) const VULKAN_HPP_NOEXCEPT
18853 {
18854 std::size_t seed = 0;
18855 VULKAN_HPP_HASH_COMBINE( seed, videoPictureResourceInfoKHR.sType );
18856 VULKAN_HPP_HASH_COMBINE( seed, videoPictureResourceInfoKHR.pNext );
18857 VULKAN_HPP_HASH_COMBINE( seed, videoPictureResourceInfoKHR.codedOffset );
18858 VULKAN_HPP_HASH_COMBINE( seed, videoPictureResourceInfoKHR.codedExtent );
18859 VULKAN_HPP_HASH_COMBINE( seed, videoPictureResourceInfoKHR.baseArrayLayer );
18860 VULKAN_HPP_HASH_COMBINE( seed, videoPictureResourceInfoKHR.imageViewBinding );
18861 return seed;
18862 }
18863 };
18864
18865 template <>
18866 struct hash<VULKAN_HPP_NAMESPACE::VideoReferenceSlotInfoKHR>
18867 {
18868 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoReferenceSlotInfoKHR const & videoReferenceSlotInfoKHR ) const VULKAN_HPP_NOEXCEPT
18869 {
18870 std::size_t seed = 0;
18871 VULKAN_HPP_HASH_COMBINE( seed, videoReferenceSlotInfoKHR.sType );
18872 VULKAN_HPP_HASH_COMBINE( seed, videoReferenceSlotInfoKHR.pNext );
18873 VULKAN_HPP_HASH_COMBINE( seed, videoReferenceSlotInfoKHR.slotIndex );
18874 VULKAN_HPP_HASH_COMBINE( seed, videoReferenceSlotInfoKHR.pPictureResource );
18875 return seed;
18876 }
18877 };
18878
18879 template <>
18880 struct hash<VULKAN_HPP_NAMESPACE::VideoBeginCodingInfoKHR>
18881 {
18882 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoBeginCodingInfoKHR const & videoBeginCodingInfoKHR ) const VULKAN_HPP_NOEXCEPT
18883 {
18884 std::size_t seed = 0;
18885 VULKAN_HPP_HASH_COMBINE( seed, videoBeginCodingInfoKHR.sType );
18886 VULKAN_HPP_HASH_COMBINE( seed, videoBeginCodingInfoKHR.pNext );
18887 VULKAN_HPP_HASH_COMBINE( seed, videoBeginCodingInfoKHR.flags );
18888 VULKAN_HPP_HASH_COMBINE( seed, videoBeginCodingInfoKHR.videoSession );
18889 VULKAN_HPP_HASH_COMBINE( seed, videoBeginCodingInfoKHR.videoSessionParameters );
18890 VULKAN_HPP_HASH_COMBINE( seed, videoBeginCodingInfoKHR.referenceSlotCount );
18891 VULKAN_HPP_HASH_COMBINE( seed, videoBeginCodingInfoKHR.pReferenceSlots );
18892 return seed;
18893 }
18894 };
18895
18896 template <>
18897 struct hash<VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR>
18898 {
18899 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR const & videoCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT
18900 {
18901 std::size_t seed = 0;
18902 VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.sType );
18903 VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.pNext );
18904 VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.flags );
18905 VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.minBitstreamBufferOffsetAlignment );
18906 VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.minBitstreamBufferSizeAlignment );
18907 VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.pictureAccessGranularity );
18908 VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.minCodedExtent );
18909 VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.maxCodedExtent );
18910 VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.maxDpbSlots );
18911 VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.maxActiveReferencePictures );
18912 VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.stdHeaderVersion );
18913 return seed;
18914 }
18915 };
18916
18917 template <>
18918 struct hash<VULKAN_HPP_NAMESPACE::VideoCodingControlInfoKHR>
18919 {
18920 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoCodingControlInfoKHR const & videoCodingControlInfoKHR ) const VULKAN_HPP_NOEXCEPT
18921 {
18922 std::size_t seed = 0;
18923 VULKAN_HPP_HASH_COMBINE( seed, videoCodingControlInfoKHR.sType );
18924 VULKAN_HPP_HASH_COMBINE( seed, videoCodingControlInfoKHR.pNext );
18925 VULKAN_HPP_HASH_COMBINE( seed, videoCodingControlInfoKHR.flags );
18926 return seed;
18927 }
18928 };
18929
18930 template <>
18931 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeAV1CapabilitiesKHR>
18932 {
18933 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeAV1CapabilitiesKHR const & videoDecodeAV1CapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT
18934 {
18935 std::size_t seed = 0;
18936 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1CapabilitiesKHR.sType );
18937 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1CapabilitiesKHR.pNext );
18938 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1CapabilitiesKHR.maxLevel );
18939 return seed;
18940 }
18941 };
18942
18943 template <>
18944 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeAV1DpbSlotInfoKHR>
18945 {
18946 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeAV1DpbSlotInfoKHR const & videoDecodeAV1DpbSlotInfoKHR ) const VULKAN_HPP_NOEXCEPT
18947 {
18948 std::size_t seed = 0;
18949 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1DpbSlotInfoKHR.sType );
18950 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1DpbSlotInfoKHR.pNext );
18951 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1DpbSlotInfoKHR.pStdReferenceInfo );
18952 return seed;
18953 }
18954 };
18955
18956 template <>
18957 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeAV1InlineSessionParametersInfoKHR>
18958 {
18959 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeAV1InlineSessionParametersInfoKHR const & videoDecodeAV1InlineSessionParametersInfoKHR ) const
18960 VULKAN_HPP_NOEXCEPT
18961 {
18962 std::size_t seed = 0;
18963 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1InlineSessionParametersInfoKHR.sType );
18964 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1InlineSessionParametersInfoKHR.pNext );
18965 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1InlineSessionParametersInfoKHR.pStdSequenceHeader );
18966 return seed;
18967 }
18968 };
18969
18970 template <>
18971 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeAV1PictureInfoKHR>
18972 {
18973 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeAV1PictureInfoKHR const & videoDecodeAV1PictureInfoKHR ) const VULKAN_HPP_NOEXCEPT
18974 {
18975 std::size_t seed = 0;
18976 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1PictureInfoKHR.sType );
18977 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1PictureInfoKHR.pNext );
18978 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1PictureInfoKHR.pStdPictureInfo );
18979 for ( size_t i = 0; i < VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR; ++i )
18980 {
18981 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1PictureInfoKHR.referenceNameSlotIndices[i] );
18982 }
18983 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1PictureInfoKHR.frameHeaderOffset );
18984 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1PictureInfoKHR.tileCount );
18985 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1PictureInfoKHR.pTileOffsets );
18986 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1PictureInfoKHR.pTileSizes );
18987 return seed;
18988 }
18989 };
18990
18991 template <>
18992 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeAV1ProfileInfoKHR>
18993 {
18994 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeAV1ProfileInfoKHR const & videoDecodeAV1ProfileInfoKHR ) const VULKAN_HPP_NOEXCEPT
18995 {
18996 std::size_t seed = 0;
18997 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1ProfileInfoKHR.sType );
18998 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1ProfileInfoKHR.pNext );
18999 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1ProfileInfoKHR.stdProfile );
19000 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1ProfileInfoKHR.filmGrainSupport );
19001 return seed;
19002 }
19003 };
19004
19005 template <>
19006 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeAV1SessionParametersCreateInfoKHR>
19007 {
19008 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeAV1SessionParametersCreateInfoKHR const & videoDecodeAV1SessionParametersCreateInfoKHR ) const
19009 VULKAN_HPP_NOEXCEPT
19010 {
19011 std::size_t seed = 0;
19012 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1SessionParametersCreateInfoKHR.sType );
19013 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1SessionParametersCreateInfoKHR.pNext );
19014 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1SessionParametersCreateInfoKHR.pStdSequenceHeader );
19015 return seed;
19016 }
19017 };
19018
19019 template <>
19020 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeCapabilitiesKHR>
19021 {
19022 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeCapabilitiesKHR const & videoDecodeCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT
19023 {
19024 std::size_t seed = 0;
19025 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeCapabilitiesKHR.sType );
19026 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeCapabilitiesKHR.pNext );
19027 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeCapabilitiesKHR.flags );
19028 return seed;
19029 }
19030 };
19031
19032 template <>
19033 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH264CapabilitiesKHR>
19034 {
19035 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264CapabilitiesKHR const & videoDecodeH264CapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT
19036 {
19037 std::size_t seed = 0;
19038 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264CapabilitiesKHR.sType );
19039 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264CapabilitiesKHR.pNext );
19040 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264CapabilitiesKHR.maxLevelIdc );
19041 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264CapabilitiesKHR.fieldOffsetGranularity );
19042 return seed;
19043 }
19044 };
19045
19046 template <>
19047 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH264DpbSlotInfoKHR>
19048 {
19049 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264DpbSlotInfoKHR const & videoDecodeH264DpbSlotInfoKHR ) const VULKAN_HPP_NOEXCEPT
19050 {
19051 std::size_t seed = 0;
19052 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264DpbSlotInfoKHR.sType );
19053 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264DpbSlotInfoKHR.pNext );
19054 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264DpbSlotInfoKHR.pStdReferenceInfo );
19055 return seed;
19056 }
19057 };
19058
19059 template <>
19060 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH264InlineSessionParametersInfoKHR>
19061 {
19062 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264InlineSessionParametersInfoKHR const & videoDecodeH264InlineSessionParametersInfoKHR ) const
19063 VULKAN_HPP_NOEXCEPT
19064 {
19065 std::size_t seed = 0;
19066 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264InlineSessionParametersInfoKHR.sType );
19067 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264InlineSessionParametersInfoKHR.pNext );
19068 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264InlineSessionParametersInfoKHR.pStdSPS );
19069 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264InlineSessionParametersInfoKHR.pStdPPS );
19070 return seed;
19071 }
19072 };
19073
19074 template <>
19075 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH264PictureInfoKHR>
19076 {
19077 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264PictureInfoKHR const & videoDecodeH264PictureInfoKHR ) const VULKAN_HPP_NOEXCEPT
19078 {
19079 std::size_t seed = 0;
19080 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264PictureInfoKHR.sType );
19081 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264PictureInfoKHR.pNext );
19082 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264PictureInfoKHR.pStdPictureInfo );
19083 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264PictureInfoKHR.sliceCount );
19084 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264PictureInfoKHR.pSliceOffsets );
19085 return seed;
19086 }
19087 };
19088
19089 template <>
19090 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH264ProfileInfoKHR>
19091 {
19092 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264ProfileInfoKHR const & videoDecodeH264ProfileInfoKHR ) const VULKAN_HPP_NOEXCEPT
19093 {
19094 std::size_t seed = 0;
19095 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264ProfileInfoKHR.sType );
19096 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264ProfileInfoKHR.pNext );
19097 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264ProfileInfoKHR.stdProfileIdc );
19098 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264ProfileInfoKHR.pictureLayout );
19099 return seed;
19100 }
19101 };
19102
19103 template <>
19104 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH264SessionParametersAddInfoKHR>
19105 {
19106 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264SessionParametersAddInfoKHR const & videoDecodeH264SessionParametersAddInfoKHR ) const
19107 VULKAN_HPP_NOEXCEPT
19108 {
19109 std::size_t seed = 0;
19110 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersAddInfoKHR.sType );
19111 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersAddInfoKHR.pNext );
19112 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersAddInfoKHR.stdSPSCount );
19113 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersAddInfoKHR.pStdSPSs );
19114 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersAddInfoKHR.stdPPSCount );
19115 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersAddInfoKHR.pStdPPSs );
19116 return seed;
19117 }
19118 };
19119
19120 template <>
19121 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH264SessionParametersCreateInfoKHR>
19122 {
19123 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264SessionParametersCreateInfoKHR const & videoDecodeH264SessionParametersCreateInfoKHR ) const
19124 VULKAN_HPP_NOEXCEPT
19125 {
19126 std::size_t seed = 0;
19127 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersCreateInfoKHR.sType );
19128 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersCreateInfoKHR.pNext );
19129 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersCreateInfoKHR.maxStdSPSCount );
19130 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersCreateInfoKHR.maxStdPPSCount );
19131 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersCreateInfoKHR.pParametersAddInfo );
19132 return seed;
19133 }
19134 };
19135
19136 template <>
19137 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH265CapabilitiesKHR>
19138 {
19139 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265CapabilitiesKHR const & videoDecodeH265CapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT
19140 {
19141 std::size_t seed = 0;
19142 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265CapabilitiesKHR.sType );
19143 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265CapabilitiesKHR.pNext );
19144 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265CapabilitiesKHR.maxLevelIdc );
19145 return seed;
19146 }
19147 };
19148
19149 template <>
19150 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH265DpbSlotInfoKHR>
19151 {
19152 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265DpbSlotInfoKHR const & videoDecodeH265DpbSlotInfoKHR ) const VULKAN_HPP_NOEXCEPT
19153 {
19154 std::size_t seed = 0;
19155 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265DpbSlotInfoKHR.sType );
19156 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265DpbSlotInfoKHR.pNext );
19157 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265DpbSlotInfoKHR.pStdReferenceInfo );
19158 return seed;
19159 }
19160 };
19161
19162 template <>
19163 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH265InlineSessionParametersInfoKHR>
19164 {
19165 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265InlineSessionParametersInfoKHR const & videoDecodeH265InlineSessionParametersInfoKHR ) const
19166 VULKAN_HPP_NOEXCEPT
19167 {
19168 std::size_t seed = 0;
19169 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265InlineSessionParametersInfoKHR.sType );
19170 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265InlineSessionParametersInfoKHR.pNext );
19171 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265InlineSessionParametersInfoKHR.pStdVPS );
19172 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265InlineSessionParametersInfoKHR.pStdSPS );
19173 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265InlineSessionParametersInfoKHR.pStdPPS );
19174 return seed;
19175 }
19176 };
19177
19178 template <>
19179 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH265PictureInfoKHR>
19180 {
19181 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265PictureInfoKHR const & videoDecodeH265PictureInfoKHR ) const VULKAN_HPP_NOEXCEPT
19182 {
19183 std::size_t seed = 0;
19184 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265PictureInfoKHR.sType );
19185 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265PictureInfoKHR.pNext );
19186 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265PictureInfoKHR.pStdPictureInfo );
19187 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265PictureInfoKHR.sliceSegmentCount );
19188 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265PictureInfoKHR.pSliceSegmentOffsets );
19189 return seed;
19190 }
19191 };
19192
19193 template <>
19194 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH265ProfileInfoKHR>
19195 {
19196 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265ProfileInfoKHR const & videoDecodeH265ProfileInfoKHR ) const VULKAN_HPP_NOEXCEPT
19197 {
19198 std::size_t seed = 0;
19199 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265ProfileInfoKHR.sType );
19200 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265ProfileInfoKHR.pNext );
19201 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265ProfileInfoKHR.stdProfileIdc );
19202 return seed;
19203 }
19204 };
19205
19206 template <>
19207 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH265SessionParametersAddInfoKHR>
19208 {
19209 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265SessionParametersAddInfoKHR const & videoDecodeH265SessionParametersAddInfoKHR ) const
19210 VULKAN_HPP_NOEXCEPT
19211 {
19212 std::size_t seed = 0;
19213 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersAddInfoKHR.sType );
19214 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersAddInfoKHR.pNext );
19215 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersAddInfoKHR.stdVPSCount );
19216 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersAddInfoKHR.pStdVPSs );
19217 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersAddInfoKHR.stdSPSCount );
19218 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersAddInfoKHR.pStdSPSs );
19219 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersAddInfoKHR.stdPPSCount );
19220 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersAddInfoKHR.pStdPPSs );
19221 return seed;
19222 }
19223 };
19224
19225 template <>
19226 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH265SessionParametersCreateInfoKHR>
19227 {
19228 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265SessionParametersCreateInfoKHR const & videoDecodeH265SessionParametersCreateInfoKHR ) const
19229 VULKAN_HPP_NOEXCEPT
19230 {
19231 std::size_t seed = 0;
19232 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersCreateInfoKHR.sType );
19233 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersCreateInfoKHR.pNext );
19234 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersCreateInfoKHR.maxStdVPSCount );
19235 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersCreateInfoKHR.maxStdSPSCount );
19236 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersCreateInfoKHR.maxStdPPSCount );
19237 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersCreateInfoKHR.pParametersAddInfo );
19238 return seed;
19239 }
19240 };
19241
19242 template <>
19243 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR>
19244 {
19245 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR const & videoDecodeInfoKHR ) const VULKAN_HPP_NOEXCEPT
19246 {
19247 std::size_t seed = 0;
19248 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.sType );
19249 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.pNext );
19250 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.flags );
19251 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.srcBuffer );
19252 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.srcBufferOffset );
19253 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.srcBufferRange );
19254 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.dstPictureResource );
19255 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.pSetupReferenceSlot );
19256 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.referenceSlotCount );
19257 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.pReferenceSlots );
19258 return seed;
19259 }
19260 };
19261
19262 template <>
19263 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeUsageInfoKHR>
19264 {
19265 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeUsageInfoKHR const & videoDecodeUsageInfoKHR ) const VULKAN_HPP_NOEXCEPT
19266 {
19267 std::size_t seed = 0;
19268 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeUsageInfoKHR.sType );
19269 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeUsageInfoKHR.pNext );
19270 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeUsageInfoKHR.videoUsageHints );
19271 return seed;
19272 }
19273 };
19274
19275 template <>
19276 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeVP9CapabilitiesKHR>
19277 {
19278 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeVP9CapabilitiesKHR const & videoDecodeVP9CapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT
19279 {
19280 std::size_t seed = 0;
19281 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeVP9CapabilitiesKHR.sType );
19282 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeVP9CapabilitiesKHR.pNext );
19283 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeVP9CapabilitiesKHR.maxLevel );
19284 return seed;
19285 }
19286 };
19287
19288 template <>
19289 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeVP9PictureInfoKHR>
19290 {
19291 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeVP9PictureInfoKHR const & videoDecodeVP9PictureInfoKHR ) const VULKAN_HPP_NOEXCEPT
19292 {
19293 std::size_t seed = 0;
19294 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeVP9PictureInfoKHR.sType );
19295 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeVP9PictureInfoKHR.pNext );
19296 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeVP9PictureInfoKHR.pStdPictureInfo );
19297 for ( size_t i = 0; i < VK_MAX_VIDEO_VP9_REFERENCES_PER_FRAME_KHR; ++i )
19298 {
19299 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeVP9PictureInfoKHR.referenceNameSlotIndices[i] );
19300 }
19301 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeVP9PictureInfoKHR.uncompressedHeaderOffset );
19302 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeVP9PictureInfoKHR.compressedHeaderOffset );
19303 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeVP9PictureInfoKHR.tilesOffset );
19304 return seed;
19305 }
19306 };
19307
19308 template <>
19309 struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeVP9ProfileInfoKHR>
19310 {
19311 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeVP9ProfileInfoKHR const & videoDecodeVP9ProfileInfoKHR ) const VULKAN_HPP_NOEXCEPT
19312 {
19313 std::size_t seed = 0;
19314 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeVP9ProfileInfoKHR.sType );
19315 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeVP9ProfileInfoKHR.pNext );
19316 VULKAN_HPP_HASH_COMBINE( seed, videoDecodeVP9ProfileInfoKHR.stdProfile );
19317 return seed;
19318 }
19319 };
19320
19321 template <>
19322 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeAV1CapabilitiesKHR>
19323 {
19324 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeAV1CapabilitiesKHR const & videoEncodeAV1CapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT
19325 {
19326 std::size_t seed = 0;
19327 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.sType );
19328 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.pNext );
19329 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.flags );
19330 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.maxLevel );
19331 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.codedPictureAlignment );
19332 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.maxTiles );
19333 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.minTileSize );
19334 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.maxTileSize );
19335 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.superblockSizes );
19336 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.maxSingleReferenceCount );
19337 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.singleReferenceNameMask );
19338 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.maxUnidirectionalCompoundReferenceCount );
19339 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.maxUnidirectionalCompoundGroup1ReferenceCount );
19340 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.unidirectionalCompoundReferenceNameMask );
19341 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.maxBidirectionalCompoundReferenceCount );
19342 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.maxBidirectionalCompoundGroup1ReferenceCount );
19343 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.maxBidirectionalCompoundGroup2ReferenceCount );
19344 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.bidirectionalCompoundReferenceNameMask );
19345 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.maxTemporalLayerCount );
19346 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.maxSpatialLayerCount );
19347 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.maxOperatingPoints );
19348 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.minQIndex );
19349 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.maxQIndex );
19350 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.prefersGopRemainingFrames );
19351 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.requiresGopRemainingFrames );
19352 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.stdSyntaxFlags );
19353 return seed;
19354 }
19355 };
19356
19357 template <>
19358 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeAV1DpbSlotInfoKHR>
19359 {
19360 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeAV1DpbSlotInfoKHR const & videoEncodeAV1DpbSlotInfoKHR ) const VULKAN_HPP_NOEXCEPT
19361 {
19362 std::size_t seed = 0;
19363 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1DpbSlotInfoKHR.sType );
19364 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1DpbSlotInfoKHR.pNext );
19365 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1DpbSlotInfoKHR.pStdReferenceInfo );
19366 return seed;
19367 }
19368 };
19369
19370 template <>
19371 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeAV1FrameSizeKHR>
19372 {
19373 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeAV1FrameSizeKHR const & videoEncodeAV1FrameSizeKHR ) const VULKAN_HPP_NOEXCEPT
19374 {
19375 std::size_t seed = 0;
19376 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1FrameSizeKHR.intraFrameSize );
19377 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1FrameSizeKHR.predictiveFrameSize );
19378 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1FrameSizeKHR.bipredictiveFrameSize );
19379 return seed;
19380 }
19381 };
19382
19383 template <>
19384 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeAV1GopRemainingFrameInfoKHR>
19385 {
19386 std::size_t
19387 operator()( VULKAN_HPP_NAMESPACE::VideoEncodeAV1GopRemainingFrameInfoKHR const & videoEncodeAV1GopRemainingFrameInfoKHR ) const VULKAN_HPP_NOEXCEPT
19388 {
19389 std::size_t seed = 0;
19390 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1GopRemainingFrameInfoKHR.sType );
19391 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1GopRemainingFrameInfoKHR.pNext );
19392 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1GopRemainingFrameInfoKHR.useGopRemainingFrames );
19393 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1GopRemainingFrameInfoKHR.gopRemainingIntra );
19394 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1GopRemainingFrameInfoKHR.gopRemainingPredictive );
19395 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1GopRemainingFrameInfoKHR.gopRemainingBipredictive );
19396 return seed;
19397 }
19398 };
19399
19400 template <>
19401 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeAV1PictureInfoKHR>
19402 {
19403 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeAV1PictureInfoKHR const & videoEncodeAV1PictureInfoKHR ) const VULKAN_HPP_NOEXCEPT
19404 {
19405 std::size_t seed = 0;
19406 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1PictureInfoKHR.sType );
19407 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1PictureInfoKHR.pNext );
19408 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1PictureInfoKHR.predictionMode );
19409 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1PictureInfoKHR.rateControlGroup );
19410 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1PictureInfoKHR.constantQIndex );
19411 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1PictureInfoKHR.pStdPictureInfo );
19412 for ( size_t i = 0; i < VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR; ++i )
19413 {
19414 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1PictureInfoKHR.referenceNameSlotIndices[i] );
19415 }
19416 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1PictureInfoKHR.primaryReferenceCdfOnly );
19417 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1PictureInfoKHR.generateObuExtensionHeader );
19418 return seed;
19419 }
19420 };
19421
19422 template <>
19423 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeAV1ProfileInfoKHR>
19424 {
19425 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeAV1ProfileInfoKHR const & videoEncodeAV1ProfileInfoKHR ) const VULKAN_HPP_NOEXCEPT
19426 {
19427 std::size_t seed = 0;
19428 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1ProfileInfoKHR.sType );
19429 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1ProfileInfoKHR.pNext );
19430 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1ProfileInfoKHR.stdProfile );
19431 return seed;
19432 }
19433 };
19434
19435 template <>
19436 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeAV1QIndexKHR>
19437 {
19438 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeAV1QIndexKHR const & videoEncodeAV1QIndexKHR ) const VULKAN_HPP_NOEXCEPT
19439 {
19440 std::size_t seed = 0;
19441 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QIndexKHR.intraQIndex );
19442 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QIndexKHR.predictiveQIndex );
19443 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QIndexKHR.bipredictiveQIndex );
19444 return seed;
19445 }
19446 };
19447
19448 template <>
19449 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeAV1QualityLevelPropertiesKHR>
19450 {
19451 std::size_t
19452 operator()( VULKAN_HPP_NAMESPACE::VideoEncodeAV1QualityLevelPropertiesKHR const & videoEncodeAV1QualityLevelPropertiesKHR ) const VULKAN_HPP_NOEXCEPT
19453 {
19454 std::size_t seed = 0;
19455 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QualityLevelPropertiesKHR.sType );
19456 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QualityLevelPropertiesKHR.pNext );
19457 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QualityLevelPropertiesKHR.preferredRateControlFlags );
19458 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QualityLevelPropertiesKHR.preferredGopFrameCount );
19459 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QualityLevelPropertiesKHR.preferredKeyFramePeriod );
19460 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QualityLevelPropertiesKHR.preferredConsecutiveBipredictiveFrameCount );
19461 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QualityLevelPropertiesKHR.preferredTemporalLayerCount );
19462 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QualityLevelPropertiesKHR.preferredConstantQIndex );
19463 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QualityLevelPropertiesKHR.preferredMaxSingleReferenceCount );
19464 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QualityLevelPropertiesKHR.preferredSingleReferenceNameMask );
19465 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QualityLevelPropertiesKHR.preferredMaxUnidirectionalCompoundReferenceCount );
19466 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QualityLevelPropertiesKHR.preferredMaxUnidirectionalCompoundGroup1ReferenceCount );
19467 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QualityLevelPropertiesKHR.preferredUnidirectionalCompoundReferenceNameMask );
19468 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QualityLevelPropertiesKHR.preferredMaxBidirectionalCompoundReferenceCount );
19469 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QualityLevelPropertiesKHR.preferredMaxBidirectionalCompoundGroup1ReferenceCount );
19470 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QualityLevelPropertiesKHR.preferredMaxBidirectionalCompoundGroup2ReferenceCount );
19471 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QualityLevelPropertiesKHR.preferredBidirectionalCompoundReferenceNameMask );
19472 return seed;
19473 }
19474 };
19475
19476 template <>
19477 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeAV1QuantizationMapCapabilitiesKHR>
19478 {
19479 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeAV1QuantizationMapCapabilitiesKHR const & videoEncodeAV1QuantizationMapCapabilitiesKHR ) const
19480 VULKAN_HPP_NOEXCEPT
19481 {
19482 std::size_t seed = 0;
19483 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QuantizationMapCapabilitiesKHR.sType );
19484 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QuantizationMapCapabilitiesKHR.pNext );
19485 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QuantizationMapCapabilitiesKHR.minQIndexDelta );
19486 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QuantizationMapCapabilitiesKHR.maxQIndexDelta );
19487 return seed;
19488 }
19489 };
19490
19491 template <>
19492 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeAV1RateControlInfoKHR>
19493 {
19494 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeAV1RateControlInfoKHR const & videoEncodeAV1RateControlInfoKHR ) const VULKAN_HPP_NOEXCEPT
19495 {
19496 std::size_t seed = 0;
19497 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1RateControlInfoKHR.sType );
19498 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1RateControlInfoKHR.pNext );
19499 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1RateControlInfoKHR.flags );
19500 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1RateControlInfoKHR.gopFrameCount );
19501 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1RateControlInfoKHR.keyFramePeriod );
19502 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1RateControlInfoKHR.consecutiveBipredictiveFrameCount );
19503 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1RateControlInfoKHR.temporalLayerCount );
19504 return seed;
19505 }
19506 };
19507
19508 template <>
19509 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeAV1RateControlLayerInfoKHR>
19510 {
19511 std::size_t
19512 operator()( VULKAN_HPP_NAMESPACE::VideoEncodeAV1RateControlLayerInfoKHR const & videoEncodeAV1RateControlLayerInfoKHR ) const VULKAN_HPP_NOEXCEPT
19513 {
19514 std::size_t seed = 0;
19515 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1RateControlLayerInfoKHR.sType );
19516 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1RateControlLayerInfoKHR.pNext );
19517 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1RateControlLayerInfoKHR.useMinQIndex );
19518 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1RateControlLayerInfoKHR.minQIndex );
19519 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1RateControlLayerInfoKHR.useMaxQIndex );
19520 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1RateControlLayerInfoKHR.maxQIndex );
19521 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1RateControlLayerInfoKHR.useMaxFrameSize );
19522 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1RateControlLayerInfoKHR.maxFrameSize );
19523 return seed;
19524 }
19525 };
19526
19527 template <>
19528 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeAV1SessionCreateInfoKHR>
19529 {
19530 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeAV1SessionCreateInfoKHR const & videoEncodeAV1SessionCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
19531 {
19532 std::size_t seed = 0;
19533 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1SessionCreateInfoKHR.sType );
19534 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1SessionCreateInfoKHR.pNext );
19535 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1SessionCreateInfoKHR.useMaxLevel );
19536 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1SessionCreateInfoKHR.maxLevel );
19537 return seed;
19538 }
19539 };
19540
19541 template <>
19542 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeAV1SessionParametersCreateInfoKHR>
19543 {
19544 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeAV1SessionParametersCreateInfoKHR const & videoEncodeAV1SessionParametersCreateInfoKHR ) const
19545 VULKAN_HPP_NOEXCEPT
19546 {
19547 std::size_t seed = 0;
19548 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1SessionParametersCreateInfoKHR.sType );
19549 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1SessionParametersCreateInfoKHR.pNext );
19550 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1SessionParametersCreateInfoKHR.pStdSequenceHeader );
19551 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1SessionParametersCreateInfoKHR.pStdDecoderModelInfo );
19552 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1SessionParametersCreateInfoKHR.stdOperatingPointCount );
19553 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1SessionParametersCreateInfoKHR.pStdOperatingPoints );
19554 return seed;
19555 }
19556 };
19557
19558 template <>
19559 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeCapabilitiesKHR>
19560 {
19561 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeCapabilitiesKHR const & videoEncodeCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT
19562 {
19563 std::size_t seed = 0;
19564 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.sType );
19565 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.pNext );
19566 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.flags );
19567 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.rateControlModes );
19568 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.maxRateControlLayers );
19569 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.maxBitrate );
19570 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.maxQualityLevels );
19571 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.encodeInputPictureGranularity );
19572 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.supportedEncodeFeedbackFlags );
19573 return seed;
19574 }
19575 };
19576
19577 template <>
19578 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilitiesKHR>
19579 {
19580 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilitiesKHR const & videoEncodeH264CapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT
19581 {
19582 std::size_t seed = 0;
19583 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.sType );
19584 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.pNext );
19585 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.flags );
19586 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.maxLevelIdc );
19587 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.maxSliceCount );
19588 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.maxPPictureL0ReferenceCount );
19589 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.maxBPictureL0ReferenceCount );
19590 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.maxL1ReferenceCount );
19591 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.maxTemporalLayerCount );
19592 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.expectDyadicTemporalLayerPattern );
19593 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.minQp );
19594 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.maxQp );
19595 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.prefersGopRemainingFrames );
19596 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.requiresGopRemainingFrames );
19597 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.stdSyntaxFlags );
19598 return seed;
19599 }
19600 };
19601
19602 template <>
19603 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoKHR>
19604 {
19605 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoKHR const & videoEncodeH264DpbSlotInfoKHR ) const VULKAN_HPP_NOEXCEPT
19606 {
19607 std::size_t seed = 0;
19608 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264DpbSlotInfoKHR.sType );
19609 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264DpbSlotInfoKHR.pNext );
19610 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264DpbSlotInfoKHR.pStdReferenceInfo );
19611 return seed;
19612 }
19613 };
19614
19615 template <>
19616 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264FrameSizeKHR>
19617 {
19618 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264FrameSizeKHR const & videoEncodeH264FrameSizeKHR ) const VULKAN_HPP_NOEXCEPT
19619 {
19620 std::size_t seed = 0;
19621 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264FrameSizeKHR.frameISize );
19622 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264FrameSizeKHR.framePSize );
19623 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264FrameSizeKHR.frameBSize );
19624 return seed;
19625 }
19626 };
19627
19628 template <>
19629 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264GopRemainingFrameInfoKHR>
19630 {
19631 std::size_t
19632 operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264GopRemainingFrameInfoKHR const & videoEncodeH264GopRemainingFrameInfoKHR ) const VULKAN_HPP_NOEXCEPT
19633 {
19634 std::size_t seed = 0;
19635 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264GopRemainingFrameInfoKHR.sType );
19636 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264GopRemainingFrameInfoKHR.pNext );
19637 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264GopRemainingFrameInfoKHR.useGopRemainingFrames );
19638 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264GopRemainingFrameInfoKHR.gopRemainingI );
19639 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264GopRemainingFrameInfoKHR.gopRemainingP );
19640 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264GopRemainingFrameInfoKHR.gopRemainingB );
19641 return seed;
19642 }
19643 };
19644
19645 template <>
19646 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264NaluSliceInfoKHR>
19647 {
19648 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264NaluSliceInfoKHR const & videoEncodeH264NaluSliceInfoKHR ) const VULKAN_HPP_NOEXCEPT
19649 {
19650 std::size_t seed = 0;
19651 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264NaluSliceInfoKHR.sType );
19652 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264NaluSliceInfoKHR.pNext );
19653 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264NaluSliceInfoKHR.constantQp );
19654 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264NaluSliceInfoKHR.pStdSliceHeader );
19655 return seed;
19656 }
19657 };
19658
19659 template <>
19660 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264PictureInfoKHR>
19661 {
19662 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264PictureInfoKHR const & videoEncodeH264PictureInfoKHR ) const VULKAN_HPP_NOEXCEPT
19663 {
19664 std::size_t seed = 0;
19665 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264PictureInfoKHR.sType );
19666 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264PictureInfoKHR.pNext );
19667 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264PictureInfoKHR.naluSliceEntryCount );
19668 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264PictureInfoKHR.pNaluSliceEntries );
19669 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264PictureInfoKHR.pStdPictureInfo );
19670 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264PictureInfoKHR.generatePrefixNalu );
19671 return seed;
19672 }
19673 };
19674
19675 template <>
19676 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264ProfileInfoKHR>
19677 {
19678 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264ProfileInfoKHR const & videoEncodeH264ProfileInfoKHR ) const VULKAN_HPP_NOEXCEPT
19679 {
19680 std::size_t seed = 0;
19681 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264ProfileInfoKHR.sType );
19682 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264ProfileInfoKHR.pNext );
19683 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264ProfileInfoKHR.stdProfileIdc );
19684 return seed;
19685 }
19686 };
19687
19688 template <>
19689 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264QpKHR>
19690 {
19691 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264QpKHR const & videoEncodeH264QpKHR ) const VULKAN_HPP_NOEXCEPT
19692 {
19693 std::size_t seed = 0;
19694 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QpKHR.qpI );
19695 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QpKHR.qpP );
19696 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QpKHR.qpB );
19697 return seed;
19698 }
19699 };
19700
19701 template <>
19702 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264QualityLevelPropertiesKHR>
19703 {
19704 std::size_t
19705 operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264QualityLevelPropertiesKHR const & videoEncodeH264QualityLevelPropertiesKHR ) const VULKAN_HPP_NOEXCEPT
19706 {
19707 std::size_t seed = 0;
19708 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesKHR.sType );
19709 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesKHR.pNext );
19710 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesKHR.preferredRateControlFlags );
19711 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesKHR.preferredGopFrameCount );
19712 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesKHR.preferredIdrPeriod );
19713 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesKHR.preferredConsecutiveBFrameCount );
19714 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesKHR.preferredTemporalLayerCount );
19715 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesKHR.preferredConstantQp );
19716 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesKHR.preferredMaxL0ReferenceCount );
19717 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesKHR.preferredMaxL1ReferenceCount );
19718 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesKHR.preferredStdEntropyCodingModeFlag );
19719 return seed;
19720 }
19721 };
19722
19723 template <>
19724 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264QuantizationMapCapabilitiesKHR>
19725 {
19726 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264QuantizationMapCapabilitiesKHR const & videoEncodeH264QuantizationMapCapabilitiesKHR ) const
19727 VULKAN_HPP_NOEXCEPT
19728 {
19729 std::size_t seed = 0;
19730 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QuantizationMapCapabilitiesKHR.sType );
19731 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QuantizationMapCapabilitiesKHR.pNext );
19732 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QuantizationMapCapabilitiesKHR.minQpDelta );
19733 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QuantizationMapCapabilitiesKHR.maxQpDelta );
19734 return seed;
19735 }
19736 };
19737
19738 template <>
19739 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlInfoKHR>
19740 {
19741 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlInfoKHR const & videoEncodeH264RateControlInfoKHR ) const VULKAN_HPP_NOEXCEPT
19742 {
19743 std::size_t seed = 0;
19744 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlInfoKHR.sType );
19745 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlInfoKHR.pNext );
19746 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlInfoKHR.flags );
19747 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlInfoKHR.gopFrameCount );
19748 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlInfoKHR.idrPeriod );
19749 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlInfoKHR.consecutiveBFrameCount );
19750 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlInfoKHR.temporalLayerCount );
19751 return seed;
19752 }
19753 };
19754
19755 template <>
19756 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlLayerInfoKHR>
19757 {
19758 std::size_t
19759 operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlLayerInfoKHR const & videoEncodeH264RateControlLayerInfoKHR ) const VULKAN_HPP_NOEXCEPT
19760 {
19761 std::size_t seed = 0;
19762 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoKHR.sType );
19763 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoKHR.pNext );
19764 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoKHR.useMinQp );
19765 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoKHR.minQp );
19766 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoKHR.useMaxQp );
19767 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoKHR.maxQp );
19768 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoKHR.useMaxFrameSize );
19769 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoKHR.maxFrameSize );
19770 return seed;
19771 }
19772 };
19773
19774 template <>
19775 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionCreateInfoKHR>
19776 {
19777 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionCreateInfoKHR const & videoEncodeH264SessionCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
19778 {
19779 std::size_t seed = 0;
19780 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionCreateInfoKHR.sType );
19781 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionCreateInfoKHR.pNext );
19782 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionCreateInfoKHR.useMaxLevelIdc );
19783 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionCreateInfoKHR.maxLevelIdc );
19784 return seed;
19785 }
19786 };
19787
19788 template <>
19789 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersAddInfoKHR>
19790 {
19791 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersAddInfoKHR const & videoEncodeH264SessionParametersAddInfoKHR ) const
19792 VULKAN_HPP_NOEXCEPT
19793 {
19794 std::size_t seed = 0;
19795 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersAddInfoKHR.sType );
19796 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersAddInfoKHR.pNext );
19797 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersAddInfoKHR.stdSPSCount );
19798 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersAddInfoKHR.pStdSPSs );
19799 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersAddInfoKHR.stdPPSCount );
19800 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersAddInfoKHR.pStdPPSs );
19801 return seed;
19802 }
19803 };
19804
19805 template <>
19806 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersCreateInfoKHR>
19807 {
19808 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersCreateInfoKHR const & videoEncodeH264SessionParametersCreateInfoKHR ) const
19809 VULKAN_HPP_NOEXCEPT
19810 {
19811 std::size_t seed = 0;
19812 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersCreateInfoKHR.sType );
19813 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersCreateInfoKHR.pNext );
19814 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersCreateInfoKHR.maxStdSPSCount );
19815 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersCreateInfoKHR.maxStdPPSCount );
19816 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersCreateInfoKHR.pParametersAddInfo );
19817 return seed;
19818 }
19819 };
19820
19821 template <>
19822 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersFeedbackInfoKHR>
19823 {
19824 std::size_t operator()(
19825 VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersFeedbackInfoKHR const & videoEncodeH264SessionParametersFeedbackInfoKHR ) const VULKAN_HPP_NOEXCEPT
19826 {
19827 std::size_t seed = 0;
19828 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersFeedbackInfoKHR.sType );
19829 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersFeedbackInfoKHR.pNext );
19830 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersFeedbackInfoKHR.hasStdSPSOverrides );
19831 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersFeedbackInfoKHR.hasStdPPSOverrides );
19832 return seed;
19833 }
19834 };
19835
19836 template <>
19837 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersGetInfoKHR>
19838 {
19839 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersGetInfoKHR const & videoEncodeH264SessionParametersGetInfoKHR ) const
19840 VULKAN_HPP_NOEXCEPT
19841 {
19842 std::size_t seed = 0;
19843 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersGetInfoKHR.sType );
19844 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersGetInfoKHR.pNext );
19845 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersGetInfoKHR.writeStdSPS );
19846 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersGetInfoKHR.writeStdPPS );
19847 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersGetInfoKHR.stdSPSId );
19848 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersGetInfoKHR.stdPPSId );
19849 return seed;
19850 }
19851 };
19852
19853 template <>
19854 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265CapabilitiesKHR>
19855 {
19856 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265CapabilitiesKHR const & videoEncodeH265CapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT
19857 {
19858 std::size_t seed = 0;
19859 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.sType );
19860 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.pNext );
19861 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.flags );
19862 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.maxLevelIdc );
19863 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.maxSliceSegmentCount );
19864 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.maxTiles );
19865 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.ctbSizes );
19866 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.transformBlockSizes );
19867 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.maxPPictureL0ReferenceCount );
19868 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.maxBPictureL0ReferenceCount );
19869 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.maxL1ReferenceCount );
19870 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.maxSubLayerCount );
19871 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.expectDyadicTemporalSubLayerPattern );
19872 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.minQp );
19873 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.maxQp );
19874 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.prefersGopRemainingFrames );
19875 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.requiresGopRemainingFrames );
19876 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.stdSyntaxFlags );
19877 return seed;
19878 }
19879 };
19880
19881 template <>
19882 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265DpbSlotInfoKHR>
19883 {
19884 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265DpbSlotInfoKHR const & videoEncodeH265DpbSlotInfoKHR ) const VULKAN_HPP_NOEXCEPT
19885 {
19886 std::size_t seed = 0;
19887 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265DpbSlotInfoKHR.sType );
19888 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265DpbSlotInfoKHR.pNext );
19889 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265DpbSlotInfoKHR.pStdReferenceInfo );
19890 return seed;
19891 }
19892 };
19893
19894 template <>
19895 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265FrameSizeKHR>
19896 {
19897 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265FrameSizeKHR const & videoEncodeH265FrameSizeKHR ) const VULKAN_HPP_NOEXCEPT
19898 {
19899 std::size_t seed = 0;
19900 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265FrameSizeKHR.frameISize );
19901 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265FrameSizeKHR.framePSize );
19902 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265FrameSizeKHR.frameBSize );
19903 return seed;
19904 }
19905 };
19906
19907 template <>
19908 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265GopRemainingFrameInfoKHR>
19909 {
19910 std::size_t
19911 operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265GopRemainingFrameInfoKHR const & videoEncodeH265GopRemainingFrameInfoKHR ) const VULKAN_HPP_NOEXCEPT
19912 {
19913 std::size_t seed = 0;
19914 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265GopRemainingFrameInfoKHR.sType );
19915 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265GopRemainingFrameInfoKHR.pNext );
19916 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265GopRemainingFrameInfoKHR.useGopRemainingFrames );
19917 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265GopRemainingFrameInfoKHR.gopRemainingI );
19918 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265GopRemainingFrameInfoKHR.gopRemainingP );
19919 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265GopRemainingFrameInfoKHR.gopRemainingB );
19920 return seed;
19921 }
19922 };
19923
19924 template <>
19925 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceSegmentInfoKHR>
19926 {
19927 std::size_t
19928 operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceSegmentInfoKHR const & videoEncodeH265NaluSliceSegmentInfoKHR ) const VULKAN_HPP_NOEXCEPT
19929 {
19930 std::size_t seed = 0;
19931 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265NaluSliceSegmentInfoKHR.sType );
19932 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265NaluSliceSegmentInfoKHR.pNext );
19933 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265NaluSliceSegmentInfoKHR.constantQp );
19934 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265NaluSliceSegmentInfoKHR.pStdSliceSegmentHeader );
19935 return seed;
19936 }
19937 };
19938
19939 template <>
19940 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265PictureInfoKHR>
19941 {
19942 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265PictureInfoKHR const & videoEncodeH265PictureInfoKHR ) const VULKAN_HPP_NOEXCEPT
19943 {
19944 std::size_t seed = 0;
19945 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265PictureInfoKHR.sType );
19946 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265PictureInfoKHR.pNext );
19947 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265PictureInfoKHR.naluSliceSegmentEntryCount );
19948 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265PictureInfoKHR.pNaluSliceSegmentEntries );
19949 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265PictureInfoKHR.pStdPictureInfo );
19950 return seed;
19951 }
19952 };
19953
19954 template <>
19955 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265ProfileInfoKHR>
19956 {
19957 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265ProfileInfoKHR const & videoEncodeH265ProfileInfoKHR ) const VULKAN_HPP_NOEXCEPT
19958 {
19959 std::size_t seed = 0;
19960 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265ProfileInfoKHR.sType );
19961 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265ProfileInfoKHR.pNext );
19962 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265ProfileInfoKHR.stdProfileIdc );
19963 return seed;
19964 }
19965 };
19966
19967 template <>
19968 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265QpKHR>
19969 {
19970 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265QpKHR const & videoEncodeH265QpKHR ) const VULKAN_HPP_NOEXCEPT
19971 {
19972 std::size_t seed = 0;
19973 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QpKHR.qpI );
19974 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QpKHR.qpP );
19975 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QpKHR.qpB );
19976 return seed;
19977 }
19978 };
19979
19980 template <>
19981 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265QualityLevelPropertiesKHR>
19982 {
19983 std::size_t
19984 operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265QualityLevelPropertiesKHR const & videoEncodeH265QualityLevelPropertiesKHR ) const VULKAN_HPP_NOEXCEPT
19985 {
19986 std::size_t seed = 0;
19987 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesKHR.sType );
19988 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesKHR.pNext );
19989 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesKHR.preferredRateControlFlags );
19990 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesKHR.preferredGopFrameCount );
19991 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesKHR.preferredIdrPeriod );
19992 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesKHR.preferredConsecutiveBFrameCount );
19993 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesKHR.preferredSubLayerCount );
19994 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesKHR.preferredConstantQp );
19995 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesKHR.preferredMaxL0ReferenceCount );
19996 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesKHR.preferredMaxL1ReferenceCount );
19997 return seed;
19998 }
19999 };
20000
20001 template <>
20002 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265QuantizationMapCapabilitiesKHR>
20003 {
20004 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265QuantizationMapCapabilitiesKHR const & videoEncodeH265QuantizationMapCapabilitiesKHR ) const
20005 VULKAN_HPP_NOEXCEPT
20006 {
20007 std::size_t seed = 0;
20008 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QuantizationMapCapabilitiesKHR.sType );
20009 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QuantizationMapCapabilitiesKHR.pNext );
20010 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QuantizationMapCapabilitiesKHR.minQpDelta );
20011 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QuantizationMapCapabilitiesKHR.maxQpDelta );
20012 return seed;
20013 }
20014 };
20015
20016 template <>
20017 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlInfoKHR>
20018 {
20019 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlInfoKHR const & videoEncodeH265RateControlInfoKHR ) const VULKAN_HPP_NOEXCEPT
20020 {
20021 std::size_t seed = 0;
20022 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlInfoKHR.sType );
20023 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlInfoKHR.pNext );
20024 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlInfoKHR.flags );
20025 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlInfoKHR.gopFrameCount );
20026 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlInfoKHR.idrPeriod );
20027 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlInfoKHR.consecutiveBFrameCount );
20028 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlInfoKHR.subLayerCount );
20029 return seed;
20030 }
20031 };
20032
20033 template <>
20034 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlLayerInfoKHR>
20035 {
20036 std::size_t
20037 operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlLayerInfoKHR const & videoEncodeH265RateControlLayerInfoKHR ) const VULKAN_HPP_NOEXCEPT
20038 {
20039 std::size_t seed = 0;
20040 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoKHR.sType );
20041 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoKHR.pNext );
20042 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoKHR.useMinQp );
20043 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoKHR.minQp );
20044 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoKHR.useMaxQp );
20045 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoKHR.maxQp );
20046 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoKHR.useMaxFrameSize );
20047 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoKHR.maxFrameSize );
20048 return seed;
20049 }
20050 };
20051
20052 template <>
20053 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionCreateInfoKHR>
20054 {
20055 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionCreateInfoKHR const & videoEncodeH265SessionCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
20056 {
20057 std::size_t seed = 0;
20058 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionCreateInfoKHR.sType );
20059 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionCreateInfoKHR.pNext );
20060 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionCreateInfoKHR.useMaxLevelIdc );
20061 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionCreateInfoKHR.maxLevelIdc );
20062 return seed;
20063 }
20064 };
20065
20066 template <>
20067 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersAddInfoKHR>
20068 {
20069 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersAddInfoKHR const & videoEncodeH265SessionParametersAddInfoKHR ) const
20070 VULKAN_HPP_NOEXCEPT
20071 {
20072 std::size_t seed = 0;
20073 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersAddInfoKHR.sType );
20074 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersAddInfoKHR.pNext );
20075 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersAddInfoKHR.stdVPSCount );
20076 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersAddInfoKHR.pStdVPSs );
20077 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersAddInfoKHR.stdSPSCount );
20078 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersAddInfoKHR.pStdSPSs );
20079 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersAddInfoKHR.stdPPSCount );
20080 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersAddInfoKHR.pStdPPSs );
20081 return seed;
20082 }
20083 };
20084
20085 template <>
20086 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersCreateInfoKHR>
20087 {
20088 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersCreateInfoKHR const & videoEncodeH265SessionParametersCreateInfoKHR ) const
20089 VULKAN_HPP_NOEXCEPT
20090 {
20091 std::size_t seed = 0;
20092 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersCreateInfoKHR.sType );
20093 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersCreateInfoKHR.pNext );
20094 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersCreateInfoKHR.maxStdVPSCount );
20095 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersCreateInfoKHR.maxStdSPSCount );
20096 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersCreateInfoKHR.maxStdPPSCount );
20097 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersCreateInfoKHR.pParametersAddInfo );
20098 return seed;
20099 }
20100 };
20101
20102 template <>
20103 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersFeedbackInfoKHR>
20104 {
20105 std::size_t operator()(
20106 VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersFeedbackInfoKHR const & videoEncodeH265SessionParametersFeedbackInfoKHR ) const VULKAN_HPP_NOEXCEPT
20107 {
20108 std::size_t seed = 0;
20109 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersFeedbackInfoKHR.sType );
20110 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersFeedbackInfoKHR.pNext );
20111 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersFeedbackInfoKHR.hasStdVPSOverrides );
20112 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersFeedbackInfoKHR.hasStdSPSOverrides );
20113 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersFeedbackInfoKHR.hasStdPPSOverrides );
20114 return seed;
20115 }
20116 };
20117
20118 template <>
20119 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersGetInfoKHR>
20120 {
20121 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersGetInfoKHR const & videoEncodeH265SessionParametersGetInfoKHR ) const
20122 VULKAN_HPP_NOEXCEPT
20123 {
20124 std::size_t seed = 0;
20125 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersGetInfoKHR.sType );
20126 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersGetInfoKHR.pNext );
20127 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersGetInfoKHR.writeStdVPS );
20128 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersGetInfoKHR.writeStdSPS );
20129 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersGetInfoKHR.writeStdPPS );
20130 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersGetInfoKHR.stdVPSId );
20131 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersGetInfoKHR.stdSPSId );
20132 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersGetInfoKHR.stdPPSId );
20133 return seed;
20134 }
20135 };
20136
20137 template <>
20138 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeInfoKHR>
20139 {
20140 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeInfoKHR const & videoEncodeInfoKHR ) const VULKAN_HPP_NOEXCEPT
20141 {
20142 std::size_t seed = 0;
20143 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.sType );
20144 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.pNext );
20145 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.flags );
20146 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.dstBuffer );
20147 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.dstBufferOffset );
20148 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.dstBufferRange );
20149 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.srcPictureResource );
20150 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.pSetupReferenceSlot );
20151 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.referenceSlotCount );
20152 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.pReferenceSlots );
20153 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.precedingExternallyEncodedBytes );
20154 return seed;
20155 }
20156 };
20157
20158 template <>
20159 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeIntraRefreshCapabilitiesKHR>
20160 {
20161 std::size_t
20162 operator()( VULKAN_HPP_NAMESPACE::VideoEncodeIntraRefreshCapabilitiesKHR const & videoEncodeIntraRefreshCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT
20163 {
20164 std::size_t seed = 0;
20165 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeIntraRefreshCapabilitiesKHR.sType );
20166 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeIntraRefreshCapabilitiesKHR.pNext );
20167 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeIntraRefreshCapabilitiesKHR.intraRefreshModes );
20168 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeIntraRefreshCapabilitiesKHR.maxIntraRefreshCycleDuration );
20169 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeIntraRefreshCapabilitiesKHR.maxIntraRefreshActiveReferencePictures );
20170 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeIntraRefreshCapabilitiesKHR.partitionIndependentIntraRefreshRegions );
20171 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeIntraRefreshCapabilitiesKHR.nonRectangularIntraRefreshRegions );
20172 return seed;
20173 }
20174 };
20175
20176 template <>
20177 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeIntraRefreshInfoKHR>
20178 {
20179 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeIntraRefreshInfoKHR const & videoEncodeIntraRefreshInfoKHR ) const VULKAN_HPP_NOEXCEPT
20180 {
20181 std::size_t seed = 0;
20182 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeIntraRefreshInfoKHR.sType );
20183 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeIntraRefreshInfoKHR.pNext );
20184 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeIntraRefreshInfoKHR.intraRefreshCycleDuration );
20185 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeIntraRefreshInfoKHR.intraRefreshIndex );
20186 return seed;
20187 }
20188 };
20189
20190 template <>
20191 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeProfileRgbConversionInfoVALVE>
20192 {
20193 std::size_t
20194 operator()( VULKAN_HPP_NAMESPACE::VideoEncodeProfileRgbConversionInfoVALVE const & videoEncodeProfileRgbConversionInfoVALVE ) const VULKAN_HPP_NOEXCEPT
20195 {
20196 std::size_t seed = 0;
20197 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeProfileRgbConversionInfoVALVE.sType );
20198 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeProfileRgbConversionInfoVALVE.pNext );
20199 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeProfileRgbConversionInfoVALVE.performEncodeRgbConversion );
20200 return seed;
20201 }
20202 };
20203
20204 template <>
20205 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelInfoKHR>
20206 {
20207 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelInfoKHR const & videoEncodeQualityLevelInfoKHR ) const VULKAN_HPP_NOEXCEPT
20208 {
20209 std::size_t seed = 0;
20210 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQualityLevelInfoKHR.sType );
20211 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQualityLevelInfoKHR.pNext );
20212 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQualityLevelInfoKHR.qualityLevel );
20213 return seed;
20214 }
20215 };
20216
20217 template <>
20218 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelPropertiesKHR>
20219 {
20220 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelPropertiesKHR const & videoEncodeQualityLevelPropertiesKHR ) const VULKAN_HPP_NOEXCEPT
20221 {
20222 std::size_t seed = 0;
20223 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQualityLevelPropertiesKHR.sType );
20224 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQualityLevelPropertiesKHR.pNext );
20225 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQualityLevelPropertiesKHR.preferredRateControlMode );
20226 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQualityLevelPropertiesKHR.preferredRateControlLayerCount );
20227 return seed;
20228 }
20229 };
20230
20231 template <>
20232 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeQuantizationMapCapabilitiesKHR>
20233 {
20234 std::size_t
20235 operator()( VULKAN_HPP_NAMESPACE::VideoEncodeQuantizationMapCapabilitiesKHR const & videoEncodeQuantizationMapCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT
20236 {
20237 std::size_t seed = 0;
20238 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQuantizationMapCapabilitiesKHR.sType );
20239 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQuantizationMapCapabilitiesKHR.pNext );
20240 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQuantizationMapCapabilitiesKHR.maxQuantizationMapExtent );
20241 return seed;
20242 }
20243 };
20244
20245 template <>
20246 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeQuantizationMapInfoKHR>
20247 {
20248 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeQuantizationMapInfoKHR const & videoEncodeQuantizationMapInfoKHR ) const VULKAN_HPP_NOEXCEPT
20249 {
20250 std::size_t seed = 0;
20251 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQuantizationMapInfoKHR.sType );
20252 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQuantizationMapInfoKHR.pNext );
20253 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQuantizationMapInfoKHR.quantizationMap );
20254 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQuantizationMapInfoKHR.quantizationMapExtent );
20255 return seed;
20256 }
20257 };
20258
20259 template <>
20260 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeQuantizationMapSessionParametersCreateInfoKHR>
20261 {
20262 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeQuantizationMapSessionParametersCreateInfoKHR const &
20263 videoEncodeQuantizationMapSessionParametersCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
20264 {
20265 std::size_t seed = 0;
20266 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQuantizationMapSessionParametersCreateInfoKHR.sType );
20267 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQuantizationMapSessionParametersCreateInfoKHR.pNext );
20268 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQuantizationMapSessionParametersCreateInfoKHR.quantizationMapTexelSize );
20269 return seed;
20270 }
20271 };
20272
20273 template <>
20274 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeRateControlLayerInfoKHR>
20275 {
20276 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeRateControlLayerInfoKHR const & videoEncodeRateControlLayerInfoKHR ) const VULKAN_HPP_NOEXCEPT
20277 {
20278 std::size_t seed = 0;
20279 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlLayerInfoKHR.sType );
20280 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlLayerInfoKHR.pNext );
20281 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlLayerInfoKHR.averageBitrate );
20282 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlLayerInfoKHR.maxBitrate );
20283 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlLayerInfoKHR.frameRateNumerator );
20284 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlLayerInfoKHR.frameRateDenominator );
20285 return seed;
20286 }
20287 };
20288
20289 template <>
20290 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeRateControlInfoKHR>
20291 {
20292 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeRateControlInfoKHR const & videoEncodeRateControlInfoKHR ) const VULKAN_HPP_NOEXCEPT
20293 {
20294 std::size_t seed = 0;
20295 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlInfoKHR.sType );
20296 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlInfoKHR.pNext );
20297 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlInfoKHR.flags );
20298 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlInfoKHR.rateControlMode );
20299 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlInfoKHR.layerCount );
20300 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlInfoKHR.pLayers );
20301 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlInfoKHR.virtualBufferSizeInMs );
20302 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlInfoKHR.initialVirtualBufferSizeInMs );
20303 return seed;
20304 }
20305 };
20306
20307 template <>
20308 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeRgbConversionCapabilitiesVALVE>
20309 {
20310 std::size_t
20311 operator()( VULKAN_HPP_NAMESPACE::VideoEncodeRgbConversionCapabilitiesVALVE const & videoEncodeRgbConversionCapabilitiesVALVE ) const VULKAN_HPP_NOEXCEPT
20312 {
20313 std::size_t seed = 0;
20314 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRgbConversionCapabilitiesVALVE.sType );
20315 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRgbConversionCapabilitiesVALVE.pNext );
20316 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRgbConversionCapabilitiesVALVE.rgbModels );
20317 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRgbConversionCapabilitiesVALVE.rgbRanges );
20318 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRgbConversionCapabilitiesVALVE.xChromaOffsets );
20319 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRgbConversionCapabilitiesVALVE.yChromaOffsets );
20320 return seed;
20321 }
20322 };
20323
20324 template <>
20325 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeSessionIntraRefreshCreateInfoKHR>
20326 {
20327 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeSessionIntraRefreshCreateInfoKHR const & videoEncodeSessionIntraRefreshCreateInfoKHR ) const
20328 VULKAN_HPP_NOEXCEPT
20329 {
20330 std::size_t seed = 0;
20331 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionIntraRefreshCreateInfoKHR.sType );
20332 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionIntraRefreshCreateInfoKHR.pNext );
20333 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionIntraRefreshCreateInfoKHR.intraRefreshMode );
20334 return seed;
20335 }
20336 };
20337
20338 template <>
20339 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersFeedbackInfoKHR>
20340 {
20341 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersFeedbackInfoKHR const & videoEncodeSessionParametersFeedbackInfoKHR ) const
20342 VULKAN_HPP_NOEXCEPT
20343 {
20344 std::size_t seed = 0;
20345 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionParametersFeedbackInfoKHR.sType );
20346 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionParametersFeedbackInfoKHR.pNext );
20347 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionParametersFeedbackInfoKHR.hasOverrides );
20348 return seed;
20349 }
20350 };
20351
20352 template <>
20353 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR>
20354 {
20355 std::size_t
20356 operator()( VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR const & videoEncodeSessionParametersGetInfoKHR ) const VULKAN_HPP_NOEXCEPT
20357 {
20358 std::size_t seed = 0;
20359 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionParametersGetInfoKHR.sType );
20360 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionParametersGetInfoKHR.pNext );
20361 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionParametersGetInfoKHR.videoSessionParameters );
20362 return seed;
20363 }
20364 };
20365
20366 template <>
20367 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeSessionRgbConversionCreateInfoVALVE>
20368 {
20369 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeSessionRgbConversionCreateInfoVALVE const & videoEncodeSessionRgbConversionCreateInfoVALVE ) const
20370 VULKAN_HPP_NOEXCEPT
20371 {
20372 std::size_t seed = 0;
20373 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionRgbConversionCreateInfoVALVE.sType );
20374 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionRgbConversionCreateInfoVALVE.pNext );
20375 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionRgbConversionCreateInfoVALVE.rgbModel );
20376 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionRgbConversionCreateInfoVALVE.rgbRange );
20377 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionRgbConversionCreateInfoVALVE.xChromaOffset );
20378 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionRgbConversionCreateInfoVALVE.yChromaOffset );
20379 return seed;
20380 }
20381 };
20382
20383 template <>
20384 struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeUsageInfoKHR>
20385 {
20386 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeUsageInfoKHR const & videoEncodeUsageInfoKHR ) const VULKAN_HPP_NOEXCEPT
20387 {
20388 std::size_t seed = 0;
20389 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeUsageInfoKHR.sType );
20390 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeUsageInfoKHR.pNext );
20391 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeUsageInfoKHR.videoUsageHints );
20392 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeUsageInfoKHR.videoContentHints );
20393 VULKAN_HPP_HASH_COMBINE( seed, videoEncodeUsageInfoKHR.tuningMode );
20394 return seed;
20395 }
20396 };
20397
20398 template <>
20399 struct hash<VULKAN_HPP_NAMESPACE::VideoEndCodingInfoKHR>
20400 {
20401 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEndCodingInfoKHR const & videoEndCodingInfoKHR ) const VULKAN_HPP_NOEXCEPT
20402 {
20403 std::size_t seed = 0;
20404 VULKAN_HPP_HASH_COMBINE( seed, videoEndCodingInfoKHR.sType );
20405 VULKAN_HPP_HASH_COMBINE( seed, videoEndCodingInfoKHR.pNext );
20406 VULKAN_HPP_HASH_COMBINE( seed, videoEndCodingInfoKHR.flags );
20407 return seed;
20408 }
20409 };
20410
20411 template <>
20412 struct hash<VULKAN_HPP_NAMESPACE::VideoFormatAV1QuantizationMapPropertiesKHR>
20413 {
20414 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoFormatAV1QuantizationMapPropertiesKHR const & videoFormatAV1QuantizationMapPropertiesKHR ) const
20415 VULKAN_HPP_NOEXCEPT
20416 {
20417 std::size_t seed = 0;
20418 VULKAN_HPP_HASH_COMBINE( seed, videoFormatAV1QuantizationMapPropertiesKHR.sType );
20419 VULKAN_HPP_HASH_COMBINE( seed, videoFormatAV1QuantizationMapPropertiesKHR.pNext );
20420 VULKAN_HPP_HASH_COMBINE( seed, videoFormatAV1QuantizationMapPropertiesKHR.compatibleSuperblockSizes );
20421 return seed;
20422 }
20423 };
20424
20425 template <>
20426 struct hash<VULKAN_HPP_NAMESPACE::VideoFormatH265QuantizationMapPropertiesKHR>
20427 {
20428 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoFormatH265QuantizationMapPropertiesKHR const & videoFormatH265QuantizationMapPropertiesKHR ) const
20429 VULKAN_HPP_NOEXCEPT
20430 {
20431 std::size_t seed = 0;
20432 VULKAN_HPP_HASH_COMBINE( seed, videoFormatH265QuantizationMapPropertiesKHR.sType );
20433 VULKAN_HPP_HASH_COMBINE( seed, videoFormatH265QuantizationMapPropertiesKHR.pNext );
20434 VULKAN_HPP_HASH_COMBINE( seed, videoFormatH265QuantizationMapPropertiesKHR.compatibleCtbSizes );
20435 return seed;
20436 }
20437 };
20438
20439 template <>
20440 struct hash<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR>
20441 {
20442 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR const & videoFormatPropertiesKHR ) const VULKAN_HPP_NOEXCEPT
20443 {
20444 std::size_t seed = 0;
20445 VULKAN_HPP_HASH_COMBINE( seed, videoFormatPropertiesKHR.sType );
20446 VULKAN_HPP_HASH_COMBINE( seed, videoFormatPropertiesKHR.pNext );
20447 VULKAN_HPP_HASH_COMBINE( seed, videoFormatPropertiesKHR.format );
20448 VULKAN_HPP_HASH_COMBINE( seed, videoFormatPropertiesKHR.componentMapping );
20449 VULKAN_HPP_HASH_COMBINE( seed, videoFormatPropertiesKHR.imageCreateFlags );
20450 VULKAN_HPP_HASH_COMBINE( seed, videoFormatPropertiesKHR.imageType );
20451 VULKAN_HPP_HASH_COMBINE( seed, videoFormatPropertiesKHR.imageTiling );
20452 VULKAN_HPP_HASH_COMBINE( seed, videoFormatPropertiesKHR.imageUsageFlags );
20453 return seed;
20454 }
20455 };
20456
20457 template <>
20458 struct hash<VULKAN_HPP_NAMESPACE::VideoFormatQuantizationMapPropertiesKHR>
20459 {
20460 std::size_t
20461 operator()( VULKAN_HPP_NAMESPACE::VideoFormatQuantizationMapPropertiesKHR const & videoFormatQuantizationMapPropertiesKHR ) const VULKAN_HPP_NOEXCEPT
20462 {
20463 std::size_t seed = 0;
20464 VULKAN_HPP_HASH_COMBINE( seed, videoFormatQuantizationMapPropertiesKHR.sType );
20465 VULKAN_HPP_HASH_COMBINE( seed, videoFormatQuantizationMapPropertiesKHR.pNext );
20466 VULKAN_HPP_HASH_COMBINE( seed, videoFormatQuantizationMapPropertiesKHR.quantizationMapTexelSize );
20467 return seed;
20468 }
20469 };
20470
20471 template <>
20472 struct hash<VULKAN_HPP_NAMESPACE::VideoInlineQueryInfoKHR>
20473 {
20474 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoInlineQueryInfoKHR const & videoInlineQueryInfoKHR ) const VULKAN_HPP_NOEXCEPT
20475 {
20476 std::size_t seed = 0;
20477 VULKAN_HPP_HASH_COMBINE( seed, videoInlineQueryInfoKHR.sType );
20478 VULKAN_HPP_HASH_COMBINE( seed, videoInlineQueryInfoKHR.pNext );
20479 VULKAN_HPP_HASH_COMBINE( seed, videoInlineQueryInfoKHR.queryPool );
20480 VULKAN_HPP_HASH_COMBINE( seed, videoInlineQueryInfoKHR.firstQuery );
20481 VULKAN_HPP_HASH_COMBINE( seed, videoInlineQueryInfoKHR.queryCount );
20482 return seed;
20483 }
20484 };
20485
20486 template <>
20487 struct hash<VULKAN_HPP_NAMESPACE::VideoProfileListInfoKHR>
20488 {
20489 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoProfileListInfoKHR const & videoProfileListInfoKHR ) const VULKAN_HPP_NOEXCEPT
20490 {
20491 std::size_t seed = 0;
20492 VULKAN_HPP_HASH_COMBINE( seed, videoProfileListInfoKHR.sType );
20493 VULKAN_HPP_HASH_COMBINE( seed, videoProfileListInfoKHR.pNext );
20494 VULKAN_HPP_HASH_COMBINE( seed, videoProfileListInfoKHR.profileCount );
20495 VULKAN_HPP_HASH_COMBINE( seed, videoProfileListInfoKHR.pProfiles );
20496 return seed;
20497 }
20498 };
20499
20500 template <>
20501 struct hash<VULKAN_HPP_NAMESPACE::VideoReferenceIntraRefreshInfoKHR>
20502 {
20503 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoReferenceIntraRefreshInfoKHR const & videoReferenceIntraRefreshInfoKHR ) const VULKAN_HPP_NOEXCEPT
20504 {
20505 std::size_t seed = 0;
20506 VULKAN_HPP_HASH_COMBINE( seed, videoReferenceIntraRefreshInfoKHR.sType );
20507 VULKAN_HPP_HASH_COMBINE( seed, videoReferenceIntraRefreshInfoKHR.pNext );
20508 VULKAN_HPP_HASH_COMBINE( seed, videoReferenceIntraRefreshInfoKHR.dirtyIntraRefreshRegions );
20509 return seed;
20510 }
20511 };
20512
20513 template <>
20514 struct hash<VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR>
20515 {
20516 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR const & videoSessionCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
20517 {
20518 std::size_t seed = 0;
20519 VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.sType );
20520 VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.pNext );
20521 VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.queueFamilyIndex );
20522 VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.flags );
20523 VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.pVideoProfile );
20524 VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.pictureFormat );
20525 VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.maxCodedExtent );
20526 VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.referencePictureFormat );
20527 VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.maxDpbSlots );
20528 VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.maxActiveReferencePictures );
20529 VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.pStdHeaderVersion );
20530 return seed;
20531 }
20532 };
20533
20534 template <>
20535 struct hash<VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR>
20536 {
20537 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR const & videoSessionMemoryRequirementsKHR ) const VULKAN_HPP_NOEXCEPT
20538 {
20539 std::size_t seed = 0;
20540 VULKAN_HPP_HASH_COMBINE( seed, videoSessionMemoryRequirementsKHR.sType );
20541 VULKAN_HPP_HASH_COMBINE( seed, videoSessionMemoryRequirementsKHR.pNext );
20542 VULKAN_HPP_HASH_COMBINE( seed, videoSessionMemoryRequirementsKHR.memoryBindIndex );
20543 VULKAN_HPP_HASH_COMBINE( seed, videoSessionMemoryRequirementsKHR.memoryRequirements );
20544 return seed;
20545 }
20546 };
20547
20548 template <>
20549 struct hash<VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR>
20550 {
20551 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR const & videoSessionParametersCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
20552 {
20553 std::size_t seed = 0;
20554 VULKAN_HPP_HASH_COMBINE( seed, videoSessionParametersCreateInfoKHR.sType );
20555 VULKAN_HPP_HASH_COMBINE( seed, videoSessionParametersCreateInfoKHR.pNext );
20556 VULKAN_HPP_HASH_COMBINE( seed, videoSessionParametersCreateInfoKHR.flags );
20557 VULKAN_HPP_HASH_COMBINE( seed, videoSessionParametersCreateInfoKHR.videoSessionParametersTemplate );
20558 VULKAN_HPP_HASH_COMBINE( seed, videoSessionParametersCreateInfoKHR.videoSession );
20559 return seed;
20560 }
20561 };
20562
20563 template <>
20564 struct hash<VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR>
20565 {
20566 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR const & videoSessionParametersUpdateInfoKHR ) const VULKAN_HPP_NOEXCEPT
20567 {
20568 std::size_t seed = 0;
20569 VULKAN_HPP_HASH_COMBINE( seed, videoSessionParametersUpdateInfoKHR.sType );
20570 VULKAN_HPP_HASH_COMBINE( seed, videoSessionParametersUpdateInfoKHR.pNext );
20571 VULKAN_HPP_HASH_COMBINE( seed, videoSessionParametersUpdateInfoKHR.updateSequenceCount );
20572 return seed;
20573 }
20574 };
20575
20576 # if defined( VK_USE_PLATFORM_WAYLAND_KHR )
20577 template <>
20578 struct hash<VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR>
20579 {
20580 std::size_t operator()( VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR const & waylandSurfaceCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
20581 {
20582 std::size_t seed = 0;
20583 VULKAN_HPP_HASH_COMBINE( seed, waylandSurfaceCreateInfoKHR.sType );
20584 VULKAN_HPP_HASH_COMBINE( seed, waylandSurfaceCreateInfoKHR.pNext );
20585 VULKAN_HPP_HASH_COMBINE( seed, waylandSurfaceCreateInfoKHR.flags );
20586 VULKAN_HPP_HASH_COMBINE( seed, waylandSurfaceCreateInfoKHR.display );
20587 VULKAN_HPP_HASH_COMBINE( seed, waylandSurfaceCreateInfoKHR.surface );
20588 return seed;
20589 }
20590 };
20591 # endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
20592
20593 # if defined( VK_USE_PLATFORM_WIN32_KHR )
20594 template <>
20595 struct hash<VULKAN_HPP_NAMESPACE::Win32KeyedMutexAcquireReleaseInfoKHR>
20596 {
20597 std::size_t operator()( VULKAN_HPP_NAMESPACE::Win32KeyedMutexAcquireReleaseInfoKHR const & win32KeyedMutexAcquireReleaseInfoKHR ) const VULKAN_HPP_NOEXCEPT
20598 {
20599 std::size_t seed = 0;
20600 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoKHR.sType );
20601 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoKHR.pNext );
20602 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoKHR.acquireCount );
20603 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoKHR.pAcquireSyncs );
20604 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoKHR.pAcquireKeys );
20605 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoKHR.pAcquireTimeouts );
20606 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoKHR.releaseCount );
20607 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoKHR.pReleaseSyncs );
20608 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoKHR.pReleaseKeys );
20609 return seed;
20610 }
20611 };
20612 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
20613
20614 # if defined( VK_USE_PLATFORM_WIN32_KHR )
20615 template <>
20616 struct hash<VULKAN_HPP_NAMESPACE::Win32KeyedMutexAcquireReleaseInfoNV>
20617 {
20618 std::size_t operator()( VULKAN_HPP_NAMESPACE::Win32KeyedMutexAcquireReleaseInfoNV const & win32KeyedMutexAcquireReleaseInfoNV ) const VULKAN_HPP_NOEXCEPT
20619 {
20620 std::size_t seed = 0;
20621 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoNV.sType );
20622 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoNV.pNext );
20623 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoNV.acquireCount );
20624 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoNV.pAcquireSyncs );
20625 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoNV.pAcquireKeys );
20626 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoNV.pAcquireTimeoutMilliseconds );
20627 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoNV.releaseCount );
20628 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoNV.pReleaseSyncs );
20629 VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoNV.pReleaseKeys );
20630 return seed;
20631 }
20632 };
20633 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
20634
20635 # if defined( VK_USE_PLATFORM_WIN32_KHR )
20636 template <>
20637 struct hash<VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR>
20638 {
20639 std::size_t operator()( VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR const & win32SurfaceCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
20640 {
20641 std::size_t seed = 0;
20642 VULKAN_HPP_HASH_COMBINE( seed, win32SurfaceCreateInfoKHR.sType );
20643 VULKAN_HPP_HASH_COMBINE( seed, win32SurfaceCreateInfoKHR.pNext );
20644 VULKAN_HPP_HASH_COMBINE( seed, win32SurfaceCreateInfoKHR.flags );
20645 VULKAN_HPP_HASH_COMBINE( seed, win32SurfaceCreateInfoKHR.hinstance );
20646 VULKAN_HPP_HASH_COMBINE( seed, win32SurfaceCreateInfoKHR.hwnd );
20647 return seed;
20648 }
20649 };
20650 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
20651
20652 template <>
20653 struct hash<VULKAN_HPP_NAMESPACE::WriteDescriptorSetAccelerationStructureKHR>
20654 {
20655 std::size_t operator()( VULKAN_HPP_NAMESPACE::WriteDescriptorSetAccelerationStructureKHR const & writeDescriptorSetAccelerationStructureKHR ) const
20656 VULKAN_HPP_NOEXCEPT
20657 {
20658 std::size_t seed = 0;
20659 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetAccelerationStructureKHR.sType );
20660 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetAccelerationStructureKHR.pNext );
20661 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetAccelerationStructureKHR.accelerationStructureCount );
20662 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetAccelerationStructureKHR.pAccelerationStructures );
20663 return seed;
20664 }
20665 };
20666
20667 template <>
20668 struct hash<VULKAN_HPP_NAMESPACE::WriteDescriptorSetAccelerationStructureNV>
20669 {
20670 std::size_t
20671 operator()( VULKAN_HPP_NAMESPACE::WriteDescriptorSetAccelerationStructureNV const & writeDescriptorSetAccelerationStructureNV ) const VULKAN_HPP_NOEXCEPT
20672 {
20673 std::size_t seed = 0;
20674 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetAccelerationStructureNV.sType );
20675 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetAccelerationStructureNV.pNext );
20676 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetAccelerationStructureNV.accelerationStructureCount );
20677 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetAccelerationStructureNV.pAccelerationStructures );
20678 return seed;
20679 }
20680 };
20681
20682 template <>
20683 struct hash<VULKAN_HPP_NAMESPACE::WriteDescriptorSetInlineUniformBlock>
20684 {
20685 std::size_t operator()( VULKAN_HPP_NAMESPACE::WriteDescriptorSetInlineUniformBlock const & writeDescriptorSetInlineUniformBlock ) const VULKAN_HPP_NOEXCEPT
20686 {
20687 std::size_t seed = 0;
20688 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetInlineUniformBlock.sType );
20689 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetInlineUniformBlock.pNext );
20690 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetInlineUniformBlock.dataSize );
20691 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetInlineUniformBlock.pData );
20692 return seed;
20693 }
20694 };
20695
20696 template <>
20697 struct hash<VULKAN_HPP_NAMESPACE::WriteDescriptorSetPartitionedAccelerationStructureNV>
20698 {
20699 std::size_t operator()( VULKAN_HPP_NAMESPACE::WriteDescriptorSetPartitionedAccelerationStructureNV const &
20700 writeDescriptorSetPartitionedAccelerationStructureNV ) const VULKAN_HPP_NOEXCEPT
20701 {
20702 std::size_t seed = 0;
20703 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetPartitionedAccelerationStructureNV.sType );
20704 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetPartitionedAccelerationStructureNV.pNext );
20705 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetPartitionedAccelerationStructureNV.accelerationStructureCount );
20706 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetPartitionedAccelerationStructureNV.pAccelerationStructures );
20707 return seed;
20708 }
20709 };
20710
20711 template <>
20712 struct hash<VULKAN_HPP_NAMESPACE::WriteDescriptorSetTensorARM>
20713 {
20714 std::size_t operator()( VULKAN_HPP_NAMESPACE::WriteDescriptorSetTensorARM const & writeDescriptorSetTensorARM ) const VULKAN_HPP_NOEXCEPT
20715 {
20716 std::size_t seed = 0;
20717 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetTensorARM.sType );
20718 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetTensorARM.pNext );
20719 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetTensorARM.tensorViewCount );
20720 VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetTensorARM.pTensorViews );
20721 return seed;
20722 }
20723 };
20724
20725 template <>
20726 struct hash<VULKAN_HPP_NAMESPACE::WriteIndirectExecutionSetPipelineEXT>
20727 {
20728 std::size_t operator()( VULKAN_HPP_NAMESPACE::WriteIndirectExecutionSetPipelineEXT const & writeIndirectExecutionSetPipelineEXT ) const VULKAN_HPP_NOEXCEPT
20729 {
20730 std::size_t seed = 0;
20731 VULKAN_HPP_HASH_COMBINE( seed, writeIndirectExecutionSetPipelineEXT.sType );
20732 VULKAN_HPP_HASH_COMBINE( seed, writeIndirectExecutionSetPipelineEXT.pNext );
20733 VULKAN_HPP_HASH_COMBINE( seed, writeIndirectExecutionSetPipelineEXT.index );
20734 VULKAN_HPP_HASH_COMBINE( seed, writeIndirectExecutionSetPipelineEXT.pipeline );
20735 return seed;
20736 }
20737 };
20738
20739 template <>
20740 struct hash<VULKAN_HPP_NAMESPACE::WriteIndirectExecutionSetShaderEXT>
20741 {
20742 std::size_t operator()( VULKAN_HPP_NAMESPACE::WriteIndirectExecutionSetShaderEXT const & writeIndirectExecutionSetShaderEXT ) const VULKAN_HPP_NOEXCEPT
20743 {
20744 std::size_t seed = 0;
20745 VULKAN_HPP_HASH_COMBINE( seed, writeIndirectExecutionSetShaderEXT.sType );
20746 VULKAN_HPP_HASH_COMBINE( seed, writeIndirectExecutionSetShaderEXT.pNext );
20747 VULKAN_HPP_HASH_COMBINE( seed, writeIndirectExecutionSetShaderEXT.index );
20748 VULKAN_HPP_HASH_COMBINE( seed, writeIndirectExecutionSetShaderEXT.shader );
20749 return seed;
20750 }
20751 };
20752
20753 # if defined( VK_USE_PLATFORM_XCB_KHR )
20754 template <>
20755 struct hash<VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR>
20756 {
20757 std::size_t operator()( VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR const & xcbSurfaceCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
20758 {
20759 std::size_t seed = 0;
20760 VULKAN_HPP_HASH_COMBINE( seed, xcbSurfaceCreateInfoKHR.sType );
20761 VULKAN_HPP_HASH_COMBINE( seed, xcbSurfaceCreateInfoKHR.pNext );
20762 VULKAN_HPP_HASH_COMBINE( seed, xcbSurfaceCreateInfoKHR.flags );
20763 VULKAN_HPP_HASH_COMBINE( seed, xcbSurfaceCreateInfoKHR.connection );
20764 VULKAN_HPP_HASH_COMBINE( seed, xcbSurfaceCreateInfoKHR.window );
20765 return seed;
20766 }
20767 };
20768 # endif /*VK_USE_PLATFORM_XCB_KHR*/
20769
20770 # if defined( VK_USE_PLATFORM_XLIB_KHR )
20771 template <>
20772 struct hash<VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR>
20773 {
20774 std::size_t operator()( VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR const & xlibSurfaceCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
20775 {
20776 std::size_t seed = 0;
20777 VULKAN_HPP_HASH_COMBINE( seed, xlibSurfaceCreateInfoKHR.sType );
20778 VULKAN_HPP_HASH_COMBINE( seed, xlibSurfaceCreateInfoKHR.pNext );
20779 VULKAN_HPP_HASH_COMBINE( seed, xlibSurfaceCreateInfoKHR.flags );
20780 VULKAN_HPP_HASH_COMBINE( seed, xlibSurfaceCreateInfoKHR.dpy );
20781 VULKAN_HPP_HASH_COMBINE( seed, xlibSurfaceCreateInfoKHR.window );
20782 return seed;
20783 }
20784 };
20785 # endif /*VK_USE_PLATFORM_XLIB_KHR*/
20786
20787 #endif // 14 <= VULKAN_HPP_CPP_VERSION
20788
20789 } // namespace std
20790 #endif