mirror/Vulkan-Hpp
1
0
Fork 0
mirror of https://github.com/KhronosGroup/Vulkan-Hpp.git synced 2024-10-14 16:32:17 +00:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

Replace hardcoded namesapce 'vk::' to 'VULKAN_HPP_NAMESPACE'.

Browse Source
This commit is contained in:
Sho Ikeda 2020-06-18 23:06:58 +09:00
parent 8c2d6d7d05
commit 3abb9592f7
2 changed files with 93 additions and 83 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
VulkanHppGenerator.cpp
View File

@ -1597,7 +1597,7 @@ void VulkanHppGenerator::appendDispatchLoaderDynamic( std::string & str )
// This interface is designed to be used for per-device function pointers in combination with a linked vulkan library. // This interface is designed to be used for per-device function pointers in combination with a linked vulkan library.
template <typename DynamicLoader template <typename DynamicLoader
#if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL #if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL
= vk::DynamicLoader = VULKAN_HPP_NAMESPACE::DynamicLoader
#endif #endif
> >
void init(VULKAN_HPP_NAMESPACE::Instance const& instance, VULKAN_HPP_NAMESPACE::Device const& device) VULKAN_HPP_NOEXCEPT void init(VULKAN_HPP_NAMESPACE::Instance const& instance, VULKAN_HPP_NAMESPACE::Device const& device) VULKAN_HPP_NOEXCEPT
@ -3373,9 +3373,9 @@ void VulkanHppGenerator::appendHashStructures( std::string & str ) const
"namespace std\n" "namespace std\n"
"{\n"; "{\n";
const std::string hashTemplate = R"( template <> struct hash<vk::${type}> const std::string hashTemplate = R"( template <> struct hash<VULKAN_HPP_NAMESPACE::${type}>
{ {
std::size_t operator()(vk::${type} const& ${name}) const VULKAN_HPP_NOEXCEPT std::size_t operator()(VULKAN_HPP_NAMESPACE::${type} const& ${name}) const VULKAN_HPP_NOEXCEPT
{ {
return std::hash<Vk${type}>{}(static_cast<Vk${type}>(${name})); return std::hash<Vk${type}>{}(static_cast<Vk${type}>(${name}));
} }

170
vulkan/vulkan.hpp
View File

@ -97878,7 +97878,7 @@ namespace VULKAN_HPP_NAMESPACE
// library. // library.
template <typename DynamicLoader template <typename DynamicLoader
# if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL # if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL
= vk::DynamicLoader = VULKAN_HPP_NAMESPACE::DynamicLoader
# endif # endif
> >
void init( VULKAN_HPP_NAMESPACE::Instance const & instance, void init( VULKAN_HPP_NAMESPACE::Instance const & instance,
@ -99340,9 +99340,10 @@ namespace VULKAN_HPP_NAMESPACE
namespace std namespace std
{ {
template <> template <>
struct hash<vk::AccelerationStructureKHR> struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureKHR>
{ {
std::size_t operator()( vk::AccelerationStructureKHR const & accelerationStructureKHR ) const VULKAN_HPP_NOEXCEPT std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR const & accelerationStructureKHR ) const
VULKAN_HPP_NOEXCEPT
{ {
return std::hash<VkAccelerationStructureKHR>{}( return std::hash<VkAccelerationStructureKHR>{}(
static_cast<VkAccelerationStructureKHR>( accelerationStructureKHR ) ); static_cast<VkAccelerationStructureKHR>( accelerationStructureKHR ) );
@ -99350,54 +99351,56 @@ namespace std
}; };
template <> template <>
struct hash<vk::Buffer> struct hash<VULKAN_HPP_NAMESPACE::Buffer>
{ {
std::size_t operator()( vk::Buffer const & buffer ) const VULKAN_HPP_NOEXCEPT std::size_t operator()( VULKAN_HPP_NAMESPACE::Buffer const & buffer ) const VULKAN_HPP_NOEXCEPT
{ {
return std::hash<VkBuffer>{}( static_cast<VkBuffer>( buffer ) ); return std::hash<VkBuffer>{}( static_cast<VkBuffer>( buffer ) );
} }
}; };
template <> template <>
struct hash<vk::BufferView> struct hash<VULKAN_HPP_NAMESPACE::BufferView>
{ {
std::size_t operator()( vk::BufferView const & bufferView ) const VULKAN_HPP_NOEXCEPT std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferView const & bufferView ) const VULKAN_HPP_NOEXCEPT
{ {
return std::hash<VkBufferView>{}( static_cast<VkBufferView>( bufferView ) ); return std::hash<VkBufferView>{}( static_cast<VkBufferView>( bufferView ) );
} }
}; };
template <> template <>
struct hash<vk::CommandBuffer> struct hash<VULKAN_HPP_NAMESPACE::CommandBuffer>
{ {
std::size_t operator()( vk::CommandBuffer const & commandBuffer ) const VULKAN_HPP_NOEXCEPT std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBuffer const & commandBuffer ) const VULKAN_HPP_NOEXCEPT
{ {
return std::hash<VkCommandBuffer>{}( static_cast<VkCommandBuffer>( commandBuffer ) ); return std::hash<VkCommandBuffer>{}( static_cast<VkCommandBuffer>( commandBuffer ) );
} }
}; };
template <> template <>
struct hash<vk::CommandPool> struct hash<VULKAN_HPP_NAMESPACE::CommandPool>
{ {
std::size_t operator()( vk::CommandPool const & commandPool ) const VULKAN_HPP_NOEXCEPT std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandPool const & commandPool ) const VULKAN_HPP_NOEXCEPT
{ {
return std::hash<VkCommandPool>{}( static_cast<VkCommandPool>( commandPool ) ); return std::hash<VkCommandPool>{}( static_cast<VkCommandPool>( commandPool ) );
} }
}; };
template <> template <>
struct hash<vk::DebugReportCallbackEXT> struct hash<VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT>
{ {
std::size_t operator()( vk::DebugReportCallbackEXT const & debugReportCallbackEXT ) const VULKAN_HPP_NOEXCEPT std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT const & debugReportCallbackEXT ) const
VULKAN_HPP_NOEXCEPT
{ {
return std::hash<VkDebugReportCallbackEXT>{}( static_cast<VkDebugReportCallbackEXT>( debugReportCallbackEXT ) ); return std::hash<VkDebugReportCallbackEXT>{}( static_cast<VkDebugReportCallbackEXT>( debugReportCallbackEXT ) );
} }
}; };
template <> template <>
struct hash<vk::DebugUtilsMessengerEXT> struct hash<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT>
{ {
std::size_t operator()( vk::DebugUtilsMessengerEXT const & debugUtilsMessengerEXT ) const VULKAN_HPP_NOEXCEPT std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT const & debugUtilsMessengerEXT ) const
VULKAN_HPP_NOEXCEPT
{ {
return std::hash<VkDebugUtilsMessengerEXT>{}( static_cast<VkDebugUtilsMessengerEXT>( debugUtilsMessengerEXT ) ); return std::hash<VkDebugUtilsMessengerEXT>{}( static_cast<VkDebugUtilsMessengerEXT>( debugUtilsMessengerEXT ) );
} }
@ -99405,9 +99408,10 @@ namespace std
#ifdef VK_ENABLE_BETA_EXTENSIONS #ifdef VK_ENABLE_BETA_EXTENSIONS
template <> template <>
struct hash<vk::DeferredOperationKHR> struct hash<VULKAN_HPP_NAMESPACE::DeferredOperationKHR>
{ {
std::size_t operator()( vk::DeferredOperationKHR const & deferredOperationKHR ) const VULKAN_HPP_NOEXCEPT std::size_t
operator()( VULKAN_HPP_NAMESPACE::DeferredOperationKHR const & deferredOperationKHR ) const VULKAN_HPP_NOEXCEPT
{ {
return std::hash<VkDeferredOperationKHR>{}( static_cast<VkDeferredOperationKHR>( deferredOperationKHR ) ); return std::hash<VkDeferredOperationKHR>{}( static_cast<VkDeferredOperationKHR>( deferredOperationKHR ) );
} }
@ -99415,36 +99419,38 @@ namespace std
#endif /*VK_ENABLE_BETA_EXTENSIONS*/ #endif /*VK_ENABLE_BETA_EXTENSIONS*/
template <> template <>
struct hash<vk::DescriptorPool> struct hash<VULKAN_HPP_NAMESPACE::DescriptorPool>
{ {
std::size_t operator()( vk::DescriptorPool const & descriptorPool ) const VULKAN_HPP_NOEXCEPT std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorPool const & descriptorPool ) const VULKAN_HPP_NOEXCEPT
{ {
return std::hash<VkDescriptorPool>{}( static_cast<VkDescriptorPool>( descriptorPool ) ); return std::hash<VkDescriptorPool>{}( static_cast<VkDescriptorPool>( descriptorPool ) );
} }
}; };
template <> template <>
struct hash<vk::DescriptorSet> struct hash<VULKAN_HPP_NAMESPACE::DescriptorSet>
{ {
std::size_t operator()( vk::DescriptorSet const & descriptorSet ) const VULKAN_HPP_NOEXCEPT std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSet const & descriptorSet ) const VULKAN_HPP_NOEXCEPT
{ {
return std::hash<VkDescriptorSet>{}( static_cast<VkDescriptorSet>( descriptorSet ) ); return std::hash<VkDescriptorSet>{}( static_cast<VkDescriptorSet>( descriptorSet ) );
} }
}; };
template <> template <>
struct hash<vk::DescriptorSetLayout> struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetLayout>
{ {
std::size_t operator()( vk::DescriptorSetLayout const & descriptorSetLayout ) const VULKAN_HPP_NOEXCEPT std::size_t
operator()( VULKAN_HPP_NAMESPACE::DescriptorSetLayout const & descriptorSetLayout ) const VULKAN_HPP_NOEXCEPT
{ {
return std::hash<VkDescriptorSetLayout>{}( static_cast<VkDescriptorSetLayout>( descriptorSetLayout ) ); return std::hash<VkDescriptorSetLayout>{}( static_cast<VkDescriptorSetLayout>( descriptorSetLayout ) );
} }
}; };
template <> template <>
struct hash<vk::DescriptorUpdateTemplate> struct hash<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate>
{ {
std::size_t operator()( vk::DescriptorUpdateTemplate const & descriptorUpdateTemplate ) const VULKAN_HPP_NOEXCEPT std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate const & descriptorUpdateTemplate ) const
VULKAN_HPP_NOEXCEPT
{ {
return std::hash<VkDescriptorUpdateTemplate>{}( return std::hash<VkDescriptorUpdateTemplate>{}(
static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ) ); static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ) );
@ -99452,90 +99458,91 @@ namespace std
}; };
template <> template <>
struct hash<vk::Device> struct hash<VULKAN_HPP_NAMESPACE::Device>
{ {
std::size_t operator()( vk::Device const & device ) const VULKAN_HPP_NOEXCEPT std::size_t operator()( VULKAN_HPP_NAMESPACE::Device const & device ) const VULKAN_HPP_NOEXCEPT
{ {
return std::hash<VkDevice>{}( static_cast<VkDevice>( device ) ); return std::hash<VkDevice>{}( static_cast<VkDevice>( device ) );
} }
}; };
template <> template <>
struct hash<vk::DeviceMemory> struct hash<VULKAN_HPP_NAMESPACE::DeviceMemory>
{ {
std::size_t operator()( vk::DeviceMemory const & deviceMemory ) const VULKAN_HPP_NOEXCEPT std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceMemory const & deviceMemory ) const VULKAN_HPP_NOEXCEPT
{ {
return std::hash<VkDeviceMemory>{}( static_cast<VkDeviceMemory>( deviceMemory ) ); return std::hash<VkDeviceMemory>{}( static_cast<VkDeviceMemory>( deviceMemory ) );
} }
}; };
template <> template <>
struct hash<vk::DisplayKHR> struct hash<VULKAN_HPP_NAMESPACE::DisplayKHR>
{ {
std::size_t operator()( vk::DisplayKHR const & displayKHR ) const VULKAN_HPP_NOEXCEPT std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayKHR const & displayKHR ) const VULKAN_HPP_NOEXCEPT
{ {
return std::hash<VkDisplayKHR>{}( static_cast<VkDisplayKHR>( displayKHR ) ); return std::hash<VkDisplayKHR>{}( static_cast<VkDisplayKHR>( displayKHR ) );
} }
}; };
template <> template <>
struct hash<vk::DisplayModeKHR> struct hash<VULKAN_HPP_NAMESPACE::DisplayModeKHR>
{ {
std::size_t operator()( vk::DisplayModeKHR const & displayModeKHR ) const VULKAN_HPP_NOEXCEPT std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayModeKHR const & displayModeKHR ) const VULKAN_HPP_NOEXCEPT
{ {
return std::hash<VkDisplayModeKHR>{}( static_cast<VkDisplayModeKHR>( displayModeKHR ) ); return std::hash<VkDisplayModeKHR>{}( static_cast<VkDisplayModeKHR>( displayModeKHR ) );
} }
}; };
template <> template <>
struct hash<vk::Event> struct hash<VULKAN_HPP_NAMESPACE::Event>
{ {
std::size_t operator()( vk::Event const & event ) const VULKAN_HPP_NOEXCEPT std::size_t operator()( VULKAN_HPP_NAMESPACE::Event const & event ) const VULKAN_HPP_NOEXCEPT
{ {
return std::hash<VkEvent>{}( static_cast<VkEvent>( event ) ); return std::hash<VkEvent>{}( static_cast<VkEvent>( event ) );
} }
}; };
template <> template <>
struct hash<vk::Fence> struct hash<VULKAN_HPP_NAMESPACE::Fence>
{ {
std::size_t operator()( vk::Fence const & fence ) const VULKAN_HPP_NOEXCEPT std::size_t operator()( VULKAN_HPP_NAMESPACE::Fence const & fence ) const VULKAN_HPP_NOEXCEPT
{ {
return std::hash<VkFence>{}( static_cast<VkFence>( fence ) ); return std::hash<VkFence>{}( static_cast<VkFence>( fence ) );
} }
}; };
template <> template <>
struct hash<vk::Framebuffer> struct hash<VULKAN_HPP_NAMESPACE::Framebuffer>
{ {
std::size_t operator()( vk::Framebuffer const & framebuffer ) const VULKAN_HPP_NOEXCEPT std::size_t operator()( VULKAN_HPP_NAMESPACE::Framebuffer const & framebuffer ) const VULKAN_HPP_NOEXCEPT
{ {
return std::hash<VkFramebuffer>{}( static_cast<VkFramebuffer>( framebuffer ) ); return std::hash<VkFramebuffer>{}( static_cast<VkFramebuffer>( framebuffer ) );
} }
}; };
template <> template <>
struct hash<vk::Image> struct hash<VULKAN_HPP_NAMESPACE::Image>
{ {
std::size_t operator()( vk::Image const & image ) const VULKAN_HPP_NOEXCEPT std::size_t operator()( VULKAN_HPP_NAMESPACE::Image const & image ) const VULKAN_HPP_NOEXCEPT
{ {
return std::hash<VkImage>{}( static_cast<VkImage>( image ) ); return std::hash<VkImage>{}( static_cast<VkImage>( image ) );
} }
}; };
template <> template <>
struct hash<vk::ImageView> struct hash<VULKAN_HPP_NAMESPACE::ImageView>
{ {
std::size_t operator()( vk::ImageView const & imageView ) const VULKAN_HPP_NOEXCEPT std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageView const & imageView ) const VULKAN_HPP_NOEXCEPT
{ {
return std::hash<VkImageView>{}( static_cast<VkImageView>( imageView ) ); return std::hash<VkImageView>{}( static_cast<VkImageView>( imageView ) );
} }
}; };
template <> template <>
struct hash<vk::IndirectCommandsLayoutNV> struct hash<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV>
{ {
std::size_t operator()( vk::IndirectCommandsLayoutNV const & indirectCommandsLayoutNV ) const VULKAN_HPP_NOEXCEPT std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV const & indirectCommandsLayoutNV ) const
VULKAN_HPP_NOEXCEPT
{ {
return std::hash<VkIndirectCommandsLayoutNV>{}( return std::hash<VkIndirectCommandsLayoutNV>{}(
static_cast<VkIndirectCommandsLayoutNV>( indirectCommandsLayoutNV ) ); static_cast<VkIndirectCommandsLayoutNV>( indirectCommandsLayoutNV ) );
@ -99543,19 +99550,19 @@ namespace std
}; };
template <> template <>
struct hash<vk::Instance> struct hash<VULKAN_HPP_NAMESPACE::Instance>
{ {
std::size_t operator()( vk::Instance const & instance ) const VULKAN_HPP_NOEXCEPT std::size_t operator()( VULKAN_HPP_NAMESPACE::Instance const & instance ) const VULKAN_HPP_NOEXCEPT
{ {
return std::hash<VkInstance>{}( static_cast<VkInstance>( instance ) ); return std::hash<VkInstance>{}( static_cast<VkInstance>( instance ) );
} }
}; };
template <> template <>
struct hash<vk::PerformanceConfigurationINTEL> struct hash<VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL>
{ {
std::size_t std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL const & performanceConfigurationINTEL )
operator()( vk::PerformanceConfigurationINTEL const & performanceConfigurationINTEL ) const VULKAN_HPP_NOEXCEPT const VULKAN_HPP_NOEXCEPT
{ {
return std::hash<VkPerformanceConfigurationINTEL>{}( return std::hash<VkPerformanceConfigurationINTEL>{}(
static_cast<VkPerformanceConfigurationINTEL>( performanceConfigurationINTEL ) ); static_cast<VkPerformanceConfigurationINTEL>( performanceConfigurationINTEL ) );
@ -99563,135 +99570,138 @@ namespace std
}; };
template <> template <>
struct hash<vk::PhysicalDevice> struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevice>
{ {
std::size_t operator()( vk::PhysicalDevice const & physicalDevice ) const VULKAN_HPP_NOEXCEPT std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevice const & physicalDevice ) const VULKAN_HPP_NOEXCEPT
{ {
return std::hash<VkPhysicalDevice>{}( static_cast<VkPhysicalDevice>( physicalDevice ) ); return std::hash<VkPhysicalDevice>{}( static_cast<VkPhysicalDevice>( physicalDevice ) );
} }
}; };
template <> template <>
struct hash<vk::Pipeline> struct hash<VULKAN_HPP_NAMESPACE::Pipeline>
{ {
std::size_t operator()( vk::Pipeline const & pipeline ) const VULKAN_HPP_NOEXCEPT std::size_t operator()( VULKAN_HPP_NAMESPACE::Pipeline const & pipeline ) const VULKAN_HPP_NOEXCEPT
{ {
return std::hash<VkPipeline>{}( static_cast<VkPipeline>( pipeline ) ); return std::hash<VkPipeline>{}( static_cast<VkPipeline>( pipeline ) );
} }
}; };
template <> template <>
struct hash<vk::PipelineCache> struct hash<VULKAN_HPP_NAMESPACE::PipelineCache>
{ {
std::size_t operator()( vk::PipelineCache const & pipelineCache ) const VULKAN_HPP_NOEXCEPT std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCache const & pipelineCache ) const VULKAN_HPP_NOEXCEPT
{ {
return std::hash<VkPipelineCache>{}( static_cast<VkPipelineCache>( pipelineCache ) ); return std::hash<VkPipelineCache>{}( static_cast<VkPipelineCache>( pipelineCache ) );
} }
}; };
template <> template <>
struct hash<vk::PipelineLayout> struct hash<VULKAN_HPP_NAMESPACE::PipelineLayout>
{ {
std::size_t operator()( vk::PipelineLayout const & pipelineLayout ) const VULKAN_HPP_NOEXCEPT std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineLayout const & pipelineLayout ) const VULKAN_HPP_NOEXCEPT
{ {
return std::hash<VkPipelineLayout>{}( static_cast<VkPipelineLayout>( pipelineLayout ) ); return std::hash<VkPipelineLayout>{}( static_cast<VkPipelineLayout>( pipelineLayout ) );
} }
}; };
template <> template <>
struct hash<vk::PrivateDataSlotEXT> struct hash<VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT>
{ {
std::size_t operator()( vk::PrivateDataSlotEXT const & privateDataSlotEXT ) const VULKAN_HPP_NOEXCEPT std::size_t
operator()( VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT const & privateDataSlotEXT ) const VULKAN_HPP_NOEXCEPT
{ {
return std::hash<VkPrivateDataSlotEXT>{}( static_cast<VkPrivateDataSlotEXT>( privateDataSlotEXT ) ); return std::hash<VkPrivateDataSlotEXT>{}( static_cast<VkPrivateDataSlotEXT>( privateDataSlotEXT ) );
} }
}; };
template <> template <>
struct hash<vk::QueryPool> struct hash<VULKAN_HPP_NAMESPACE::QueryPool>
{ {
std::size_t operator()( vk::QueryPool const & queryPool ) const VULKAN_HPP_NOEXCEPT std::size_t operator()( VULKAN_HPP_NAMESPACE::QueryPool const & queryPool ) const VULKAN_HPP_NOEXCEPT
{ {
return std::hash<VkQueryPool>{}( static_cast<VkQueryPool>( queryPool ) ); return std::hash<VkQueryPool>{}( static_cast<VkQueryPool>( queryPool ) );
} }
}; };
template <> template <>
struct hash<vk::Queue> struct hash<VULKAN_HPP_NAMESPACE::Queue>
{ {
std::size_t operator()( vk::Queue const & queue ) const VULKAN_HPP_NOEXCEPT std::size_t operator()( VULKAN_HPP_NAMESPACE::Queue const & queue ) const VULKAN_HPP_NOEXCEPT
{ {
return std::hash<VkQueue>{}( static_cast<VkQueue>( queue ) ); return std::hash<VkQueue>{}( static_cast<VkQueue>( queue ) );
} }
}; };
template <> template <>
struct hash<vk::RenderPass> struct hash<VULKAN_HPP_NAMESPACE::RenderPass>
{ {
std::size_t operator()( vk::RenderPass const & renderPass ) const VULKAN_HPP_NOEXCEPT std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPass const & renderPass ) const VULKAN_HPP_NOEXCEPT
{ {
return std::hash<VkRenderPass>{}( static_cast<VkRenderPass>( renderPass ) ); return std::hash<VkRenderPass>{}( static_cast<VkRenderPass>( renderPass ) );
} }
}; };
template <> template <>
struct hash<vk::Sampler> struct hash<VULKAN_HPP_NAMESPACE::Sampler>
{ {
std::size_t operator()( vk::Sampler const & sampler ) const VULKAN_HPP_NOEXCEPT std::size_t operator()( VULKAN_HPP_NAMESPACE::Sampler const & sampler ) const VULKAN_HPP_NOEXCEPT
{ {
return std::hash<VkSampler>{}( static_cast<VkSampler>( sampler ) ); return std::hash<VkSampler>{}( static_cast<VkSampler>( sampler ) );
} }
}; };
template <> template <>
struct hash<vk::SamplerYcbcrConversion> struct hash<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion>
{ {
std::size_t operator()( vk::SamplerYcbcrConversion const & samplerYcbcrConversion ) const VULKAN_HPP_NOEXCEPT std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion const & samplerYcbcrConversion ) const
VULKAN_HPP_NOEXCEPT
{ {
return std::hash<VkSamplerYcbcrConversion>{}( static_cast<VkSamplerYcbcrConversion>( samplerYcbcrConversion ) ); return std::hash<VkSamplerYcbcrConversion>{}( static_cast<VkSamplerYcbcrConversion>( samplerYcbcrConversion ) );
} }
}; };
template <> template <>
struct hash<vk::Semaphore> struct hash<VULKAN_HPP_NAMESPACE::Semaphore>
{ {
std::size_t operator()( vk::Semaphore const & semaphore ) const VULKAN_HPP_NOEXCEPT std::size_t operator()( VULKAN_HPP_NAMESPACE::Semaphore const & semaphore ) const VULKAN_HPP_NOEXCEPT
{ {
return std::hash<VkSemaphore>{}( static_cast<VkSemaphore>( semaphore ) ); return std::hash<VkSemaphore>{}( static_cast<VkSemaphore>( semaphore ) );
} }
}; };
template <> template <>
struct hash<vk::ShaderModule> struct hash<VULKAN_HPP_NAMESPACE::ShaderModule>
{ {
std::size_t operator()( vk::ShaderModule const & shaderModule ) const VULKAN_HPP_NOEXCEPT std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderModule const & shaderModule ) const VULKAN_HPP_NOEXCEPT
{ {
return std::hash<VkShaderModule>{}( static_cast<VkShaderModule>( shaderModule ) ); return std::hash<VkShaderModule>{}( static_cast<VkShaderModule>( shaderModule ) );
} }
}; };
template <> template <>
struct hash<vk::SurfaceKHR> struct hash<VULKAN_HPP_NAMESPACE::SurfaceKHR>
{ {
std::size_t operator()( vk::SurfaceKHR const & surfaceKHR ) const VULKAN_HPP_NOEXCEPT std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceKHR const & surfaceKHR ) const VULKAN_HPP_NOEXCEPT
{ {
return std::hash<VkSurfaceKHR>{}( static_cast<VkSurfaceKHR>( surfaceKHR ) ); return std::hash<VkSurfaceKHR>{}( static_cast<VkSurfaceKHR>( surfaceKHR ) );
} }
}; };
template <> template <>
struct hash<vk::SwapchainKHR> struct hash<VULKAN_HPP_NAMESPACE::SwapchainKHR>
{ {
std::size_t operator()( vk::SwapchainKHR const & swapchainKHR ) const VULKAN_HPP_NOEXCEPT std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainKHR const & swapchainKHR ) const VULKAN_HPP_NOEXCEPT
{ {
return std::hash<VkSwapchainKHR>{}( static_cast<VkSwapchainKHR>( swapchainKHR ) ); return std::hash<VkSwapchainKHR>{}( static_cast<VkSwapchainKHR>( swapchainKHR ) );
} }
}; };
template <> template <>
struct hash<vk::ValidationCacheEXT> struct hash<VULKAN_HPP_NAMESPACE::ValidationCacheEXT>
{ {
std::size_t operator()( vk::ValidationCacheEXT const & validationCacheEXT ) const VULKAN_HPP_NOEXCEPT std::size_t
operator()( VULKAN_HPP_NAMESPACE::ValidationCacheEXT const & validationCacheEXT ) const VULKAN_HPP_NOEXCEPT
{ {
return std::hash<VkValidationCacheEXT>{}( static_cast<VkValidationCacheEXT>( validationCacheEXT ) ); return std::hash<VkValidationCacheEXT>{}( static_cast<VkValidationCacheEXT>( validationCacheEXT ) );
} }