| // Copyright 2015-2024 The Khronos Group Inc. |
| // |
| // SPDX-License-Identifier: Apache-2.0 OR MIT |
| // |
| |
| // This header is generated from the Khronos Vulkan XML API Registry. |
| |
| #ifndef VULKAN_HASH_HPP |
| #define VULKAN_HASH_HPP |
| |
| #include <vulkan/vulkan.hpp> |
| |
| namespace std |
| { |
| //======================================= |
| //=== HASH structures for Flags types === |
| //======================================= |
| |
| template <typename BitType> |
| struct hash<VULKAN_HPP_NAMESPACE::Flags<BitType>> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::Flags<BitType> const & flags ) const VULKAN_HPP_NOEXCEPT |
| { |
| return std::hash<typename std::underlying_type<BitType>::type>{}( static_cast<typename std::underlying_type<BitType>::type>( flags ) ); |
| } |
| }; |
| |
| //=================================== |
| //=== HASH structures for handles === |
| //=================================== |
| |
| //=== VK_VERSION_1_0 === |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::Instance> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::Instance const & instance ) const VULKAN_HPP_NOEXCEPT |
| { |
| return std::hash<VkInstance>{}( static_cast<VkInstance>( instance ) ); |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevice> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevice const & physicalDevice ) const VULKAN_HPP_NOEXCEPT |
| { |
| return std::hash<VkPhysicalDevice>{}( static_cast<VkPhysicalDevice>( physicalDevice ) ); |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::Device> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::Device const & device ) const VULKAN_HPP_NOEXCEPT |
| { |
| return std::hash<VkDevice>{}( static_cast<VkDevice>( device ) ); |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::Queue> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::Queue const & queue ) const VULKAN_HPP_NOEXCEPT |
| { |
| return std::hash<VkQueue>{}( static_cast<VkQueue>( queue ) ); |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::DeviceMemory> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceMemory const & deviceMemory ) const VULKAN_HPP_NOEXCEPT |
| { |
| return std::hash<VkDeviceMemory>{}( static_cast<VkDeviceMemory>( deviceMemory ) ); |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::Fence> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::Fence const & fence ) const VULKAN_HPP_NOEXCEPT |
| { |
| return std::hash<VkFence>{}( static_cast<VkFence>( fence ) ); |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::Semaphore> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::Semaphore const & semaphore ) const VULKAN_HPP_NOEXCEPT |
| { |
| return std::hash<VkSemaphore>{}( static_cast<VkSemaphore>( semaphore ) ); |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::Event> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::Event const & event ) const VULKAN_HPP_NOEXCEPT |
| { |
| return std::hash<VkEvent>{}( static_cast<VkEvent>( event ) ); |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::QueryPool> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::QueryPool const & queryPool ) const VULKAN_HPP_NOEXCEPT |
| { |
| return std::hash<VkQueryPool>{}( static_cast<VkQueryPool>( queryPool ) ); |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::Buffer> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::Buffer const & buffer ) const VULKAN_HPP_NOEXCEPT |
| { |
| return std::hash<VkBuffer>{}( static_cast<VkBuffer>( buffer ) ); |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::BufferView> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferView const & bufferView ) const VULKAN_HPP_NOEXCEPT |
| { |
| return std::hash<VkBufferView>{}( static_cast<VkBufferView>( bufferView ) ); |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::Image> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::Image const & image ) const VULKAN_HPP_NOEXCEPT |
| { |
| return std::hash<VkImage>{}( static_cast<VkImage>( image ) ); |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::ImageView> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageView const & imageView ) const VULKAN_HPP_NOEXCEPT |
| { |
| return std::hash<VkImageView>{}( static_cast<VkImageView>( imageView ) ); |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::ShaderModule> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderModule const & shaderModule ) const VULKAN_HPP_NOEXCEPT |
| { |
| return std::hash<VkShaderModule>{}( static_cast<VkShaderModule>( shaderModule ) ); |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::PipelineCache> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCache const & pipelineCache ) const VULKAN_HPP_NOEXCEPT |
| { |
| return std::hash<VkPipelineCache>{}( static_cast<VkPipelineCache>( pipelineCache ) ); |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::Pipeline> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::Pipeline const & pipeline ) const VULKAN_HPP_NOEXCEPT |
| { |
| return std::hash<VkPipeline>{}( static_cast<VkPipeline>( pipeline ) ); |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::PipelineLayout> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineLayout const & pipelineLayout ) const VULKAN_HPP_NOEXCEPT |
| { |
| return std::hash<VkPipelineLayout>{}( static_cast<VkPipelineLayout>( pipelineLayout ) ); |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::Sampler> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::Sampler const & sampler ) const VULKAN_HPP_NOEXCEPT |
| { |
| return std::hash<VkSampler>{}( static_cast<VkSampler>( sampler ) ); |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::DescriptorPool> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorPool const & descriptorPool ) const VULKAN_HPP_NOEXCEPT |
| { |
| return std::hash<VkDescriptorPool>{}( static_cast<VkDescriptorPool>( descriptorPool ) ); |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::DescriptorSet> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSet const & descriptorSet ) const VULKAN_HPP_NOEXCEPT |
| { |
| return std::hash<VkDescriptorSet>{}( static_cast<VkDescriptorSet>( descriptorSet ) ); |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetLayout> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetLayout const & descriptorSetLayout ) const VULKAN_HPP_NOEXCEPT |
| { |
| return std::hash<VkDescriptorSetLayout>{}( static_cast<VkDescriptorSetLayout>( descriptorSetLayout ) ); |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::Framebuffer> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::Framebuffer const & framebuffer ) const VULKAN_HPP_NOEXCEPT |
| { |
| return std::hash<VkFramebuffer>{}( static_cast<VkFramebuffer>( framebuffer ) ); |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::RenderPass> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPass const & renderPass ) const VULKAN_HPP_NOEXCEPT |
| { |
| return std::hash<VkRenderPass>{}( static_cast<VkRenderPass>( renderPass ) ); |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::CommandPool> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandPool const & commandPool ) const VULKAN_HPP_NOEXCEPT |
| { |
| return std::hash<VkCommandPool>{}( static_cast<VkCommandPool>( commandPool ) ); |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::CommandBuffer> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBuffer const & commandBuffer ) const VULKAN_HPP_NOEXCEPT |
| { |
| return std::hash<VkCommandBuffer>{}( static_cast<VkCommandBuffer>( commandBuffer ) ); |
| } |
| }; |
| |
| //=== VK_VERSION_1_1 === |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion const & samplerYcbcrConversion ) const VULKAN_HPP_NOEXCEPT |
| { |
| return std::hash<VkSamplerYcbcrConversion>{}( static_cast<VkSamplerYcbcrConversion>( samplerYcbcrConversion ) ); |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate const & descriptorUpdateTemplate ) const VULKAN_HPP_NOEXCEPT |
| { |
| return std::hash<VkDescriptorUpdateTemplate>{}( static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ) ); |
| } |
| }; |
| |
| //=== VK_VERSION_1_3 === |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::PrivateDataSlot> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::PrivateDataSlot const & privateDataSlot ) const VULKAN_HPP_NOEXCEPT |
| { |
| return std::hash<VkPrivateDataSlot>{}( static_cast<VkPrivateDataSlot>( privateDataSlot ) ); |
| } |
| }; |
| |
| //=== VK_KHR_surface === |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::SurfaceKHR> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceKHR const & surfaceKHR ) const VULKAN_HPP_NOEXCEPT |
| { |
| return std::hash<VkSurfaceKHR>{}( static_cast<VkSurfaceKHR>( surfaceKHR ) ); |
| } |
| }; |
| |
| //=== VK_KHR_swapchain === |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::SwapchainKHR> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainKHR const & swapchainKHR ) const VULKAN_HPP_NOEXCEPT |
| { |
| return std::hash<VkSwapchainKHR>{}( static_cast<VkSwapchainKHR>( swapchainKHR ) ); |
| } |
| }; |
| |
| //=== VK_KHR_display === |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::DisplayKHR> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayKHR const & displayKHR ) const VULKAN_HPP_NOEXCEPT |
| { |
| return std::hash<VkDisplayKHR>{}( static_cast<VkDisplayKHR>( displayKHR ) ); |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::DisplayModeKHR> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayModeKHR const & displayModeKHR ) const VULKAN_HPP_NOEXCEPT |
| { |
| return std::hash<VkDisplayModeKHR>{}( static_cast<VkDisplayModeKHR>( displayModeKHR ) ); |
| } |
| }; |
| |
| //=== VK_EXT_debug_report === |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT const & debugReportCallbackEXT ) const VULKAN_HPP_NOEXCEPT |
| { |
| return std::hash<VkDebugReportCallbackEXT>{}( static_cast<VkDebugReportCallbackEXT>( debugReportCallbackEXT ) ); |
| } |
| }; |
| |
| //=== VK_KHR_video_queue === |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::VideoSessionKHR> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoSessionKHR const & videoSessionKHR ) const VULKAN_HPP_NOEXCEPT |
| { |
| return std::hash<VkVideoSessionKHR>{}( static_cast<VkVideoSessionKHR>( videoSessionKHR ) ); |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR const & videoSessionParametersKHR ) const VULKAN_HPP_NOEXCEPT |
| { |
| return std::hash<VkVideoSessionParametersKHR>{}( static_cast<VkVideoSessionParametersKHR>( videoSessionParametersKHR ) ); |
| } |
| }; |
| |
| //=== VK_NVX_binary_import === |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::CuModuleNVX> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::CuModuleNVX const & cuModuleNVX ) const VULKAN_HPP_NOEXCEPT |
| { |
| return std::hash<VkCuModuleNVX>{}( static_cast<VkCuModuleNVX>( cuModuleNVX ) ); |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::CuFunctionNVX> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::CuFunctionNVX const & cuFunctionNVX ) const VULKAN_HPP_NOEXCEPT |
| { |
| return std::hash<VkCuFunctionNVX>{}( static_cast<VkCuFunctionNVX>( cuFunctionNVX ) ); |
| } |
| }; |
| |
| //=== VK_EXT_debug_utils === |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT const & debugUtilsMessengerEXT ) const VULKAN_HPP_NOEXCEPT |
| { |
| return std::hash<VkDebugUtilsMessengerEXT>{}( static_cast<VkDebugUtilsMessengerEXT>( debugUtilsMessengerEXT ) ); |
| } |
| }; |
| |
| //=== VK_KHR_acceleration_structure === |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR const & accelerationStructureKHR ) const VULKAN_HPP_NOEXCEPT |
| { |
| return std::hash<VkAccelerationStructureKHR>{}( static_cast<VkAccelerationStructureKHR>( accelerationStructureKHR ) ); |
| } |
| }; |
| |
| //=== VK_EXT_validation_cache === |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::ValidationCacheEXT> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::ValidationCacheEXT const & validationCacheEXT ) const VULKAN_HPP_NOEXCEPT |
| { |
| return std::hash<VkValidationCacheEXT>{}( static_cast<VkValidationCacheEXT>( validationCacheEXT ) ); |
| } |
| }; |
| |
| //=== VK_NV_ray_tracing === |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureNV> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureNV const & accelerationStructureNV ) const VULKAN_HPP_NOEXCEPT |
| { |
| return std::hash<VkAccelerationStructureNV>{}( static_cast<VkAccelerationStructureNV>( accelerationStructureNV ) ); |
| } |
| }; |
| |
| //=== VK_INTEL_performance_query === |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL const & performanceConfigurationINTEL ) const VULKAN_HPP_NOEXCEPT |
| { |
| return std::hash<VkPerformanceConfigurationINTEL>{}( static_cast<VkPerformanceConfigurationINTEL>( performanceConfigurationINTEL ) ); |
| } |
| }; |
| |
| //=== VK_KHR_deferred_host_operations === |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::DeferredOperationKHR> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::DeferredOperationKHR const & deferredOperationKHR ) const VULKAN_HPP_NOEXCEPT |
| { |
| return std::hash<VkDeferredOperationKHR>{}( static_cast<VkDeferredOperationKHR>( deferredOperationKHR ) ); |
| } |
| }; |
| |
| //=== VK_NV_device_generated_commands === |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV const & indirectCommandsLayoutNV ) const VULKAN_HPP_NOEXCEPT |
| { |
| return std::hash<VkIndirectCommandsLayoutNV>{}( static_cast<VkIndirectCommandsLayoutNV>( indirectCommandsLayoutNV ) ); |
| } |
| }; |
| |
| #if defined( VK_ENABLE_BETA_EXTENSIONS ) |
| //=== VK_NV_cuda_kernel_launch === |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::CudaModuleNV> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::CudaModuleNV const & cudaModuleNV ) const VULKAN_HPP_NOEXCEPT |
| { |
| return std::hash<VkCudaModuleNV>{}( static_cast<VkCudaModuleNV>( cudaModuleNV ) ); |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::CudaFunctionNV> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::CudaFunctionNV const & cudaFunctionNV ) const VULKAN_HPP_NOEXCEPT |
| { |
| return std::hash<VkCudaFunctionNV>{}( static_cast<VkCudaFunctionNV>( cudaFunctionNV ) ); |
| } |
| }; |
| #endif /*VK_ENABLE_BETA_EXTENSIONS*/ |
| |
| #if defined( VK_USE_PLATFORM_FUCHSIA ) |
| //=== VK_FUCHSIA_buffer_collection === |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA const & bufferCollectionFUCHSIA ) const VULKAN_HPP_NOEXCEPT |
| { |
| return std::hash<VkBufferCollectionFUCHSIA>{}( static_cast<VkBufferCollectionFUCHSIA>( bufferCollectionFUCHSIA ) ); |
| } |
| }; |
| #endif /*VK_USE_PLATFORM_FUCHSIA*/ |
| |
| //=== VK_EXT_opacity_micromap === |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::MicromapEXT> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::MicromapEXT const & micromapEXT ) const VULKAN_HPP_NOEXCEPT |
| { |
| return std::hash<VkMicromapEXT>{}( static_cast<VkMicromapEXT>( micromapEXT ) ); |
| } |
| }; |
| |
| //=== VK_NV_optical_flow === |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV const & opticalFlowSessionNV ) const VULKAN_HPP_NOEXCEPT |
| { |
| return std::hash<VkOpticalFlowSessionNV>{}( static_cast<VkOpticalFlowSessionNV>( opticalFlowSessionNV ) ); |
| } |
| }; |
| |
| //=== VK_EXT_shader_object === |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::ShaderEXT> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderEXT const & shaderEXT ) const VULKAN_HPP_NOEXCEPT |
| { |
| return std::hash<VkShaderEXT>{}( static_cast<VkShaderEXT>( shaderEXT ) ); |
| } |
| }; |
| |
| //=== VK_KHR_pipeline_binary === |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::PipelineBinaryKHR> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineBinaryKHR const & pipelineBinaryKHR ) const VULKAN_HPP_NOEXCEPT |
| { |
| return std::hash<VkPipelineBinaryKHR>{}( static_cast<VkPipelineBinaryKHR>( pipelineBinaryKHR ) ); |
| } |
| }; |
| |
| //=== VK_EXT_device_generated_commands === |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutEXT> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutEXT const & indirectCommandsLayoutEXT ) const VULKAN_HPP_NOEXCEPT |
| { |
| return std::hash<VkIndirectCommandsLayoutEXT>{}( static_cast<VkIndirectCommandsLayoutEXT>( indirectCommandsLayoutEXT ) ); |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::IndirectExecutionSetEXT> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectExecutionSetEXT const & indirectExecutionSetEXT ) const VULKAN_HPP_NOEXCEPT |
| { |
| return std::hash<VkIndirectExecutionSetEXT>{}( static_cast<VkIndirectExecutionSetEXT>( indirectExecutionSetEXT ) ); |
| } |
| }; |
| |
| #if 14 <= VULKAN_HPP_CPP_VERSION |
| //====================================== |
| //=== HASH structures for structures === |
| //====================================== |
| |
| # if !defined( VULKAN_HPP_HASH_COMBINE ) |
| # define VULKAN_HPP_HASH_COMBINE( seed, value ) \ |
| seed ^= std::hash<std::decay<decltype( value )>::type>{}( value ) + 0x9e3779b9 + ( seed << 6 ) + ( seed >> 2 ) |
| # endif |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::AabbPositionsKHR> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::AabbPositionsKHR const & aabbPositionsKHR ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, aabbPositionsKHR.minX ); |
| VULKAN_HPP_HASH_COMBINE( seed, aabbPositionsKHR.minY ); |
| VULKAN_HPP_HASH_COMBINE( seed, aabbPositionsKHR.minZ ); |
| VULKAN_HPP_HASH_COMBINE( seed, aabbPositionsKHR.maxX ); |
| VULKAN_HPP_HASH_COMBINE( seed, aabbPositionsKHR.maxY ); |
| VULKAN_HPP_HASH_COMBINE( seed, aabbPositionsKHR.maxZ ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR> |
| { |
| std::size_t |
| operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR const & accelerationStructureBuildRangeInfoKHR ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildRangeInfoKHR.primitiveCount ); |
| VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildRangeInfoKHR.primitiveOffset ); |
| VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildRangeInfoKHR.firstVertex ); |
| VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildRangeInfoKHR.transformOffset ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR> |
| { |
| std::size_t |
| operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR const & accelerationStructureBuildSizesInfoKHR ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildSizesInfoKHR.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildSizesInfoKHR.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildSizesInfoKHR.accelerationStructureSize ); |
| VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildSizesInfoKHR.updateScratchSize ); |
| VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildSizesInfoKHR.buildScratchSize ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureCaptureDescriptorDataInfoEXT> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureCaptureDescriptorDataInfoEXT const & accelerationStructureCaptureDescriptorDataInfoEXT ) |
| const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCaptureDescriptorDataInfoEXT.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCaptureDescriptorDataInfoEXT.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCaptureDescriptorDataInfoEXT.accelerationStructure ); |
| VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCaptureDescriptorDataInfoEXT.accelerationStructureNV ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR const & accelerationStructureCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoKHR.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoKHR.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoKHR.createFlags ); |
| VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoKHR.buffer ); |
| VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoKHR.offset ); |
| VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoKHR.size ); |
| VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoKHR.type ); |
| VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoKHR.deviceAddress ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::GeometryTrianglesNV> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::GeometryTrianglesNV const & geometryTrianglesNV ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.vertexData ); |
| VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.vertexOffset ); |
| VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.vertexCount ); |
| VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.vertexStride ); |
| VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.vertexFormat ); |
| VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.indexData ); |
| VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.indexOffset ); |
| VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.indexCount ); |
| VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.indexType ); |
| VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.transformData ); |
| VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.transformOffset ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::GeometryAABBNV> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::GeometryAABBNV const & geometryAABBNV ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, geometryAABBNV.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, geometryAABBNV.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, geometryAABBNV.aabbData ); |
| VULKAN_HPP_HASH_COMBINE( seed, geometryAABBNV.numAABBs ); |
| VULKAN_HPP_HASH_COMBINE( seed, geometryAABBNV.stride ); |
| VULKAN_HPP_HASH_COMBINE( seed, geometryAABBNV.offset ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::GeometryDataNV> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::GeometryDataNV const & geometryDataNV ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, geometryDataNV.triangles ); |
| VULKAN_HPP_HASH_COMBINE( seed, geometryDataNV.aabbs ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::GeometryNV> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::GeometryNV const & geometryNV ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, geometryNV.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, geometryNV.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, geometryNV.geometryType ); |
| VULKAN_HPP_HASH_COMBINE( seed, geometryNV.geometry ); |
| VULKAN_HPP_HASH_COMBINE( seed, geometryNV.flags ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV const & accelerationStructureInfoNV ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInfoNV.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInfoNV.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInfoNV.type ); |
| VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInfoNV.flags ); |
| VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInfoNV.instanceCount ); |
| VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInfoNV.geometryCount ); |
| VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInfoNV.pGeometries ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV const & accelerationStructureCreateInfoNV ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoNV.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoNV.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoNV.compactedSize ); |
| VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoNV.info ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR> |
| { |
| std::size_t |
| operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR const & accelerationStructureDeviceAddressInfoKHR ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureDeviceAddressInfoKHR.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureDeviceAddressInfoKHR.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureDeviceAddressInfoKHR.accelerationStructure ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::TransformMatrixKHR> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::TransformMatrixKHR const & transformMatrixKHR ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| for ( size_t i = 0; i < 3; ++i ) |
| { |
| for ( size_t j = 0; j < 4; ++j ) |
| { |
| VULKAN_HPP_HASH_COMBINE( seed, transformMatrixKHR.matrix[i][j] ); |
| } |
| } |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureInstanceKHR> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureInstanceKHR const & accelerationStructureInstanceKHR ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInstanceKHR.transform ); |
| VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInstanceKHR.instanceCustomIndex ); |
| VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInstanceKHR.mask ); |
| VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInstanceKHR.instanceShaderBindingTableRecordOffset ); |
| VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInstanceKHR.flags ); |
| VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInstanceKHR.accelerationStructureReference ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureMatrixMotionInstanceNV> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureMatrixMotionInstanceNV const & accelerationStructureMatrixMotionInstanceNV ) const |
| VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMatrixMotionInstanceNV.transformT0 ); |
| VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMatrixMotionInstanceNV.transformT1 ); |
| VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMatrixMotionInstanceNV.instanceCustomIndex ); |
| VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMatrixMotionInstanceNV.mask ); |
| VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMatrixMotionInstanceNV.instanceShaderBindingTableRecordOffset ); |
| VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMatrixMotionInstanceNV.flags ); |
| VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMatrixMotionInstanceNV.accelerationStructureReference ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV const & accelerationStructureMemoryRequirementsInfoNV ) const |
| VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMemoryRequirementsInfoNV.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMemoryRequirementsInfoNV.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMemoryRequirementsInfoNV.type ); |
| VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMemoryRequirementsInfoNV.accelerationStructure ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInfoNV> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInfoNV const & accelerationStructureMotionInfoNV ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMotionInfoNV.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMotionInfoNV.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMotionInfoNV.maxInstances ); |
| VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMotionInfoNV.flags ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::SRTDataNV> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::SRTDataNV const & sRTDataNV ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.sx ); |
| VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.a ); |
| VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.b ); |
| VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.pvx ); |
| VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.sy ); |
| VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.c ); |
| VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.pvy ); |
| VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.sz ); |
| VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.pvz ); |
| VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.qx ); |
| VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.qy ); |
| VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.qz ); |
| VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.qw ); |
| VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.tx ); |
| VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.ty ); |
| VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.tz ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureSRTMotionInstanceNV> |
| { |
| std::size_t |
| operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureSRTMotionInstanceNV const & accelerationStructureSRTMotionInstanceNV ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureSRTMotionInstanceNV.transformT0 ); |
| VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureSRTMotionInstanceNV.transformT1 ); |
| VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureSRTMotionInstanceNV.instanceCustomIndex ); |
| VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureSRTMotionInstanceNV.mask ); |
| VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureSRTMotionInstanceNV.instanceShaderBindingTableRecordOffset ); |
| VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureSRTMotionInstanceNV.flags ); |
| VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureSRTMotionInstanceNV.accelerationStructureReference ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::MicromapUsageEXT> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::MicromapUsageEXT const & micromapUsageEXT ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, micromapUsageEXT.count ); |
| VULKAN_HPP_HASH_COMBINE( seed, micromapUsageEXT.subdivisionLevel ); |
| VULKAN_HPP_HASH_COMBINE( seed, micromapUsageEXT.format ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureVersionInfoKHR> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureVersionInfoKHR const & accelerationStructureVersionInfoKHR ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureVersionInfoKHR.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureVersionInfoKHR.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureVersionInfoKHR.pVersionData ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR const & acquireNextImageInfoKHR ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, acquireNextImageInfoKHR.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, acquireNextImageInfoKHR.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, acquireNextImageInfoKHR.swapchain ); |
| VULKAN_HPP_HASH_COMBINE( seed, acquireNextImageInfoKHR.timeout ); |
| VULKAN_HPP_HASH_COMBINE( seed, acquireNextImageInfoKHR.semaphore ); |
| VULKAN_HPP_HASH_COMBINE( seed, acquireNextImageInfoKHR.fence ); |
| VULKAN_HPP_HASH_COMBINE( seed, acquireNextImageInfoKHR.deviceMask ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR const & acquireProfilingLockInfoKHR ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, acquireProfilingLockInfoKHR.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, acquireProfilingLockInfoKHR.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, acquireProfilingLockInfoKHR.flags ); |
| VULKAN_HPP_HASH_COMBINE( seed, acquireProfilingLockInfoKHR.timeout ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::AllocationCallbacks> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::AllocationCallbacks const & allocationCallbacks ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, allocationCallbacks.pUserData ); |
| VULKAN_HPP_HASH_COMBINE( seed, allocationCallbacks.pfnAllocation ); |
| VULKAN_HPP_HASH_COMBINE( seed, allocationCallbacks.pfnReallocation ); |
| VULKAN_HPP_HASH_COMBINE( seed, allocationCallbacks.pfnFree ); |
| VULKAN_HPP_HASH_COMBINE( seed, allocationCallbacks.pfnInternalAllocation ); |
| VULKAN_HPP_HASH_COMBINE( seed, allocationCallbacks.pfnInternalFree ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::AmigoProfilingSubmitInfoSEC> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::AmigoProfilingSubmitInfoSEC const & amigoProfilingSubmitInfoSEC ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, amigoProfilingSubmitInfoSEC.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, amigoProfilingSubmitInfoSEC.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, amigoProfilingSubmitInfoSEC.firstDrawTimestamp ); |
| VULKAN_HPP_HASH_COMBINE( seed, amigoProfilingSubmitInfoSEC.swapBufferTimestamp ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::ComponentMapping> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::ComponentMapping const & componentMapping ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, componentMapping.r ); |
| VULKAN_HPP_HASH_COMBINE( seed, componentMapping.g ); |
| VULKAN_HPP_HASH_COMBINE( seed, componentMapping.b ); |
| VULKAN_HPP_HASH_COMBINE( seed, componentMapping.a ); |
| return seed; |
| } |
| }; |
| |
| # if defined( VK_USE_PLATFORM_ANDROID_KHR ) |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatProperties2ANDROID> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatProperties2ANDROID const & androidHardwareBufferFormatProperties2ANDROID ) const |
| VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.format ); |
| VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.externalFormat ); |
| VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.formatFeatures ); |
| VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.samplerYcbcrConversionComponents ); |
| VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.suggestedYcbcrModel ); |
| VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.suggestedYcbcrRange ); |
| VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.suggestedXChromaOffset ); |
| VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.suggestedYChromaOffset ); |
| return seed; |
| } |
| }; |
| # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ |
| |
| # if defined( VK_USE_PLATFORM_ANDROID_KHR ) |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatPropertiesANDROID> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatPropertiesANDROID const & androidHardwareBufferFormatPropertiesANDROID ) const |
| VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.format ); |
| VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.externalFormat ); |
| VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.formatFeatures ); |
| VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.samplerYcbcrConversionComponents ); |
| VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.suggestedYcbcrModel ); |
| VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.suggestedYcbcrRange ); |
| VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.suggestedXChromaOffset ); |
| VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.suggestedYChromaOffset ); |
| return seed; |
| } |
| }; |
| # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ |
| |
| # if defined( VK_USE_PLATFORM_ANDROID_KHR ) |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatResolvePropertiesANDROID> |
| { |
| std::size_t |
| operator()( VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatResolvePropertiesANDROID const & androidHardwareBufferFormatResolvePropertiesANDROID ) const |
| VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatResolvePropertiesANDROID.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatResolvePropertiesANDROID.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatResolvePropertiesANDROID.colorAttachmentFormat ); |
| return seed; |
| } |
| }; |
| # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ |
| |
| # if defined( VK_USE_PLATFORM_ANDROID_KHR ) |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID> |
| { |
| std::size_t |
| operator()( VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID const & androidHardwareBufferPropertiesANDROID ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferPropertiesANDROID.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferPropertiesANDROID.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferPropertiesANDROID.allocationSize ); |
| VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferPropertiesANDROID.memoryTypeBits ); |
| return seed; |
| } |
| }; |
| # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ |
| |
| # if defined( VK_USE_PLATFORM_ANDROID_KHR ) |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferUsageANDROID> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::AndroidHardwareBufferUsageANDROID const & androidHardwareBufferUsageANDROID ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferUsageANDROID.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferUsageANDROID.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferUsageANDROID.androidHardwareBufferUsage ); |
| return seed; |
| } |
| }; |
| # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ |
| |
| # if defined( VK_USE_PLATFORM_ANDROID_KHR ) |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR const & androidSurfaceCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, androidSurfaceCreateInfoKHR.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, androidSurfaceCreateInfoKHR.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, androidSurfaceCreateInfoKHR.flags ); |
| VULKAN_HPP_HASH_COMBINE( seed, androidSurfaceCreateInfoKHR.window ); |
| return seed; |
| } |
| }; |
| # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::AntiLagPresentationInfoAMD> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::AntiLagPresentationInfoAMD const & antiLagPresentationInfoAMD ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, antiLagPresentationInfoAMD.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, antiLagPresentationInfoAMD.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, antiLagPresentationInfoAMD.stage ); |
| VULKAN_HPP_HASH_COMBINE( seed, antiLagPresentationInfoAMD.frameIndex ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::AntiLagDataAMD> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::AntiLagDataAMD const & antiLagDataAMD ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, antiLagDataAMD.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, antiLagDataAMD.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, antiLagDataAMD.mode ); |
| VULKAN_HPP_HASH_COMBINE( seed, antiLagDataAMD.maxFPS ); |
| VULKAN_HPP_HASH_COMBINE( seed, antiLagDataAMD.pPresentationInfo ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::ApplicationInfo> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::ApplicationInfo const & applicationInfo ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, applicationInfo.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, applicationInfo.pNext ); |
| for ( const char * p = applicationInfo.pApplicationName; *p != '\0'; ++p ) |
| { |
| VULKAN_HPP_HASH_COMBINE( seed, *p ); |
| } |
| VULKAN_HPP_HASH_COMBINE( seed, applicationInfo.applicationVersion ); |
| for ( const char * p = applicationInfo.pEngineName; *p != '\0'; ++p ) |
| { |
| VULKAN_HPP_HASH_COMBINE( seed, *p ); |
| } |
| VULKAN_HPP_HASH_COMBINE( seed, applicationInfo.engineVersion ); |
| VULKAN_HPP_HASH_COMBINE( seed, applicationInfo.apiVersion ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::AttachmentDescription> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentDescription const & attachmentDescription ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.flags ); |
| VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.format ); |
| VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.samples ); |
| VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.loadOp ); |
| VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.storeOp ); |
| VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.stencilLoadOp ); |
| VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.stencilStoreOp ); |
| VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.initialLayout ); |
| VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.finalLayout ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::AttachmentDescription2> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentDescription2 const & attachmentDescription2 ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.flags ); |
| VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.format ); |
| VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.samples ); |
| VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.loadOp ); |
| VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.storeOp ); |
| VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.stencilLoadOp ); |
| VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.stencilStoreOp ); |
| VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.initialLayout ); |
| VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.finalLayout ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::AttachmentDescriptionStencilLayout> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentDescriptionStencilLayout const & attachmentDescriptionStencilLayout ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, attachmentDescriptionStencilLayout.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, attachmentDescriptionStencilLayout.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, attachmentDescriptionStencilLayout.stencilInitialLayout ); |
| VULKAN_HPP_HASH_COMBINE( seed, attachmentDescriptionStencilLayout.stencilFinalLayout ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::AttachmentReference> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentReference const & attachmentReference ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, attachmentReference.attachment ); |
| VULKAN_HPP_HASH_COMBINE( seed, attachmentReference.layout ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::AttachmentReference2> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentReference2 const & attachmentReference2 ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, attachmentReference2.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, attachmentReference2.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, attachmentReference2.attachment ); |
| VULKAN_HPP_HASH_COMBINE( seed, attachmentReference2.layout ); |
| VULKAN_HPP_HASH_COMBINE( seed, attachmentReference2.aspectMask ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::AttachmentReferenceStencilLayout> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentReferenceStencilLayout const & attachmentReferenceStencilLayout ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, attachmentReferenceStencilLayout.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, attachmentReferenceStencilLayout.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, attachmentReferenceStencilLayout.stencilLayout ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::AttachmentSampleCountInfoAMD> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentSampleCountInfoAMD const & attachmentSampleCountInfoAMD ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, attachmentSampleCountInfoAMD.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, attachmentSampleCountInfoAMD.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, attachmentSampleCountInfoAMD.colorAttachmentCount ); |
| VULKAN_HPP_HASH_COMBINE( seed, attachmentSampleCountInfoAMD.pColorAttachmentSamples ); |
| VULKAN_HPP_HASH_COMBINE( seed, attachmentSampleCountInfoAMD.depthStencilAttachmentSamples ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::Extent2D> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::Extent2D const & extent2D ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, extent2D.width ); |
| VULKAN_HPP_HASH_COMBINE( seed, extent2D.height ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::SampleLocationEXT> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::SampleLocationEXT const & sampleLocationEXT ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, sampleLocationEXT.x ); |
| VULKAN_HPP_HASH_COMBINE( seed, sampleLocationEXT.y ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT const & sampleLocationsInfoEXT ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, sampleLocationsInfoEXT.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, sampleLocationsInfoEXT.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, sampleLocationsInfoEXT.sampleLocationsPerPixel ); |
| VULKAN_HPP_HASH_COMBINE( seed, sampleLocationsInfoEXT.sampleLocationGridSize ); |
| VULKAN_HPP_HASH_COMBINE( seed, sampleLocationsInfoEXT.sampleLocationsCount ); |
| VULKAN_HPP_HASH_COMBINE( seed, sampleLocationsInfoEXT.pSampleLocations ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::AttachmentSampleLocationsEXT> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentSampleLocationsEXT const & attachmentSampleLocationsEXT ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, attachmentSampleLocationsEXT.attachmentIndex ); |
| VULKAN_HPP_HASH_COMBINE( seed, attachmentSampleLocationsEXT.sampleLocationsInfo ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::BaseInStructure> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::BaseInStructure const & baseInStructure ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, baseInStructure.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, baseInStructure.pNext ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::BaseOutStructure> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::BaseOutStructure const & baseOutStructure ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, baseOutStructure.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, baseOutStructure.pNext ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV> |
| { |
| std::size_t |
| operator()( VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV const & bindAccelerationStructureMemoryInfoNV ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, bindAccelerationStructureMemoryInfoNV.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, bindAccelerationStructureMemoryInfoNV.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, bindAccelerationStructureMemoryInfoNV.accelerationStructure ); |
| VULKAN_HPP_HASH_COMBINE( seed, bindAccelerationStructureMemoryInfoNV.memory ); |
| VULKAN_HPP_HASH_COMBINE( seed, bindAccelerationStructureMemoryInfoNV.memoryOffset ); |
| VULKAN_HPP_HASH_COMBINE( seed, bindAccelerationStructureMemoryInfoNV.deviceIndexCount ); |
| VULKAN_HPP_HASH_COMBINE( seed, bindAccelerationStructureMemoryInfoNV.pDeviceIndices ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::BindBufferMemoryDeviceGroupInfo> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::BindBufferMemoryDeviceGroupInfo const & bindBufferMemoryDeviceGroupInfo ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryDeviceGroupInfo.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryDeviceGroupInfo.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryDeviceGroupInfo.deviceIndexCount ); |
| VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryDeviceGroupInfo.pDeviceIndices ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo const & bindBufferMemoryInfo ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryInfo.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryInfo.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryInfo.buffer ); |
| VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryInfo.memory ); |
| VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryInfo.memoryOffset ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::BindDescriptorBufferEmbeddedSamplersInfoEXT> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::BindDescriptorBufferEmbeddedSamplersInfoEXT const & bindDescriptorBufferEmbeddedSamplersInfoEXT ) const |
| VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorBufferEmbeddedSamplersInfoEXT.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorBufferEmbeddedSamplersInfoEXT.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorBufferEmbeddedSamplersInfoEXT.stageFlags ); |
| VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorBufferEmbeddedSamplersInfoEXT.layout ); |
| VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorBufferEmbeddedSamplersInfoEXT.set ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::BindDescriptorSetsInfoKHR> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::BindDescriptorSetsInfoKHR const & bindDescriptorSetsInfoKHR ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorSetsInfoKHR.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorSetsInfoKHR.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorSetsInfoKHR.stageFlags ); |
| VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorSetsInfoKHR.layout ); |
| VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorSetsInfoKHR.firstSet ); |
| VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorSetsInfoKHR.descriptorSetCount ); |
| VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorSetsInfoKHR.pDescriptorSets ); |
| VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorSetsInfoKHR.dynamicOffsetCount ); |
| VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorSetsInfoKHR.pDynamicOffsets ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::Offset2D> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::Offset2D const & offset2D ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, offset2D.x ); |
| VULKAN_HPP_HASH_COMBINE( seed, offset2D.y ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::Rect2D> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::Rect2D const & rect2D ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, rect2D.offset ); |
| VULKAN_HPP_HASH_COMBINE( seed, rect2D.extent ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::BindImageMemoryDeviceGroupInfo> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::BindImageMemoryDeviceGroupInfo const & bindImageMemoryDeviceGroupInfo ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryDeviceGroupInfo.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryDeviceGroupInfo.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryDeviceGroupInfo.deviceIndexCount ); |
| VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryDeviceGroupInfo.pDeviceIndices ); |
| VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryDeviceGroupInfo.splitInstanceBindRegionCount ); |
| VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryDeviceGroupInfo.pSplitInstanceBindRegions ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::BindImageMemoryInfo> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::BindImageMemoryInfo const & bindImageMemoryInfo ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryInfo.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryInfo.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryInfo.image ); |
| VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryInfo.memory ); |
| VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryInfo.memoryOffset ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::BindImageMemorySwapchainInfoKHR> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::BindImageMemorySwapchainInfoKHR const & bindImageMemorySwapchainInfoKHR ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, bindImageMemorySwapchainInfoKHR.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, bindImageMemorySwapchainInfoKHR.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, bindImageMemorySwapchainInfoKHR.swapchain ); |
| VULKAN_HPP_HASH_COMBINE( seed, bindImageMemorySwapchainInfoKHR.imageIndex ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::BindImagePlaneMemoryInfo> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::BindImagePlaneMemoryInfo const & bindImagePlaneMemoryInfo ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, bindImagePlaneMemoryInfo.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, bindImagePlaneMemoryInfo.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, bindImagePlaneMemoryInfo.planeAspect ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::BindIndexBufferIndirectCommandEXT> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::BindIndexBufferIndirectCommandEXT const & bindIndexBufferIndirectCommandEXT ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, bindIndexBufferIndirectCommandEXT.bufferAddress ); |
| VULKAN_HPP_HASH_COMBINE( seed, bindIndexBufferIndirectCommandEXT.size ); |
| VULKAN_HPP_HASH_COMBINE( seed, bindIndexBufferIndirectCommandEXT.indexType ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::BindIndexBufferIndirectCommandNV> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::BindIndexBufferIndirectCommandNV const & bindIndexBufferIndirectCommandNV ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, bindIndexBufferIndirectCommandNV.bufferAddress ); |
| VULKAN_HPP_HASH_COMBINE( seed, bindIndexBufferIndirectCommandNV.size ); |
| VULKAN_HPP_HASH_COMBINE( seed, bindIndexBufferIndirectCommandNV.indexType ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::BindMemoryStatusKHR> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::BindMemoryStatusKHR const & bindMemoryStatusKHR ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, bindMemoryStatusKHR.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, bindMemoryStatusKHR.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, bindMemoryStatusKHR.pResult ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::BindPipelineIndirectCommandNV> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::BindPipelineIndirectCommandNV const & bindPipelineIndirectCommandNV ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, bindPipelineIndirectCommandNV.pipelineAddress ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::BindShaderGroupIndirectCommandNV> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::BindShaderGroupIndirectCommandNV const & bindShaderGroupIndirectCommandNV ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, bindShaderGroupIndirectCommandNV.groupIndex ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::SparseMemoryBind> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseMemoryBind const & sparseMemoryBind ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, sparseMemoryBind.resourceOffset ); |
| VULKAN_HPP_HASH_COMBINE( seed, sparseMemoryBind.size ); |
| VULKAN_HPP_HASH_COMBINE( seed, sparseMemoryBind.memory ); |
| VULKAN_HPP_HASH_COMBINE( seed, sparseMemoryBind.memoryOffset ); |
| VULKAN_HPP_HASH_COMBINE( seed, sparseMemoryBind.flags ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::SparseBufferMemoryBindInfo> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseBufferMemoryBindInfo const & sparseBufferMemoryBindInfo ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, sparseBufferMemoryBindInfo.buffer ); |
| VULKAN_HPP_HASH_COMBINE( seed, sparseBufferMemoryBindInfo.bindCount ); |
| VULKAN_HPP_HASH_COMBINE( seed, sparseBufferMemoryBindInfo.pBinds ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::SparseImageOpaqueMemoryBindInfo> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageOpaqueMemoryBindInfo const & sparseImageOpaqueMemoryBindInfo ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, sparseImageOpaqueMemoryBindInfo.image ); |
| VULKAN_HPP_HASH_COMBINE( seed, sparseImageOpaqueMemoryBindInfo.bindCount ); |
| VULKAN_HPP_HASH_COMBINE( seed, sparseImageOpaqueMemoryBindInfo.pBinds ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::ImageSubresource> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageSubresource const & imageSubresource ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, imageSubresource.aspectMask ); |
| VULKAN_HPP_HASH_COMBINE( seed, imageSubresource.mipLevel ); |
| VULKAN_HPP_HASH_COMBINE( seed, imageSubresource.arrayLayer ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::Offset3D> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::Offset3D const & offset3D ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, offset3D.x ); |
| VULKAN_HPP_HASH_COMBINE( seed, offset3D.y ); |
| VULKAN_HPP_HASH_COMBINE( seed, offset3D.z ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::Extent3D> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::Extent3D const & extent3D ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, extent3D.width ); |
| VULKAN_HPP_HASH_COMBINE( seed, extent3D.height ); |
| VULKAN_HPP_HASH_COMBINE( seed, extent3D.depth ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::SparseImageMemoryBind> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageMemoryBind const & sparseImageMemoryBind ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBind.subresource ); |
| VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBind.offset ); |
| VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBind.extent ); |
| VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBind.memory ); |
| VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBind.memoryOffset ); |
| VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBind.flags ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::SparseImageMemoryBindInfo> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageMemoryBindInfo const & sparseImageMemoryBindInfo ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBindInfo.image ); |
| VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBindInfo.bindCount ); |
| VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBindInfo.pBinds ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::BindSparseInfo> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::BindSparseInfo const & bindSparseInfo ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.waitSemaphoreCount ); |
| VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.pWaitSemaphores ); |
| VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.bufferBindCount ); |
| VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.pBufferBinds ); |
| VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.imageOpaqueBindCount ); |
| VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.pImageOpaqueBinds ); |
| VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.imageBindCount ); |
| VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.pImageBinds ); |
| VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.signalSemaphoreCount ); |
| VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.pSignalSemaphores ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::BindVertexBufferIndirectCommandEXT> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::BindVertexBufferIndirectCommandEXT const & bindVertexBufferIndirectCommandEXT ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, bindVertexBufferIndirectCommandEXT.bufferAddress ); |
| VULKAN_HPP_HASH_COMBINE( seed, bindVertexBufferIndirectCommandEXT.size ); |
| VULKAN_HPP_HASH_COMBINE( seed, bindVertexBufferIndirectCommandEXT.stride ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::BindVertexBufferIndirectCommandNV> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::BindVertexBufferIndirectCommandNV const & bindVertexBufferIndirectCommandNV ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, bindVertexBufferIndirectCommandNV.bufferAddress ); |
| VULKAN_HPP_HASH_COMBINE( seed, bindVertexBufferIndirectCommandNV.size ); |
| VULKAN_HPP_HASH_COMBINE( seed, bindVertexBufferIndirectCommandNV.stride ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::BindVideoSessionMemoryInfoKHR> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::BindVideoSessionMemoryInfoKHR const & bindVideoSessionMemoryInfoKHR ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, bindVideoSessionMemoryInfoKHR.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, bindVideoSessionMemoryInfoKHR.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, bindVideoSessionMemoryInfoKHR.memoryBindIndex ); |
| VULKAN_HPP_HASH_COMBINE( seed, bindVideoSessionMemoryInfoKHR.memory ); |
| VULKAN_HPP_HASH_COMBINE( seed, bindVideoSessionMemoryInfoKHR.memoryOffset ); |
| VULKAN_HPP_HASH_COMBINE( seed, bindVideoSessionMemoryInfoKHR.memorySize ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::BlitImageCubicWeightsInfoQCOM> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::BlitImageCubicWeightsInfoQCOM const & blitImageCubicWeightsInfoQCOM ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, blitImageCubicWeightsInfoQCOM.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, blitImageCubicWeightsInfoQCOM.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, blitImageCubicWeightsInfoQCOM.cubicWeights ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::ImageSubresourceLayers> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const & imageSubresourceLayers ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceLayers.aspectMask ); |
| VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceLayers.mipLevel ); |
| VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceLayers.baseArrayLayer ); |
| VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceLayers.layerCount ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::ImageBlit2> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageBlit2 const & imageBlit2 ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, imageBlit2.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, imageBlit2.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, imageBlit2.srcSubresource ); |
| for ( size_t i = 0; i < 2; ++i ) |
| { |
| VULKAN_HPP_HASH_COMBINE( seed, imageBlit2.srcOffsets[i] ); |
| } |
| VULKAN_HPP_HASH_COMBINE( seed, imageBlit2.dstSubresource ); |
| for ( size_t i = 0; i < 2; ++i ) |
| { |
| VULKAN_HPP_HASH_COMBINE( seed, imageBlit2.dstOffsets[i] ); |
| } |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::BlitImageInfo2> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::BlitImageInfo2 const & blitImageInfo2 ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.srcImage ); |
| VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.srcImageLayout ); |
| VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.dstImage ); |
| VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.dstImageLayout ); |
| VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.regionCount ); |
| VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.pRegions ); |
| VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.filter ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::BufferCaptureDescriptorDataInfoEXT> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCaptureDescriptorDataInfoEXT const & bufferCaptureDescriptorDataInfoEXT ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, bufferCaptureDescriptorDataInfoEXT.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferCaptureDescriptorDataInfoEXT.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferCaptureDescriptorDataInfoEXT.buffer ); |
| return seed; |
| } |
| }; |
| |
| # if defined( VK_USE_PLATFORM_FUCHSIA ) |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::BufferCollectionBufferCreateInfoFUCHSIA> |
| { |
| std::size_t |
| operator()( VULKAN_HPP_NAMESPACE::BufferCollectionBufferCreateInfoFUCHSIA const & bufferCollectionBufferCreateInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionBufferCreateInfoFUCHSIA.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionBufferCreateInfoFUCHSIA.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionBufferCreateInfoFUCHSIA.collection ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionBufferCreateInfoFUCHSIA.index ); |
| return seed; |
| } |
| }; |
| # endif /*VK_USE_PLATFORM_FUCHSIA*/ |
| |
| # if defined( VK_USE_PLATFORM_FUCHSIA ) |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::BufferCollectionConstraintsInfoFUCHSIA> |
| { |
| std::size_t |
| operator()( VULKAN_HPP_NAMESPACE::BufferCollectionConstraintsInfoFUCHSIA const & bufferCollectionConstraintsInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionConstraintsInfoFUCHSIA.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionConstraintsInfoFUCHSIA.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionConstraintsInfoFUCHSIA.minBufferCount ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionConstraintsInfoFUCHSIA.maxBufferCount ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionConstraintsInfoFUCHSIA.minBufferCountForCamping ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionConstraintsInfoFUCHSIA.minBufferCountForDedicatedSlack ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionConstraintsInfoFUCHSIA.minBufferCountForSharedSlack ); |
| return seed; |
| } |
| }; |
| # endif /*VK_USE_PLATFORM_FUCHSIA*/ |
| |
| # if defined( VK_USE_PLATFORM_FUCHSIA ) |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA const & bufferCollectionCreateInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionCreateInfoFUCHSIA.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionCreateInfoFUCHSIA.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionCreateInfoFUCHSIA.collectionToken ); |
| return seed; |
| } |
| }; |
| # endif /*VK_USE_PLATFORM_FUCHSIA*/ |
| |
| # if defined( VK_USE_PLATFORM_FUCHSIA ) |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::BufferCollectionImageCreateInfoFUCHSIA> |
| { |
| std::size_t |
| operator()( VULKAN_HPP_NAMESPACE::BufferCollectionImageCreateInfoFUCHSIA const & bufferCollectionImageCreateInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionImageCreateInfoFUCHSIA.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionImageCreateInfoFUCHSIA.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionImageCreateInfoFUCHSIA.collection ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionImageCreateInfoFUCHSIA.index ); |
| return seed; |
| } |
| }; |
| # endif /*VK_USE_PLATFORM_FUCHSIA*/ |
| |
| # if defined( VK_USE_PLATFORM_FUCHSIA ) |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::SysmemColorSpaceFUCHSIA> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::SysmemColorSpaceFUCHSIA const & sysmemColorSpaceFUCHSIA ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, sysmemColorSpaceFUCHSIA.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, sysmemColorSpaceFUCHSIA.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, sysmemColorSpaceFUCHSIA.colorSpace ); |
| return seed; |
| } |
| }; |
| # endif /*VK_USE_PLATFORM_FUCHSIA*/ |
| |
| # if defined( VK_USE_PLATFORM_FUCHSIA ) |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA const & bufferCollectionPropertiesFUCHSIA ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.memoryTypeBits ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.bufferCount ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.createInfoIndex ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.sysmemPixelFormat ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.formatFeatures ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.sysmemColorSpaceIndex ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.samplerYcbcrConversionComponents ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.suggestedYcbcrModel ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.suggestedYcbcrRange ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.suggestedXChromaOffset ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.suggestedYChromaOffset ); |
| return seed; |
| } |
| }; |
| # endif /*VK_USE_PLATFORM_FUCHSIA*/ |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::BufferCreateInfo> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCreateInfo const & bufferCreateInfo ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, bufferCreateInfo.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferCreateInfo.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferCreateInfo.flags ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferCreateInfo.size ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferCreateInfo.usage ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferCreateInfo.sharingMode ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferCreateInfo.queueFamilyIndexCount ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferCreateInfo.pQueueFamilyIndices ); |
| return seed; |
| } |
| }; |
| |
| # if defined( VK_USE_PLATFORM_FUCHSIA ) |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::BufferConstraintsInfoFUCHSIA> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferConstraintsInfoFUCHSIA const & bufferConstraintsInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, bufferConstraintsInfoFUCHSIA.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferConstraintsInfoFUCHSIA.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferConstraintsInfoFUCHSIA.createInfo ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferConstraintsInfoFUCHSIA.requiredFormatFeatures ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferConstraintsInfoFUCHSIA.bufferCollectionConstraints ); |
| return seed; |
| } |
| }; |
| # endif /*VK_USE_PLATFORM_FUCHSIA*/ |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::BufferCopy> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCopy const & bufferCopy ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, bufferCopy.srcOffset ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferCopy.dstOffset ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferCopy.size ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::BufferCopy2> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCopy2 const & bufferCopy2 ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, bufferCopy2.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferCopy2.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferCopy2.srcOffset ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferCopy2.dstOffset ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferCopy2.size ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::BufferDeviceAddressCreateInfoEXT> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferDeviceAddressCreateInfoEXT const & bufferDeviceAddressCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, bufferDeviceAddressCreateInfoEXT.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferDeviceAddressCreateInfoEXT.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferDeviceAddressCreateInfoEXT.deviceAddress ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo const & bufferDeviceAddressInfo ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, bufferDeviceAddressInfo.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferDeviceAddressInfo.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferDeviceAddressInfo.buffer ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::BufferImageCopy> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferImageCopy const & bufferImageCopy ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy.bufferOffset ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy.bufferRowLength ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy.bufferImageHeight ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy.imageSubresource ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy.imageOffset ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy.imageExtent ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::BufferImageCopy2> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferImageCopy2 const & bufferImageCopy2 ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy2.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy2.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy2.bufferOffset ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy2.bufferRowLength ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy2.bufferImageHeight ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy2.imageSubresource ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy2.imageOffset ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy2.imageExtent ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::BufferMemoryBarrier> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferMemoryBarrier const & bufferMemoryBarrier ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.srcAccessMask ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.dstAccessMask ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.srcQueueFamilyIndex ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.dstQueueFamilyIndex ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.buffer ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.offset ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.size ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::BufferMemoryBarrier2> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferMemoryBarrier2 const & bufferMemoryBarrier2 ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.srcStageMask ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.srcAccessMask ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.dstStageMask ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.dstAccessMask ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.srcQueueFamilyIndex ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.dstQueueFamilyIndex ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.buffer ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.offset ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.size ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 const & bufferMemoryRequirementsInfo2 ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryRequirementsInfo2.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryRequirementsInfo2.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryRequirementsInfo2.buffer ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::BufferOpaqueCaptureAddressCreateInfo> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferOpaqueCaptureAddressCreateInfo const & bufferOpaqueCaptureAddressCreateInfo ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, bufferOpaqueCaptureAddressCreateInfo.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferOpaqueCaptureAddressCreateInfo.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferOpaqueCaptureAddressCreateInfo.opaqueCaptureAddress ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::BufferUsageFlags2CreateInfoKHR> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferUsageFlags2CreateInfoKHR const & bufferUsageFlags2CreateInfoKHR ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, bufferUsageFlags2CreateInfoKHR.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferUsageFlags2CreateInfoKHR.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferUsageFlags2CreateInfoKHR.usage ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::BufferViewCreateInfo> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferViewCreateInfo const & bufferViewCreateInfo ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, bufferViewCreateInfo.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferViewCreateInfo.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferViewCreateInfo.flags ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferViewCreateInfo.buffer ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferViewCreateInfo.format ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferViewCreateInfo.offset ); |
| VULKAN_HPP_HASH_COMBINE( seed, bufferViewCreateInfo.range ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR const & calibratedTimestampInfoKHR ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, calibratedTimestampInfoKHR.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, calibratedTimestampInfoKHR.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, calibratedTimestampInfoKHR.timeDomain ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::CheckpointData2NV> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::CheckpointData2NV const & checkpointData2NV ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, checkpointData2NV.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, checkpointData2NV.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, checkpointData2NV.stage ); |
| VULKAN_HPP_HASH_COMBINE( seed, checkpointData2NV.pCheckpointMarker ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::CheckpointDataNV> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::CheckpointDataNV const & checkpointDataNV ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, checkpointDataNV.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, checkpointDataNV.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, checkpointDataNV.stage ); |
| VULKAN_HPP_HASH_COMBINE( seed, checkpointDataNV.pCheckpointMarker ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::ClearDepthStencilValue> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::ClearDepthStencilValue const & clearDepthStencilValue ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, clearDepthStencilValue.depth ); |
| VULKAN_HPP_HASH_COMBINE( seed, clearDepthStencilValue.stencil ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::ClearRect> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::ClearRect const & clearRect ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, clearRect.rect ); |
| VULKAN_HPP_HASH_COMBINE( seed, clearRect.baseArrayLayer ); |
| VULKAN_HPP_HASH_COMBINE( seed, clearRect.layerCount ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::CoarseSampleLocationNV> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::CoarseSampleLocationNV const & coarseSampleLocationNV ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, coarseSampleLocationNV.pixelX ); |
| VULKAN_HPP_HASH_COMBINE( seed, coarseSampleLocationNV.pixelY ); |
| VULKAN_HPP_HASH_COMBINE( seed, coarseSampleLocationNV.sample ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV const & coarseSampleOrderCustomNV ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, coarseSampleOrderCustomNV.shadingRate ); |
| VULKAN_HPP_HASH_COMBINE( seed, coarseSampleOrderCustomNV.sampleCount ); |
| VULKAN_HPP_HASH_COMBINE( seed, coarseSampleOrderCustomNV.sampleLocationCount ); |
| VULKAN_HPP_HASH_COMBINE( seed, coarseSampleOrderCustomNV.pSampleLocations ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::ColorBlendAdvancedEXT> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::ColorBlendAdvancedEXT const & colorBlendAdvancedEXT ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, colorBlendAdvancedEXT.advancedBlendOp ); |
| VULKAN_HPP_HASH_COMBINE( seed, colorBlendAdvancedEXT.srcPremultiplied ); |
| VULKAN_HPP_HASH_COMBINE( seed, colorBlendAdvancedEXT.dstPremultiplied ); |
| VULKAN_HPP_HASH_COMBINE( seed, colorBlendAdvancedEXT.blendOverlap ); |
| VULKAN_HPP_HASH_COMBINE( seed, colorBlendAdvancedEXT.clampResults ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::ColorBlendEquationEXT> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::ColorBlendEquationEXT const & colorBlendEquationEXT ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, colorBlendEquationEXT.srcColorBlendFactor ); |
| VULKAN_HPP_HASH_COMBINE( seed, colorBlendEquationEXT.dstColorBlendFactor ); |
| VULKAN_HPP_HASH_COMBINE( seed, colorBlendEquationEXT.colorBlendOp ); |
| VULKAN_HPP_HASH_COMBINE( seed, colorBlendEquationEXT.srcAlphaBlendFactor ); |
| VULKAN_HPP_HASH_COMBINE( seed, colorBlendEquationEXT.dstAlphaBlendFactor ); |
| VULKAN_HPP_HASH_COMBINE( seed, colorBlendEquationEXT.alphaBlendOp ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo const & commandBufferAllocateInfo ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, commandBufferAllocateInfo.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, commandBufferAllocateInfo.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, commandBufferAllocateInfo.commandPool ); |
| VULKAN_HPP_HASH_COMBINE( seed, commandBufferAllocateInfo.level ); |
| VULKAN_HPP_HASH_COMBINE( seed, commandBufferAllocateInfo.commandBufferCount ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::CommandBufferInheritanceInfo> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceInfo const & commandBufferInheritanceInfo ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceInfo.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceInfo.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceInfo.renderPass ); |
| VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceInfo.subpass ); |
| VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceInfo.framebuffer ); |
| VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceInfo.occlusionQueryEnable ); |
| VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceInfo.queryFlags ); |
| VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceInfo.pipelineStatistics ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo const & commandBufferBeginInfo ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, commandBufferBeginInfo.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, commandBufferBeginInfo.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, commandBufferBeginInfo.flags ); |
| VULKAN_HPP_HASH_COMBINE( seed, commandBufferBeginInfo.pInheritanceInfo ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::CommandBufferInheritanceConditionalRenderingInfoEXT> |
| { |
| std::size_t |
| operator()( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceConditionalRenderingInfoEXT const & commandBufferInheritanceConditionalRenderingInfoEXT ) const |
| VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceConditionalRenderingInfoEXT.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceConditionalRenderingInfoEXT.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceConditionalRenderingInfoEXT.conditionalRenderingEnable ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::CommandBufferInheritanceRenderPassTransformInfoQCOM> |
| { |
| std::size_t |
| operator()( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceRenderPassTransformInfoQCOM const & commandBufferInheritanceRenderPassTransformInfoQCOM ) const |
| VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderPassTransformInfoQCOM.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderPassTransformInfoQCOM.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderPassTransformInfoQCOM.transform ); |
| VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderPassTransformInfoQCOM.renderArea ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::CommandBufferInheritanceRenderingInfo> |
| { |
| std::size_t |
| operator()( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceRenderingInfo const & commandBufferInheritanceRenderingInfo ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.flags ); |
| VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.viewMask ); |
| VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.colorAttachmentCount ); |
| VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.pColorAttachmentFormats ); |
| VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.depthAttachmentFormat ); |
| VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.stencilAttachmentFormat ); |
| VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.rasterizationSamples ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::Viewport> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::Viewport const & viewport ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, viewport.x ); |
| VULKAN_HPP_HASH_COMBINE( seed, viewport.y ); |
| VULKAN_HPP_HASH_COMBINE( seed, viewport.width ); |
| VULKAN_HPP_HASH_COMBINE( seed, viewport.height ); |
| VULKAN_HPP_HASH_COMBINE( seed, viewport.minDepth ); |
| VULKAN_HPP_HASH_COMBINE( seed, viewport.maxDepth ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::CommandBufferInheritanceViewportScissorInfoNV> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceViewportScissorInfoNV const & commandBufferInheritanceViewportScissorInfoNV ) const |
| VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceViewportScissorInfoNV.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceViewportScissorInfoNV.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceViewportScissorInfoNV.viewportScissor2D ); |
| VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceViewportScissorInfoNV.viewportDepthCount ); |
| VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceViewportScissorInfoNV.pViewportDepths ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::CommandBufferSubmitInfo> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBufferSubmitInfo const & commandBufferSubmitInfo ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, commandBufferSubmitInfo.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, commandBufferSubmitInfo.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, commandBufferSubmitInfo.commandBuffer ); |
| VULKAN_HPP_HASH_COMBINE( seed, commandBufferSubmitInfo.deviceMask ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo const & commandPoolCreateInfo ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, commandPoolCreateInfo.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, commandPoolCreateInfo.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, commandPoolCreateInfo.flags ); |
| VULKAN_HPP_HASH_COMBINE( seed, commandPoolCreateInfo.queueFamilyIndex ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::SpecializationMapEntry> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::SpecializationMapEntry const & specializationMapEntry ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, specializationMapEntry.constantID ); |
| VULKAN_HPP_HASH_COMBINE( seed, specializationMapEntry.offset ); |
| VULKAN_HPP_HASH_COMBINE( seed, specializationMapEntry.size ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::SpecializationInfo> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::SpecializationInfo const & specializationInfo ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, specializationInfo.mapEntryCount ); |
| VULKAN_HPP_HASH_COMBINE( seed, specializationInfo.pMapEntries ); |
| VULKAN_HPP_HASH_COMBINE( seed, specializationInfo.dataSize ); |
| VULKAN_HPP_HASH_COMBINE( seed, specializationInfo.pData ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo const & pipelineShaderStageCreateInfo ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageCreateInfo.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageCreateInfo.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageCreateInfo.flags ); |
| VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageCreateInfo.stage ); |
| VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageCreateInfo.module ); |
| for ( const char * p = pipelineShaderStageCreateInfo.pName; *p != '\0'; ++p ) |
| { |
| VULKAN_HPP_HASH_COMBINE( seed, *p ); |
| } |
| VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageCreateInfo.pSpecializationInfo ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo const & computePipelineCreateInfo ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, computePipelineCreateInfo.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, computePipelineCreateInfo.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, computePipelineCreateInfo.flags ); |
| VULKAN_HPP_HASH_COMBINE( seed, computePipelineCreateInfo.stage ); |
| VULKAN_HPP_HASH_COMBINE( seed, computePipelineCreateInfo.layout ); |
| VULKAN_HPP_HASH_COMBINE( seed, computePipelineCreateInfo.basePipelineHandle ); |
| VULKAN_HPP_HASH_COMBINE( seed, computePipelineCreateInfo.basePipelineIndex ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::ComputePipelineIndirectBufferInfoNV> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::ComputePipelineIndirectBufferInfoNV const & computePipelineIndirectBufferInfoNV ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, computePipelineIndirectBufferInfoNV.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, computePipelineIndirectBufferInfoNV.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, computePipelineIndirectBufferInfoNV.deviceAddress ); |
| VULKAN_HPP_HASH_COMBINE( seed, computePipelineIndirectBufferInfoNV.size ); |
| VULKAN_HPP_HASH_COMBINE( seed, computePipelineIndirectBufferInfoNV.pipelineDeviceAddressCaptureReplay ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfoEXT> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfoEXT const & conditionalRenderingBeginInfoEXT ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, conditionalRenderingBeginInfoEXT.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, conditionalRenderingBeginInfoEXT.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, conditionalRenderingBeginInfoEXT.buffer ); |
| VULKAN_HPP_HASH_COMBINE( seed, conditionalRenderingBeginInfoEXT.offset ); |
| VULKAN_HPP_HASH_COMBINE( seed, conditionalRenderingBeginInfoEXT.flags ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::ConformanceVersion> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::ConformanceVersion const & conformanceVersion ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, conformanceVersion.major ); |
| VULKAN_HPP_HASH_COMBINE( seed, conformanceVersion.minor ); |
| VULKAN_HPP_HASH_COMBINE( seed, conformanceVersion.subminor ); |
| VULKAN_HPP_HASH_COMBINE( seed, conformanceVersion.patch ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::CooperativeMatrixFlexibleDimensionsPropertiesNV> |
| { |
| std::size_t operator()( |
| VULKAN_HPP_NAMESPACE::CooperativeMatrixFlexibleDimensionsPropertiesNV const & cooperativeMatrixFlexibleDimensionsPropertiesNV ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixFlexibleDimensionsPropertiesNV.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixFlexibleDimensionsPropertiesNV.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixFlexibleDimensionsPropertiesNV.MGranularity ); |
| VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixFlexibleDimensionsPropertiesNV.NGranularity ); |
| VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixFlexibleDimensionsPropertiesNV.KGranularity ); |
| VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixFlexibleDimensionsPropertiesNV.AType ); |
| VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixFlexibleDimensionsPropertiesNV.BType ); |
| VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixFlexibleDimensionsPropertiesNV.CType ); |
| VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixFlexibleDimensionsPropertiesNV.ResultType ); |
| VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixFlexibleDimensionsPropertiesNV.saturatingAccumulation ); |
| VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixFlexibleDimensionsPropertiesNV.scope ); |
| VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixFlexibleDimensionsPropertiesNV.workgroupInvocations ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR const & cooperativeMatrixPropertiesKHR ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.MSize ); |
| VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.NSize ); |
| VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.KSize ); |
| VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.AType ); |
| VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.BType ); |
| VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.CType ); |
| VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.ResultType ); |
| VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.saturatingAccumulation ); |
| VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.scope ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV const & cooperativeMatrixPropertiesNV ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.MSize ); |
| VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.NSize ); |
| VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.KSize ); |
| VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.AType ); |
| VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.BType ); |
| VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.CType ); |
| VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.DType ); |
| VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.scope ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR const & copyAccelerationStructureInfoKHR ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, copyAccelerationStructureInfoKHR.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, copyAccelerationStructureInfoKHR.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, copyAccelerationStructureInfoKHR.src ); |
| VULKAN_HPP_HASH_COMBINE( seed, copyAccelerationStructureInfoKHR.dst ); |
| VULKAN_HPP_HASH_COMBINE( seed, copyAccelerationStructureInfoKHR.mode ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::CopyBufferInfo2> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyBufferInfo2 const & copyBufferInfo2 ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, copyBufferInfo2.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, copyBufferInfo2.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, copyBufferInfo2.srcBuffer ); |
| VULKAN_HPP_HASH_COMBINE( seed, copyBufferInfo2.dstBuffer ); |
| VULKAN_HPP_HASH_COMBINE( seed, copyBufferInfo2.regionCount ); |
| VULKAN_HPP_HASH_COMBINE( seed, copyBufferInfo2.pRegions ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 const & copyBufferToImageInfo2 ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, copyBufferToImageInfo2.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, copyBufferToImageInfo2.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, copyBufferToImageInfo2.srcBuffer ); |
| VULKAN_HPP_HASH_COMBINE( seed, copyBufferToImageInfo2.dstImage ); |
| VULKAN_HPP_HASH_COMBINE( seed, copyBufferToImageInfo2.dstImageLayout ); |
| VULKAN_HPP_HASH_COMBINE( seed, copyBufferToImageInfo2.regionCount ); |
| VULKAN_HPP_HASH_COMBINE( seed, copyBufferToImageInfo2.pRegions ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::CopyCommandTransformInfoQCOM> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyCommandTransformInfoQCOM const & copyCommandTransformInfoQCOM ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, copyCommandTransformInfoQCOM.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, copyCommandTransformInfoQCOM.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, copyCommandTransformInfoQCOM.transform ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::CopyDescriptorSet> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyDescriptorSet const & copyDescriptorSet ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.srcSet ); |
| VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.srcBinding ); |
| VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.srcArrayElement ); |
| VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.dstSet ); |
| VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.dstBinding ); |
| VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.dstArrayElement ); |
| VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.descriptorCount ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::ImageCopy2> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageCopy2 const & imageCopy2 ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, imageCopy2.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, imageCopy2.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, imageCopy2.srcSubresource ); |
| VULKAN_HPP_HASH_COMBINE( seed, imageCopy2.srcOffset ); |
| VULKAN_HPP_HASH_COMBINE( seed, imageCopy2.dstSubresource ); |
| VULKAN_HPP_HASH_COMBINE( seed, imageCopy2.dstOffset ); |
| VULKAN_HPP_HASH_COMBINE( seed, imageCopy2.extent ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::CopyImageInfo2> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyImageInfo2 const & copyImageInfo2 ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, copyImageInfo2.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, copyImageInfo2.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, copyImageInfo2.srcImage ); |
| VULKAN_HPP_HASH_COMBINE( seed, copyImageInfo2.srcImageLayout ); |
| VULKAN_HPP_HASH_COMBINE( seed, copyImageInfo2.dstImage ); |
| VULKAN_HPP_HASH_COMBINE( seed, copyImageInfo2.dstImageLayout ); |
| VULKAN_HPP_HASH_COMBINE( seed, copyImageInfo2.regionCount ); |
| VULKAN_HPP_HASH_COMBINE( seed, copyImageInfo2.pRegions ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 const & copyImageToBufferInfo2 ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, copyImageToBufferInfo2.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, copyImageToBufferInfo2.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, copyImageToBufferInfo2.srcImage ); |
| VULKAN_HPP_HASH_COMBINE( seed, copyImageToBufferInfo2.srcImageLayout ); |
| VULKAN_HPP_HASH_COMBINE( seed, copyImageToBufferInfo2.dstBuffer ); |
| VULKAN_HPP_HASH_COMBINE( seed, copyImageToBufferInfo2.regionCount ); |
| VULKAN_HPP_HASH_COMBINE( seed, copyImageToBufferInfo2.pRegions ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::CopyImageToImageInfoEXT> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyImageToImageInfoEXT const & copyImageToImageInfoEXT ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, copyImageToImageInfoEXT.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, copyImageToImageInfoEXT.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, copyImageToImageInfoEXT.flags ); |
| VULKAN_HPP_HASH_COMBINE( seed, copyImageToImageInfoEXT.srcImage ); |
| VULKAN_HPP_HASH_COMBINE( seed, copyImageToImageInfoEXT.srcImageLayout ); |
| VULKAN_HPP_HASH_COMBINE( seed, copyImageToImageInfoEXT.dstImage ); |
| VULKAN_HPP_HASH_COMBINE( seed, copyImageToImageInfoEXT.dstImageLayout ); |
| VULKAN_HPP_HASH_COMBINE( seed, copyImageToImageInfoEXT.regionCount ); |
| VULKAN_HPP_HASH_COMBINE( seed, copyImageToImageInfoEXT.pRegions ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::ImageToMemoryCopyEXT> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageToMemoryCopyEXT const & imageToMemoryCopyEXT ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, imageToMemoryCopyEXT.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, imageToMemoryCopyEXT.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, imageToMemoryCopyEXT.pHostPointer ); |
| VULKAN_HPP_HASH_COMBINE( seed, imageToMemoryCopyEXT.memoryRowLength ); |
| VULKAN_HPP_HASH_COMBINE( seed, imageToMemoryCopyEXT.memoryImageHeight ); |
| VULKAN_HPP_HASH_COMBINE( seed, imageToMemoryCopyEXT.imageSubresource ); |
| VULKAN_HPP_HASH_COMBINE( seed, imageToMemoryCopyEXT.imageOffset ); |
| VULKAN_HPP_HASH_COMBINE( seed, imageToMemoryCopyEXT.imageExtent ); |
| return seed; |
| } |
| }; |
| |
| template <> |
| struct hash<VULKAN_HPP_NAMESPACE::CopyImageToMemoryInfoEXT> |
| { |
| std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyImageToMemoryInfoEXT const & copyImageToMemoryInfoEXT ) const VULKAN_HPP_NOEXCEPT |
| { |
| std::size_t seed = 0; |
| VULKAN_HPP_HASH_COMBINE( seed, copyImageToMemoryInfoEXT.sType ); |
| VULKAN_HPP_HASH_COMBINE( seed, copyImageToMemoryInfoEXT.pNext ); |
| VULKAN_HPP_HASH_COMBINE( seed, copyImageToMemoryInfoEXT.flags ); |
| VULKAN_HPP_HASH_COMBINE( seed, copyImageToMemoryInfoEXT.srcImage ); |
| VULKAN_HPP_HASH_COMBINE( seed, copyImageToMemoryInfoEXT.srcImageLayout ); |
| VULKAN_HPP_HASH_COMBINE( seed, copyImageToMemoryInfoEXT.regionCount ); |
| VULKAN_HPP_HASH_COMBINE( seed, copyImageToMemoryInfoEXT.pRegions ); |
| <
|