From nobody Mon Dec 13 12:20:34 2021 X-Original-To: dev-commits-ports-main@mlmmj.nyi.freebsd.org Received: from mx1.freebsd.org (mx1.freebsd.org [IPv6:2610:1c1:1:606c::19:1]) by mlmmj.nyi.freebsd.org (Postfix) with ESMTP id E820B18E97BF; Mon, 13 Dec 2021 12:20:34 +0000 (UTC) (envelope-from git@FreeBSD.org) Received: from mxrelay.nyi.freebsd.org (mxrelay.nyi.freebsd.org [IPv6:2610:1c1:1:606c::19:3]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256 client-signature RSA-PSS (4096 bits) client-digest SHA256) (Client CN "mxrelay.nyi.freebsd.org", Issuer "R3" (verified OK)) by mx1.freebsd.org (Postfix) with ESMTPS id 4JCLFG4gR3z4kNH; Mon, 13 Dec 2021 12:20:34 +0000 (UTC) (envelope-from git@FreeBSD.org) Received: from gitrepo.freebsd.org (gitrepo.freebsd.org [IPv6:2610:1c1:1:6068::e6a:5]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (Client did not present a certificate) by mxrelay.nyi.freebsd.org (Postfix) with ESMTPS id 8165614660; Mon, 13 Dec 2021 12:20:34 +0000 (UTC) (envelope-from git@FreeBSD.org) Received: from gitrepo.freebsd.org ([127.0.1.44]) by gitrepo.freebsd.org (8.16.1/8.16.1) with ESMTP id 1BDCKYqY015816; Mon, 13 Dec 2021 12:20:34 GMT (envelope-from git@gitrepo.freebsd.org) Received: (from git@localhost) by gitrepo.freebsd.org (8.16.1/8.16.1/Submit) id 1BDCKYaa015815; Mon, 13 Dec 2021 12:20:34 GMT (envelope-from git) Date: Mon, 13 Dec 2021 12:20:34 GMT Message-Id: <202112131220.1BDCKYaa015815@gitrepo.freebsd.org> To: ports-committers@FreeBSD.org, dev-commits-ports-all@FreeBSD.org, dev-commits-ports-main@FreeBSD.org From: Jan Beich Subject: git: db70f7d7b329 - main - graphics/vulkan-headers: replace std::hash workaround with upstream fix List-Id: Commits to the main branch of the FreeBSD ports repository List-Archive: https://lists.freebsd.org/archives/dev-commits-ports-main List-Help: List-Post: List-Subscribe: List-Unsubscribe: Sender: owner-dev-commits-ports-main@freebsd.org X-BeenThere: dev-commits-ports-main@freebsd.org MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: 8bit X-Git-Committer: jbeich X-Git-Repository: ports X-Git-Refname: refs/heads/main X-Git-Reftype: branch X-Git-Commit: db70f7d7b329c1b429363e3541204ae3096ce8ce Auto-Submitted: auto-generated ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=freebsd.org; s=dkim; t=1639398034; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding; bh=aNdGCacrA1JO4ccbQFmk5Igqx97GhXP0Dvir6cfwhsQ=; b=l3EL8133Ydc8ckoucnJMv+xT2BNaOl9cof4+CzlFTnkbe+j7IMYwlQEITZr+DvQRWKpcPx /oHZDXFdlxXg7jxjqufeuwclww+MkaBfN5sI7kNij17QMs7jZPVLcXKiglFaADsDx8I/nJ RdtodacJa3lDVSgsl3/JUSKc9NuV0j54TYP+n++AK0nx9fx/3KQGHn2BvqDy7hHEhjGKlS r0kSWBLNi4FcbMrw/0RNhIQCUXVRS2FdAj3tLkgdhBpBEkXrCnyjXr78AZ1DsDHb1/EsVg QCOPNXsaNHWpmZjmd2H4llbvbAGcZstyo4/A9xOz4JDQUFks7lHyCMsXgy2JYg== ARC-Seal: i=1; s=dkim; d=freebsd.org; t=1639398034; a=rsa-sha256; cv=none; b=s5il/RWK3sQSI5wUa6MrV3UKeDULBjmRTW97DesoXD9R0saruLyaf0jqFTvUs7YI1JHh2y JbOGcytWg8TZlzO0pzRepCSgSRjBQq1O+08eDBz/0Fa7MNH7eHllckgV3RmcrK7trk9BXZ a6jk3//aD5Iam24SVVlbhxwKaOstZTNheeE2xJW0GJQ9Ip6VAlOF+mBAHRqfVgDHBjOXaj /f74e5oyxSpZlba3wmyN62My6xsb99HnuepCAr9zul6/Hq4GpuYgBxYEr6riULgKQk73Nz 01hTuH2oPUrBTqdl2qv88hNIXGSr1jJP6yE//AXjaTztnbfHYErADPEYJ5J4Jg== ARC-Authentication-Results: i=1; mx1.freebsd.org; none X-ThisMailContainsUnwantedMimeParts: N The branch main has been updated by jbeich: URL: https://cgit.FreeBSD.org/ports/commit/?id=db70f7d7b329c1b429363e3541204ae3096ce8ce commit db70f7d7b329c1b429363e3541204ae3096ce8ce Author: Jan Beich AuthorDate: 2021-12-13 12:10:13 +0000 Commit: Jan Beich CommitDate: 2021-12-13 12:20:14 +0000 graphics/vulkan-headers: replace std::hash workaround with upstream fix --- .../warzone2100/files/patch-vulkan-headers-1.2.202 | 30 - graphics/vulkan-headers/Makefile | 1 + .../files/patch-include_vulkan_vulkan.hpp | 30 - graphics/vulkan-headers/files/patch-vulkan-hpp | 35141 +++++++++++++++++++ graphics/vulkan-headers/pkg-plist | 1 + 5 files changed, 35143 insertions(+), 60 deletions(-) diff --git a/games/warzone2100/files/patch-vulkan-headers-1.2.202 b/games/warzone2100/files/patch-vulkan-headers-1.2.202 deleted file mode 100644 index 94c67b83349f..000000000000 --- a/games/warzone2100/files/patch-vulkan-headers-1.2.202 +++ /dev/null @@ -1,30 +0,0 @@ -In file included from warzone2100-4.0.1/lib/ivis_opengl/gfx_api_vk.cpp:42: -lib/ivis_opengl/gfx_api_vk.h:123:9: error: redefinition of 'hash' - struct hash - ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -/usr/local/include/vulkan/vulkan_structs.hpp:20333:13: note: previous definition is here -struct std::hash - ^ - ---- lib/ivis_opengl/gfx_api_vk.h.orig 2021-04-18 18:28:41 UTC -+++ lib/ivis_opengl/gfx_api_vk.h -@@ -118,19 +118,6 @@ inline void hash_combine(std::size_t& seed, const T& v - #endif - hash_combine(seed, rest...); - } --namespace std { -- template <> -- struct hash -- { -- std::size_t operator()(const vk::DescriptorBufferInfo& k) const -- { -- std::size_t h = 0; -- hash_combine(h, static_cast(k.buffer), k.offset, k.range); -- return h; -- } -- }; --} -- - struct BlockBufferAllocator - { - BlockBufferAllocator(VmaAllocator allocator, uint32_t minimumBlockSize, const vk::BufferUsageFlags& usageFlags, const VmaAllocationCreateInfo& allocInfo, bool autoMap = false); diff --git a/graphics/vulkan-headers/Makefile b/graphics/vulkan-headers/Makefile index 5d89bac9c1ec..c1e5ac8d11ad 100644 --- a/graphics/vulkan-headers/Makefile +++ b/graphics/vulkan-headers/Makefile @@ -1,6 +1,7 @@ PORTNAME= vulkan-headers DISTVERSIONPREFIX= v DISTVERSION= 1.2.202 +PORTREVISION= 1 CATEGORIES= graphics MAINTAINER= jbeich@FreeBSD.org diff --git a/graphics/vulkan-headers/files/patch-include_vulkan_vulkan.hpp b/graphics/vulkan-headers/files/patch-include_vulkan_vulkan.hpp deleted file mode 100644 index edb4a98c9d2e..000000000000 --- a/graphics/vulkan-headers/files/patch-include_vulkan_vulkan.hpp +++ /dev/null @@ -1,30 +0,0 @@ -https://github.com/KhronosGroup/Vulkan-Hpp/issues/1161 - ---- include/vulkan/vulkan.hpp.orig 2021-12-07 09:36:34 UTC -+++ include/vulkan/vulkan.hpp -@@ -234,9 +234,23 @@ static_assert( VK_HEADER_VERSION == 202, "Wrong VK_HEA - # define VULKAN_HPP_NAMESPACE vk - #endif - -+template ::type> -+struct safe_underlying_type -+{ -+ using type = T; -+}; -+ -+template -+struct safe_underlying_type -+{ -+ using type = typename std::underlying_type::type; -+}; -+ - #if !defined( VULKAN_HPP_HASH_COMBINE ) --# define VULKAN_HPP_HASH_COMBINE( valueType, seed, value ) \ -- seed ^= std::hash::type>{}( value ) + 0x9e3779b9 + ( seed << 6 ) + ( seed >> 2 ) -+# define VULKAN_HPP_HASH_COMBINE( valueType, seed, value ) \ -+ seed ^= std::hash::type>::type>{}( \ -+ static_cast::type>( value ) ) + \ -+ 0x9e3779b9 + ( seed << 6 ) + ( seed >> 2 ) - #endif - - #define VULKAN_HPP_STRINGIFY2( text ) #text diff --git a/graphics/vulkan-headers/files/patch-vulkan-hpp b/graphics/vulkan-headers/files/patch-vulkan-hpp new file mode 100644 index 000000000000..8f4e9dcc5507 --- /dev/null +++ b/graphics/vulkan-headers/files/patch-vulkan-hpp @@ -0,0 +1,35141 @@ +https://github.com/KhronosGroup/Vulkan-Hpp/pull/1165 (c7751f7725a4) + +--- include/vulkan/vulkan.hpp.orig 2021-12-07 09:36:34 UTC ++++ include/vulkan/vulkan.hpp +@@ -234,11 +234,6 @@ static_assert( VK_HEADER_VERSION == 202, "Wrong VK_HEA + # define VULKAN_HPP_NAMESPACE vk + #endif + +-#if !defined( VULKAN_HPP_HASH_COMBINE ) +-# define VULKAN_HPP_HASH_COMBINE( valueType, seed, value ) \ +- seed ^= std::hash::type>{}( value ) + 0x9e3779b9 + ( seed << 6 ) + ( seed >> 2 ) +-#endif +- + #define VULKAN_HPP_STRINGIFY2( text ) #text + #define VULKAN_HPP_STRINGIFY( text ) VULKAN_HPP_STRINGIFY2( text ) + #define VULKAN_HPP_NAMESPACE_STRING VULKAN_HPP_STRINGIFY( VULKAN_HPP_NAMESPACE ) +@@ -818,20 +813,7 @@ namespace VULKAN_HPP_NAMESPACE + { + return flags.operator^( bit ); + } +-} // namespace VULKAN_HPP_NAMESPACE + +-template +-struct std::hash> +-{ +- std::size_t operator()( VULKAN_HPP_NAMESPACE::Flags const & flags ) const VULKAN_HPP_NOEXCEPT +- { +- return std::hash::type>{}( +- static_cast::type>( flags ) ); +- } +-}; +- +-namespace VULKAN_HPP_NAMESPACE +-{ + template + class Optional + { +--- include/vulkan/vulkan_handles.hpp.orig 2021-12-07 09:36:34 UTC ++++ include/vulkan/vulkan_handles.hpp +@@ -14531,476 +14531,4 @@ namespace VULKAN_HPP_NAMESPACE + #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + } // namespace VULKAN_HPP_NAMESPACE +- +-namespace std +-{ +- //======================= +- //=== HASH structures === +- //======================= +- +- //=== VK_VERSION_1_0 === +- +- template <> +- struct hash +- { +- std::size_t operator()( VULKAN_HPP_NAMESPACE::Instance const & instance ) const VULKAN_HPP_NOEXCEPT +- { +- return std::hash{}( static_cast( instance ) ); +- } +- }; +- +- template <> +- struct hash +- { +- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevice const & physicalDevice ) const VULKAN_HPP_NOEXCEPT +- { +- return std::hash{}( static_cast( physicalDevice ) ); +- } +- }; +- +- template <> +- struct hash +- { +- std::size_t operator()( VULKAN_HPP_NAMESPACE::Device const & device ) const VULKAN_HPP_NOEXCEPT +- { +- return std::hash{}( static_cast( device ) ); +- } +- }; +- +- template <> +- struct hash +- { +- std::size_t operator()( VULKAN_HPP_NAMESPACE::Queue const & queue ) const VULKAN_HPP_NOEXCEPT +- { +- return std::hash{}( static_cast( queue ) ); +- } +- }; +- +- template <> +- struct hash +- { +- std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceMemory const & deviceMemory ) const VULKAN_HPP_NOEXCEPT +- { +- return std::hash{}( static_cast( deviceMemory ) ); +- } +- }; +- +- template <> +- struct hash +- { +- std::size_t operator()( VULKAN_HPP_NAMESPACE::Fence const & fence ) const VULKAN_HPP_NOEXCEPT +- { +- return std::hash{}( static_cast( fence ) ); +- } +- }; +- +- template <> +- struct hash +- { +- std::size_t operator()( VULKAN_HPP_NAMESPACE::Semaphore const & semaphore ) const VULKAN_HPP_NOEXCEPT +- { +- return std::hash{}( static_cast( semaphore ) ); +- } +- }; +- +- template <> +- struct hash +- { +- std::size_t operator()( VULKAN_HPP_NAMESPACE::Event const & event ) const VULKAN_HPP_NOEXCEPT +- { +- return std::hash{}( static_cast( event ) ); +- } +- }; +- +- template <> +- struct hash +- { +- std::size_t operator()( VULKAN_HPP_NAMESPACE::QueryPool const & queryPool ) const VULKAN_HPP_NOEXCEPT +- { +- return std::hash{}( static_cast( queryPool ) ); +- } +- }; +- +- template <> +- struct hash +- { +- std::size_t operator()( VULKAN_HPP_NAMESPACE::Buffer const & buffer ) const VULKAN_HPP_NOEXCEPT +- { +- return std::hash{}( static_cast( buffer ) ); +- } +- }; +- +- template <> +- struct hash +- { +- std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferView const & bufferView ) const VULKAN_HPP_NOEXCEPT +- { +- return std::hash{}( static_cast( bufferView ) ); +- } +- }; +- +- template <> +- struct hash +- { +- std::size_t operator()( VULKAN_HPP_NAMESPACE::Image const & image ) const VULKAN_HPP_NOEXCEPT +- { +- return std::hash{}( static_cast( image ) ); +- } +- }; +- +- template <> +- struct hash +- { +- std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageView const & imageView ) const VULKAN_HPP_NOEXCEPT +- { +- return std::hash{}( static_cast( imageView ) ); +- } +- }; +- +- template <> +- struct hash +- { +- std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderModule const & shaderModule ) const VULKAN_HPP_NOEXCEPT +- { +- return std::hash{}( static_cast( shaderModule ) ); +- } +- }; +- +- template <> +- struct hash +- { +- std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCache const & pipelineCache ) const VULKAN_HPP_NOEXCEPT +- { +- return std::hash{}( static_cast( pipelineCache ) ); +- } +- }; +- +- template <> +- struct hash +- { +- std::size_t operator()( VULKAN_HPP_NAMESPACE::Pipeline const & pipeline ) const VULKAN_HPP_NOEXCEPT +- { +- return std::hash{}( static_cast( pipeline ) ); +- } +- }; +- +- template <> +- struct hash +- { +- std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineLayout const & pipelineLayout ) const VULKAN_HPP_NOEXCEPT +- { +- return std::hash{}( static_cast( pipelineLayout ) ); +- } +- }; +- +- template <> +- struct hash +- { +- std::size_t operator()( VULKAN_HPP_NAMESPACE::Sampler const & sampler ) const VULKAN_HPP_NOEXCEPT +- { +- return std::hash{}( static_cast( sampler ) ); +- } +- }; +- +- template <> +- struct hash +- { +- std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorPool const & descriptorPool ) const VULKAN_HPP_NOEXCEPT +- { +- return std::hash{}( static_cast( descriptorPool ) ); +- } +- }; +- +- template <> +- struct hash +- { +- std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSet const & descriptorSet ) const VULKAN_HPP_NOEXCEPT +- { +- return std::hash{}( static_cast( descriptorSet ) ); +- } +- }; +- +- template <> +- struct hash +- { +- std::size_t +- operator()( VULKAN_HPP_NAMESPACE::DescriptorSetLayout const & descriptorSetLayout ) const VULKAN_HPP_NOEXCEPT +- { +- return std::hash{}( static_cast( descriptorSetLayout ) ); +- } +- }; +- +- template <> +- struct hash +- { +- std::size_t operator()( VULKAN_HPP_NAMESPACE::Framebuffer const & framebuffer ) const VULKAN_HPP_NOEXCEPT +- { +- return std::hash{}( static_cast( framebuffer ) ); +- } +- }; +- +- template <> +- struct hash +- { +- std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPass const & renderPass ) const VULKAN_HPP_NOEXCEPT +- { +- return std::hash{}( static_cast( renderPass ) ); +- } +- }; +- +- template <> +- struct hash +- { +- std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandPool const & commandPool ) const VULKAN_HPP_NOEXCEPT +- { +- return std::hash{}( static_cast( commandPool ) ); +- } +- }; +- +- template <> +- struct hash +- { +- std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBuffer const & commandBuffer ) const VULKAN_HPP_NOEXCEPT +- { +- return std::hash{}( static_cast( commandBuffer ) ); +- } +- }; +- +- //=== VK_VERSION_1_1 === +- +- template <> +- struct hash +- { +- std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion const & samplerYcbcrConversion ) const +- VULKAN_HPP_NOEXCEPT +- { +- return std::hash{}( static_cast( samplerYcbcrConversion ) ); +- } +- }; +- +- template <> +- struct hash +- { +- std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate const & descriptorUpdateTemplate ) const +- VULKAN_HPP_NOEXCEPT +- { +- return std::hash{}( +- static_cast( descriptorUpdateTemplate ) ); +- } +- }; +- +- //=== VK_KHR_surface === +- +- template <> +- struct hash +- { +- std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceKHR const & surfaceKHR ) const VULKAN_HPP_NOEXCEPT +- { +- return std::hash{}( static_cast( surfaceKHR ) ); +- } +- }; +- +- //=== VK_KHR_swapchain === +- +- template <> +- struct hash +- { +- std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainKHR const & swapchainKHR ) const VULKAN_HPP_NOEXCEPT +- { +- return std::hash{}( static_cast( swapchainKHR ) ); +- } +- }; +- +- //=== VK_KHR_display === +- +- template <> +- struct hash +- { +- std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayKHR const & displayKHR ) const VULKAN_HPP_NOEXCEPT +- { +- return std::hash{}( static_cast( displayKHR ) ); +- } +- }; +- +- template <> +- struct hash +- { +- std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayModeKHR const & displayModeKHR ) const VULKAN_HPP_NOEXCEPT +- { +- return std::hash{}( static_cast( displayModeKHR ) ); +- } +- }; +- +- //=== VK_EXT_debug_report === +- +- template <> +- struct hash +- { +- std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT const & debugReportCallbackEXT ) const +- VULKAN_HPP_NOEXCEPT +- { +- return std::hash{}( static_cast( debugReportCallbackEXT ) ); +- } +- }; +- +-#if defined( VK_ENABLE_BETA_EXTENSIONS ) +- //=== VK_KHR_video_queue === +- +- template <> +- struct hash +- { +- std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoSessionKHR const & videoSessionKHR ) const VULKAN_HPP_NOEXCEPT +- { +- return std::hash{}( static_cast( videoSessionKHR ) ); +- } +- }; +- +- template <> +- struct hash +- { +- std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR const & videoSessionParametersKHR ) const +- VULKAN_HPP_NOEXCEPT +- { +- return std::hash{}( +- static_cast( videoSessionParametersKHR ) ); +- } +- }; +-#endif /*VK_ENABLE_BETA_EXTENSIONS*/ +- +- //=== VK_NVX_binary_import === +- +- template <> +- struct hash +- { +- std::size_t operator()( VULKAN_HPP_NAMESPACE::CuModuleNVX const & cuModuleNVX ) const VULKAN_HPP_NOEXCEPT +- { +- return std::hash{}( static_cast( cuModuleNVX ) ); +- } +- }; +- +- template <> +- struct hash +- { +- std::size_t operator()( VULKAN_HPP_NAMESPACE::CuFunctionNVX const & cuFunctionNVX ) const VULKAN_HPP_NOEXCEPT +- { +- return std::hash{}( static_cast( cuFunctionNVX ) ); +- } +- }; +- +- //=== VK_EXT_debug_utils === +- +- template <> +- struct hash +- { +- std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT const & debugUtilsMessengerEXT ) const +- VULKAN_HPP_NOEXCEPT +- { +- return std::hash{}( static_cast( debugUtilsMessengerEXT ) ); +- } +- }; +- +- //=== VK_KHR_acceleration_structure === +- +- template <> +- struct hash +- { +- std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR const & accelerationStructureKHR ) const +- VULKAN_HPP_NOEXCEPT +- { +- return std::hash{}( +- static_cast( accelerationStructureKHR ) ); +- } +- }; +- +- //=== VK_EXT_validation_cache === +- +- template <> +- struct hash +- { +- std::size_t +- operator()( VULKAN_HPP_NAMESPACE::ValidationCacheEXT const & validationCacheEXT ) const VULKAN_HPP_NOEXCEPT +- { +- return std::hash{}( static_cast( validationCacheEXT ) ); +- } +- }; +- +- //=== VK_NV_ray_tracing === +- +- template <> +- struct hash +- { +- std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureNV const & accelerationStructureNV ) const +- VULKAN_HPP_NOEXCEPT +- { +- return std::hash{}( +- static_cast( accelerationStructureNV ) ); +- } +- }; +- +- //=== VK_INTEL_performance_query === +- +- template <> +- struct hash +- { +- std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL const & performanceConfigurationINTEL ) +- const VULKAN_HPP_NOEXCEPT +- { +- return std::hash{}( +- static_cast( performanceConfigurationINTEL ) ); +- } +- }; +- +- //=== VK_KHR_deferred_host_operations === +- +- template <> +- struct hash +- { +- std::size_t +- operator()( VULKAN_HPP_NAMESPACE::DeferredOperationKHR const & deferredOperationKHR ) const VULKAN_HPP_NOEXCEPT +- { +- return std::hash{}( static_cast( deferredOperationKHR ) ); +- } +- }; +- +- //=== VK_NV_device_generated_commands === +- +- template <> +- struct hash +- { +- std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV const & indirectCommandsLayoutNV ) const +- VULKAN_HPP_NOEXCEPT +- { +- return std::hash{}( +- static_cast( indirectCommandsLayoutNV ) ); +- } +- }; +- +- //=== VK_EXT_private_data === +- +- template <> +- struct hash +- { +- std::size_t +- operator()( VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT const & privateDataSlotEXT ) const VULKAN_HPP_NOEXCEPT +- { +- return std::hash{}( static_cast( privateDataSlotEXT ) ); +- } +- }; +- +-#if defined( VK_USE_PLATFORM_FUCHSIA ) +- //=== VK_FUCHSIA_buffer_collection === +- +- template <> +- struct hash +- { +- std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA const & bufferCollectionFUCHSIA ) const +- VULKAN_HPP_NOEXCEPT +- { +- return std::hash{}( +- static_cast( bufferCollectionFUCHSIA ) ); +- } +- }; +-#endif /*VK_USE_PLATFORM_FUCHSIA*/ +- +-} // namespace std + #endif +--- include/vulkan/vulkan_hash.hpp.orig 2021-12-13 12:09:23 UTC ++++ include/vulkan/vulkan_hash.hpp +@@ -0,0 +1,12959 @@ ++// Copyright 2015-2021 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 ++ ++namespace std ++{ ++ //======================================= ++ //=== HASH structures for Flags types === ++ //======================================= ++ ++ template ++ struct hash> ++ { ++ std::size_t operator()( VULKAN_HPP_NAMESPACE::Flags const & flags ) const VULKAN_HPP_NOEXCEPT ++ { ++ return std::hash::type>{}( ++ static_cast::type>( flags ) ); ++ } ++ }; ++ ++ //=================================== ++ //=== HASH structures for handles === ++ //=================================== ++ ++ //=== VK_VERSION_1_0 === ++ ++ template <> ++ struct hash ++ { ++ std::size_t operator()( VULKAN_HPP_NAMESPACE::Instance const & instance ) const VULKAN_HPP_NOEXCEPT ++ { ++ return std::hash{}( static_cast( instance ) ); ++ } ++ }; ++ ++ template <> ++ struct hash ++ { ++ std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevice const & physicalDevice ) const VULKAN_HPP_NOEXCEPT ++ { ++ return std::hash{}( static_cast( physicalDevice ) ); ++ } ++ }; ++ ++ template <> ++ struct hash ++ { ++ std::size_t operator()( VULKAN_HPP_NAMESPACE::Device const & device ) const VULKAN_HPP_NOEXCEPT ++ { ++ return std::hash{}( static_cast( device ) ); ++ } ++ }; ++ ++ template <> ++ struct hash ++ { ++ std::size_t operator()( VULKAN_HPP_NAMESPACE::Queue const & queue ) const VULKAN_HPP_NOEXCEPT ++ { ++ return std::hash{}( static_cast( queue ) ); ++ } ++ }; ++ ++ template <> ++ struct hash ++ { ++ std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceMemory const & deviceMemory ) const VULKAN_HPP_NOEXCEPT ++ { ++ return std::hash{}( static_cast( deviceMemory ) ); ++ } ++ }; ++ ++ template <> ++ struct hash ++ { ++ std::size_t operator()( VULKAN_HPP_NAMESPACE::Fence const & fence ) const VULKAN_HPP_NOEXCEPT ++ { ++ return std::hash{}( static_cast( fence ) ); ++ } ++ }; ++ ++ template <> ++ struct hash ++ { ++ std::size_t operator()( VULKAN_HPP_NAMESPACE::Semaphore const & semaphore ) const VULKAN_HPP_NOEXCEPT ++ { ++ return std::hash{}( static_cast( semaphore ) ); ++ } ++ }; ++ ++ template <> ++ struct hash ++ { ++ std::size_t operator()( VULKAN_HPP_NAMESPACE::Event const & event ) const VULKAN_HPP_NOEXCEPT ++ { ++ return std::hash{}( static_cast( event ) ); ++ } ++ }; ++ ++ template <> ++ struct hash ++ { ++ std::size_t operator()( VULKAN_HPP_NAMESPACE::QueryPool const & queryPool ) const VULKAN_HPP_NOEXCEPT ++ { ++ return std::hash{}( static_cast( queryPool ) ); ++ } ++ }; ++ ++ template <> ++ struct hash ++ { ++ std::size_t operator()( VULKAN_HPP_NAMESPACE::Buffer const & buffer ) const VULKAN_HPP_NOEXCEPT ++ { ++ return std::hash{}( static_cast( buffer ) ); ++ } ++ }; ++ ++ template <> ++ struct hash ++ { ++ std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferView const & bufferView ) const VULKAN_HPP_NOEXCEPT ++ { ++ return std::hash{}( static_cast( bufferView ) ); ++ } ++ }; ++ ++ template <> ++ struct hash ++ { ++ std::size_t operator()( VULKAN_HPP_NAMESPACE::Image const & image ) const VULKAN_HPP_NOEXCEPT ++ { ++ return std::hash{}( static_cast( image ) ); ++ } ++ }; ++ ++ template <> ++ struct hash ++ { ++ std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageView const & imageView ) const VULKAN_HPP_NOEXCEPT ++ { ++ return std::hash{}( static_cast( imageView ) ); ++ } ++ }; ++ ++ template <> ++ struct hash ++ { ++ std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderModule const & shaderModule ) const VULKAN_HPP_NOEXCEPT ++ { ++ return std::hash{}( static_cast( shaderModule ) ); ++ } ++ }; ++ ++ template <> ++ struct hash ++ { ++ std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCache const & pipelineCache ) const VULKAN_HPP_NOEXCEPT ++ { ++ return std::hash{}( static_cast( pipelineCache ) ); ++ } ++ }; ++ ++ template <> ++ struct hash ++ { ++ std::size_t operator()( VULKAN_HPP_NAMESPACE::Pipeline const & pipeline ) const VULKAN_HPP_NOEXCEPT ++ { ++ return std::hash{}( static_cast( pipeline ) ); ++ } ++ }; ++ ++ template <> ++ struct hash ++ { ++ std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineLayout const & pipelineLayout ) const VULKAN_HPP_NOEXCEPT ++ { ++ return std::hash{}( static_cast( pipelineLayout ) ); ++ } ++ }; ++ ++ template <> ++ struct hash ++ { ++ std::size_t operator()( VULKAN_HPP_NAMESPACE::Sampler const & sampler ) const VULKAN_HPP_NOEXCEPT ++ { ++ return std::hash{}( static_cast( sampler ) ); ++ } ++ }; ++ ++ template <> ++ struct hash ++ { ++ std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorPool const & descriptorPool ) const VULKAN_HPP_NOEXCEPT ++ { ++ return std::hash{}( static_cast( descriptorPool ) ); ++ } ++ }; ++ ++ template <> ++ struct hash ++ { ++ std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSet const & descriptorSet ) const VULKAN_HPP_NOEXCEPT ++ { ++ return std::hash{}( static_cast( descriptorSet ) ); ++ } ++ }; ++ ++ template <> ++ struct hash ++ { ++ std::size_t ++ operator()( VULKAN_HPP_NAMESPACE::DescriptorSetLayout const & descriptorSetLayout ) const VULKAN_HPP_NOEXCEPT ++ { ++ return std::hash{}( static_cast( descriptorSetLayout ) ); ++ } ++ }; ++ ++ template <> ++ struct hash ++ { ++ std::size_t operator()( VULKAN_HPP_NAMESPACE::Framebuffer const & framebuffer ) const VULKAN_HPP_NOEXCEPT ++ { ++ return std::hash{}( static_cast( framebuffer ) ); ++ } ++ }; ++ ++ template <> ++ struct hash ++ { ++ std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPass const & renderPass ) const VULKAN_HPP_NOEXCEPT ++ { ++ return std::hash{}( static_cast( renderPass ) ); ++ } ++ }; ++ ++ template <> ++ struct hash ++ { ++ std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandPool const & commandPool ) const VULKAN_HPP_NOEXCEPT ++ { ++ return std::hash{}( static_cast( commandPool ) ); ++ } ++ }; ++ ++ template <> ++ struct hash ++ { ++ std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBuffer const & commandBuffer ) const VULKAN_HPP_NOEXCEPT ++ { ++ return std::hash{}( static_cast( commandBuffer ) ); ++ } ++ }; ++ ++ //=== VK_VERSION_1_1 === ++ ++ template <> ++ struct hash ++ { ++ std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion const & samplerYcbcrConversion ) const ++ VULKAN_HPP_NOEXCEPT ++ { ++ return std::hash{}( static_cast( samplerYcbcrConversion ) ); ++ } ++ }; ++ ++ template <> ++ struct hash ++ { ++ std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate const & descriptorUpdateTemplate ) const ++ VULKAN_HPP_NOEXCEPT ++ { ++ return std::hash{}( ++ static_cast( descriptorUpdateTemplate ) ); ++ } ++ }; ++ ++ //=== VK_KHR_surface === ++ ++ template <> ++ struct hash ++ { ++ std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceKHR const & surfaceKHR ) const VULKAN_HPP_NOEXCEPT ++ { ++ return std::hash{}( static_cast( surfaceKHR ) ); ++ } ++ }; ++ ++ //=== VK_KHR_swapchain === ++ ++ template <> ++ struct hash ++ { ++ std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainKHR const & swapchainKHR ) const VULKAN_HPP_NOEXCEPT ++ { ++ return std::hash{}( static_cast( swapchainKHR ) ); ++ } ++ }; ++ ++ //=== VK_KHR_display === ++ ++ template <> ++ struct hash ++ { ++ std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayKHR const & displayKHR ) const VULKAN_HPP_NOEXCEPT ++ { ++ return std::hash{}( static_cast( displayKHR ) ); ++ } ++ }; ++ ++ template <> ++ struct hash ++ { ++ std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayModeKHR const & displayModeKHR ) const VULKAN_HPP_NOEXCEPT ++ { ++ return std::hash{}( static_cast( displayModeKHR ) ); ++ } ++ }; ++ ++ //=== VK_EXT_debug_report === ++ ++ template <> ++ struct hash ++ { ++ std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT const & debugReportCallbackEXT ) const ++ VULKAN_HPP_NOEXCEPT ++ { ++ return std::hash{}( static_cast( debugReportCallbackEXT ) ); ++ } ++ }; ++ ++#if defined( VK_ENABLE_BETA_EXTENSIONS ) ++ //=== VK_KHR_video_queue === ++ ++ template <> ++ struct hash ++ { ++ std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoSessionKHR const & videoSessionKHR ) const VULKAN_HPP_NOEXCEPT ++ { ++ return std::hash{}( static_cast( videoSessionKHR ) ); ++ } ++ }; ++ ++ template <> ++ struct hash ++ { ++ std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR const & videoSessionParametersKHR ) const ++ VULKAN_HPP_NOEXCEPT ++ { ++ return std::hash{}( ++ static_cast( videoSessionParametersKHR ) ); ++ } ++ }; *** 34275 LINES SKIPPED ***