blob: fd04725e61da37400dff1f7e1f687594adcfde7e [file] [log] [blame]
// Copyright 2015-2022 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 ) );
}
};
#if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== 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 ) );
}
};
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
//=== 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_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*/
#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::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::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::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::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::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::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::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::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::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;
}
};
# 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::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::CalibratedTimestampInfoEXT>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT const & calibratedTimestampInfoEXT ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, calibratedTimestampInfoEXT.sType );
VULKAN_HPP_HASH_COMBINE( seed, calibratedTimestampInfoEXT.pNext );
VULKAN_HPP_HASH_COMBINE( seed, calibratedTimestampInfoEXT.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::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::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::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::CuFunctionCreateInfoNVX>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX const & cuFunctionCreateInfoNVX ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, cuFunctionCreateInfoNVX.sType );
VULKAN_HPP_HASH_COMBINE( seed, cuFunctionCreateInfoNVX.pNext );
VULKAN_HPP_HASH_COMBINE( seed, cuFunctionCreateInfoNVX.module );
for ( const char * p = cuFunctionCreateInfoNVX.pName; *p != '\0'; ++p )
{
VULKAN_HPP_HASH_COMBINE( seed, *p );
}
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX const & cuLaunchInfoNVX ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.sType );
VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.pNext );
VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.function );
VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.gridDimX );
VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.gridDimY );
VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.gridDimZ );
VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.blockDimX );
VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.blockDimY );
VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.blockDimZ );
VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.sharedMemBytes );
VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.paramCount );
VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.pParams );
VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.extraCount );
VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.pExtras );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX const & cuModuleCreateInfoNVX ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, cuModuleCreateInfoNVX.sType );
VULKAN_HPP_HASH_COMBINE( seed, cuModuleCreateInfoNVX.pNext );
VULKAN_HPP_HASH_COMBINE( seed, cuModuleCreateInfoNVX.dataSize );
VULKAN_HPP_HASH_COMBINE( seed, cuModuleCreateInfoNVX.pData );
return seed;
}
};
# if defined( VK_USE_PLATFORM_WIN32_KHR )
template <>
struct hash<VULKAN_HPP_NAMESPACE::D3D12FenceSubmitInfoKHR>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::D3D12FenceSubmitInfoKHR const & d3D12FenceSubmitInfoKHR ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, d3D12FenceSubmitInfoKHR.sType );
VULKAN_HPP_HASH_COMBINE( seed, d3D12FenceSubmitInfoKHR.pNext );
VULKAN_HPP_HASH_COMBINE( seed, d3D12FenceSubmitInfoKHR.waitSemaphoreValuesCount );
VULKAN_HPP_HASH_COMBINE( seed, d3D12FenceSubmitInfoKHR.pWaitSemaphoreValues );
VULKAN_HPP_HASH_COMBINE( seed, d3D12FenceSubmitInfoKHR.signalSemaphoreValuesCount );
VULKAN_HPP_HASH_COMBINE( seed, d3D12FenceSubmitInfoKHR.pSignalSemaphoreValues );
return seed;
}
};
# endif /*VK_USE_PLATFORM_WIN32_KHR*/
template <>
struct hash<VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT const & debugMarkerMarkerInfoEXT ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, debugMarkerMarkerInfoEXT.sType );
VULKAN_HPP_HASH_COMBINE( seed, debugMarkerMarkerInfoEXT.pNext );
for ( const char * p = debugMarkerMarkerInfoEXT.pMarkerName; *p != '\0'; ++p )
{
VULKAN_HPP_HASH_COMBINE( seed, *p );
}
for ( size_t i = 0; i < 4; ++i )
{
VULKAN_HPP_HASH_COMBINE( seed, debugMarkerMarkerInfoEXT.color[i] );
}
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT const & debugMarkerObjectNameInfoEXT ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectNameInfoEXT.sType );
VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectNameInfoEXT.pNext );
VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectNameInfoEXT.objectType );
VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectNameInfoEXT.object );
for ( const char * p = debugMarkerObjectNameInfoEXT.pObjectName; *p != '\0'; ++p )
{
VULKAN_HPP_HASH_COMBINE( seed, *p );
}
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT const & debugMarkerObjectTagInfoEXT ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectTagInfoEXT.sType );
VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectTagInfoEXT.pNext );
VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectTagInfoEXT.objectType );
VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectTagInfoEXT.object );
VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectTagInfoEXT.tagName );
VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectTagInfoEXT.tagSize );
VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectTagInfoEXT.pTag );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT const & debugReportCallbackCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, debugReportCallbackCreateInfoEXT.sType );
VULKAN_HPP_HASH_COMBINE( seed, debugReportCallbackCreateInfoEXT.pNext );
VULKAN_HPP_HASH_COMBINE( seed, debugReportCallbackCreateInfoEXT.flags );
VULKAN_HPP_HASH_COMBINE( seed, debugReportCallbackCreateInfoEXT.pfnCallback );
VULKAN_HPP_HASH_COMBINE( seed, debugReportCallbackCreateInfoEXT.pUserData );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT const & debugUtilsLabelEXT ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, debugUtilsLabelEXT.sType );
VULKAN_HPP_HASH_COMBINE( seed, debugUtilsLabelEXT.pNext );
for ( const char * p = debugUtilsLabelEXT.pLabelName; *p != '\0'; ++p )
{
VULKAN_HPP_HASH_COMBINE( seed, *p );
}
for ( size_t i = 0; i < 4; ++i )
{
VULKAN_HPP_HASH_COMBINE( seed, debugUtilsLabelEXT.color[i] );
}
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT const & debugUtilsObjectNameInfoEXT ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectNameInfoEXT.sType );
VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectNameInfoEXT.pNext );
VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectNameInfoEXT.objectType );
VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectNameInfoEXT.objectHandle );
for ( const char * p = debugUtilsObjectNameInfoEXT.pObjectName; *p != '\0'; ++p )
{
VULKAN_HPP_HASH_COMBINE( seed, *p );
}