From d99496fcb1f4aecbeb25c1e70eda0cdee7e1eba5 Mon Sep 17 00:00:00 2001 From: Mike Schuchardt Date: Tue, 4 Jan 2022 09:03:58 -0800 Subject: [PATCH] Update to latest Vulkan-Hpp Notably includes fix for https://github.com/KhronosGroup/Vulkan-Hpp/issues/1167 which is blocking downstream CI systems --- include/vulkan/vulkan_funcs.hpp | 30 +- include/vulkan/vulkan_handles.hpp | 5 - include/vulkan/vulkan_hash.hpp | 87 +- include/vulkan/vulkan_structs.hpp | 11811 +++++++++++++++++++++++++++--------- 4 files changed, 8923 insertions(+), 3010 deletions(-) diff --git a/include/vulkan/vulkan_funcs.hpp b/include/vulkan/vulkan_funcs.hpp index a3d1293..656154a 100644 --- a/include/vulkan/vulkan_funcs.hpp +++ b/include/vulkan/vulkan_funcs.hpp @@ -15652,35 +15652,6 @@ namespace VULKAN_HPP_NAMESPACE } #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_DEPRECATED( "This function is deprecated. Use one of the other flavours of it." ) - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE - typename ResultValueType::type Device::getCalibratedTimestampsEXT( - ArrayProxy const & timestampInfos, - ArrayProxy const & timestamps, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# ifdef VULKAN_HPP_NO_EXCEPTIONS - VULKAN_HPP_ASSERT( timestampInfos.size() == timestamps.size() ); -# else - if ( timestampInfos.size() != timestamps.size() ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING - "::VkDevice::getCalibratedTimestampsEXT: timestampInfos.size() != timestamps.size()" ); - } -# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ - uint64_t maxDeviation; - Result result = static_cast( - d.vkGetCalibratedTimestampsEXT( m_device, - timestampInfos.size(), - reinterpret_cast( timestampInfos.data() ), - timestamps.data(), - &maxDeviation ) ); - return createResultValue( - result, maxDeviation, VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampsEXT" ); - } - template VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType, uint64_t>>::type @@ -15728,6 +15699,7 @@ namespace VULKAN_HPP_NAMESPACE &maxDeviation ) ); return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampsEXT" ); } + template VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType>::type diff --git a/include/vulkan/vulkan_handles.hpp b/include/vulkan/vulkan_handles.hpp index 741f759..d735a72 100644 --- a/include/vulkan/vulkan_handles.hpp +++ b/include/vulkan/vulkan_handles.hpp @@ -11040,11 +11040,6 @@ namespace VULKAN_HPP_NAMESPACE uint64_t * pMaxDeviation, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type getCalibratedTimestampsEXT( - ArrayProxy const & timestampInfos, - ArrayProxy const & timestamps, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; template , typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS diff --git a/include/vulkan/vulkan_hash.hpp b/include/vulkan/vulkan_hash.hpp index 7a9cc4a..705936f 100644 --- a/include/vulkan/vulkan_hash.hpp +++ b/include/vulkan/vulkan_hash.hpp @@ -994,9 +994,15 @@ namespace std std::size_t seed = 0; VULKAN_HPP_HASH_COMBINE( seed, applicationInfo.sType ); VULKAN_HPP_HASH_COMBINE( seed, applicationInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, applicationInfo.pApplicationName ); + for ( const char * p = applicationInfo.pApplicationName; *p != '\0'; ++p ) + { + VULKAN_HPP_HASH_COMBINE( seed, *p ); + } VULKAN_HPP_HASH_COMBINE( seed, applicationInfo.applicationVersion ); - VULKAN_HPP_HASH_COMBINE( seed, applicationInfo.pEngineName ); + 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; @@ -2196,7 +2202,10 @@ namespace std VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageCreateInfo.flags ); VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageCreateInfo.stage ); VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageCreateInfo.module ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageCreateInfo.pName ); + for ( const char * p = pipelineShaderStageCreateInfo.pName; *p != '\0'; ++p ) + { + VULKAN_HPP_HASH_COMBINE( seed, *p ); + } VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageCreateInfo.pSpecializationInfo ); return seed; } @@ -2421,7 +2430,10 @@ namespace std VULKAN_HPP_HASH_COMBINE( seed, cuFunctionCreateInfoNVX.sType ); VULKAN_HPP_HASH_COMBINE( seed, cuFunctionCreateInfoNVX.pNext ); VULKAN_HPP_HASH_COMBINE( seed, cuFunctionCreateInfoNVX.module ); - VULKAN_HPP_HASH_COMBINE( seed, cuFunctionCreateInfoNVX.pName ); + for ( const char * p = cuFunctionCreateInfoNVX.pName; *p != '\0'; ++p ) + { + VULKAN_HPP_HASH_COMBINE( seed, *p ); + } return seed; } }; @@ -2493,7 +2505,10 @@ namespace std std::size_t seed = 0; VULKAN_HPP_HASH_COMBINE( seed, debugMarkerMarkerInfoEXT.sType ); VULKAN_HPP_HASH_COMBINE( seed, debugMarkerMarkerInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, debugMarkerMarkerInfoEXT.pMarkerName ); + 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] ); @@ -2513,7 +2528,10 @@ namespace std VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectNameInfoEXT.pNext ); VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectNameInfoEXT.objectType ); VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectNameInfoEXT.object ); - VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectNameInfoEXT.pObjectName ); + for ( const char * p = debugMarkerObjectNameInfoEXT.pObjectName; *p != '\0'; ++p ) + { + VULKAN_HPP_HASH_COMBINE( seed, *p ); + } return seed; } }; @@ -2561,7 +2579,10 @@ namespace std std::size_t seed = 0; VULKAN_HPP_HASH_COMBINE( seed, debugUtilsLabelEXT.sType ); VULKAN_HPP_HASH_COMBINE( seed, debugUtilsLabelEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, debugUtilsLabelEXT.pLabelName ); + 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] ); @@ -2581,7 +2602,10 @@ namespace std VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectNameInfoEXT.pNext ); VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectNameInfoEXT.objectType ); VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectNameInfoEXT.objectHandle ); - VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectNameInfoEXT.pObjectName ); + for ( const char * p = debugUtilsObjectNameInfoEXT.pObjectName; *p != '\0'; ++p ) + { + VULKAN_HPP_HASH_COMBINE( seed, *p ); + } return seed; } }; @@ -2596,9 +2620,15 @@ namespace std VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.sType ); VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.pNext ); VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.flags ); - VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.pMessageIdName ); + for ( const char * p = debugUtilsMessengerCallbackDataEXT.pMessageIdName; *p != '\0'; ++p ) + { + VULKAN_HPP_HASH_COMBINE( seed, *p ); + } VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.messageIdNumber ); - VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.pMessage ); + for ( const char * p = debugUtilsMessengerCallbackDataEXT.pMessage; *p != '\0'; ++p ) + { + VULKAN_HPP_HASH_COMBINE( seed, *p ); + } VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.queueLabelCount ); VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.pQueueLabels ); VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.cmdBufLabelCount ); @@ -3089,9 +3119,21 @@ namespace std VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.queueCreateInfoCount ); VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.pQueueCreateInfos ); VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.enabledLayerCount ); - VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.ppEnabledLayerNames ); + for ( size_t i = 0; i < deviceCreateInfo.enabledLayerCount; ++i ) + { + for ( const char * p = deviceCreateInfo.ppEnabledLayerNames[i]; *p != '\0'; ++p ) + { + VULKAN_HPP_HASH_COMBINE( seed, *p ); + } + } VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.enabledExtensionCount ); - VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.ppEnabledExtensionNames ); + for ( size_t i = 0; i < deviceCreateInfo.enabledExtensionCount; ++i ) + { + for ( const char * p = deviceCreateInfo.ppEnabledExtensionNames[i]; *p != '\0'; ++p ) + { + VULKAN_HPP_HASH_COMBINE( seed, *p ); + } + } VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.pEnabledFeatures ); return seed; } @@ -3630,7 +3672,10 @@ namespace std { std::size_t seed = 0; VULKAN_HPP_HASH_COMBINE( seed, displayPropertiesKHR.display ); - VULKAN_HPP_HASH_COMBINE( seed, displayPropertiesKHR.displayName ); + for ( const char * p = displayPropertiesKHR.displayName; *p != '\0'; ++p ) + { + VULKAN_HPP_HASH_COMBINE( seed, *p ); + } VULKAN_HPP_HASH_COMBINE( seed, displayPropertiesKHR.physicalDimensions ); VULKAN_HPP_HASH_COMBINE( seed, displayPropertiesKHR.physicalResolution ); VULKAN_HPP_HASH_COMBINE( seed, displayPropertiesKHR.supportedTransforms ); @@ -5411,9 +5456,21 @@ namespace std VULKAN_HPP_HASH_COMBINE( seed, instanceCreateInfo.flags ); VULKAN_HPP_HASH_COMBINE( seed, instanceCreateInfo.pApplicationInfo ); VULKAN_HPP_HASH_COMBINE( seed, instanceCreateInfo.enabledLayerCount ); - VULKAN_HPP_HASH_COMBINE( seed, instanceCreateInfo.ppEnabledLayerNames ); + for ( size_t i = 0; i < instanceCreateInfo.enabledLayerCount; ++i ) + { + for ( const char * p = instanceCreateInfo.ppEnabledLayerNames[i]; *p != '\0'; ++p ) + { + VULKAN_HPP_HASH_COMBINE( seed, *p ); + } + } VULKAN_HPP_HASH_COMBINE( seed, instanceCreateInfo.enabledExtensionCount ); - VULKAN_HPP_HASH_COMBINE( seed, instanceCreateInfo.ppEnabledExtensionNames ); + for ( size_t i = 0; i < instanceCreateInfo.enabledExtensionCount; ++i ) + { + for ( const char * p = instanceCreateInfo.ppEnabledExtensionNames[i]; *p != '\0'; ++p ) + { + VULKAN_HPP_HASH_COMBINE( seed, *p ); + } + } return seed; } }; diff --git a/include/vulkan/vulkan_structs.hpp b/include/vulkan/vulkan_structs.hpp index bc87d15..d029dbf 100644 --- a/include/vulkan/vulkan_structs.hpp +++ b/include/vulkan/vulkan_structs.hpp @@ -96,27 +96,34 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( minX, minY, minZ, maxX, maxY, maxZ ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AabbPositionsKHR const & ) const = default; #else bool operator==( AabbPositionsKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( minX == rhs.minX ) && ( minY == rhs.minY ) && ( minZ == rhs.minZ ) && ( maxX == rhs.maxX ) && + ( maxY == rhs.maxY ) && ( maxZ == rhs.maxZ ); +# endif } bool operator!=( AabbPositionsKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -178,8 +185,8 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::DeviceAddress deviceAddress; const void * hostAddress; #else - VkDeviceAddress deviceAddress; - const void * hostAddress; + VkDeviceAddress deviceAddress; + const void * hostAddress; #endif /*VULKAN_HPP_HAS_UNRESTRICTED_UNIONS*/ }; @@ -297,9 +304,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, vertexFormat, vertexData, vertexStride, maxVertex, indexType, indexData, transformData ); } +#endif public: VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eAccelerationStructureGeometryTrianglesDataKHR; @@ -412,18 +421,20 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, data, stride ); } +#endif public: VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eAccelerationStructureGeometryAabbsDataKHR; @@ -516,18 +527,20 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, arrayOfPointers, data ); } +#endif public: VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eAccelerationStructureGeometryInstancesDataKHR; @@ -689,19 +702,21 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, geometryType, geometry, flags ); } +#endif public: VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eAccelerationStructureGeometryKHR; @@ -766,8 +781,8 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::DeviceAddress deviceAddress; void * hostAddress; #else - VkDeviceAddress deviceAddress; - void * hostAddress; + VkDeviceAddress deviceAddress; + void * hostAddress; #endif /*VULKAN_HPP_HAS_UNRESTRICTED_UNIONS*/ }; @@ -962,9 +977,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -991,6 +1007,7 @@ namespace VULKAN_HPP_NAMESPACE ppGeometries, scratchData ); } +#endif public: VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eAccelerationStructureBuildGeometryInfoKHR; @@ -1097,27 +1114,34 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( primitiveCount, primitiveOffset, firstVertex, transformOffset ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AccelerationStructureBuildRangeInfoKHR const & ) const = default; #else bool operator==( AccelerationStructureBuildRangeInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( primitiveCount == rhs.primitiveCount ) && ( primitiveOffset == rhs.primitiveOffset ) && + ( firstVertex == rhs.firstVertex ) && ( transformOffset == rhs.transformOffset ); +# endif } bool operator!=( AccelerationStructureBuildRangeInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -1213,31 +1237,39 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, accelerationStructureSize, updateScratchSize, buildScratchSize ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AccelerationStructureBuildSizesInfoKHR const & ) const = default; #else bool operator==( AccelerationStructureBuildSizesInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( accelerationStructureSize == rhs.accelerationStructureSize ) && + ( updateScratchSize == rhs.updateScratchSize ) && ( buildScratchSize == rhs.buildScratchSize ); +# endif } bool operator!=( AccelerationStructureBuildSizesInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -1367,9 +1399,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, createFlags, buffer, offset, size, type, deviceAddress ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AccelerationStructureCreateInfoKHR const & ) const = default; #else bool operator==( AccelerationStructureCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( createFlags == rhs.createFlags ) && + ( buffer == rhs.buffer ) && ( offset == rhs.offset ) && ( size == rhs.size ) && ( type == rhs.type ) && + ( deviceAddress == rhs.deviceAddress ); +# endif } bool operator!=( AccelerationStructureCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -1565,9 +1605,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -1598,18 +1639,28 @@ namespace VULKAN_HPP_NAMESPACE transformData, transformOffset ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( GeometryTrianglesNV const & ) const = default; #else bool operator==( GeometryTrianglesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( vertexData == rhs.vertexData ) && + ( vertexOffset == rhs.vertexOffset ) && ( vertexCount == rhs.vertexCount ) && + ( vertexStride == rhs.vertexStride ) && ( vertexFormat == rhs.vertexFormat ) && + ( indexData == rhs.indexData ) && ( indexOffset == rhs.indexOffset ) && ( indexCount == rhs.indexCount ) && + ( indexType == rhs.indexType ) && ( transformData == rhs.transformData ) && + ( transformOffset == rhs.transformOffset ); +# endif } bool operator!=( GeometryTrianglesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -1716,32 +1767,39 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, aabbData, numAABBs, stride, offset ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( GeometryAABBNV const & ) const = default; #else bool operator==( GeometryAABBNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( aabbData == rhs.aabbData ) && + ( numAABBs == rhs.numAABBs ) && ( stride == rhs.stride ) && ( offset == rhs.offset ); +# endif } bool operator!=( GeometryAABBNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -1818,27 +1876,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( triangles, aabbs ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( GeometryDataNV const & ) const = default; #else bool operator==( GeometryDataNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( triangles == rhs.triangles ) && ( aabbs == rhs.aabbs ); +# endif } bool operator!=( GeometryDataNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -1923,31 +1987,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, geometryType, geometry, flags ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( GeometryNV const & ) const = default; #else bool operator==( GeometryNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( geometryType == rhs.geometryType ) && + ( geometry == rhs.geometry ) && ( flags == rhs.flags ); +# endif } bool operator!=( GeometryNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -2086,9 +2157,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, type, flags, instanceCount, geometryCount, pGeometries ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AccelerationStructureInfoNV const & ) const = default; #else bool operator==( AccelerationStructureInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( type == rhs.type ) && ( flags == rhs.flags ) && + ( instanceCount == rhs.instanceCount ) && ( geometryCount == rhs.geometryCount ) && + ( pGeometries == rhs.pGeometries ); +# endif } bool operator!=( AccelerationStructureInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -2205,30 +2284,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, compactedSize, info ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AccelerationStructureCreateInfoNV const & ) const = default; #else bool operator==( AccelerationStructureCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( compactedSize == rhs.compactedSize ) && + ( info == rhs.info ); +# endif } bool operator!=( AccelerationStructureCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -2313,29 +2399,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, accelerationStructure ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AccelerationStructureDeviceAddressInfoKHR const & ) const = default; #else bool operator==( AccelerationStructureDeviceAddressInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( accelerationStructure == rhs.accelerationStructure ); +# endif } bool operator!=( AccelerationStructureDeviceAddressInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -2421,17 +2513,19 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, vertexData ); } +#endif public: VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eAccelerationStructureGeometryMotionTrianglesDataNV; @@ -2498,27 +2592,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple const &> -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( matrix ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( TransformMatrixKHR const & ) const = default; #else bool operator==( TransformMatrixKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( matrix == rhs.matrix ); +# endif } bool operator!=( TransformMatrixKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -2623,16 +2723,17 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( transform, @@ -2642,18 +2743,26 @@ namespace VULKAN_HPP_NAMESPACE flags, accelerationStructureReference ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AccelerationStructureInstanceKHR const & ) const = default; #else bool operator==( AccelerationStructureInstanceKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( transform == rhs.transform ) && ( instanceCustomIndex == rhs.instanceCustomIndex ) && + ( mask == rhs.mask ) && + ( instanceShaderBindingTableRecordOffset == rhs.instanceShaderBindingTableRecordOffset ) && + ( flags == rhs.flags ) && ( accelerationStructureReference == rhs.accelerationStructureReference ); +# endif } bool operator!=( AccelerationStructureInstanceKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -2777,9 +2886,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( transformT0, @@ -2798,18 +2908,26 @@ namespace VULKAN_HPP_NAMESPACE flags, accelerationStructureReference ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AccelerationStructureMatrixMotionInstanceNV const & ) const = default; #else bool operator==( AccelerationStructureMatrixMotionInstanceNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( transformT0 == rhs.transformT0 ) && ( transformT1 == rhs.transformT1 ) && + ( instanceCustomIndex == rhs.instanceCustomIndex ) && ( mask == rhs.mask ) && + ( instanceShaderBindingTableRecordOffset == rhs.instanceShaderBindingTableRecordOffset ) && + ( flags == rhs.flags ) && ( accelerationStructureReference == rhs.accelerationStructureReference ); +# endif } bool operator!=( AccelerationStructureMatrixMotionInstanceNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -2902,30 +3020,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, type, accelerationStructure ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AccelerationStructureMemoryRequirementsInfoNV const & ) const = default; #else bool operator==( AccelerationStructureMemoryRequirementsInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( type == rhs.type ) && + ( accelerationStructure == rhs.accelerationStructure ); +# endif } bool operator!=( AccelerationStructureMemoryRequirementsInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -3017,30 +3142,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, maxInstances, flags ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AccelerationStructureMotionInfoNV const & ) const = default; #else bool operator==( AccelerationStructureMotionInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxInstances == rhs.maxInstances ) && + ( flags == rhs.flags ); +# endif } bool operator!=( AccelerationStructureMotionInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -3226,9 +3358,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sx, a, b, pvx, sy, c, pvy, sz, pvz, qx, qy, qz, qw, tx, ty, tz ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SRTDataNV const & ) const = default; #else bool operator==( SRTDataNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sx == rhs.sx ) && ( a == rhs.a ) && ( b == rhs.b ) && ( pvx == rhs.pvx ) && ( sy == rhs.sy ) && + ( c == rhs.c ) && ( pvy == rhs.pvy ) && ( sz == rhs.sz ) && ( pvz == rhs.pvz ) && ( qx == rhs.qx ) && + ( qy == rhs.qy ) && ( qz == rhs.qz ) && ( qw == rhs.qw ) && ( tx == rhs.tx ) && ( ty == rhs.ty ) && + ( tz == rhs.tz ); +# endif } bool operator!=( SRTDataNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -3392,9 +3533,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( transformT0, @@ -3413,18 +3555,26 @@ namespace VULKAN_HPP_NAMESPACE flags, accelerationStructureReference ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AccelerationStructureSRTMotionInstanceNV const & ) const = default; #else bool operator==( AccelerationStructureSRTMotionInstanceNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( transformT0 == rhs.transformT0 ) && ( transformT1 == rhs.transformT1 ) && + ( instanceCustomIndex == rhs.instanceCustomIndex ) && ( mask == rhs.mask ) && + ( instanceShaderBindingTableRecordOffset == rhs.instanceShaderBindingTableRecordOffset ) && + ( flags == rhs.flags ) && ( accelerationStructureReference == rhs.accelerationStructureReference ); +# endif } bool operator!=( AccelerationStructureSRTMotionInstanceNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -3580,17 +3730,19 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( type, flags, data ); } +#endif public: VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInstanceTypeNV type = @@ -3663,27 +3815,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, pVersionData ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AccelerationStructureVersionInfoKHR const & ) const = default; #else bool operator==( AccelerationStructureVersionInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pVersionData == rhs.pVersionData ); +# endif } bool operator!=( AccelerationStructureVersionInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -3792,9 +3950,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, swapchain, timeout, semaphore, fence, deviceMask ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AcquireNextImageInfoKHR const & ) const = default; #else bool operator==( AcquireNextImageInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchain == rhs.swapchain ) && + ( timeout == rhs.timeout ) && ( semaphore == rhs.semaphore ) && ( fence == rhs.fence ) && + ( deviceMask == rhs.deviceMask ); +# endif } bool operator!=( AcquireNextImageInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -3906,30 +4072,36 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, flags, timeout ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AcquireProfilingLockInfoKHR const & ) const = default; #else bool operator==( AcquireProfilingLockInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( timeout == rhs.timeout ); +# endif } bool operator!=( AcquireProfilingLockInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -4040,32 +4212,40 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( pUserData, pfnAllocation, pfnReallocation, pfnFree, pfnInternalAllocation, pfnInternalFree ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AllocationCallbacks const & ) const = default; #else bool operator==( AllocationCallbacks const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( pUserData == rhs.pUserData ) && ( pfnAllocation == rhs.pfnAllocation ) && + ( pfnReallocation == rhs.pfnReallocation ) && ( pfnFree == rhs.pfnFree ) && + ( pfnInternalAllocation == rhs.pfnInternalAllocation ) && ( pfnInternalFree == rhs.pfnInternalFree ); +# endif } bool operator!=( AllocationCallbacks const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -4152,30 +4332,36 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( r, g, b, a ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ComponentMapping const & ) const = default; #else bool operator==( ComponentMapping const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( r == rhs.r ) && ( g == rhs.g ) && ( b == rhs.b ) && ( a == rhs.a ); +# endif } bool operator!=( ComponentMapping const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -4253,9 +4439,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -4280,18 +4467,28 @@ namespace VULKAN_HPP_NAMESPACE suggestedXChromaOffset, suggestedYChromaOffset ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AndroidHardwareBufferFormatProperties2ANDROID const & ) const = default; # else bool operator==( AndroidHardwareBufferFormatProperties2ANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( format == rhs.format ) && + ( externalFormat == rhs.externalFormat ) && ( formatFeatures == rhs.formatFeatures ) && + ( samplerYcbcrConversionComponents == rhs.samplerYcbcrConversionComponents ) && + ( suggestedYcbcrModel == rhs.suggestedYcbcrModel ) && ( suggestedYcbcrRange == rhs.suggestedYcbcrRange ) && + ( suggestedXChromaOffset == rhs.suggestedXChromaOffset ) && + ( suggestedYChromaOffset == rhs.suggestedYChromaOffset ); +# endif } bool operator!=( AndroidHardwareBufferFormatProperties2ANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -4386,9 +4583,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -4413,18 +4611,28 @@ namespace VULKAN_HPP_NAMESPACE suggestedXChromaOffset, suggestedYChromaOffset ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AndroidHardwareBufferFormatPropertiesANDROID const & ) const = default; # else bool operator==( AndroidHardwareBufferFormatPropertiesANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( format == rhs.format ) && + ( externalFormat == rhs.externalFormat ) && ( formatFeatures == rhs.formatFeatures ) && + ( samplerYcbcrConversionComponents == rhs.samplerYcbcrConversionComponents ) && + ( suggestedYcbcrModel == rhs.suggestedYcbcrModel ) && ( suggestedYcbcrRange == rhs.suggestedYcbcrRange ) && + ( suggestedXChromaOffset == rhs.suggestedXChromaOffset ) && + ( suggestedYChromaOffset == rhs.suggestedYChromaOffset ); +# endif } bool operator!=( AndroidHardwareBufferFormatPropertiesANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -4503,30 +4711,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, allocationSize, memoryTypeBits ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AndroidHardwareBufferPropertiesANDROID const & ) const = default; # else bool operator==( AndroidHardwareBufferPropertiesANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( allocationSize == rhs.allocationSize ) && + ( memoryTypeBits == rhs.memoryTypeBits ); +# endif } bool operator!=( AndroidHardwareBufferPropertiesANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -4595,27 +4810,34 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, androidHardwareBufferUsage ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AndroidHardwareBufferUsageANDROID const & ) const = default; # else bool operator==( AndroidHardwareBufferUsageANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( androidHardwareBufferUsage == rhs.androidHardwareBufferUsage ); +# endif } bool operator!=( AndroidHardwareBufferUsageANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -4703,30 +4925,36 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, flags, window ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AndroidSurfaceCreateInfoKHR const & ) const = default; # else bool operator==( AndroidSurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( window == rhs.window ); +# endif } bool operator!=( AndroidSurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -4835,9 +5063,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, pApplicationName, applicationVersion, pEngineName, engineVersion, apiVersion ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ApplicationInfo const & ) const = default; #else bool operator==( ApplicationInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pApplicationName == rhs.pApplicationName ) && + ( applicationVersion == rhs.applicationVersion ) && ( pEngineName == rhs.pEngineName ) && + ( engineVersion == rhs.engineVersion ) && ( apiVersion == rhs.apiVersion ); +# endif } bool operator!=( ApplicationInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -5004,9 +5240,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( flags, format, samples, loadOp, storeOp, stencilLoadOp, stencilStoreOp, initialLayout, finalLayout ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AttachmentDescription const & ) const = default; #else bool operator==( AttachmentDescription const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( flags == rhs.flags ) && ( format == rhs.format ) && ( samples == rhs.samples ) && + ( loadOp == rhs.loadOp ) && ( storeOp == rhs.storeOp ) && ( stencilLoadOp == rhs.stencilLoadOp ) && + ( stencilStoreOp == rhs.stencilStoreOp ) && ( initialLayout == rhs.initialLayout ) && + ( finalLayout == rhs.finalLayout ); +# endif } bool operator!=( AttachmentDescription const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -5181,9 +5426,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -5210,18 +5456,26 @@ namespace VULKAN_HPP_NAMESPACE initialLayout, finalLayout ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AttachmentDescription2 const & ) const = default; #else bool operator==( AttachmentDescription2 const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( format == rhs.format ) && + ( samples == rhs.samples ) && ( loadOp == rhs.loadOp ) && ( storeOp == rhs.storeOp ) && + ( stencilLoadOp == rhs.stencilLoadOp ) && ( stencilStoreOp == rhs.stencilStoreOp ) && + ( initialLayout == rhs.initialLayout ) && ( finalLayout == rhs.finalLayout ); +# endif } bool operator!=( AttachmentDescription2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -5320,30 +5574,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, stencilInitialLayout, stencilFinalLayout ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AttachmentDescriptionStencilLayout const & ) const = default; #else bool operator==( AttachmentDescriptionStencilLayout const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stencilInitialLayout == rhs.stencilInitialLayout ) && + ( stencilFinalLayout == rhs.stencilFinalLayout ); +# endif } bool operator!=( AttachmentDescriptionStencilLayout const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -5421,27 +5682,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( attachment, layout ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AttachmentReference const & ) const = default; #else bool operator==( AttachmentReference const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( attachment == rhs.attachment ) && ( layout == rhs.layout ); +# endif } bool operator!=( AttachmentReference const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -5526,31 +5793,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, attachment, layout, aspectMask ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AttachmentReference2 const & ) const = default; #else bool operator==( AttachmentReference2 const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( attachment == rhs.attachment ) && + ( layout == rhs.layout ) && ( aspectMask == rhs.aspectMask ); +# endif } bool operator!=( AttachmentReference2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -5631,27 +5905,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, stencilLayout ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AttachmentReferenceStencilLayout const & ) const = default; #else bool operator==( AttachmentReferenceStencilLayout const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stencilLayout == rhs.stencilLayout ); +# endif } bool operator!=( AttachmentReferenceStencilLayout const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -5771,31 +6051,39 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, colorAttachmentCount, pColorAttachmentSamples, depthStencilAttachmentSamples ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AttachmentSampleCountInfoAMD const & ) const = default; #else bool operator==( AttachmentSampleCountInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( colorAttachmentCount == rhs.colorAttachmentCount ) && + ( pColorAttachmentSamples == rhs.pColorAttachmentSamples ) && + ( depthStencilAttachmentSamples == rhs.depthStencilAttachmentSamples ); +# endif } bool operator!=( AttachmentSampleCountInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -5870,27 +6158,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( width, height ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( Extent2D const & ) const = default; #else bool operator==( Extent2D const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( width == rhs.width ) && ( height == rhs.height ); +# endif } bool operator!=( Extent2D const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -5954,27 +6248,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( x, y ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SampleLocationEXT const & ) const = default; #else bool operator==( SampleLocationEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( x == rhs.x ) && ( y == rhs.y ); +# endif } bool operator!=( SampleLocationEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -6094,33 +6394,42 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, sampleLocationsPerPixel, sampleLocationGridSize, sampleLocationsCount, pSampleLocations ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SampleLocationsInfoEXT const & ) const = default; #else bool operator==( SampleLocationsInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( sampleLocationsPerPixel == rhs.sampleLocationsPerPixel ) && + ( sampleLocationGridSize == rhs.sampleLocationGridSize ) && + ( sampleLocationsCount == rhs.sampleLocationsCount ) && ( pSampleLocations == rhs.pSampleLocations ); +# endif } bool operator!=( SampleLocationsInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -6200,27 +6509,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( attachmentIndex, sampleLocationsInfo ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AttachmentSampleLocationsEXT const & ) const = default; #else bool operator==( AttachmentSampleLocationsEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( attachmentIndex == rhs.attachmentIndex ) && ( sampleLocationsInfo == rhs.sampleLocationsInfo ); +# endif } bool operator!=( AttachmentSampleLocationsEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -6280,28 +6595,34 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BaseInStructure const & ) const = default; #else bool operator==( BaseInStructure const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ); +# endif } bool operator!=( BaseInStructure const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -6359,27 +6680,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BaseOutStructure const & ) const = default; #else bool operator==( BaseOutStructure const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ); +# endif } bool operator!=( BaseOutStructure const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -6512,9 +6839,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, accelerationStructure, memory, memoryOffset, deviceIndexCount, pDeviceIndices ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BindAccelerationStructureMemoryInfoNV const & ) const = default; #else bool operator==( BindAccelerationStructureMemoryInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( accelerationStructure == rhs.accelerationStructure ) && ( memory == rhs.memory ) && + ( memoryOffset == rhs.memoryOffset ) && ( deviceIndexCount == rhs.deviceIndexCount ) && + ( pDeviceIndices == rhs.pDeviceIndices ); +# endif } bool operator!=( BindAccelerationStructureMemoryInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -6646,30 +6982,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, deviceIndexCount, pDeviceIndices ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BindBufferMemoryDeviceGroupInfo const & ) const = default; #else bool operator==( BindBufferMemoryDeviceGroupInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceIndexCount == rhs.deviceIndexCount ) && + ( pDeviceIndices == rhs.pDeviceIndices ); +# endif } bool operator!=( BindBufferMemoryDeviceGroupInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -6764,31 +7107,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, buffer, memory, memoryOffset ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BindBufferMemoryInfo const & ) const = default; #else bool operator==( BindBufferMemoryInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( buffer == rhs.buffer ) && ( memory == rhs.memory ) && + ( memoryOffset == rhs.memoryOffset ); +# endif } bool operator!=( BindBufferMemoryInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -6860,27 +7210,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( x, y ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( Offset2D const & ) const = default; #else bool operator==( Offset2D const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( x == rhs.x ) && ( y == rhs.y ); +# endif } bool operator!=( Offset2D const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -6943,27 +7299,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( offset, extent ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( Rect2D const & ) const = default; #else bool operator==( Rect2D const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( offset == rhs.offset ) && ( extent == rhs.extent ); +# endif } bool operator!=( Rect2D const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -7093,33 +7455,42 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, deviceIndexCount, pDeviceIndices, splitInstanceBindRegionCount, pSplitInstanceBindRegions ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BindImageMemoryDeviceGroupInfo const & ) const = default; #else bool operator==( BindImageMemoryDeviceGroupInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceIndexCount == rhs.deviceIndexCount ) && + ( pDeviceIndices == rhs.pDeviceIndices ) && + ( splitInstanceBindRegionCount == rhs.splitInstanceBindRegionCount ) && + ( pSplitInstanceBindRegions == rhs.pSplitInstanceBindRegions ); +# endif } bool operator!=( BindImageMemoryDeviceGroupInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -7216,31 +7587,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, image, memory, memoryOffset ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BindImageMemoryInfo const & ) const = default; #else bool operator==( BindImageMemoryInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( image == rhs.image ) && ( memory == rhs.memory ) && + ( memoryOffset == rhs.memoryOffset ); +# endif } bool operator!=( BindImageMemoryInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -7327,30 +7705,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, swapchain, imageIndex ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BindImageMemorySwapchainInfoKHR const & ) const = default; #else bool operator==( BindImageMemorySwapchainInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchain == rhs.swapchain ) && + ( imageIndex == rhs.imageIndex ); +# endif } bool operator!=( BindImageMemorySwapchainInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -7429,29 +7814,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, planeAspect ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BindImagePlaneMemoryInfo const & ) const = default; #else bool operator==( BindImagePlaneMemoryInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( planeAspect == rhs.planeAspect ); +# endif } bool operator!=( BindImagePlaneMemoryInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -7538,27 +7929,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( bufferAddress, size, indexType ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BindIndexBufferIndirectCommandNV const & ) const = default; #else bool operator==( BindIndexBufferIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( bufferAddress == rhs.bufferAddress ) && ( size == rhs.size ) && ( indexType == rhs.indexType ); +# endif } bool operator!=( BindIndexBufferIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -7620,27 +8017,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( groupIndex ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BindShaderGroupIndirectCommandNV const & ) const = default; #else bool operator==( BindShaderGroupIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( groupIndex == rhs.groupIndex ); +# endif } bool operator!=( BindShaderGroupIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -7734,31 +8137,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( resourceOffset, size, memory, memoryOffset, flags ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SparseMemoryBind const & ) const = default; #else bool operator==( SparseMemoryBind const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( resourceOffset == rhs.resourceOffset ) && ( size == rhs.size ) && ( memory == rhs.memory ) && + ( memoryOffset == rhs.memoryOffset ) && ( flags == rhs.flags ); +# endif } bool operator!=( SparseMemoryBind const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -7857,29 +8267,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( buffer, bindCount, pBinds ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SparseBufferMemoryBindInfo const & ) const = default; #else bool operator==( SparseBufferMemoryBindInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( buffer == rhs.buffer ) && ( bindCount == rhs.bindCount ) && ( pBinds == rhs.pBinds ); +# endif } bool operator!=( SparseBufferMemoryBindInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -7978,29 +8394,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( image, bindCount, pBinds ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SparseImageOpaqueMemoryBindInfo const & ) const = default; #else bool operator==( SparseImageOpaqueMemoryBindInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( image == rhs.image ) && ( bindCount == rhs.bindCount ) && ( pBinds == rhs.pBinds ); +# endif } bool operator!=( SparseImageOpaqueMemoryBindInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -8077,27 +8499,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( aspectMask, mipLevel, arrayLayer ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageSubresource const & ) const = default; #else bool operator==( ImageSubresource const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( aspectMask == rhs.aspectMask ) && ( mipLevel == rhs.mipLevel ) && ( arrayLayer == rhs.arrayLayer ); +# endif } bool operator!=( ImageSubresource const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -8169,27 +8597,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( x, y, z ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( Offset3D const & ) const = default; #else bool operator==( Offset3D const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( x == rhs.x ) && ( y == rhs.y ) && ( z == rhs.z ); +# endif } bool operator!=( Offset3D const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -8264,27 +8698,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( width, height, depth ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( Extent3D const & ) const = default; #else bool operator==( Extent3D const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( width == rhs.width ) && ( height == rhs.height ) && ( depth == rhs.depth ); +# endif } bool operator!=( Extent3D const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -8389,32 +8829,39 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( subresource, offset, extent, memory, memoryOffset, flags ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SparseImageMemoryBind const & ) const = default; #else bool operator==( SparseImageMemoryBind const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( subresource == rhs.subresource ) && ( offset == rhs.offset ) && ( extent == rhs.extent ) && + ( memory == rhs.memory ) && ( memoryOffset == rhs.memoryOffset ) && ( flags == rhs.flags ); +# endif } bool operator!=( SparseImageMemoryBind const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -8514,29 +8961,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( image, bindCount, pBinds ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SparseImageMemoryBindInfo const & ) const = default; #else bool operator==( SparseImageMemoryBindInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( image == rhs.image ) && ( bindCount == rhs.bindCount ) && ( pBinds == rhs.pBinds ); +# endif } bool operator!=( SparseImageMemoryBindInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -8763,9 +9216,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -8794,18 +9248,28 @@ namespace VULKAN_HPP_NAMESPACE signalSemaphoreCount, pSignalSemaphores ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BindSparseInfo const & ) const = default; #else bool operator==( BindSparseInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( waitSemaphoreCount == rhs.waitSemaphoreCount ) && + ( pWaitSemaphores == rhs.pWaitSemaphores ) && ( bufferBindCount == rhs.bufferBindCount ) && + ( pBufferBinds == rhs.pBufferBinds ) && ( imageOpaqueBindCount == rhs.imageOpaqueBindCount ) && + ( pImageOpaqueBinds == rhs.pImageOpaqueBinds ) && ( imageBindCount == rhs.imageBindCount ) && + ( pImageBinds == rhs.pImageBinds ) && ( signalSemaphoreCount == rhs.signalSemaphoreCount ) && + ( pSignalSemaphores == rhs.pSignalSemaphores ); +# endif } bool operator!=( BindSparseInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -8897,27 +9361,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( bufferAddress, size, stride ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BindVertexBufferIndirectCommandNV const & ) const = default; #else bool operator==( BindVertexBufferIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( bufferAddress == rhs.bufferAddress ) && ( size == rhs.size ) && ( stride == rhs.stride ); +# endif } bool operator!=( BindVertexBufferIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -9002,27 +9472,34 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( aspectMask, mipLevel, baseArrayLayer, layerCount ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageSubresourceLayers const & ) const = default; #else bool operator==( ImageSubresourceLayers const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( aspectMask == rhs.aspectMask ) && ( mipLevel == rhs.mipLevel ) && + ( baseArrayLayer == rhs.baseArrayLayer ) && ( layerCount == rhs.layerCount ); +# endif } bool operator!=( ImageSubresourceLayers const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -9120,32 +9597,40 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple const &, VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const &, VULKAN_HPP_NAMESPACE::ArrayWrapper1D const &> -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, srcSubresource, srcOffsets, dstSubresource, dstOffsets ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageBlit2KHR const & ) const = default; #else bool operator==( ImageBlit2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcSubresource == rhs.srcSubresource ) && + ( srcOffsets == rhs.srcOffsets ) && ( dstSubresource == rhs.dstSubresource ) && + ( dstOffsets == rhs.dstOffsets ); +# endif } bool operator!=( ImageBlit2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -9302,9 +9787,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BlitImageInfo2KHR const & ) const = default; #else bool operator==( BlitImageInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcImage == rhs.srcImage ) && + ( srcImageLayout == rhs.srcImageLayout ) && ( dstImage == rhs.dstImage ) && + ( dstImageLayout == rhs.dstImageLayout ) && ( regionCount == rhs.regionCount ) && + ( pRegions == rhs.pRegions ) && ( filter == rhs.filter ); +# endif } bool operator!=( BlitImageInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -9427,30 +9921,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, collection, index ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BufferCollectionBufferCreateInfoFUCHSIA const & ) const = default; # else bool operator==( BufferCollectionBufferCreateInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( collection == rhs.collection ) && + ( index == rhs.index ); +# endif } bool operator!=( BufferCollectionBufferCreateInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -9572,9 +10073,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -9593,18 +10095,26 @@ namespace VULKAN_HPP_NAMESPACE minBufferCountForDedicatedSlack, minBufferCountForSharedSlack ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BufferCollectionConstraintsInfoFUCHSIA const & ) const = default; # else bool operator==( BufferCollectionConstraintsInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( minBufferCount == rhs.minBufferCount ) && + ( maxBufferCount == rhs.maxBufferCount ) && ( minBufferCountForCamping == rhs.minBufferCountForCamping ) && + ( minBufferCountForDedicatedSlack == rhs.minBufferCountForDedicatedSlack ) && + ( minBufferCountForSharedSlack == rhs.minBufferCountForSharedSlack ); +# endif } bool operator!=( BufferCollectionConstraintsInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -9690,27 +10200,34 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, collectionToken ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BufferCollectionCreateInfoFUCHSIA const & ) const = default; # else bool operator==( BufferCollectionCreateInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( memcmp( &collectionToken, &rhs.collectionToken, sizeof( zx_handle_t ) ) == 0 ); +# endif } bool operator!=( BufferCollectionCreateInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -9802,30 +10319,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, collection, index ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BufferCollectionImageCreateInfoFUCHSIA const & ) const = default; # else bool operator==( BufferCollectionImageCreateInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( collection == rhs.collection ) && + ( index == rhs.index ); +# endif } bool operator!=( BufferCollectionImageCreateInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -9904,27 +10428,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, colorSpace ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SysmemColorSpaceFUCHSIA const & ) const = default; # else bool operator==( SysmemColorSpaceFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( colorSpace == rhs.colorSpace ); +# endif } bool operator!=( SysmemColorSpaceFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -10097,9 +10627,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -10130,18 +10661,30 @@ namespace VULKAN_HPP_NAMESPACE suggestedXChromaOffset, suggestedYChromaOffset ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BufferCollectionPropertiesFUCHSIA const & ) const = default; # else bool operator==( BufferCollectionPropertiesFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryTypeBits == rhs.memoryTypeBits ) && + ( bufferCount == rhs.bufferCount ) && ( createInfoIndex == rhs.createInfoIndex ) && + ( sysmemPixelFormat == rhs.sysmemPixelFormat ) && ( formatFeatures == rhs.formatFeatures ) && + ( sysmemColorSpaceIndex == rhs.sysmemColorSpaceIndex ) && + ( samplerYcbcrConversionComponents == rhs.samplerYcbcrConversionComponents ) && + ( suggestedYcbcrModel == rhs.suggestedYcbcrModel ) && ( suggestedYcbcrRange == rhs.suggestedYcbcrRange ) && + ( suggestedXChromaOffset == rhs.suggestedXChromaOffset ) && + ( suggestedYChromaOffset == rhs.suggestedYChromaOffset ); +# endif } bool operator!=( BufferCollectionPropertiesFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -10299,9 +10842,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, flags, size, usage, sharingMode, queueFamilyIndexCount, pQueueFamilyIndices ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BufferCreateInfo const & ) const = default; #else bool operator==( BufferCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( size == rhs.size ) && + ( usage == rhs.usage ) && ( sharingMode == rhs.sharingMode ) && + ( queueFamilyIndexCount == rhs.queueFamilyIndexCount ) && + ( pQueueFamilyIndices == rhs.pQueueFamilyIndices ); +# endif } bool operator!=( BufferCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -10428,31 +10980,39 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, createInfo, requiredFormatFeatures, bufferCollectionConstraints ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BufferConstraintsInfoFUCHSIA const & ) const = default; # else bool operator==( BufferConstraintsInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( createInfo == rhs.createInfo ) && + ( requiredFormatFeatures == rhs.requiredFormatFeatures ) && + ( bufferCollectionConstraints == rhs.bufferCollectionConstraints ); +# endif } bool operator!=( BufferConstraintsInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -10537,29 +11097,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( srcOffset, dstOffset, size ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BufferCopy const & ) const = default; #else bool operator==( BufferCopy const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( srcOffset == rhs.srcOffset ) && ( dstOffset == rhs.dstOffset ) && ( size == rhs.size ); +# endif } bool operator!=( BufferCopy const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -10644,31 +11210,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, srcOffset, dstOffset, size ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BufferCopy2KHR const & ) const = default; #else bool operator==( BufferCopy2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcOffset == rhs.srcOffset ) && + ( dstOffset == rhs.dstOffset ) && ( size == rhs.size ); +# endif } bool operator!=( BufferCopy2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -10747,29 +11320,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, deviceAddress ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BufferDeviceAddressCreateInfoEXT const & ) const = default; #else bool operator==( BufferDeviceAddressCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceAddress == rhs.deviceAddress ); +# endif } bool operator!=( BufferDeviceAddressCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -10845,27 +11424,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, buffer ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BufferDeviceAddressInfo const & ) const = default; #else bool operator==( BufferDeviceAddressInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( buffer == rhs.buffer ); +# endif } bool operator!=( BufferDeviceAddressInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -10976,32 +11561,40 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( bufferOffset, bufferRowLength, bufferImageHeight, imageSubresource, imageOffset, imageExtent ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BufferImageCopy const & ) const = default; #else bool operator==( BufferImageCopy const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( bufferOffset == rhs.bufferOffset ) && ( bufferRowLength == rhs.bufferRowLength ) && + ( bufferImageHeight == rhs.bufferImageHeight ) && ( imageSubresource == rhs.imageSubresource ) && + ( imageOffset == rhs.imageOffset ) && ( imageExtent == rhs.imageExtent ); +# endif } bool operator!=( BufferImageCopy const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -11116,9 +11709,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, bufferOffset, bufferRowLength, bufferImageHeight, imageSubresource, imageOffset, imageExtent ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BufferImageCopy2KHR const & ) const = default; #else bool operator==( BufferImageCopy2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( bufferOffset == rhs.bufferOffset ) && + ( bufferRowLength == rhs.bufferRowLength ) && ( bufferImageHeight == rhs.bufferImageHeight ) && + ( imageSubresource == rhs.imageSubresource ) && ( imageOffset == rhs.imageOffset ) && + ( imageExtent == rhs.imageExtent ); +# endif } bool operator!=( BufferImageCopy2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -11275,9 +11877,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, srcAccessMask, dstAccessMask, srcQueueFamilyIndex, dstQueueFamilyIndex, buffer, offset, size ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BufferMemoryBarrier const & ) const = default; #else bool operator==( BufferMemoryBarrier const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcAccessMask == rhs.srcAccessMask ) && + ( dstAccessMask == rhs.dstAccessMask ) && ( srcQueueFamilyIndex == rhs.srcQueueFamilyIndex ) && + ( dstQueueFamilyIndex == rhs.dstQueueFamilyIndex ) && ( buffer == rhs.buffer ) && + ( offset == rhs.offset ) && ( size == rhs.size ); +# endif } bool operator!=( BufferMemoryBarrier const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -11456,9 +12067,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -11485,18 +12097,27 @@ namespace VULKAN_HPP_NAMESPACE offset, size ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BufferMemoryBarrier2KHR const & ) const = default; #else bool operator==( BufferMemoryBarrier2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcStageMask == rhs.srcStageMask ) && + ( srcAccessMask == rhs.srcAccessMask ) && ( dstStageMask == rhs.dstStageMask ) && + ( dstAccessMask == rhs.dstAccessMask ) && ( srcQueueFamilyIndex == rhs.srcQueueFamilyIndex ) && + ( dstQueueFamilyIndex == rhs.dstQueueFamilyIndex ) && ( buffer == rhs.buffer ) && + ( offset == rhs.offset ) && ( size == rhs.size ); +# endif } bool operator!=( BufferMemoryBarrier2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -11581,27 +12202,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, buffer ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BufferMemoryRequirementsInfo2 const & ) const = default; #else bool operator==( BufferMemoryRequirementsInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( buffer == rhs.buffer ); +# endif } bool operator!=( BufferMemoryRequirementsInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -11682,27 +12309,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, opaqueCaptureAddress ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BufferOpaqueCaptureAddressCreateInfo const & ) const = default; #else bool operator==( BufferOpaqueCaptureAddressCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( opaqueCaptureAddress == rhs.opaqueCaptureAddress ); +# endif } bool operator!=( BufferOpaqueCaptureAddressCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -11814,9 +12447,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, flags, buffer, format, offset, range ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BufferViewCreateInfo const & ) const = default; #else bool operator==( BufferViewCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( buffer == rhs.buffer ) && + ( format == rhs.format ) && ( offset == rhs.offset ) && ( range == rhs.range ); +# endif } bool operator!=( BufferViewCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -11921,29 +12561,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, timeDomain ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( CalibratedTimestampInfoEXT const & ) const = default; #else bool operator==( CalibratedTimestampInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( timeDomain == rhs.timeDomain ); +# endif } bool operator!=( CalibratedTimestampInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -12005,30 +12651,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, stage, pCheckpointMarker ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( CheckpointData2NV const & ) const = default; #else bool operator==( CheckpointData2NV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stage == rhs.stage ) && + ( pCheckpointMarker == rhs.pCheckpointMarker ); +# endif } bool operator!=( CheckpointData2NV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -12091,30 +12744,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, stage, pCheckpointMarker ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( CheckpointDataNV const & ) const = default; #else bool operator==( CheckpointDataNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stage == rhs.stage ) && + ( pCheckpointMarker == rhs.pCheckpointMarker ); +# endif } bool operator!=( CheckpointDataNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -12233,27 +12893,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( depth, stencil ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ClearDepthStencilValue const & ) const = default; #else bool operator==( ClearDepthStencilValue const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( depth == rhs.depth ) && ( stencil == rhs.stencil ); +# endif } bool operator!=( ClearDepthStencilValue const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -12376,16 +13042,18 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std:: tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( aspectMask, colorAttachment, clearValue ); } +#endif public: VULKAN_HPP_NAMESPACE::ImageAspectFlags aspectMask = {}; @@ -12456,27 +13124,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( rect, baseArrayLayer, layerCount ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ClearRect const & ) const = default; #else - bool operator==( ClearRect const & rhs ) const VULKAN_HPP_NOEXCEPT + bool operator==( ClearRect const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( rect == rhs.rect ) && ( baseArrayLayer == rhs.baseArrayLayer ) && ( layerCount == rhs.layerCount ); +# endif } bool operator!=( ClearRect const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -12549,27 +13223,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( pixelX, pixelY, sample ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( CoarseSampleLocationNV const & ) const = default; #else bool operator==( CoarseSampleLocationNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( pixelX == rhs.pixelX ) && ( pixelY == rhs.pixelY ) && ( sample == rhs.sample ); +# endif } bool operator!=( CoarseSampleLocationNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -12682,30 +13362,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( shadingRate, sampleCount, sampleLocationCount, pSampleLocations ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( CoarseSampleOrderCustomNV const & ) const = default; #else bool operator==( CoarseSampleOrderCustomNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( shadingRate == rhs.shadingRate ) && ( sampleCount == rhs.sampleCount ) && + ( sampleLocationCount == rhs.sampleLocationCount ) && ( pSampleLocations == rhs.pSampleLocations ); +# endif } bool operator!=( CoarseSampleOrderCustomNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -12796,31 +13483,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, commandPool, level, commandBufferCount ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( CommandBufferAllocateInfo const & ) const = default; #else bool operator==( CommandBufferAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( commandPool == rhs.commandPool ) && + ( level == rhs.level ) && ( commandBufferCount == rhs.commandBufferCount ); +# endif } bool operator!=( CommandBufferAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -12943,9 +13637,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, renderPass, subpass, framebuffer, occlusionQueryEnable, queryFlags, pipelineStatistics ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( CommandBufferInheritanceInfo const & ) const = default; #else bool operator==( CommandBufferInheritanceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( renderPass == rhs.renderPass ) && + ( subpass == rhs.subpass ) && ( framebuffer == rhs.framebuffer ) && + ( occlusionQueryEnable == rhs.occlusionQueryEnable ) && ( queryFlags == rhs.queryFlags ) && + ( pipelineStatistics == rhs.pipelineStatistics ); +# endif } bool operator!=( CommandBufferInheritanceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -13062,30 +13765,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, flags, pInheritanceInfo ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( CommandBufferBeginInfo const & ) const = default; #else bool operator==( CommandBufferBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && + ( pInheritanceInfo == rhs.pInheritanceInfo ); +# endif } bool operator!=( CommandBufferBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -13170,27 +13880,34 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, conditionalRenderingEnable ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( CommandBufferInheritanceConditionalRenderingInfoEXT const & ) const = default; #else bool operator==( CommandBufferInheritanceConditionalRenderingInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( conditionalRenderingEnable == rhs.conditionalRenderingEnable ); +# endif } bool operator!=( CommandBufferInheritanceConditionalRenderingInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -13286,30 +14003,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, transform, renderArea ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( CommandBufferInheritanceRenderPassTransformInfoQCOM const & ) const = default; #else bool operator==( CommandBufferInheritanceRenderPassTransformInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( transform == rhs.transform ) && + ( renderArea == rhs.renderArea ); +# endif } bool operator!=( CommandBufferInheritanceRenderPassTransformInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -13480,9 +14204,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -13505,18 +14230,28 @@ namespace VULKAN_HPP_NAMESPACE stencilAttachmentFormat, rasterizationSamples ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( CommandBufferInheritanceRenderingInfoKHR const & ) const = default; #else bool operator==( CommandBufferInheritanceRenderingInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && + ( viewMask == rhs.viewMask ) && ( colorAttachmentCount == rhs.colorAttachmentCount ) && + ( pColorAttachmentFormats == rhs.pColorAttachmentFormats ) && + ( depthAttachmentFormat == rhs.depthAttachmentFormat ) && + ( stencilAttachmentFormat == rhs.stencilAttachmentFormat ) && + ( rasterizationSamples == rhs.rasterizationSamples ); +# endif } bool operator!=( CommandBufferInheritanceRenderingInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -13627,27 +14362,34 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( x, y, width, height, minDepth, maxDepth ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( Viewport const & ) const = default; #else bool operator==( Viewport const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( x == rhs.x ) && ( y == rhs.y ) && ( width == rhs.width ) && ( height == rhs.height ) && + ( minDepth == rhs.minDepth ) && ( maxDepth == rhs.maxDepth ); +# endif } bool operator!=( Viewport const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -13744,31 +14486,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, viewportScissor2D, viewportDepthCount, pViewportDepths ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( CommandBufferInheritanceViewportScissorInfoNV const & ) const = default; #else bool operator==( CommandBufferInheritanceViewportScissorInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( viewportScissor2D == rhs.viewportScissor2D ) && + ( viewportDepthCount == rhs.viewportDepthCount ) && ( pViewportDepths == rhs.pViewportDepths ); +# endif } bool operator!=( CommandBufferInheritanceViewportScissorInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -13856,30 +14605,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, commandBuffer, deviceMask ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( CommandBufferSubmitInfoKHR const & ) const = default; #else bool operator==( CommandBufferSubmitInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( commandBuffer == rhs.commandBuffer ) && + ( deviceMask == rhs.deviceMask ); +# endif } bool operator!=( CommandBufferSubmitInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -13964,30 +14720,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, flags, queueFamilyIndex ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( CommandPoolCreateInfo const & ) const = default; #else bool operator==( CommandPoolCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && + ( queueFamilyIndex == rhs.queueFamilyIndex ); +# endif } bool operator!=( CommandPoolCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -14067,27 +14830,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( constantID, offset, size ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SpecializationMapEntry const & ) const = default; #else bool operator==( SpecializationMapEntry const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( constantID == rhs.constantID ) && ( offset == rhs.offset ) && ( size == rhs.size ); +# endif } bool operator!=( SpecializationMapEntry const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -14205,30 +14974,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( mapEntryCount, pMapEntries, dataSize, pData ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SpecializationInfo const & ) const = default; #else bool operator==( SpecializationInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( mapEntryCount == rhs.mapEntryCount ) && ( pMapEntries == rhs.pMapEntries ) && + ( dataSize == rhs.dataSize ) && ( pData == rhs.pData ); +# endif } bool operator!=( SpecializationInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -14335,9 +15111,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, flags, stage, module, pName, pSpecializationInfo ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineShaderStageCreateInfo const & ) const = default; #else bool operator==( PipelineShaderStageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( stage == rhs.stage ) && + ( module == rhs.module ) && ( pName == rhs.pName ) && ( pSpecializationInfo == rhs.pSpecializationInfo ); +# endif } bool operator!=( PipelineShaderStageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -14478,9 +15261,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, flags, stage, layout, basePipelineHandle, basePipelineIndex ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ComputePipelineCreateInfo const & ) const = default; #else bool operator==( ComputePipelineCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( stage == rhs.stage ) && + ( layout == rhs.layout ) && ( basePipelineHandle == rhs.basePipelineHandle ) && + ( basePipelineIndex == rhs.basePipelineIndex ); +# endif } bool operator!=( ComputePipelineCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -14604,31 +15395,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, buffer, offset, flags ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ConditionalRenderingBeginInfoEXT const & ) const = default; #else bool operator==( ConditionalRenderingBeginInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( buffer == rhs.buffer ) && ( offset == rhs.offset ) && + ( flags == rhs.flags ); +# endif } bool operator!=( ConditionalRenderingBeginInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -14720,27 +15518,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( major, minor, subminor, patch ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ConformanceVersion const & ) const = default; #else bool operator==( ConformanceVersion const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( major == rhs.major ) && ( minor == rhs.minor ) && ( subminor == rhs.subminor ) && ( patch == rhs.patch ); +# endif } bool operator!=( ConformanceVersion const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -14873,9 +15677,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, MSize, NSize, KSize, AType, BType, CType, DType, scope ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( CooperativeMatrixPropertiesNV const & ) const = default; #else bool operator==( CooperativeMatrixPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( MSize == rhs.MSize ) && ( NSize == rhs.NSize ) && + ( KSize == rhs.KSize ) && ( AType == rhs.AType ) && ( BType == rhs.BType ) && ( CType == rhs.CType ) && + ( DType == rhs.DType ) && ( scope == rhs.scope ); +# endif } bool operator!=( CooperativeMatrixPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -15007,31 +15819,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, src, dst, mode ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( CopyAccelerationStructureInfoKHR const & ) const = default; #else bool operator==( CopyAccelerationStructureInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( src == rhs.src ) && ( dst == rhs.dst ) && + ( mode == rhs.mode ); +# endif } bool operator!=( CopyAccelerationStructureInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -15137,19 +15956,21 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, src, dst, mode ); } +#endif public: VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eCopyAccelerationStructureToMemoryInfoKHR; @@ -15277,32 +16098,39 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, srcBuffer, dstBuffer, regionCount, pRegions ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( CopyBufferInfo2KHR const & ) const = default; #else bool operator==( CopyBufferInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcBuffer == rhs.srcBuffer ) && + ( dstBuffer == rhs.dstBuffer ) && ( regionCount == rhs.regionCount ) && ( pRegions == rhs.pRegions ); +# endif } bool operator!=( CopyBufferInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -15441,9 +16269,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( CopyBufferToImageInfo2KHR const & ) const = default; #else bool operator==( CopyBufferToImageInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcBuffer == rhs.srcBuffer ) && + ( dstImage == rhs.dstImage ) && ( dstImageLayout == rhs.dstImageLayout ) && + ( regionCount == rhs.regionCount ) && ( pRegions == rhs.pRegions ); +# endif } bool operator!=( CopyBufferToImageInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -15549,29 +16385,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, transform ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( CopyCommandTransformInfoQCOM const & ) const = default; #else bool operator==( CopyCommandTransformInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( transform == rhs.transform ); +# endif } bool operator!=( CopyCommandTransformInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -15697,9 +16539,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, srcSet, srcBinding, srcArrayElement, dstSet, dstBinding, dstArrayElement, descriptorCount ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( CopyDescriptorSet const & ) const = default; #else bool operator==( CopyDescriptorSet const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcSet == rhs.srcSet ) && + ( srcBinding == rhs.srcBinding ) && ( srcArrayElement == rhs.srcArrayElement ) && + ( dstSet == rhs.dstSet ) && ( dstBinding == rhs.dstBinding ) && + ( dstArrayElement == rhs.dstArrayElement ) && ( descriptorCount == rhs.descriptorCount ); +# endif } bool operator!=( CopyDescriptorSet const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -15842,9 +16693,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, srcSubresource, srcOffset, dstSubresource, dstOffset, extent ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageCopy2KHR const & ) const = default; #else bool operator==( ImageCopy2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcSubresource == rhs.srcSubresource ) && + ( srcOffset == rhs.srcOffset ) && ( dstSubresource == rhs.dstSubresource ) && + ( dstOffset == rhs.dstOffset ) && ( extent == rhs.extent ); +# endif } bool operator!=( ImageCopy2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -16016,9 +16875,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( CopyImageInfo2KHR const & ) const = default; #else bool operator==( CopyImageInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcImage == rhs.srcImage ) && + ( srcImageLayout == rhs.srcImageLayout ) && ( dstImage == rhs.dstImage ) && + ( dstImageLayout == rhs.dstImageLayout ) && ( regionCount == rhs.regionCount ) && + ( pRegions == rhs.pRegions ); +# endif } bool operator!=( CopyImageInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -16184,9 +17052,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( CopyImageToBufferInfo2KHR const & ) const = default; #else bool operator==( CopyImageToBufferInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcImage == rhs.srcImage ) && + ( srcImageLayout == rhs.srcImageLayout ) && ( dstBuffer == rhs.dstBuffer ) && + ( regionCount == rhs.regionCount ) && ( pRegions == rhs.pRegions ); +# endif } bool operator!=( CopyImageToBufferInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -16316,19 +17192,21 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, src, dst, mode ); } +#endif public: VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eCopyMemoryToAccelerationStructureInfoKHR; @@ -16414,30 +17292,36 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, module, pName ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( CuFunctionCreateInfoNVX const & ) const = default; #else bool operator==( CuFunctionCreateInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( module == rhs.module ) && ( pName == rhs.pName ); +# endif } bool operator!=( CuFunctionCreateInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -16647,9 +17531,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -16682,18 +17567,27 @@ namespace VULKAN_HPP_NAMESPACE extraCount, pExtras ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( CuLaunchInfoNVX const & ) const = default; #else bool operator==( CuLaunchInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( function == rhs.function ) && + ( gridDimX == rhs.gridDimX ) && ( gridDimY == rhs.gridDimY ) && ( gridDimZ == rhs.gridDimZ ) && + ( blockDimX == rhs.blockDimX ) && ( blockDimY == rhs.blockDimY ) && ( blockDimZ == rhs.blockDimZ ) && + ( sharedMemBytes == rhs.sharedMemBytes ) && ( paramCount == rhs.paramCount ) && + ( pParams == rhs.pParams ) && ( extraCount == rhs.extraCount ) && ( pExtras == rhs.pExtras ); +# endif } bool operator!=( CuLaunchInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -16802,27 +17696,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, dataSize, pData ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( CuModuleCreateInfoNVX const & ) const = default; #else bool operator==( CuModuleCreateInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dataSize == rhs.dataSize ) && ( pData == rhs.pData ); +# endif } bool operator!=( CuModuleCreateInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -16956,16 +17856,17 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -16975,18 +17876,27 @@ namespace VULKAN_HPP_NAMESPACE signalSemaphoreValuesCount, pSignalSemaphoreValues ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( D3D12FenceSubmitInfoKHR const & ) const = default; # else bool operator==( D3D12FenceSubmitInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( waitSemaphoreValuesCount == rhs.waitSemaphoreValuesCount ) && + ( pWaitSemaphoreValues == rhs.pWaitSemaphoreValues ) && + ( signalSemaphoreValuesCount == rhs.signalSemaphoreValuesCount ) && + ( pSignalSemaphoreValues == rhs.pSignalSemaphoreValues ); +# endif } bool operator!=( D3D12FenceSubmitInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -17073,30 +17983,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple const &> -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, pMarkerName, color ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DebugMarkerMarkerInfoEXT const & ) const = default; #else bool operator==( DebugMarkerMarkerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pMarkerName == rhs.pMarkerName ) && + ( color == rhs.color ); +# endif } bool operator!=( DebugMarkerMarkerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -17191,31 +18108,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, objectType, object, pObjectName ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DebugMarkerObjectNameInfoEXT const & ) const = default; #else bool operator==( DebugMarkerObjectNameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( objectType == rhs.objectType ) && + ( object == rhs.object ) && ( pObjectName == rhs.pObjectName ); +# endif } bool operator!=( DebugMarkerObjectNameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -17353,9 +18277,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, objectType, object, tagName, tagSize, pTag ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DebugMarkerObjectTagInfoEXT const & ) const = default; #else bool operator==( DebugMarkerObjectTagInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( objectType == rhs.objectType ) && + ( object == rhs.object ) && ( tagName == rhs.tagName ) && ( tagSize == rhs.tagSize ) && + ( pTag == rhs.pTag ); +# endif } bool operator!=( DebugMarkerObjectTagInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -17479,31 +18411,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, flags, pfnCallback, pUserData ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DebugReportCallbackCreateInfoEXT const & ) const = default; #else bool operator==( DebugReportCallbackCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && + ( pfnCallback == rhs.pfnCallback ) && ( pUserData == rhs.pUserData ); +# endif } bool operator!=( DebugReportCallbackCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -17588,30 +18527,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple const &> -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, pLabelName, color ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DebugUtilsLabelEXT const & ) const = default; #else bool operator==( DebugUtilsLabelEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pLabelName == rhs.pLabelName ) && + ( color == rhs.color ); +# endif } bool operator!=( DebugUtilsLabelEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -17705,31 +18651,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, objectType, objectHandle, pObjectName ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DebugUtilsObjectNameInfoEXT const & ) const = default; #else bool operator==( DebugUtilsObjectNameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( objectType == rhs.objectType ) && + ( objectHandle == rhs.objectHandle ) && ( pObjectName == rhs.pObjectName ); +# endif } bool operator!=( DebugUtilsObjectNameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -17951,9 +18904,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -17982,18 +18936,28 @@ namespace VULKAN_HPP_NAMESPACE objectCount, pObjects ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DebugUtilsMessengerCallbackDataEXT const & ) const = default; #else bool operator==( DebugUtilsMessengerCallbackDataEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && + ( pMessageIdName == rhs.pMessageIdName ) && ( messageIdNumber == rhs.messageIdNumber ) && + ( pMessage == rhs.pMessage ) && ( queueLabelCount == rhs.queueLabelCount ) && + ( pQueueLabels == rhs.pQueueLabels ) && ( cmdBufLabelCount == rhs.cmdBufLabelCount ) && + ( pCmdBufLabels == rhs.pCmdBufLabels ) && ( objectCount == rhs.objectCount ) && + ( pObjects == rhs.pObjects ); +# endif } bool operator!=( DebugUtilsMessengerCallbackDataEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -18116,9 +19080,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, flags, messageSeverity, messageType, pfnUserCallback, pUserData ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DebugUtilsMessengerCreateInfoEXT const & ) const = default; #else bool operator==( DebugUtilsMessengerCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && + ( messageSeverity == rhs.messageSeverity ) && ( messageType == rhs.messageType ) && + ( pfnUserCallback == rhs.pfnUserCallback ) && ( pUserData == rhs.pUserData ); +# endif } bool operator!=( DebugUtilsMessengerCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -18281,9 +19253,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, objectType, objectHandle, tagName, tagSize, pTag ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DebugUtilsObjectTagInfoEXT const & ) const = default; #else bool operator==( DebugUtilsObjectTagInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( objectType == rhs.objectType ) && + ( objectHandle == rhs.objectHandle ) && ( tagName == rhs.tagName ) && ( tagSize == rhs.tagSize ) && + ( pTag == rhs.pTag ); +# endif } bool operator!=( DebugUtilsObjectTagInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -18391,27 +19371,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, dedicatedAllocation ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DedicatedAllocationBufferCreateInfoNV const & ) const = default; #else bool operator==( DedicatedAllocationBufferCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dedicatedAllocation == rhs.dedicatedAllocation ); +# endif } bool operator!=( DedicatedAllocationBufferCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -18492,27 +19478,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, dedicatedAllocation ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DedicatedAllocationImageCreateInfoNV const & ) const = default; #else bool operator==( DedicatedAllocationImageCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dedicatedAllocation == rhs.dedicatedAllocation ); +# endif } bool operator!=( DedicatedAllocationImageCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -18604,30 +19596,36 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, image, buffer ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DedicatedAllocationMemoryAllocateInfoNV const & ) const = default; #else bool operator==( DedicatedAllocationMemoryAllocateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( image == rhs.image ) && ( buffer == rhs.buffer ); +# endif } bool operator!=( DedicatedAllocationMemoryAllocateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -18733,32 +19731,40 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, srcStageMask, srcAccessMask, dstStageMask, dstAccessMask ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MemoryBarrier2KHR const & ) const = default; #else bool operator==( MemoryBarrier2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcStageMask == rhs.srcStageMask ) && + ( srcAccessMask == rhs.srcAccessMask ) && ( dstStageMask == rhs.dstStageMask ) && + ( dstAccessMask == rhs.dstAccessMask ); +# endif } bool operator!=( MemoryBarrier2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -18858,31 +19864,39 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( aspectMask, baseMipLevel, levelCount, baseArrayLayer, layerCount ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageSubresourceRange const & ) const = default; #else bool operator==( ImageSubresourceRange const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( aspectMask == rhs.aspectMask ) && ( baseMipLevel == rhs.baseMipLevel ) && + ( levelCount == rhs.levelCount ) && ( baseArrayLayer == rhs.baseArrayLayer ) && + ( layerCount == rhs.layerCount ); +# endif } bool operator!=( ImageSubresourceRange const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -19033,9 +20047,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -19064,18 +20079,28 @@ namespace VULKAN_HPP_NAMESPACE image, subresourceRange ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageMemoryBarrier2KHR const & ) const = default; #else bool operator==( ImageMemoryBarrier2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcStageMask == rhs.srcStageMask ) && + ( srcAccessMask == rhs.srcAccessMask ) && ( dstStageMask == rhs.dstStageMask ) && + ( dstAccessMask == rhs.dstAccessMask ) && ( oldLayout == rhs.oldLayout ) && + ( newLayout == rhs.newLayout ) && ( srcQueueFamilyIndex == rhs.srcQueueFamilyIndex ) && + ( dstQueueFamilyIndex == rhs.dstQueueFamilyIndex ) && ( image == rhs.image ) && + ( subresourceRange == rhs.subresourceRange ); +# endif } bool operator!=( ImageMemoryBarrier2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -19266,9 +20291,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -19291,18 +20317,28 @@ namespace VULKAN_HPP_NAMESPACE imageMemoryBarrierCount, pImageMemoryBarriers ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DependencyInfoKHR const & ) const = default; #else bool operator==( DependencyInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dependencyFlags == rhs.dependencyFlags ) && + ( memoryBarrierCount == rhs.memoryBarrierCount ) && ( pMemoryBarriers == rhs.pMemoryBarriers ) && + ( bufferMemoryBarrierCount == rhs.bufferMemoryBarrierCount ) && + ( pBufferMemoryBarriers == rhs.pBufferMemoryBarriers ) && + ( imageMemoryBarrierCount == rhs.imageMemoryBarrierCount ) && + ( pImageMemoryBarriers == rhs.pImageMemoryBarriers ); +# endif } bool operator!=( DependencyInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -19390,29 +20426,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( buffer, offset, range ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DescriptorBufferInfo const & ) const = default; #else bool operator==( DescriptorBufferInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( buffer == rhs.buffer ) && ( offset == rhs.offset ) && ( range == rhs.range ); +# endif } bool operator!=( DescriptorBufferInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -19490,29 +20532,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sampler, imageView, imageLayout ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DescriptorImageInfo const & ) const = default; #else bool operator==( DescriptorImageInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sampler == rhs.sampler ) && ( imageView == rhs.imageView ) && ( imageLayout == rhs.imageLayout ); +# endif } bool operator!=( DescriptorImageInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -19580,27 +20628,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( type, descriptorCount ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DescriptorPoolSize const & ) const = default; #else bool operator==( DescriptorPoolSize const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( type == rhs.type ) && ( descriptorCount == rhs.descriptorCount ); +# endif } bool operator!=( DescriptorPoolSize const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -19716,32 +20770,39 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, flags, maxSets, poolSizeCount, pPoolSizes ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DescriptorPoolCreateInfo const & ) const = default; #else bool operator==( DescriptorPoolCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( maxSets == rhs.maxSets ) && + ( poolSizeCount == rhs.poolSizeCount ) && ( pPoolSizes == rhs.pPoolSizes ); +# endif } bool operator!=( DescriptorPoolCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -19827,27 +20888,34 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, maxInlineUniformBlockBindings ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DescriptorPoolInlineUniformBlockCreateInfoEXT const & ) const = default; #else bool operator==( DescriptorPoolInlineUniformBlockCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( maxInlineUniformBlockBindings == rhs.maxInlineUniformBlockBindings ); +# endif } bool operator!=( DescriptorPoolInlineUniformBlockCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -19966,31 +21034,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, descriptorPool, descriptorSetCount, pSetLayouts ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DescriptorSetAllocateInfo const & ) const = default; #else bool operator==( DescriptorSetAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( descriptorPool == rhs.descriptorPool ) && + ( descriptorSetCount == rhs.descriptorSetCount ) && ( pSetLayouts == rhs.pSetLayouts ); +# endif } bool operator!=( DescriptorSetAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -20120,31 +21195,39 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( binding, descriptorType, descriptorCount, stageFlags, pImmutableSamplers ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DescriptorSetLayoutBinding const & ) const = default; #else bool operator==( DescriptorSetLayoutBinding const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( binding == rhs.binding ) && ( descriptorType == rhs.descriptorType ) && + ( descriptorCount == rhs.descriptorCount ) && ( stageFlags == rhs.stageFlags ) && + ( pImmutableSamplers == rhs.pImmutableSamplers ); +# endif } bool operator!=( DescriptorSetLayoutBinding const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -20251,30 +21334,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, bindingCount, pBindingFlags ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DescriptorSetLayoutBindingFlagsCreateInfo const & ) const = default; #else bool operator==( DescriptorSetLayoutBindingFlagsCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( bindingCount == rhs.bindingCount ) && + ( pBindingFlags == rhs.pBindingFlags ); +# endif } bool operator!=( DescriptorSetLayoutBindingFlagsCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -20394,31 +21484,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, flags, bindingCount, pBindings ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DescriptorSetLayoutCreateInfo const & ) const = default; #else bool operator==( DescriptorSetLayoutCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && + ( bindingCount == rhs.bindingCount ) && ( pBindings == rhs.pBindings ); +# endif } bool operator!=( DescriptorSetLayoutCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -20482,27 +21579,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, supported ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DescriptorSetLayoutSupport const & ) const = default; #else bool operator==( DescriptorSetLayoutSupport const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( supported == rhs.supported ); +# endif } bool operator!=( DescriptorSetLayoutSupport const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -20613,30 +21716,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, descriptorSetCount, pDescriptorCounts ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DescriptorSetVariableDescriptorCountAllocateInfo const & ) const = default; #else bool operator==( DescriptorSetVariableDescriptorCountAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( descriptorSetCount == rhs.descriptorSetCount ) && + ( pDescriptorCounts == rhs.pDescriptorCounts ); +# endif } bool operator!=( DescriptorSetVariableDescriptorCountAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -20708,27 +21818,34 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, maxVariableDescriptorCount ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DescriptorSetVariableDescriptorCountLayoutSupport const & ) const = default; #else bool operator==( DescriptorSetVariableDescriptorCountLayoutSupport const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( maxVariableDescriptorCount == rhs.maxVariableDescriptorCount ); +# endif } bool operator!=( DescriptorSetVariableDescriptorCountLayoutSupport const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -20842,32 +21959,40 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( dstBinding, dstArrayElement, descriptorCount, descriptorType, offset, stride ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DescriptorUpdateTemplateEntry const & ) const = default; #else bool operator==( DescriptorUpdateTemplateEntry const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( dstBinding == rhs.dstBinding ) && ( dstArrayElement == rhs.dstArrayElement ) && + ( descriptorCount == rhs.descriptorCount ) && ( descriptorType == rhs.descriptorType ) && + ( offset == rhs.offset ) && ( stride == rhs.stride ); +# endif } bool operator!=( DescriptorUpdateTemplateEntry const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -21042,9 +22167,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -21069,18 +22195,27 @@ namespace VULKAN_HPP_NAMESPACE pipelineLayout, set ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DescriptorUpdateTemplateCreateInfo const & ) const = default; #else bool operator==( DescriptorUpdateTemplateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && + ( descriptorUpdateEntryCount == rhs.descriptorUpdateEntryCount ) && + ( pDescriptorUpdateEntries == rhs.pDescriptorUpdateEntries ) && ( templateType == rhs.templateType ) && + ( descriptorSetLayout == rhs.descriptorSetLayout ) && ( pipelineBindPoint == rhs.pipelineBindPoint ) && + ( pipelineLayout == rhs.pipelineLayout ) && ( set == rhs.set ); +# endif } bool operator!=( DescriptorUpdateTemplateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -21169,29 +22304,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, pCreateInfo ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DeviceBufferMemoryRequirementsKHR const & ) const = default; #else bool operator==( DeviceBufferMemoryRequirementsKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pCreateInfo == rhs.pCreateInfo ); +# endif } bool operator!=( DeviceBufferMemoryRequirementsKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -21314,32 +22455,40 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, flags, queueFamilyIndex, queueCount, pQueuePriorities ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DeviceQueueCreateInfo const & ) const = default; #else bool operator==( DeviceQueueCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && + ( queueFamilyIndex == rhs.queueFamilyIndex ) && ( queueCount == rhs.queueCount ) && + ( pQueuePriorities == rhs.pQueuePriorities ); +# endif } bool operator!=( DeviceQueueCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -21894,9 +23043,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( robustBufferAccess, @@ -22011,18 +23161,62 @@ namespace VULKAN_HPP_NAMESPACE variableMultisampleRate, inheritedQueries ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceFeatures const & ) const = default; #else bool operator==( PhysicalDeviceFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( robustBufferAccess == rhs.robustBufferAccess ) && ( fullDrawIndexUint32 == rhs.fullDrawIndexUint32 ) && + ( imageCubeArray == rhs.imageCubeArray ) && ( independentBlend == rhs.independentBlend ) && + ( geometryShader == rhs.geometryShader ) && ( tessellationShader == rhs.tessellationShader ) && + ( sampleRateShading == rhs.sampleRateShading ) && ( dualSrcBlend == rhs.dualSrcBlend ) && + ( logicOp == rhs.logicOp ) && ( multiDrawIndirect == rhs.multiDrawIndirect ) && + ( drawIndirectFirstInstance == rhs.drawIndirectFirstInstance ) && ( depthClamp == rhs.depthClamp ) && + ( depthBiasClamp == rhs.depthBiasClamp ) && ( fillModeNonSolid == rhs.fillModeNonSolid ) && + ( depthBounds == rhs.depthBounds ) && ( wideLines == rhs.wideLines ) && + ( largePoints == rhs.largePoints ) && ( alphaToOne == rhs.alphaToOne ) && + ( multiViewport == rhs.multiViewport ) && ( samplerAnisotropy == rhs.samplerAnisotropy ) && + ( textureCompressionETC2 == rhs.textureCompressionETC2 ) && + ( textureCompressionASTC_LDR == rhs.textureCompressionASTC_LDR ) && + ( textureCompressionBC == rhs.textureCompressionBC ) && + ( occlusionQueryPrecise == rhs.occlusionQueryPrecise ) && + ( pipelineStatisticsQuery == rhs.pipelineStatisticsQuery ) && + ( vertexPipelineStoresAndAtomics == rhs.vertexPipelineStoresAndAtomics ) && + ( fragmentStoresAndAtomics == rhs.fragmentStoresAndAtomics ) && + ( shaderTessellationAndGeometryPointSize == rhs.shaderTessellationAndGeometryPointSize ) && + ( shaderImageGatherExtended == rhs.shaderImageGatherExtended ) && + ( shaderStorageImageExtendedFormats == rhs.shaderStorageImageExtendedFormats ) && + ( shaderStorageImageMultisample == rhs.shaderStorageImageMultisample ) && + ( shaderStorageImageReadWithoutFormat == rhs.shaderStorageImageReadWithoutFormat ) && + ( shaderStorageImageWriteWithoutFormat == rhs.shaderStorageImageWriteWithoutFormat ) && + ( shaderUniformBufferArrayDynamicIndexing == rhs.shaderUniformBufferArrayDynamicIndexing ) && + ( shaderSampledImageArrayDynamicIndexing == rhs.shaderSampledImageArrayDynamicIndexing ) && + ( shaderStorageBufferArrayDynamicIndexing == rhs.shaderStorageBufferArrayDynamicIndexing ) && + ( shaderStorageImageArrayDynamicIndexing == rhs.shaderStorageImageArrayDynamicIndexing ) && + ( shaderClipDistance == rhs.shaderClipDistance ) && ( shaderCullDistance == rhs.shaderCullDistance ) && + ( shaderFloat64 == rhs.shaderFloat64 ) && ( shaderInt64 == rhs.shaderInt64 ) && + ( shaderInt16 == rhs.shaderInt16 ) && ( shaderResourceResidency == rhs.shaderResourceResidency ) && + ( shaderResourceMinLod == rhs.shaderResourceMinLod ) && ( sparseBinding == rhs.sparseBinding ) && + ( sparseResidencyBuffer == rhs.sparseResidencyBuffer ) && + ( sparseResidencyImage2D == rhs.sparseResidencyImage2D ) && + ( sparseResidencyImage3D == rhs.sparseResidencyImage3D ) && + ( sparseResidency2Samples == rhs.sparseResidency2Samples ) && + ( sparseResidency4Samples == rhs.sparseResidency4Samples ) && + ( sparseResidency8Samples == rhs.sparseResidency8Samples ) && + ( sparseResidency16Samples == rhs.sparseResidency16Samples ) && + ( sparseResidencyAliased == rhs.sparseResidencyAliased ) && + ( variableMultisampleRate == rhs.variableMultisampleRate ) && ( inheritedQueries == rhs.inheritedQueries ); +# endif } bool operator!=( PhysicalDeviceFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -22257,9 +23451,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -22284,18 +23479,27 @@ namespace VULKAN_HPP_NAMESPACE ppEnabledExtensionNames, pEnabledFeatures ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DeviceCreateInfo const & ) const = default; #else bool operator==( DeviceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && + ( queueCreateInfoCount == rhs.queueCreateInfoCount ) && ( pQueueCreateInfos == rhs.pQueueCreateInfos ) && + ( enabledLayerCount == rhs.enabledLayerCount ) && ( ppEnabledLayerNames == rhs.ppEnabledLayerNames ) && + ( enabledExtensionCount == rhs.enabledExtensionCount ) && + ( ppEnabledExtensionNames == rhs.ppEnabledExtensionNames ) && ( pEnabledFeatures == rhs.pEnabledFeatures ); +# endif } bool operator!=( DeviceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -22400,31 +23604,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, flags, pfnUserCallback, pUserData ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DeviceDeviceMemoryReportCreateInfoEXT const & ) const = default; #else bool operator==( DeviceDeviceMemoryReportCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && + ( pfnUserCallback == rhs.pfnUserCallback ) && ( pUserData == rhs.pUserData ); +# endif } bool operator!=( DeviceDeviceMemoryReportCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -22506,29 +23717,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, flags ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DeviceDiagnosticsConfigCreateInfoNV const & ) const = default; #else bool operator==( DeviceDiagnosticsConfigCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ); +# endif } bool operator!=( DeviceDiagnosticsConfigCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -22606,29 +23823,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, deviceEvent ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DeviceEventInfoEXT const & ) const = default; #else bool operator==( DeviceEventInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceEvent == rhs.deviceEvent ); +# endif } bool operator!=( DeviceEventInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -22712,27 +23935,34 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, resourceDeviceIndex, memoryDeviceIndex ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DeviceGroupBindSparseInfo const & ) const = default; #else bool operator==( DeviceGroupBindSparseInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( resourceDeviceIndex == rhs.resourceDeviceIndex ) && + ( memoryDeviceIndex == rhs.memoryDeviceIndex ); +# endif } bool operator!=( DeviceGroupBindSparseInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -22812,27 +24042,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, deviceMask ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DeviceGroupCommandBufferBeginInfo const & ) const = default; #else bool operator==( DeviceGroupCommandBufferBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceMask == rhs.deviceMask ); +# endif } bool operator!=( DeviceGroupCommandBufferBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -22940,30 +24176,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, physicalDeviceCount, pPhysicalDevices ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DeviceGroupDeviceCreateInfo const & ) const = default; #else bool operator==( DeviceGroupDeviceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( physicalDeviceCount == rhs.physicalDeviceCount ) && + ( pPhysicalDevices == rhs.pPhysicalDevices ); +# endif } bool operator!=( DeviceGroupDeviceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -23032,30 +24275,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple const &, VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR const &> -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, presentMask, modes ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DeviceGroupPresentCapabilitiesKHR const & ) const = default; #else bool operator==( DeviceGroupPresentCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentMask == rhs.presentMask ) && + ( modes == rhs.modes ); +# endif } bool operator!=( DeviceGroupPresentCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -23173,31 +24423,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, swapchainCount, pDeviceMasks, mode ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DeviceGroupPresentInfoKHR const & ) const = default; #else bool operator==( DeviceGroupPresentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchainCount == rhs.swapchainCount ) && + ( pDeviceMasks == rhs.pDeviceMasks ) && ( mode == rhs.mode ); +# endif } bool operator!=( DeviceGroupPresentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -23316,31 +24573,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, deviceMask, deviceRenderAreaCount, pDeviceRenderAreas ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DeviceGroupRenderPassBeginInfo const & ) const = default; #else bool operator==( DeviceGroupRenderPassBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceMask == rhs.deviceMask ) && + ( deviceRenderAreaCount == rhs.deviceRenderAreaCount ) && ( pDeviceRenderAreas == rhs.pDeviceRenderAreas ); +# endif } bool operator!=( DeviceGroupRenderPassBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -23512,9 +24776,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -23535,18 +24800,28 @@ namespace VULKAN_HPP_NAMESPACE signalSemaphoreCount, pSignalSemaphoreDeviceIndices ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DeviceGroupSubmitInfo const & ) const = default; #else bool operator==( DeviceGroupSubmitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( waitSemaphoreCount == rhs.waitSemaphoreCount ) && + ( pWaitSemaphoreDeviceIndices == rhs.pWaitSemaphoreDeviceIndices ) && + ( commandBufferCount == rhs.commandBufferCount ) && + ( pCommandBufferDeviceMasks == rhs.pCommandBufferDeviceMasks ) && + ( signalSemaphoreCount == rhs.signalSemaphoreCount ) && + ( pSignalSemaphoreDeviceIndices == rhs.pSignalSemaphoreDeviceIndices ); +# endif } bool operator!=( DeviceGroupSubmitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -23629,29 +24904,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, modes ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DeviceGroupSwapchainCreateInfoKHR const & ) const = default; #else bool operator==( DeviceGroupSwapchainCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( modes == rhs.modes ); +# endif } bool operator!=( DeviceGroupSwapchainCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -23872,9 +25153,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -23909,18 +25191,28 @@ namespace VULKAN_HPP_NAMESPACE pQueueFamilyIndices, initialLayout ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageCreateInfo const & ) const = default; #else bool operator==( ImageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && + ( imageType == rhs.imageType ) && ( format == rhs.format ) && ( extent == rhs.extent ) && + ( mipLevels == rhs.mipLevels ) && ( arrayLayers == rhs.arrayLayers ) && ( samples == rhs.samples ) && + ( tiling == rhs.tiling ) && ( usage == rhs.usage ) && ( sharingMode == rhs.sharingMode ) && + ( queueFamilyIndexCount == rhs.queueFamilyIndexCount ) && + ( pQueueFamilyIndices == rhs.pQueueFamilyIndices ) && ( initialLayout == rhs.initialLayout ); +# endif } bool operator!=( ImageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -24019,30 +25311,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, pCreateInfo, planeAspect ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DeviceImageMemoryRequirementsKHR const & ) const = default; #else bool operator==( DeviceImageMemoryRequirementsKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pCreateInfo == rhs.pCreateInfo ) && + ( planeAspect == rhs.planeAspect ); +# endif } bool operator!=( DeviceImageMemoryRequirementsKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -24124,29 +25423,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, memory ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DeviceMemoryOpaqueCaptureAddressInfo const & ) const = default; #else bool operator==( DeviceMemoryOpaqueCaptureAddressInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memory == rhs.memory ); +# endif } bool operator!=( DeviceMemoryOpaqueCaptureAddressInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -24231,29 +25536,36 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, overallocationBehavior ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DeviceMemoryOverallocationCreateInfoAMD const & ) const = default; #else bool operator==( DeviceMemoryOverallocationCreateInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( overallocationBehavior == rhs.overallocationBehavior ); +# endif } bool operator!=( DeviceMemoryOverallocationCreateInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -24333,9 +25645,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, flags, type, memoryObjectId, size, objectType, objectHandle, heapIndex ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DeviceMemoryReportCallbackDataEXT const & ) const = default; #else bool operator==( DeviceMemoryReportCallbackDataEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( type == rhs.type ) && + ( memoryObjectId == rhs.memoryObjectId ) && ( size == rhs.size ) && ( objectType == rhs.objectType ) && + ( objectHandle == rhs.objectHandle ) && ( heapIndex == rhs.heapIndex ); +# endif } bool operator!=( DeviceMemoryReportCallbackDataEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -24447,27 +25767,34 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, privateDataSlotRequestCount ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DevicePrivateDataCreateInfoEXT const & ) const = default; #else bool operator==( DevicePrivateDataCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( privateDataSlotRequestCount == rhs.privateDataSlotRequestCount ); +# endif } bool operator!=( DevicePrivateDataCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -24550,29 +25877,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, globalPriority ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DeviceQueueGlobalPriorityCreateInfoEXT const & ) const = default; #else bool operator==( DeviceQueueGlobalPriorityCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( globalPriority == rhs.globalPriority ); +# endif } bool operator!=( DeviceQueueGlobalPriorityCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -24665,31 +25998,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, flags, queueFamilyIndex, queueIndex ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DeviceQueueInfo2 const & ) const = default; #else bool operator==( DeviceQueueInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && + ( queueFamilyIndex == rhs.queueFamilyIndex ) && ( queueIndex == rhs.queueIndex ); +# endif } bool operator!=( DeviceQueueInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -24783,31 +26123,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, flags, dfb, surface ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DirectFBSurfaceCreateInfoEXT const & ) const = default; # else bool operator==( DirectFBSurfaceCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( dfb == rhs.dfb ) && + ( surface == rhs.surface ); +# endif } bool operator!=( DirectFBSurfaceCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -24891,27 +26238,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( x, y, z ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DispatchIndirectCommand const & ) const = default; #else bool operator==( DispatchIndirectCommand const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( x == rhs.x ) && ( y == rhs.y ) && ( z == rhs.z ); +# endif } bool operator!=( DispatchIndirectCommand const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -24982,29 +26335,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, displayEvent ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DisplayEventInfoEXT const & ) const = default; #else bool operator==( DisplayEventInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( displayEvent == rhs.displayEvent ); +# endif } bool operator!=( DisplayEventInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -25077,27 +26436,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( visibleRegion, refreshRate ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DisplayModeParametersKHR const & ) const = default; #else bool operator==( DisplayModeParametersKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( visibleRegion == rhs.visibleRegion ) && ( refreshRate == rhs.refreshRate ); +# endif } bool operator!=( DisplayModeParametersKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -25175,30 +26540,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, flags, parameters ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DisplayModeCreateInfoKHR const & ) const = default; #else bool operator==( DisplayModeCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && + ( parameters == rhs.parameters ); +# endif } bool operator!=( DisplayModeCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -25259,27 +26631,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( displayMode, parameters ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DisplayModePropertiesKHR const & ) const = default; #else bool operator==( DisplayModePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( displayMode == rhs.displayMode ) && ( parameters == rhs.parameters ); +# endif } bool operator!=( DisplayModePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -25334,29 +26712,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, displayModeProperties ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DisplayModeProperties2KHR const & ) const = default; #else bool operator==( DisplayModeProperties2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( displayModeProperties == rhs.displayModeProperties ); +# endif } bool operator!=( DisplayModeProperties2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -25422,27 +26806,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, localDimmingSupport ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DisplayNativeHdrSurfaceCapabilitiesAMD const & ) const = default; #else bool operator==( DisplayNativeHdrSurfaceCapabilitiesAMD const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( localDimmingSupport == rhs.localDimmingSupport ); +# endif } bool operator!=( DisplayNativeHdrSurfaceCapabilitiesAMD const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -25519,9 +26909,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( supportedAlpha, @@ -25544,18 +26935,27 @@ namespace VULKAN_HPP_NAMESPACE minDstExtent, maxDstExtent ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DisplayPlaneCapabilitiesKHR const & ) const = default; #else bool operator==( DisplayPlaneCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( supportedAlpha == rhs.supportedAlpha ) && ( minSrcPosition == rhs.minSrcPosition ) && + ( maxSrcPosition == rhs.maxSrcPosition ) && ( minSrcExtent == rhs.minSrcExtent ) && + ( maxSrcExtent == rhs.maxSrcExtent ) && ( minDstPosition == rhs.minDstPosition ) && + ( maxDstPosition == rhs.maxDstPosition ) && ( minDstExtent == rhs.minDstExtent ) && + ( maxDstExtent == rhs.maxDstExtent ); +# endif } bool operator!=( DisplayPlaneCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -25618,29 +27018,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, capabilities ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DisplayPlaneCapabilities2KHR const & ) const = default; #else bool operator==( DisplayPlaneCapabilities2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( capabilities == rhs.capabilities ); +# endif } bool operator!=( DisplayPlaneCapabilities2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -25724,30 +27130,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, mode, planeIndex ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DisplayPlaneInfo2KHR const & ) const = default; #else bool operator==( DisplayPlaneInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( mode == rhs.mode ) && + ( planeIndex == rhs.planeIndex ); +# endif } bool operator!=( DisplayPlaneInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -25807,27 +27220,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( currentDisplay, currentStackIndex ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DisplayPlanePropertiesKHR const & ) const = default; #else bool operator==( DisplayPlanePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( currentDisplay == rhs.currentDisplay ) && ( currentStackIndex == rhs.currentStackIndex ); +# endif } bool operator!=( DisplayPlanePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -25882,29 +27301,36 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, displayPlaneProperties ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DisplayPlaneProperties2KHR const & ) const = default; #else bool operator==( DisplayPlaneProperties2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( displayPlaneProperties == rhs.displayPlaneProperties ); +# endif } bool operator!=( DisplayPlaneProperties2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -25980,29 +27406,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, powerState ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DisplayPowerInfoEXT const & ) const = default; #else bool operator==( DisplayPowerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( powerState == rhs.powerState ); +# endif } bool operator!=( DisplayPowerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -26094,31 +27526,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, srcRect, dstRect, persistent ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DisplayPresentInfoKHR const & ) const = default; #else bool operator==( DisplayPresentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcRect == rhs.srcRect ) && + ( dstRect == rhs.dstRect ) && ( persistent == rhs.persistent ); +# endif } bool operator!=( DisplayPresentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -26189,9 +27628,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( display, @@ -26210,18 +27650,26 @@ namespace VULKAN_HPP_NAMESPACE planeReorderPossible, persistentContent ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DisplayPropertiesKHR const & ) const = default; #else bool operator==( DisplayPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( display == rhs.display ) && ( displayName == rhs.displayName ) && + ( physicalDimensions == rhs.physicalDimensions ) && ( physicalResolution == rhs.physicalResolution ) && + ( supportedTransforms == rhs.supportedTransforms ) && + ( planeReorderPossible == rhs.planeReorderPossible ) && ( persistentContent == rhs.persistentContent ); +# endif } bool operator!=( DisplayPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -26279,29 +27727,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, displayProperties ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DisplayProperties2KHR const & ) const = default; #else bool operator==( DisplayProperties2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( displayProperties == rhs.displayProperties ); +# endif } bool operator!=( DisplayProperties2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -26440,9 +27894,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, flags, displayMode, planeIndex, planeStackIndex, transform, globalAlpha, alphaMode, imageExtent ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DisplaySurfaceCreateInfoKHR const & ) const = default; #else bool operator==( DisplaySurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && + ( displayMode == rhs.displayMode ) && ( planeIndex == rhs.planeIndex ) && + ( planeStackIndex == rhs.planeStackIndex ) && ( transform == rhs.transform ) && + ( globalAlpha == rhs.globalAlpha ) && ( alphaMode == rhs.alphaMode ) && ( imageExtent == rhs.imageExtent ); +# endif } bool operator!=( DisplaySurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -26578,27 +28041,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( indexCount, instanceCount, firstIndex, vertexOffset, firstInstance ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DrawIndexedIndirectCommand const & ) const = default; #else bool operator==( DrawIndexedIndirectCommand const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( indexCount == rhs.indexCount ) && ( instanceCount == rhs.instanceCount ) && + ( firstIndex == rhs.firstIndex ) && ( vertexOffset == rhs.vertexOffset ) && + ( firstInstance == rhs.firstInstance ); +# endif } bool operator!=( DrawIndexedIndirectCommand const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -26683,27 +28154,34 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( vertexCount, instanceCount, firstVertex, firstInstance ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DrawIndirectCommand const & ) const = default; #else bool operator==( DrawIndirectCommand const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( vertexCount == rhs.vertexCount ) && ( instanceCount == rhs.instanceCount ) && + ( firstVertex == rhs.firstVertex ) && ( firstInstance == rhs.firstInstance ); +# endif } bool operator!=( DrawIndirectCommand const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -26772,27 +28250,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( taskCount, firstTask ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DrawMeshTasksIndirectCommandNV const & ) const = default; #else bool operator==( DrawMeshTasksIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( taskCount == rhs.taskCount ) && ( firstTask == rhs.firstTask ); +# endif } bool operator!=( DrawMeshTasksIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -26850,27 +28334,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( drmFormatModifier, drmFormatModifierPlaneCount, drmFormatModifierTilingFeatures ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DrmFormatModifierProperties2EXT const & ) const = default; #else bool operator==( DrmFormatModifierProperties2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( drmFormatModifier == rhs.drmFormatModifier ) && + ( drmFormatModifierPlaneCount == rhs.drmFormatModifierPlaneCount ) && + ( drmFormatModifierTilingFeatures == rhs.drmFormatModifierTilingFeatures ); +# endif } bool operator!=( DrmFormatModifierProperties2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -26929,27 +28421,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( drmFormatModifier, drmFormatModifierPlaneCount, drmFormatModifierTilingFeatures ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DrmFormatModifierPropertiesEXT const & ) const = default; #else bool operator==( DrmFormatModifierPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( drmFormatModifier == rhs.drmFormatModifier ) && + ( drmFormatModifierPlaneCount == rhs.drmFormatModifierPlaneCount ) && + ( drmFormatModifierTilingFeatures == rhs.drmFormatModifierTilingFeatures ); +# endif } bool operator!=( DrmFormatModifierPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -27020,30 +28520,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, drmFormatModifierCount, pDrmFormatModifierProperties ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DrmFormatModifierPropertiesList2EXT const & ) const = default; #else bool operator==( DrmFormatModifierPropertiesList2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( drmFormatModifierCount == rhs.drmFormatModifierCount ) && + ( pDrmFormatModifierProperties == rhs.pDrmFormatModifierProperties ); +# endif } bool operator!=( DrmFormatModifierPropertiesList2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -27121,30 +28629,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, drmFormatModifierCount, pDrmFormatModifierProperties ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DrmFormatModifierPropertiesListEXT const & ) const = default; #else bool operator==( DrmFormatModifierPropertiesListEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( drmFormatModifierCount == rhs.drmFormatModifierCount ) && + ( pDrmFormatModifierProperties == rhs.pDrmFormatModifierProperties ); +# endif } bool operator!=( DrmFormatModifierPropertiesListEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -27221,29 +28737,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, flags ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( EventCreateInfo const & ) const = default; #else bool operator==( EventCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ); +# endif } bool operator!=( EventCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -27318,29 +28840,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, handleTypes ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ExportFenceCreateInfo const & ) const = default; #else bool operator==( ExportFenceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleTypes == rhs.handleTypes ); +# endif } bool operator!=( ExportFenceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -27434,31 +28962,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, pAttributes, dwAccess, name ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ExportFenceWin32HandleInfoKHR const & ) const = default; # else bool operator==( ExportFenceWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pAttributes == rhs.pAttributes ) && + ( dwAccess == rhs.dwAccess ) && ( name == rhs.name ); +# endif } bool operator!=( ExportFenceWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -27538,29 +29073,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, handleTypes ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ExportMemoryAllocateInfo const & ) const = default; #else bool operator==( ExportMemoryAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleTypes == rhs.handleTypes ); +# endif } bool operator!=( ExportMemoryAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -27638,29 +29179,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, handleTypes ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ExportMemoryAllocateInfoNV const & ) const = default; #else bool operator==( ExportMemoryAllocateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleTypes == rhs.handleTypes ); +# endif } bool operator!=( ExportMemoryAllocateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -27754,31 +29301,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, pAttributes, dwAccess, name ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ExportMemoryWin32HandleInfoKHR const & ) const = default; # else bool operator==( ExportMemoryWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pAttributes == rhs.pAttributes ) && + ( dwAccess == rhs.dwAccess ) && ( name == rhs.name ); +# endif } bool operator!=( ExportMemoryWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -27868,30 +29422,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, pAttributes, dwAccess ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ExportMemoryWin32HandleInfoNV const & ) const = default; # else bool operator==( ExportMemoryWin32HandleInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pAttributes == rhs.pAttributes ) && + ( dwAccess == rhs.dwAccess ); +# endif } bool operator!=( ExportMemoryWin32HandleInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -27971,29 +29532,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, handleTypes ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ExportSemaphoreCreateInfo const & ) const = default; #else bool operator==( ExportSemaphoreCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleTypes == rhs.handleTypes ); +# endif } bool operator!=( ExportSemaphoreCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -28089,31 +29656,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, pAttributes, dwAccess, name ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ExportSemaphoreWin32HandleInfoKHR const & ) const = default; # else bool operator==( ExportSemaphoreWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pAttributes == rhs.pAttributes ) && + ( dwAccess == rhs.dwAccess ) && ( name == rhs.name ); +# endif } bool operator!=( ExportSemaphoreWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -28177,27 +29751,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple const &, uint32_t const &> -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( extensionName, specVersion ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ExtensionProperties const & ) const = default; #else bool operator==( ExtensionProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( extensionName == rhs.extensionName ) && ( specVersion == rhs.specVersion ); +# endif } bool operator!=( ExtensionProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -28251,29 +29831,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( externalMemoryFeatures, exportFromImportedHandleTypes, compatibleHandleTypes ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ExternalMemoryProperties const & ) const = default; #else bool operator==( ExternalMemoryProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( externalMemoryFeatures == rhs.externalMemoryFeatures ) && + ( exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes ) && + ( compatibleHandleTypes == rhs.compatibleHandleTypes ); +# endif } bool operator!=( ExternalMemoryProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -28329,29 +29917,36 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, externalMemoryProperties ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ExternalBufferProperties const & ) const = default; #else bool operator==( ExternalBufferProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( externalMemoryProperties == rhs.externalMemoryProperties ); +# endif } bool operator!=( ExternalBufferProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -28417,31 +30012,40 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, exportFromImportedHandleTypes, compatibleHandleTypes, externalFenceFeatures ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ExternalFenceProperties const & ) const = default; #else bool operator==( ExternalFenceProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes ) && + ( compatibleHandleTypes == rhs.compatibleHandleTypes ) && + ( externalFenceFeatures == rhs.externalFenceFeatures ); +# endif } bool operator!=( ExternalFenceProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -28519,27 +30123,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, externalFormat ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ExternalFormatANDROID const & ) const = default; # else bool operator==( ExternalFormatANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( externalFormat == rhs.externalFormat ); +# endif } bool operator!=( ExternalFormatANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -28602,29 +30212,36 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, externalMemoryProperties ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ExternalImageFormatProperties const & ) const = default; #else bool operator==( ExternalImageFormatProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( externalMemoryProperties == rhs.externalMemoryProperties ); +# endif } bool operator!=( ExternalImageFormatProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -28692,31 +30309,39 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( maxExtent, maxMipLevels, maxArrayLayers, sampleCounts, maxResourceSize ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageFormatProperties const & ) const = default; #else bool operator==( ImageFormatProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( maxExtent == rhs.maxExtent ) && ( maxMipLevels == rhs.maxMipLevels ) && + ( maxArrayLayers == rhs.maxArrayLayers ) && ( sampleCounts == rhs.sampleCounts ) && + ( maxResourceSize == rhs.maxResourceSize ); +# endif } bool operator!=( ImageFormatProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -28777,31 +30402,40 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( imageFormatProperties, externalMemoryFeatures, exportFromImportedHandleTypes, compatibleHandleTypes ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ExternalImageFormatPropertiesNV const & ) const = default; #else bool operator==( ExternalImageFormatPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( imageFormatProperties == rhs.imageFormatProperties ) && + ( externalMemoryFeatures == rhs.externalMemoryFeatures ) && + ( exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes ) && + ( compatibleHandleTypes == rhs.compatibleHandleTypes ); +# endif } bool operator!=( ExternalImageFormatPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -28875,29 +30509,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, handleTypes ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ExternalMemoryBufferCreateInfo const & ) const = default; #else bool operator==( ExternalMemoryBufferCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleTypes == rhs.handleTypes ); +# endif } bool operator!=( ExternalMemoryBufferCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -28977,29 +30617,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, handleTypes ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ExternalMemoryImageCreateInfo const & ) const = default; #else bool operator==( ExternalMemoryImageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleTypes == rhs.handleTypes ); +# endif } bool operator!=( ExternalMemoryImageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -29079,29 +30725,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, handleTypes ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ExternalMemoryImageCreateInfoNV const & ) const = default; #else bool operator==( ExternalMemoryImageCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleTypes == rhs.handleTypes ); +# endif } bool operator!=( ExternalMemoryImageCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -29168,31 +30820,40 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, exportFromImportedHandleTypes, compatibleHandleTypes, externalSemaphoreFeatures ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ExternalSemaphoreProperties const & ) const = default; #else bool operator==( ExternalSemaphoreProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes ) && + ( compatibleHandleTypes == rhs.compatibleHandleTypes ) && + ( externalSemaphoreFeatures == rhs.externalSemaphoreFeatures ); +# endif } bool operator!=( ExternalSemaphoreProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -29271,29 +30932,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, flags ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( FenceCreateInfo const & ) const = default; #else bool operator==( FenceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ); +# endif } bool operator!=( FenceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -29377,30 +31044,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, fence, handleType ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( FenceGetFdInfoKHR const & ) const = default; #else bool operator==( FenceGetFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fence == rhs.fence ) && + ( handleType == rhs.handleType ); +# endif } bool operator!=( FenceGetFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -29489,30 +31163,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, fence, handleType ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( FenceGetWin32HandleInfoKHR const & ) const = default; # else bool operator==( FenceGetWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fence == rhs.fence ) && + ( handleType == rhs.handleType ); +# endif } bool operator!=( FenceGetWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -29584,30 +31265,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, filterCubic, filterCubicMinmax ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( FilterCubicImageViewImageFormatPropertiesEXT const & ) const = default; #else bool operator==( FilterCubicImageViewImageFormatPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( filterCubic == rhs.filterCubic ) && + ( filterCubicMinmax == rhs.filterCubicMinmax ); +# endif } bool operator!=( FilterCubicImageViewImageFormatPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -29672,29 +31360,36 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( linearTilingFeatures, optimalTilingFeatures, bufferFeatures ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( FormatProperties const & ) const = default; #else bool operator==( FormatProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( linearTilingFeatures == rhs.linearTilingFeatures ) && + ( optimalTilingFeatures == rhs.optimalTilingFeatures ) && ( bufferFeatures == rhs.bufferFeatures ); +# endif } bool operator!=( FormatProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -29748,28 +31443,34 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std:: tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, formatProperties ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( FormatProperties2 const & ) const = default; #else bool operator==( FormatProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( formatProperties == rhs.formatProperties ); +# endif } bool operator!=( FormatProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -29834,31 +31535,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, linearTilingFeatures, optimalTilingFeatures, bufferFeatures ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( FormatProperties3KHR const & ) const = default; #else bool operator==( FormatProperties3KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( linearTilingFeatures == rhs.linearTilingFeatures ) && + ( optimalTilingFeatures == rhs.optimalTilingFeatures ) && ( bufferFeatures == rhs.bufferFeatures ); +# endif } bool operator!=( FormatProperties3KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -29948,30 +31656,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, pFragmentShadingRateAttachment, shadingRateAttachmentTexelSize ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( FragmentShadingRateAttachmentInfoKHR const & ) const = default; #else bool operator==( FragmentShadingRateAttachmentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( pFragmentShadingRateAttachment == rhs.pFragmentShadingRateAttachment ) && + ( shadingRateAttachmentTexelSize == rhs.shadingRateAttachmentTexelSize ); +# endif } bool operator!=( FragmentShadingRateAttachmentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -30131,9 +31847,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, flags, usage, width, height, layerCount, viewFormatCount, pViewFormats ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( FramebufferAttachmentImageInfo const & ) const = default; #else bool operator==( FramebufferAttachmentImageInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( usage == rhs.usage ) && + ( width == rhs.width ) && ( height == rhs.height ) && ( layerCount == rhs.layerCount ) && + ( viewFormatCount == rhs.viewFormatCount ) && ( pViewFormats == rhs.pViewFormats ); +# endif } bool operator!=( FramebufferAttachmentImageInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -30274,30 +31998,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, attachmentImageInfoCount, pAttachmentImageInfos ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( FramebufferAttachmentsCreateInfo const & ) const = default; #else bool operator==( FramebufferAttachmentsCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( attachmentImageInfoCount == rhs.attachmentImageInfoCount ) && + ( pAttachmentImageInfos == rhs.pAttachmentImageInfos ); +# endif } bool operator!=( FramebufferAttachmentsCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -30454,9 +32186,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, flags, renderPass, attachmentCount, pAttachments, width, height, layers ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( FramebufferCreateInfo const & ) const = default; #else bool operator==( FramebufferCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && + ( renderPass == rhs.renderPass ) && ( attachmentCount == rhs.attachmentCount ) && + ( pAttachments == rhs.pAttachments ) && ( width == rhs.width ) && ( height == rhs.height ) && + ( layers == rhs.layers ); +# endif } bool operator!=( FramebufferCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -30559,32 +32300,41 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, coverageReductionMode, rasterizationSamples, depthStencilSamples, colorSamples ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( FramebufferMixedSamplesCombinationNV const & ) const = default; #else bool operator==( FramebufferMixedSamplesCombinationNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( coverageReductionMode == rhs.coverageReductionMode ) && + ( rasterizationSamples == rhs.rasterizationSamples ) && + ( depthStencilSamples == rhs.depthStencilSamples ) && ( colorSamples == rhs.colorSamples ); +# endif } bool operator!=( FramebufferMixedSamplesCombinationNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -30664,27 +32414,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( buffer, offset ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( IndirectCommandsStreamNV const & ) const = default; #else bool operator==( IndirectCommandsStreamNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( buffer == rhs.buffer ) && ( offset == rhs.offset ); +# endif } bool operator!=( IndirectCommandsStreamNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -30901,9 +32657,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -30938,18 +32695,31 @@ namespace VULKAN_HPP_NAMESPACE sequencesIndexBuffer, sequencesIndexOffset ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( GeneratedCommandsInfoNV const & ) const = default; #else bool operator==( GeneratedCommandsInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pipelineBindPoint == rhs.pipelineBindPoint ) && + ( pipeline == rhs.pipeline ) && ( indirectCommandsLayout == rhs.indirectCommandsLayout ) && + ( streamCount == rhs.streamCount ) && ( pStreams == rhs.pStreams ) && + ( sequencesCount == rhs.sequencesCount ) && ( preprocessBuffer == rhs.preprocessBuffer ) && + ( preprocessOffset == rhs.preprocessOffset ) && ( preprocessSize == rhs.preprocessSize ) && + ( sequencesCountBuffer == rhs.sequencesCountBuffer ) && + ( sequencesCountOffset == rhs.sequencesCountOffset ) && + ( sequencesIndexBuffer == rhs.sequencesIndexBuffer ) && + ( sequencesIndexOffset == rhs.sequencesIndexOffset ); +# endif } bool operator!=( GeneratedCommandsInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -31071,32 +32841,40 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, pipelineBindPoint, pipeline, indirectCommandsLayout, maxSequencesCount ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( GeneratedCommandsMemoryRequirementsInfoNV const & ) const = default; #else bool operator==( GeneratedCommandsMemoryRequirementsInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pipelineBindPoint == rhs.pipelineBindPoint ) && + ( pipeline == rhs.pipeline ) && ( indirectCommandsLayout == rhs.indirectCommandsLayout ) && + ( maxSequencesCount == rhs.maxSequencesCount ); +# endif } bool operator!=( GeneratedCommandsMemoryRequirementsInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -31187,27 +32965,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( binding, stride, inputRate ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VertexInputBindingDescription const & ) const = default; #else bool operator==( VertexInputBindingDescription const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( binding == rhs.binding ) && ( stride == rhs.stride ) && ( inputRate == rhs.inputRate ); +# endif } bool operator!=( VertexInputBindingDescription const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -31295,27 +33079,34 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( location, binding, format, offset ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VertexInputAttributeDescription const & ) const = default; #else bool operator==( VertexInputAttributeDescription const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( location == rhs.location ) && ( binding == rhs.binding ) && ( format == rhs.format ) && + ( offset == rhs.offset ); +# endif } bool operator!=( VertexInputAttributeDescription const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -31465,9 +33256,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -31486,18 +33278,27 @@ namespace VULKAN_HPP_NAMESPACE vertexAttributeDescriptionCount, pVertexAttributeDescriptions ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineVertexInputStateCreateInfo const & ) const = default; #else bool operator==( PipelineVertexInputStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && + ( vertexBindingDescriptionCount == rhs.vertexBindingDescriptionCount ) && + ( pVertexBindingDescriptions == rhs.pVertexBindingDescriptions ) && + ( vertexAttributeDescriptionCount == rhs.vertexAttributeDescriptionCount ) && + ( pVertexAttributeDescriptions == rhs.pVertexAttributeDescriptions ); +# endif } bool operator!=( PipelineVertexInputStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -31600,31 +33401,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, flags, topology, primitiveRestartEnable ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineInputAssemblyStateCreateInfo const & ) const = default; #else bool operator==( PipelineInputAssemblyStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && + ( topology == rhs.topology ) && ( primitiveRestartEnable == rhs.primitiveRestartEnable ); +# endif } bool operator!=( PipelineInputAssemblyStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -31716,30 +33524,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, flags, patchControlPoints ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineTessellationStateCreateInfo const & ) const = default; #else bool operator==( PipelineTessellationStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && + ( patchControlPoints == rhs.patchControlPoints ); +# endif } bool operator!=( PipelineTessellationStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -31890,9 +33705,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, flags, viewportCount, pViewports, scissorCount, pScissors ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineViewportStateCreateInfo const & ) const = default; #else bool operator==( PipelineViewportStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && + ( viewportCount == rhs.viewportCount ) && ( pViewports == rhs.pViewports ) && + ( scissorCount == rhs.scissorCount ) && ( pScissors == rhs.pScissors ); +# endif } bool operator!=( PipelineViewportStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -32090,9 +33913,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -32123,18 +33947,29 @@ namespace VULKAN_HPP_NAMESPACE depthBiasSlopeFactor, lineWidth ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineRasterizationStateCreateInfo const & ) const = default; #else bool operator==( PipelineRasterizationStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && + ( depthClampEnable == rhs.depthClampEnable ) && + ( rasterizerDiscardEnable == rhs.rasterizerDiscardEnable ) && ( polygonMode == rhs.polygonMode ) && + ( cullMode == rhs.cullMode ) && ( frontFace == rhs.frontFace ) && + ( depthBiasEnable == rhs.depthBiasEnable ) && ( depthBiasConstantFactor == rhs.depthBiasConstantFactor ) && + ( depthBiasClamp == rhs.depthBiasClamp ) && ( depthBiasSlopeFactor == rhs.depthBiasSlopeFactor ) && + ( lineWidth == rhs.lineWidth ); +# endif } bool operator!=( PipelineRasterizationStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -32279,9 +34114,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -32304,18 +34140,27 @@ namespace VULKAN_HPP_NAMESPACE alphaToCoverageEnable, alphaToOneEnable ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineMultisampleStateCreateInfo const & ) const = default; #else bool operator==( PipelineMultisampleStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && + ( rasterizationSamples == rhs.rasterizationSamples ) && + ( sampleShadingEnable == rhs.sampleShadingEnable ) && ( minSampleShading == rhs.minSampleShading ) && + ( pSampleMask == rhs.pSampleMask ) && ( alphaToCoverageEnable == rhs.alphaToCoverageEnable ) && + ( alphaToOneEnable == rhs.alphaToOneEnable ); +# endif } bool operator!=( PipelineMultisampleStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -32438,9 +34283,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( failOp, passOp, depthFailOp, compareOp, compareMask, writeMask, reference ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( StencilOpState const & ) const = default; #else bool operator==( StencilOpState const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( failOp == rhs.failOp ) && ( passOp == rhs.passOp ) && ( depthFailOp == rhs.depthFailOp ) && + ( compareOp == rhs.compareOp ) && ( compareMask == rhs.compareMask ) && ( writeMask == rhs.writeMask ) && + ( reference == rhs.reference ); +# endif } bool operator!=( StencilOpState const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -32622,9 +34475,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -32653,18 +34507,27 @@ namespace VULKAN_HPP_NAMESPACE minDepthBounds, maxDepthBounds ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineDepthStencilStateCreateInfo const & ) const = default; #else bool operator==( PipelineDepthStencilStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && + ( depthTestEnable == rhs.depthTestEnable ) && ( depthWriteEnable == rhs.depthWriteEnable ) && + ( depthCompareOp == rhs.depthCompareOp ) && ( depthBoundsTestEnable == rhs.depthBoundsTestEnable ) && + ( stencilTestEnable == rhs.stencilTestEnable ) && ( front == rhs.front ) && ( back == rhs.back ) && + ( minDepthBounds == rhs.minDepthBounds ) && ( maxDepthBounds == rhs.maxDepthBounds ); +# endif } bool operator!=( PipelineDepthStencilStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -32806,9 +34669,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( blendEnable, @@ -32829,18 +34693,26 @@ namespace VULKAN_HPP_NAMESPACE alphaBlendOp, colorWriteMask ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineColorBlendAttachmentState const & ) const = default; #else bool operator==( PipelineColorBlendAttachmentState const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( blendEnable == rhs.blendEnable ) && ( srcColorBlendFactor == rhs.srcColorBlendFactor ) && + ( dstColorBlendFactor == rhs.dstColorBlendFactor ) && ( colorBlendOp == rhs.colorBlendOp ) && + ( srcAlphaBlendFactor == rhs.srcAlphaBlendFactor ) && ( dstAlphaBlendFactor == rhs.dstAlphaBlendFactor ) && + ( alphaBlendOp == rhs.alphaBlendOp ) && ( colorWriteMask == rhs.colorWriteMask ); +# endif } bool operator!=( PipelineColorBlendAttachmentState const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -32992,9 +34864,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple const &> -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, flags, logicOpEnable, logicOp, attachmentCount, pAttachments, blendConstants ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineColorBlendStateCreateInfo const & ) const = default; #else bool operator==( PipelineColorBlendStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && + ( logicOpEnable == rhs.logicOpEnable ) && ( logicOp == rhs.logicOp ) && + ( attachmentCount == rhs.attachmentCount ) && ( pAttachments == rhs.pAttachments ) && + ( blendConstants == rhs.blendConstants ); +# endif } bool operator!=( PipelineColorBlendStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -33142,31 +35023,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, flags, dynamicStateCount, pDynamicStates ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineDynamicStateCreateInfo const & ) const = default; #else bool operator==( PipelineDynamicStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && + ( dynamicStateCount == rhs.dynamicStateCount ) && ( pDynamicStates == rhs.pDynamicStates ); +# endif } bool operator!=( PipelineDynamicStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -33438,9 +35326,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -33483,18 +35372,31 @@ namespace VULKAN_HPP_NAMESPACE basePipelineHandle, basePipelineIndex ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( GraphicsPipelineCreateInfo const & ) const = default; #else bool operator==( GraphicsPipelineCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && + ( stageCount == rhs.stageCount ) && ( pStages == rhs.pStages ) && + ( pVertexInputState == rhs.pVertexInputState ) && ( pInputAssemblyState == rhs.pInputAssemblyState ) && + ( pTessellationState == rhs.pTessellationState ) && ( pViewportState == rhs.pViewportState ) && + ( pRasterizationState == rhs.pRasterizationState ) && ( pMultisampleState == rhs.pMultisampleState ) && + ( pDepthStencilState == rhs.pDepthStencilState ) && ( pColorBlendState == rhs.pColorBlendState ) && + ( pDynamicState == rhs.pDynamicState ) && ( layout == rhs.layout ) && ( renderPass == rhs.renderPass ) && + ( subpass == rhs.subpass ) && ( basePipelineHandle == rhs.basePipelineHandle ) && + ( basePipelineIndex == rhs.basePipelineIndex ); +# endif } bool operator!=( GraphicsPipelineCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -33638,32 +35540,40 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, stageCount, pStages, pVertexInputState, pTessellationState ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( GraphicsShaderGroupCreateInfoNV const & ) const = default; #else bool operator==( GraphicsShaderGroupCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stageCount == rhs.stageCount ) && + ( pStages == rhs.pStages ) && ( pVertexInputState == rhs.pVertexInputState ) && + ( pTessellationState == rhs.pTessellationState ); +# endif } bool operator!=( GraphicsShaderGroupCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -33811,32 +35721,39 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, groupCount, pGroups, pipelineCount, pPipelines ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( GraphicsPipelineShaderGroupsCreateInfoNV const & ) const = default; #else bool operator==( GraphicsPipelineShaderGroupsCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( groupCount == rhs.groupCount ) && + ( pGroups == rhs.pGroups ) && ( pipelineCount == rhs.pipelineCount ) && ( pPipelines == rhs.pPipelines ); +# endif } bool operator!=( GraphicsPipelineShaderGroupsCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -33913,27 +35830,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( x, y ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( XYColorEXT const & ) const = default; #else bool operator==( XYColorEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( x == rhs.x ) && ( y == rhs.y ); +# endif } bool operator!=( XYColorEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -34060,9 +35983,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -34087,18 +36011,27 @@ namespace VULKAN_HPP_NAMESPACE maxContentLightLevel, maxFrameAverageLightLevel ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( HdrMetadataEXT const & ) const = default; #else bool operator==( HdrMetadataEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( displayPrimaryRed == rhs.displayPrimaryRed ) && + ( displayPrimaryGreen == rhs.displayPrimaryGreen ) && ( displayPrimaryBlue == rhs.displayPrimaryBlue ) && + ( whitePoint == rhs.whitePoint ) && ( maxLuminance == rhs.maxLuminance ) && + ( minLuminance == rhs.minLuminance ) && ( maxContentLightLevel == rhs.maxContentLightLevel ) && + ( maxFrameAverageLightLevel == rhs.maxFrameAverageLightLevel ); +# endif } bool operator!=( HdrMetadataEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -34180,29 +36113,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, flags ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( HeadlessSurfaceCreateInfoEXT const & ) const = default; #else bool operator==( HeadlessSurfaceCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ); +# endif } bool operator!=( HeadlessSurfaceCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -34287,30 +36226,36 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, flags, pView ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( IOSSurfaceCreateInfoMVK const & ) const = default; # else bool operator==( IOSSurfaceCreateInfoMVK const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( pView == rhs.pView ); +# endif } bool operator!=( IOSSurfaceCreateInfoMVK const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -34405,30 +36350,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple const &, VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const &, VULKAN_HPP_NAMESPACE::ArrayWrapper1D const &> -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( srcSubresource, srcOffsets, dstSubresource, dstOffsets ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageBlit const & ) const = default; #else bool operator==( ImageBlit const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( srcSubresource == rhs.srcSubresource ) && ( srcOffsets == rhs.srcOffsets ) && + ( dstSubresource == rhs.dstSubresource ) && ( dstOffsets == rhs.dstOffsets ); +# endif } bool operator!=( ImageBlit const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -34547,9 +36499,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -34570,18 +36523,26 @@ namespace VULKAN_HPP_NAMESPACE colorSpaceCount, pColorSpaces ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageFormatConstraintsInfoFUCHSIA const & ) const = default; # else bool operator==( ImageFormatConstraintsInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageCreateInfo == rhs.imageCreateInfo ) && + ( requiredFormatFeatures == rhs.requiredFormatFeatures ) && ( flags == rhs.flags ) && + ( sysmemPixelFormat == rhs.sysmemPixelFormat ) && ( colorSpaceCount == rhs.colorSpaceCount ) && + ( pColorSpaces == rhs.pColorSpaces ); +# endif } bool operator!=( ImageFormatConstraintsInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -34718,32 +36679,41 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, formatConstraintsCount, pFormatConstraints, bufferCollectionConstraints, flags ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageConstraintsInfoFUCHSIA const & ) const = default; # else bool operator==( ImageConstraintsInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( formatConstraintsCount == rhs.formatConstraintsCount ) && + ( pFormatConstraints == rhs.pFormatConstraints ) && + ( bufferCollectionConstraints == rhs.bufferCollectionConstraints ) && ( flags == rhs.flags ); +# endif } bool operator!=( ImageConstraintsInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -34848,31 +36818,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( srcSubresource, srcOffset, dstSubresource, dstOffset, extent ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageCopy const & ) const = default; #else bool operator==( ImageCopy const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( srcSubresource == rhs.srcSubresource ) && ( srcOffset == rhs.srcOffset ) && + ( dstSubresource == rhs.dstSubresource ) && ( dstOffset == rhs.dstOffset ) && ( extent == rhs.extent ); +# endif } bool operator!=( ImageCopy const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -34932,31 +36909,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( offset, size, rowPitch, arrayPitch, depthPitch ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SubresourceLayout const & ) const = default; #else bool operator==( SubresourceLayout const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( offset == rhs.offset ) && ( size == rhs.size ) && ( rowPitch == rhs.rowPitch ) && + ( arrayPitch == rhs.arrayPitch ) && ( depthPitch == rhs.depthPitch ); +# endif } bool operator!=( SubresourceLayout const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -35074,31 +37058,39 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, drmFormatModifier, drmFormatModifierPlaneCount, pPlaneLayouts ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageDrmFormatModifierExplicitCreateInfoEXT const & ) const = default; #else bool operator==( ImageDrmFormatModifierExplicitCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( drmFormatModifier == rhs.drmFormatModifier ) && + ( drmFormatModifierPlaneCount == rhs.drmFormatModifierPlaneCount ) && + ( pPlaneLayouts == rhs.pPlaneLayouts ); +# endif } bool operator!=( ImageDrmFormatModifierExplicitCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -35211,30 +37203,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, drmFormatModifierCount, pDrmFormatModifiers ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageDrmFormatModifierListCreateInfoEXT const & ) const = default; #else bool operator==( ImageDrmFormatModifierListCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( drmFormatModifierCount == rhs.drmFormatModifierCount ) && + ( pDrmFormatModifiers == rhs.pDrmFormatModifiers ); +# endif } bool operator!=( ImageDrmFormatModifierListCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -35301,27 +37301,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, drmFormatModifier ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageDrmFormatModifierPropertiesEXT const & ) const = default; #else bool operator==( ImageDrmFormatModifierPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( drmFormatModifier == rhs.drmFormatModifier ); +# endif } bool operator!=( ImageDrmFormatModifierPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -35426,30 +37432,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, viewFormatCount, pViewFormats ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageFormatListCreateInfo const & ) const = default; #else bool operator==( ImageFormatListCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( viewFormatCount == rhs.viewFormatCount ) && + ( pViewFormats == rhs.pViewFormats ); +# endif } bool operator!=( ImageFormatListCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -35512,29 +37525,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, imageFormatProperties ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageFormatProperties2 const & ) const = default; #else bool operator==( ImageFormatProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageFormatProperties == rhs.imageFormatProperties ); +# endif } bool operator!=( ImageFormatProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -35673,9 +37692,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -35700,18 +37720,27 @@ namespace VULKAN_HPP_NAMESPACE image, subresourceRange ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageMemoryBarrier const & ) const = default; #else bool operator==( ImageMemoryBarrier const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcAccessMask == rhs.srcAccessMask ) && + ( dstAccessMask == rhs.dstAccessMask ) && ( oldLayout == rhs.oldLayout ) && + ( newLayout == rhs.newLayout ) && ( srcQueueFamilyIndex == rhs.srcQueueFamilyIndex ) && + ( dstQueueFamilyIndex == rhs.dstQueueFamilyIndex ) && ( image == rhs.image ) && + ( subresourceRange == rhs.subresourceRange ); +# endif } bool operator!=( ImageMemoryBarrier const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -35793,27 +37822,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, image ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageMemoryRequirementsInfo2 const & ) const = default; #else bool operator==( ImageMemoryRequirementsInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( image == rhs.image ); +# endif } bool operator!=( ImageMemoryRequirementsInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -35904,30 +37939,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, flags, imagePipeHandle ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImagePipeSurfaceCreateInfoFUCHSIA const & ) const = default; # else bool operator==( ImagePipeSurfaceCreateInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && + ( memcmp( &imagePipeHandle, &rhs.imagePipeHandle, sizeof( zx_handle_t ) ) == 0 ); +# endif } bool operator!=( ImagePipeSurfaceCreateInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -36009,29 +38051,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, planeAspect ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImagePlaneMemoryRequirementsInfo const & ) const = default; #else bool operator==( ImagePlaneMemoryRequirementsInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( planeAspect == rhs.planeAspect ); +# endif } bool operator!=( ImagePlaneMemoryRequirementsInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -36135,31 +38183,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( srcSubresource, srcOffset, dstSubresource, dstOffset, extent ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageResolve const & ) const = default; #else bool operator==( ImageResolve const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( srcSubresource == rhs.srcSubresource ) && ( srcOffset == rhs.srcOffset ) && + ( dstSubresource == rhs.dstSubresource ) && ( dstOffset == rhs.dstOffset ) && ( extent == rhs.extent ); +# endif } bool operator!=( ImageResolve const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -36265,9 +38320,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, srcSubresource, srcOffset, dstSubresource, dstOffset, extent ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageResolve2KHR const & ) const = default; #else bool operator==( ImageResolve2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcSubresource == rhs.srcSubresource ) && + ( srcOffset == rhs.srcOffset ) && ( dstSubresource == rhs.dstSubresource ) && + ( dstOffset == rhs.dstOffset ) && ( extent == rhs.extent ); +# endif } bool operator!=( ImageResolve2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -36374,27 +38437,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, image ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageSparseMemoryRequirementsInfo2 const & ) const = default; #else bool operator==( ImageSparseMemoryRequirementsInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( image == rhs.image ); +# endif } bool operator!=( ImageSparseMemoryRequirementsInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -36473,29 +38542,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, stencilUsage ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageStencilUsageCreateInfo const & ) const = default; #else bool operator==( ImageStencilUsageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stencilUsage == rhs.stencilUsage ); +# endif } bool operator!=( ImageStencilUsageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -36574,29 +38649,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, swapchain ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageSwapchainCreateInfoKHR const & ) const = default; #else bool operator==( ImageSwapchainCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchain == rhs.swapchain ); +# endif } bool operator!=( ImageSwapchainCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -36674,27 +38755,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, decodeMode ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageViewASTCDecodeModeEXT const & ) const = default; #else bool operator==( ImageViewASTCDecodeModeEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( decodeMode == rhs.decodeMode ); +# endif } bool operator!=( ImageViewASTCDecodeModeEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -36759,30 +38846,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, deviceAddress, size ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageViewAddressPropertiesNVX const & ) const = default; #else bool operator==( ImageViewAddressPropertiesNVX const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceAddress == rhs.deviceAddress ) && + ( size == rhs.size ); +# endif } bool operator!=( ImageViewAddressPropertiesNVX const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -36903,9 +38997,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, flags, image, viewType, format, components, subresourceRange ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageViewCreateInfo const & ) const = default; #else bool operator==( ImageViewCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( image == rhs.image ) && + ( viewType == rhs.viewType ) && ( format == rhs.format ) && ( components == rhs.components ) && + ( subresourceRange == rhs.subresourceRange ); +# endif } bool operator!=( ImageViewCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -37028,31 +39130,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, imageView, descriptorType, sampler ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageViewHandleInfoNVX const & ) const = default; #else bool operator==( ImageViewHandleInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageView == rhs.imageView ) && + ( descriptorType == rhs.descriptorType ) && ( sampler == rhs.sampler ); +# endif } bool operator!=( ImageViewHandleInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -37127,27 +39236,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, minLod ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageViewMinLodCreateInfoEXT const & ) const = default; #else bool operator==( ImageViewMinLodCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( minLod == rhs.minLod ); +# endif } bool operator!=( ImageViewMinLodCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -37224,29 +39339,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, usage ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageViewUsageCreateInfo const & ) const = default; #else bool operator==( ImageViewUsageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( usage == rhs.usage ); +# endif } bool operator!=( ImageViewUsageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -37329,27 +39450,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, buffer ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImportAndroidHardwareBufferInfoANDROID const & ) const = default; # else bool operator==( ImportAndroidHardwareBufferInfoANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( buffer == rhs.buffer ); +# endif } bool operator!=( ImportAndroidHardwareBufferInfoANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -37453,32 +39580,39 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, fence, flags, handleType, fd ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImportFenceFdInfoKHR const & ) const = default; #else bool operator==( ImportFenceFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fence == rhs.fence ) && ( flags == rhs.flags ) && + ( handleType == rhs.handleType ) && ( fd == rhs.fd ); +# endif } bool operator!=( ImportFenceFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -37595,9 +39729,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, fence, flags, handleType, handle, name ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImportFenceWin32HandleInfoKHR const & ) const = default; # else bool operator==( ImportFenceWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fence == rhs.fence ) && ( flags == rhs.flags ) && + ( handleType == rhs.handleType ) && ( handle == rhs.handle ) && ( name == rhs.name ); +# endif } bool operator!=( ImportFenceWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -37717,30 +39858,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, collection, index ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImportMemoryBufferCollectionFUCHSIA const & ) const = default; # else bool operator==( ImportMemoryBufferCollectionFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( collection == rhs.collection ) && + ( index == rhs.index ); +# endif } bool operator!=( ImportMemoryBufferCollectionFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -37827,30 +39975,36 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, handleType, fd ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImportMemoryFdInfoKHR const & ) const = default; #else bool operator==( ImportMemoryFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleType == rhs.handleType ) && ( fd == rhs.fd ); +# endif } bool operator!=( ImportMemoryFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -37938,30 +40092,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, handleType, pHostPointer ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImportMemoryHostPointerInfoEXT const & ) const = default; #else bool operator==( ImportMemoryHostPointerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleType == rhs.handleType ) && + ( pHostPointer == rhs.pHostPointer ); +# endif } bool operator!=( ImportMemoryHostPointerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -38060,31 +40221,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, handleType, handle, name ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImportMemoryWin32HandleInfoKHR const & ) const = default; # else bool operator==( ImportMemoryWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleType == rhs.handleType ) && + ( handle == rhs.handle ) && ( name == rhs.name ); +# endif } bool operator!=( ImportMemoryWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -38176,30 +40344,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, handleType, handle ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImportMemoryWin32HandleInfoNV const & ) const = default; # else bool operator==( ImportMemoryWin32HandleInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleType == rhs.handleType ) && + ( handle == rhs.handle ); +# endif } bool operator!=( ImportMemoryWin32HandleInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -38292,30 +40467,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, handleType, handle ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImportMemoryZirconHandleInfoFUCHSIA const & ) const = default; # else bool operator==( ImportMemoryZirconHandleInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleType == rhs.handleType ) && + ( memcmp( &handle, &rhs.handle, sizeof( zx_handle_t ) ) == 0 ); +# endif } bool operator!=( ImportMemoryZirconHandleInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -38422,32 +40604,39 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, semaphore, flags, handleType, fd ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImportSemaphoreFdInfoKHR const & ) const = default; #else bool operator==( ImportSemaphoreFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphore == rhs.semaphore ) && + ( flags == rhs.flags ) && ( handleType == rhs.handleType ) && ( fd == rhs.fd ); +# endif } bool operator!=( ImportSemaphoreFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -38566,9 +40755,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, semaphore, flags, handleType, handle, name ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImportSemaphoreWin32HandleInfoKHR const & ) const = default; # else bool operator==( ImportSemaphoreWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphore == rhs.semaphore ) && + ( flags == rhs.flags ) && ( handleType == rhs.handleType ) && ( handle == rhs.handle ) && + ( name == rhs.name ); +# endif } bool operator!=( ImportSemaphoreWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -38709,32 +40906,40 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, semaphore, flags, handleType, zirconHandle ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImportSemaphoreZirconHandleInfoFUCHSIA const & ) const = default; # else bool operator==( ImportSemaphoreZirconHandleInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphore == rhs.semaphore ) && + ( flags == rhs.flags ) && ( handleType == rhs.handleType ) && + ( memcmp( &zirconHandle, &rhs.zirconHandle, sizeof( zx_handle_t ) ) == 0 ); +# endif } bool operator!=( ImportSemaphoreZirconHandleInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -38988,9 +41193,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -39025,18 +41231,30 @@ namespace VULKAN_HPP_NAMESPACE pIndexTypes, pIndexTypeValues ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( IndirectCommandsLayoutTokenNV const & ) const = default; #else bool operator==( IndirectCommandsLayoutTokenNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( tokenType == rhs.tokenType ) && + ( stream == rhs.stream ) && ( offset == rhs.offset ) && ( vertexBindingUnit == rhs.vertexBindingUnit ) && + ( vertexDynamicStride == rhs.vertexDynamicStride ) && + ( pushconstantPipelineLayout == rhs.pushconstantPipelineLayout ) && + ( pushconstantShaderStageFlags == rhs.pushconstantShaderStageFlags ) && + ( pushconstantOffset == rhs.pushconstantOffset ) && ( pushconstantSize == rhs.pushconstantSize ) && + ( indirectStateFlags == rhs.indirectStateFlags ) && ( indexTypeCount == rhs.indexTypeCount ) && + ( pIndexTypes == rhs.pIndexTypes ) && ( pIndexTypeValues == rhs.pIndexTypeValues ); +# endif } bool operator!=( IndirectCommandsLayoutTokenNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -39212,9 +41430,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, flags, pipelineBindPoint, tokenCount, pTokens, streamCount, pStreamStrides ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( IndirectCommandsLayoutCreateInfoNV const & ) const = default; #else bool operator==( IndirectCommandsLayoutCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && + ( pipelineBindPoint == rhs.pipelineBindPoint ) && ( tokenCount == rhs.tokenCount ) && + ( pTokens == rhs.pTokens ) && ( streamCount == rhs.streamCount ) && + ( pStreamStrides == rhs.pStreamStrides ); +# endif } bool operator!=( IndirectCommandsLayoutCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -39322,27 +41549,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, pUserData ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( InitializePerformanceApiInfoINTEL const & ) const = default; #else bool operator==( InitializePerformanceApiInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pUserData == rhs.pUserData ); +# endif } bool operator!=( InitializePerformanceApiInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -39429,27 +41662,34 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( subpass, inputAttachmentIndex, aspectMask ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( InputAttachmentAspectReference const & ) const = default; #else bool operator==( InputAttachmentAspectReference const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( subpass == rhs.subpass ) && ( inputAttachmentIndex == rhs.inputAttachmentIndex ) && + ( aspectMask == rhs.aspectMask ); +# endif } bool operator!=( InputAttachmentAspectReference const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -39601,9 +41841,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -39624,18 +41865,27 @@ namespace VULKAN_HPP_NAMESPACE enabledExtensionCount, ppEnabledExtensionNames ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( InstanceCreateInfo const & ) const = default; #else bool operator==( InstanceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && + ( pApplicationInfo == rhs.pApplicationInfo ) && ( enabledLayerCount == rhs.enabledLayerCount ) && + ( ppEnabledLayerNames == rhs.ppEnabledLayerNames ) && + ( enabledExtensionCount == rhs.enabledExtensionCount ) && + ( ppEnabledExtensionNames == rhs.ppEnabledExtensionNames ); +# endif } bool operator!=( InstanceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -39703,30 +41953,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple const &, uint32_t const &, uint32_t const &, VULKAN_HPP_NAMESPACE::ArrayWrapper1D const &> -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( layerName, specVersion, implementationVersion, description ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( LayerProperties const & ) const = default; #else bool operator==( LayerProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( layerName == rhs.layerName ) && ( specVersion == rhs.specVersion ) && + ( implementationVersion == rhs.implementationVersion ) && ( description == rhs.description ); +# endif } bool operator!=( LayerProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -39805,30 +42062,36 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, flags, pView ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MacOSSurfaceCreateInfoMVK const & ) const = default; # else bool operator==( MacOSSurfaceCreateInfoMVK const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( pView == rhs.pView ); +# endif } bool operator!=( MacOSSurfaceCreateInfoMVK const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -39922,31 +42185,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, memory, offset, size ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MappedMemoryRange const & ) const = default; #else bool operator==( MappedMemoryRange const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memory == rhs.memory ) && ( offset == rhs.offset ) && + ( size == rhs.size ); +# endif } bool operator!=( MappedMemoryRange const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -40030,30 +42300,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, flags, deviceMask ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MemoryAllocateFlagsInfo const & ) const = default; #else bool operator==( MemoryAllocateFlagsInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && + ( deviceMask == rhs.deviceMask ); +# endif } bool operator!=( MemoryAllocateFlagsInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -40138,30 +42415,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, allocationSize, memoryTypeIndex ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MemoryAllocateInfo const & ) const = default; #else bool operator==( MemoryAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( allocationSize == rhs.allocationSize ) && + ( memoryTypeIndex == rhs.memoryTypeIndex ); +# endif } bool operator!=( MemoryAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -40245,30 +42529,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, srcAccessMask, dstAccessMask ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MemoryBarrier const & ) const = default; #else bool operator==( MemoryBarrier const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcAccessMask == rhs.srcAccessMask ) && + ( dstAccessMask == rhs.dstAccessMask ); +# endif } bool operator!=( MemoryBarrier const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -40353,30 +42644,36 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, image, buffer ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MemoryDedicatedAllocateInfo const & ) const = default; #else bool operator==( MemoryDedicatedAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( image == rhs.image ) && ( buffer == rhs.buffer ); +# endif } bool operator!=( MemoryDedicatedAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -40443,30 +42740,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, prefersDedicatedAllocation, requiresDedicatedAllocation ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MemoryDedicatedRequirements const & ) const = default; #else bool operator==( MemoryDedicatedRequirements const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( prefersDedicatedAllocation == rhs.prefersDedicatedAllocation ) && + ( requiresDedicatedAllocation == rhs.requiresDedicatedAllocation ); +# endif } bool operator!=( MemoryDedicatedRequirements const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -40529,27 +42834,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, memoryTypeBits ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MemoryFdPropertiesKHR const & ) const = default; #else bool operator==( MemoryFdPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryTypeBits == rhs.memoryTypeBits ); +# endif } bool operator!=( MemoryFdPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -40632,29 +42943,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, memory ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MemoryGetAndroidHardwareBufferInfoANDROID const & ) const = default; # else bool operator==( MemoryGetAndroidHardwareBufferInfoANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memory == rhs.memory ); +# endif } bool operator!=( MemoryGetAndroidHardwareBufferInfoANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -40743,30 +43060,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, memory, handleType ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MemoryGetFdInfoKHR const & ) const = default; #else bool operator==( MemoryGetFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memory == rhs.memory ) && + ( handleType == rhs.handleType ); +# endif } bool operator!=( MemoryGetFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -40854,30 +43178,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, memory, handleType ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MemoryGetRemoteAddressInfoNV const & ) const = default; #else bool operator==( MemoryGetRemoteAddressInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memory == rhs.memory ) && + ( handleType == rhs.handleType ); +# endif } bool operator!=( MemoryGetRemoteAddressInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -40968,30 +43299,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, memory, handleType ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MemoryGetWin32HandleInfoKHR const & ) const = default; # else bool operator==( MemoryGetWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memory == rhs.memory ) && + ( handleType == rhs.handleType ); +# endif } bool operator!=( MemoryGetWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -41084,30 +43422,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, memory, handleType ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MemoryGetZirconHandleInfoFUCHSIA const & ) const = default; # else bool operator==( MemoryGetZirconHandleInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memory == rhs.memory ) && + ( handleType == rhs.handleType ); +# endif } bool operator!=( MemoryGetZirconHandleInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -41170,27 +43515,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( size, flags ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MemoryHeap const & ) const = default; #else bool operator==( MemoryHeap const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( size == rhs.size ) && ( flags == rhs.flags ); +# endif } bool operator!=( MemoryHeap const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -41244,27 +43595,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, memoryTypeBits ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MemoryHostPointerPropertiesEXT const & ) const = default; #else bool operator==( MemoryHostPointerPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryTypeBits == rhs.memoryTypeBits ); +# endif } bool operator!=( MemoryHostPointerPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -41346,27 +43703,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, opaqueCaptureAddress ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MemoryOpaqueCaptureAddressAllocateInfo const & ) const = default; #else bool operator==( MemoryOpaqueCaptureAddressAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( opaqueCaptureAddress == rhs.opaqueCaptureAddress ); +# endif } bool operator!=( MemoryOpaqueCaptureAddressAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -41445,27 +43808,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, priority ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MemoryPriorityAllocateInfoEXT const & ) const = default; #else bool operator==( MemoryPriorityAllocateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( priority == rhs.priority ); +# endif } bool operator!=( MemoryPriorityAllocateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -41527,27 +43896,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( size, alignment, memoryTypeBits ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MemoryRequirements const & ) const = default; #else bool operator==( MemoryRequirements const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( size == rhs.size ) && ( alignment == rhs.alignment ) && ( memoryTypeBits == rhs.memoryTypeBits ); +# endif } bool operator!=( MemoryRequirements const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -41601,29 +43976,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, memoryRequirements ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MemoryRequirements2 const & ) const = default; #else bool operator==( MemoryRequirements2 const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryRequirements == rhs.memoryRequirements ); +# endif } bool operator!=( MemoryRequirements2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -41682,27 +44063,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( propertyFlags, heapIndex ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MemoryType const & ) const = default; #else bool operator==( MemoryType const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( propertyFlags == rhs.propertyFlags ) && ( heapIndex == rhs.heapIndex ); +# endif } bool operator!=( MemoryType const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -41757,27 +44144,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, memoryTypeBits ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MemoryWin32HandlePropertiesKHR const & ) const = default; # else bool operator==( MemoryWin32HandlePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryTypeBits == rhs.memoryTypeBits ); +# endif } bool operator!=( MemoryWin32HandlePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -41844,27 +44237,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, memoryTypeBits ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MemoryZirconHandlePropertiesFUCHSIA const & ) const = default; # else bool operator==( MemoryZirconHandlePropertiesFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryTypeBits == rhs.memoryTypeBits ); +# endif } bool operator!=( MemoryZirconHandlePropertiesFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -41951,30 +44350,36 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, flags, pLayer ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MetalSurfaceCreateInfoEXT const & ) const = default; # else bool operator==( MetalSurfaceCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( pLayer == rhs.pLayer ); +# endif } bool operator!=( MetalSurfaceCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -42057,27 +44462,34 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( firstIndex, indexCount, vertexOffset ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MultiDrawIndexedInfoEXT const & ) const = default; #else bool operator==( MultiDrawIndexedInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( firstIndex == rhs.firstIndex ) && ( indexCount == rhs.indexCount ) && + ( vertexOffset == rhs.vertexOffset ); +# endif } bool operator!=( MultiDrawIndexedInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -42143,27 +44555,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( firstVertex, vertexCount ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MultiDrawInfoEXT const & ) const = default; #else bool operator==( MultiDrawInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( firstVertex == rhs.firstVertex ) && ( vertexCount == rhs.vertexCount ); +# endif } bool operator!=( MultiDrawInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -42216,27 +44634,34 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, maxSampleLocationGridSize ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MultisamplePropertiesEXT const & ) const = default; #else bool operator==( MultisamplePropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( maxSampleLocationGridSize == rhs.maxSampleLocationGridSize ); +# endif } bool operator!=( MultisamplePropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -42324,30 +44749,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, perViewAttributes, perViewAttributesPositionXOnly ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MultiviewPerViewAttributesInfoNVX const & ) const = default; #else bool operator==( MultiviewPerViewAttributesInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( perViewAttributes == rhs.perViewAttributes ) && + ( perViewAttributesPositionXOnly == rhs.perViewAttributesPositionXOnly ); +# endif } bool operator!=( MultiviewPerViewAttributesInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -42447,27 +44879,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( descriptorTypeCount, pDescriptorTypes ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MutableDescriptorTypeListVALVE const & ) const = default; #else bool operator==( MutableDescriptorTypeListVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( descriptorTypeCount == rhs.descriptorTypeCount ) && ( pDescriptorTypes == rhs.pDescriptorTypes ); +# endif } bool operator!=( MutableDescriptorTypeListVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -42571,30 +45009,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, mutableDescriptorTypeListCount, pMutableDescriptorTypeLists ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MutableDescriptorTypeCreateInfoVALVE const & ) const = default; #else bool operator==( MutableDescriptorTypeCreateInfoVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( mutableDescriptorTypeListCount == rhs.mutableDescriptorTypeListCount ) && + ( pMutableDescriptorTypeLists == rhs.pMutableDescriptorTypeLists ); +# endif } bool operator!=( MutableDescriptorTypeCreateInfoVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -42662,27 +45108,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( presentID, desiredPresentTime, actualPresentTime, earliestPresentTime, presentMargin ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PastPresentationTimingGOOGLE const & ) const = default; #else bool operator==( PastPresentationTimingGOOGLE const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( presentID == rhs.presentID ) && ( desiredPresentTime == rhs.desiredPresentTime ) && + ( actualPresentTime == rhs.actualPresentTime ) && ( earliestPresentTime == rhs.earliestPresentTime ) && + ( presentMargin == rhs.presentMargin ); +# endif } bool operator!=( PastPresentationTimingGOOGLE const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -42763,29 +45217,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, type ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PerformanceConfigurationAcquireInfoINTEL const & ) const = default; #else bool operator==( PerformanceConfigurationAcquireInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( type == rhs.type ); +# endif } bool operator!=( PerformanceConfigurationAcquireInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -42857,32 +45317,39 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple const &, VULKAN_HPP_NAMESPACE::ArrayWrapper1D const &, VULKAN_HPP_NAMESPACE::ArrayWrapper1D const &> -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, flags, name, category, description ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PerformanceCounterDescriptionKHR const & ) const = default; #else bool operator==( PerformanceCounterDescriptionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( name == rhs.name ) && + ( category == rhs.category ) && ( description == rhs.description ); +# endif } bool operator!=( PerformanceCounterDescriptionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -42955,32 +45422,39 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple const &> -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, unit, scope, storage, uuid ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PerformanceCounterKHR const & ) const = default; #else bool operator==( PerformanceCounterKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( unit == rhs.unit ) && ( scope == rhs.scope ) && + ( storage == rhs.storage ) && ( uuid == rhs.uuid ); +# endif } bool operator!=( PerformanceCounterKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -43131,27 +45605,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, marker ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PerformanceMarkerInfoINTEL const & ) const = default; #else bool operator==( PerformanceMarkerInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( marker == rhs.marker ); +# endif } bool operator!=( PerformanceMarkerInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -43246,31 +45726,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, type, enable, parameter ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PerformanceOverrideInfoINTEL const & ) const = default; #else bool operator==( PerformanceOverrideInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( type == rhs.type ) && ( enable == rhs.enable ) && + ( parameter == rhs.parameter ); +# endif } bool operator!=( PerformanceOverrideInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -43351,27 +45838,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, counterPassIndex ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PerformanceQuerySubmitInfoKHR const & ) const = default; #else bool operator==( PerformanceQuerySubmitInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( counterPassIndex == rhs.counterPassIndex ); +# endif } bool operator!=( PerformanceQuerySubmitInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -43448,27 +45941,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, marker ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PerformanceStreamMarkerInfoINTEL const & ) const = default; #else bool operator==( PerformanceStreamMarkerInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( marker == rhs.marker ); +# endif } bool operator!=( PerformanceStreamMarkerInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -43617,16 +46116,18 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( type, data ); } +#endif public: VULKAN_HPP_NAMESPACE::PerformanceValueTypeINTEL type = VULKAN_HPP_NAMESPACE::PerformanceValueTypeINTEL::eUint32; @@ -43723,16 +46224,17 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -43742,18 +46244,27 @@ namespace VULKAN_HPP_NAMESPACE storagePushConstant16, storageInputOutput16 ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDevice16BitStorageFeatures const & ) const = default; #else - bool operator==( PhysicalDevice16BitStorageFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT + bool operator==( PhysicalDevice16BitStorageFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( storageBuffer16BitAccess == rhs.storageBuffer16BitAccess ) && + ( uniformAndStorageBuffer16BitAccess == rhs.uniformAndStorageBuffer16BitAccess ) && + ( storagePushConstant16 == rhs.storagePushConstant16 ) && + ( storageInputOutput16 == rhs.storageInputOutput16 ); +# endif } bool operator!=( PhysicalDevice16BitStorageFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -43847,30 +46358,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, formatA4R4G4B4, formatA4B4G4R4 ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDevice4444FormatsFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDevice4444FormatsFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( formatA4R4G4B4 == rhs.formatA4R4G4B4 ) && + ( formatA4B4G4R4 == rhs.formatA4B4G4R4 ); +# endif } bool operator!=( PhysicalDevice4444FormatsFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -43969,31 +46487,40 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, storageBuffer8BitAccess, uniformAndStorageBuffer8BitAccess, storagePushConstant8 ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDevice8BitStorageFeatures const & ) const = default; #else bool operator==( PhysicalDevice8BitStorageFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( storageBuffer8BitAccess == rhs.storageBuffer8BitAccess ) && + ( uniformAndStorageBuffer8BitAccess == rhs.uniformAndStorageBuffer8BitAccess ) && + ( storagePushConstant8 == rhs.storagePushConstant8 ); +# endif } bool operator!=( PhysicalDevice8BitStorageFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -44077,27 +46604,34 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, decodeModeSharedExponent ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceASTCDecodeFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceASTCDecodeFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( decodeModeSharedExponent == rhs.decodeModeSharedExponent ); +# endif } bool operator!=( PhysicalDeviceASTCDecodeFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -44218,9 +46752,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -44239,18 +46774,29 @@ namespace VULKAN_HPP_NAMESPACE accelerationStructureHostCommands, descriptorBindingAccelerationStructureUpdateAfterBind ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceAccelerationStructureFeaturesKHR const & ) const = default; #else bool operator==( PhysicalDeviceAccelerationStructureFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( accelerationStructure == rhs.accelerationStructure ) && + ( accelerationStructureCaptureReplay == rhs.accelerationStructureCaptureReplay ) && + ( accelerationStructureIndirectBuild == rhs.accelerationStructureIndirectBuild ) && + ( accelerationStructureHostCommands == rhs.accelerationStructureHostCommands ) && + ( descriptorBindingAccelerationStructureUpdateAfterBind == + rhs.descriptorBindingAccelerationStructureUpdateAfterBind ); +# endif } bool operator!=( PhysicalDeviceAccelerationStructureFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -44338,9 +46884,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -44365,18 +46912,31 @@ namespace VULKAN_HPP_NAMESPACE maxDescriptorSetUpdateAfterBindAccelerationStructures, minAccelerationStructureScratchOffsetAlignment ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceAccelerationStructurePropertiesKHR const & ) const = default; #else bool operator==( PhysicalDeviceAccelerationStructurePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxGeometryCount == rhs.maxGeometryCount ) && + ( maxInstanceCount == rhs.maxInstanceCount ) && ( maxPrimitiveCount == rhs.maxPrimitiveCount ) && + ( maxPerStageDescriptorAccelerationStructures == rhs.maxPerStageDescriptorAccelerationStructures ) && + ( maxPerStageDescriptorUpdateAfterBindAccelerationStructures == + rhs.maxPerStageDescriptorUpdateAfterBindAccelerationStructures ) && + ( maxDescriptorSetAccelerationStructures == rhs.maxDescriptorSetAccelerationStructures ) && + ( maxDescriptorSetUpdateAfterBindAccelerationStructures == + rhs.maxDescriptorSetUpdateAfterBindAccelerationStructures ) && + ( minAccelerationStructureScratchOffsetAlignment == rhs.minAccelerationStructureScratchOffsetAlignment ); +# endif } bool operator!=( PhysicalDeviceAccelerationStructurePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -44468,27 +47028,34 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, advancedBlendCoherentOperations ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceBlendOperationAdvancedFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceBlendOperationAdvancedFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( advancedBlendCoherentOperations == rhs.advancedBlendCoherentOperations ); +# endif } bool operator!=( PhysicalDeviceBlendOperationAdvancedFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -44568,9 +47135,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -44591,18 +47159,29 @@ namespace VULKAN_HPP_NAMESPACE advancedBlendCorrelatedOverlap, advancedBlendAllOperations ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceBlendOperationAdvancedPropertiesEXT const & ) const = default; #else bool operator==( PhysicalDeviceBlendOperationAdvancedPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( advancedBlendMaxColorAttachments == rhs.advancedBlendMaxColorAttachments ) && + ( advancedBlendIndependentBlend == rhs.advancedBlendIndependentBlend ) && + ( advancedBlendNonPremultipliedSrcColor == rhs.advancedBlendNonPremultipliedSrcColor ) && + ( advancedBlendNonPremultipliedDstColor == rhs.advancedBlendNonPremultipliedDstColor ) && + ( advancedBlendCorrelatedOverlap == rhs.advancedBlendCorrelatedOverlap ) && + ( advancedBlendAllOperations == rhs.advancedBlendAllOperations ); +# endif } bool operator!=( PhysicalDeviceBlendOperationAdvancedPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -44700,30 +47279,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, borderColorSwizzle, borderColorSwizzleFromImage ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceBorderColorSwizzleFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceBorderColorSwizzleFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( borderColorSwizzle == rhs.borderColorSwizzle ) && + ( borderColorSwizzleFromImage == rhs.borderColorSwizzleFromImage ); +# endif } bool operator!=( PhysicalDeviceBorderColorSwizzleFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -44826,32 +47412,40 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, bufferDeviceAddress, bufferDeviceAddressCaptureReplay, bufferDeviceAddressMultiDevice ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceBufferDeviceAddressFeatures const & ) const = default; #else bool operator==( PhysicalDeviceBufferDeviceAddressFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( bufferDeviceAddress == rhs.bufferDeviceAddress ) && + ( bufferDeviceAddressCaptureReplay == rhs.bufferDeviceAddressCaptureReplay ) && + ( bufferDeviceAddressMultiDevice == rhs.bufferDeviceAddressMultiDevice ); +# endif } bool operator!=( PhysicalDeviceBufferDeviceAddressFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -44956,32 +47550,40 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, bufferDeviceAddress, bufferDeviceAddressCaptureReplay, bufferDeviceAddressMultiDevice ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceBufferDeviceAddressFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceBufferDeviceAddressFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( bufferDeviceAddress == rhs.bufferDeviceAddress ) && + ( bufferDeviceAddressCaptureReplay == rhs.bufferDeviceAddressCaptureReplay ) && + ( bufferDeviceAddressMultiDevice == rhs.bufferDeviceAddressMultiDevice ); +# endif } bool operator!=( PhysicalDeviceBufferDeviceAddressFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -45067,27 +47669,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, deviceCoherentMemory ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceCoherentMemoryFeaturesAMD const & ) const = default; #else bool operator==( PhysicalDeviceCoherentMemoryFeaturesAMD const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceCoherentMemory == rhs.deviceCoherentMemory ); +# endif } bool operator!=( PhysicalDeviceCoherentMemoryFeaturesAMD const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -45170,27 +47778,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, colorWriteEnable ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceColorWriteEnableFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceColorWriteEnableFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( colorWriteEnable == rhs.colorWriteEnable ); +# endif } bool operator!=( PhysicalDeviceColorWriteEnableFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -45284,30 +47898,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, computeDerivativeGroupQuads, computeDerivativeGroupLinear ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceComputeShaderDerivativesFeaturesNV const & ) const = default; #else bool operator==( PhysicalDeviceComputeShaderDerivativesFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( computeDerivativeGroupQuads == rhs.computeDerivativeGroupQuads ) && + ( computeDerivativeGroupLinear == rhs.computeDerivativeGroupLinear ); +# endif } bool operator!=( PhysicalDeviceComputeShaderDerivativesFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -45402,30 +48024,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, conditionalRendering, inheritedConditionalRendering ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceConditionalRenderingFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceConditionalRenderingFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( conditionalRendering == rhs.conditionalRendering ) && + ( inheritedConditionalRendering == rhs.inheritedConditionalRendering ); +# endif } bool operator!=( PhysicalDeviceConditionalRenderingFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -45512,9 +48141,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -45541,18 +48171,32 @@ namespace VULKAN_HPP_NAMESPACE fullyCoveredFragmentShaderInputVariable, conservativeRasterizationPostDepthCoverage ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceConservativeRasterizationPropertiesEXT const & ) const = default; #else bool operator==( PhysicalDeviceConservativeRasterizationPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( primitiveOverestimationSize == rhs.primitiveOverestimationSize ) && + ( maxExtraPrimitiveOverestimationSize == rhs.maxExtraPrimitiveOverestimationSize ) && + ( extraPrimitiveOverestimationSizeGranularity == rhs.extraPrimitiveOverestimationSizeGranularity ) && + ( primitiveUnderestimation == rhs.primitiveUnderestimation ) && + ( conservativePointAndLineRasterization == rhs.conservativePointAndLineRasterization ) && + ( degenerateTrianglesRasterized == rhs.degenerateTrianglesRasterized ) && + ( degenerateLinesRasterized == rhs.degenerateLinesRasterized ) && + ( fullyCoveredFragmentShaderInputVariable == rhs.fullyCoveredFragmentShaderInputVariable ) && + ( conservativeRasterizationPostDepthCoverage == rhs.conservativeRasterizationPostDepthCoverage ); +# endif } bool operator!=( PhysicalDeviceConservativeRasterizationPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -45653,30 +48297,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, cooperativeMatrix, cooperativeMatrixRobustBufferAccess ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceCooperativeMatrixFeaturesNV const & ) const = default; #else bool operator==( PhysicalDeviceCooperativeMatrixFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( cooperativeMatrix == rhs.cooperativeMatrix ) && + ( cooperativeMatrixRobustBufferAccess == rhs.cooperativeMatrixRobustBufferAccess ); +# endif } bool operator!=( PhysicalDeviceCooperativeMatrixFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -45746,28 +48397,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std:: tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, cooperativeMatrixSupportedStages ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceCooperativeMatrixPropertiesNV const & ) const = default; #else bool operator==( PhysicalDeviceCooperativeMatrixPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( cooperativeMatrixSupportedStages == rhs.cooperativeMatrixSupportedStages ); +# endif } bool operator!=( PhysicalDeviceCooperativeMatrixPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -45851,27 +48509,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, cornerSampledImage ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceCornerSampledImageFeaturesNV const & ) const = default; #else bool operator==( PhysicalDeviceCornerSampledImageFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( cornerSampledImage == rhs.cornerSampledImage ); +# endif } bool operator!=( PhysicalDeviceCornerSampledImageFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -45956,27 +48620,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, coverageReductionMode ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceCoverageReductionModeFeaturesNV const & ) const = default; #else bool operator==( PhysicalDeviceCoverageReductionModeFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( coverageReductionMode == rhs.coverageReductionMode ); +# endif } bool operator!=( PhysicalDeviceCoverageReductionModeFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -46069,30 +48739,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, customBorderColors, customBorderColorWithoutFormat ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceCustomBorderColorFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceCustomBorderColorFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( customBorderColors == rhs.customBorderColors ) && + ( customBorderColorWithoutFormat == rhs.customBorderColorWithoutFormat ); +# endif } bool operator!=( PhysicalDeviceCustomBorderColorFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -46162,27 +48839,34 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, maxCustomBorderColorSamplers ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceCustomBorderColorPropertiesEXT const & ) const = default; #else bool operator==( PhysicalDeviceCustomBorderColorPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( maxCustomBorderColorSamplers == rhs.maxCustomBorderColorSamplers ); +# endif } bool operator!=( PhysicalDeviceCustomBorderColorPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -46269,27 +48953,34 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, dedicatedAllocationImageAliasing ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const & ) const = default; #else bool operator==( PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( dedicatedAllocationImageAliasing == rhs.dedicatedAllocationImageAliasing ); +# endif } bool operator!=( PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -46374,27 +49065,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, depthClipControl ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceDepthClipControlFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceDepthClipControlFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( depthClipControl == rhs.depthClipControl ); +# endif } bool operator!=( PhysicalDeviceDepthClipControlFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -46478,27 +49175,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, depthClipEnable ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceDepthClipEnableFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceDepthClipEnableFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( depthClipEnable == rhs.depthClipEnable ); +# endif } bool operator!=( PhysicalDeviceDepthClipEnableFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -46573,16 +49276,17 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -46592,18 +49296,27 @@ namespace VULKAN_HPP_NAMESPACE independentResolveNone, independentResolve ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceDepthStencilResolveProperties const & ) const = default; #else bool operator==( PhysicalDeviceDepthStencilResolveProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( supportedDepthResolveModes == rhs.supportedDepthResolveModes ) && + ( supportedStencilResolveModes == rhs.supportedStencilResolveModes ) && + ( independentResolveNone == rhs.independentResolveNone ) && + ( independentResolve == rhs.independentResolve ); +# endif } bool operator!=( PhysicalDeviceDepthStencilResolveProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -46866,9 +49579,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -46917,18 +49631,47 @@ namespace VULKAN_HPP_NAMESPACE descriptorBindingVariableDescriptorCount, runtimeDescriptorArray ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceDescriptorIndexingFeatures const & ) const = default; #else bool operator==( PhysicalDeviceDescriptorIndexingFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( shaderInputAttachmentArrayDynamicIndexing == rhs.shaderInputAttachmentArrayDynamicIndexing ) && + ( shaderUniformTexelBufferArrayDynamicIndexing == rhs.shaderUniformTexelBufferArrayDynamicIndexing ) && + ( shaderStorageTexelBufferArrayDynamicIndexing == rhs.shaderStorageTexelBufferArrayDynamicIndexing ) && + ( shaderUniformBufferArrayNonUniformIndexing == rhs.shaderUniformBufferArrayNonUniformIndexing ) && + ( shaderSampledImageArrayNonUniformIndexing == rhs.shaderSampledImageArrayNonUniformIndexing ) && + ( shaderStorageBufferArrayNonUniformIndexing == rhs.shaderStorageBufferArrayNonUniformIndexing ) && + ( shaderStorageImageArrayNonUniformIndexing == rhs.shaderStorageImageArrayNonUniformIndexing ) && + ( shaderInputAttachmentArrayNonUniformIndexing == rhs.shaderInputAttachmentArrayNonUniformIndexing ) && + ( shaderUniformTexelBufferArrayNonUniformIndexing == + rhs.shaderUniformTexelBufferArrayNonUniformIndexing ) && + ( shaderStorageTexelBufferArrayNonUniformIndexing == + rhs.shaderStorageTexelBufferArrayNonUniformIndexing ) && + ( descriptorBindingUniformBufferUpdateAfterBind == rhs.descriptorBindingUniformBufferUpdateAfterBind ) && + ( descriptorBindingSampledImageUpdateAfterBind == rhs.descriptorBindingSampledImageUpdateAfterBind ) && + ( descriptorBindingStorageImageUpdateAfterBind == rhs.descriptorBindingStorageImageUpdateAfterBind ) && + ( descriptorBindingStorageBufferUpdateAfterBind == rhs.descriptorBindingStorageBufferUpdateAfterBind ) && + ( descriptorBindingUniformTexelBufferUpdateAfterBind == + rhs.descriptorBindingUniformTexelBufferUpdateAfterBind ) && + ( descriptorBindingStorageTexelBufferUpdateAfterBind == + rhs.descriptorBindingStorageTexelBufferUpdateAfterBind ) && + ( descriptorBindingUpdateUnusedWhilePending == rhs.descriptorBindingUpdateUnusedWhilePending ) && + ( descriptorBindingPartiallyBound == rhs.descriptorBindingPartiallyBound ) && + ( descriptorBindingVariableDescriptorCount == rhs.descriptorBindingVariableDescriptorCount ) && + ( runtimeDescriptorArray == rhs.runtimeDescriptorArray ); +# endif } bool operator!=( PhysicalDeviceDescriptorIndexingFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -47061,9 +49804,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -47118,18 +49862,58 @@ namespace VULKAN_HPP_NAMESPACE maxDescriptorSetUpdateAfterBindStorageImages, maxDescriptorSetUpdateAfterBindInputAttachments ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceDescriptorIndexingProperties const & ) const = default; #else bool operator==( PhysicalDeviceDescriptorIndexingProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( maxUpdateAfterBindDescriptorsInAllPools == rhs.maxUpdateAfterBindDescriptorsInAllPools ) && + ( shaderUniformBufferArrayNonUniformIndexingNative == + rhs.shaderUniformBufferArrayNonUniformIndexingNative ) && + ( shaderSampledImageArrayNonUniformIndexingNative == + rhs.shaderSampledImageArrayNonUniformIndexingNative ) && + ( shaderStorageBufferArrayNonUniformIndexingNative == + rhs.shaderStorageBufferArrayNonUniformIndexingNative ) && + ( shaderStorageImageArrayNonUniformIndexingNative == + rhs.shaderStorageImageArrayNonUniformIndexingNative ) && + ( shaderInputAttachmentArrayNonUniformIndexingNative == + rhs.shaderInputAttachmentArrayNonUniformIndexingNative ) && + ( robustBufferAccessUpdateAfterBind == rhs.robustBufferAccessUpdateAfterBind ) && + ( quadDivergentImplicitLod == rhs.quadDivergentImplicitLod ) && + ( maxPerStageDescriptorUpdateAfterBindSamplers == rhs.maxPerStageDescriptorUpdateAfterBindSamplers ) && + ( maxPerStageDescriptorUpdateAfterBindUniformBuffers == + rhs.maxPerStageDescriptorUpdateAfterBindUniformBuffers ) && + ( maxPerStageDescriptorUpdateAfterBindStorageBuffers == + rhs.maxPerStageDescriptorUpdateAfterBindStorageBuffers ) && + ( maxPerStageDescriptorUpdateAfterBindSampledImages == + rhs.maxPerStageDescriptorUpdateAfterBindSampledImages ) && + ( maxPerStageDescriptorUpdateAfterBindStorageImages == + rhs.maxPerStageDescriptorUpdateAfterBindStorageImages ) && + ( maxPerStageDescriptorUpdateAfterBindInputAttachments == + rhs.maxPerStageDescriptorUpdateAfterBindInputAttachments ) && + ( maxPerStageUpdateAfterBindResources == rhs.maxPerStageUpdateAfterBindResources ) && + ( maxDescriptorSetUpdateAfterBindSamplers == rhs.maxDescriptorSetUpdateAfterBindSamplers ) && + ( maxDescriptorSetUpdateAfterBindUniformBuffers == rhs.maxDescriptorSetUpdateAfterBindUniformBuffers ) && + ( maxDescriptorSetUpdateAfterBindUniformBuffersDynamic == + rhs.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic ) && + ( maxDescriptorSetUpdateAfterBindStorageBuffers == rhs.maxDescriptorSetUpdateAfterBindStorageBuffers ) && + ( maxDescriptorSetUpdateAfterBindStorageBuffersDynamic == + rhs.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic ) && + ( maxDescriptorSetUpdateAfterBindSampledImages == rhs.maxDescriptorSetUpdateAfterBindSampledImages ) && + ( maxDescriptorSetUpdateAfterBindStorageImages == rhs.maxDescriptorSetUpdateAfterBindStorageImages ) && + ( maxDescriptorSetUpdateAfterBindInputAttachments == rhs.maxDescriptorSetUpdateAfterBindInputAttachments ); +# endif } bool operator!=( PhysicalDeviceDescriptorIndexingProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -47237,27 +50021,34 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, deviceGeneratedCommands ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceDeviceGeneratedCommandsFeaturesNV const & ) const = default; #else bool operator==( PhysicalDeviceDeviceGeneratedCommandsFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( deviceGeneratedCommands == rhs.deviceGeneratedCommands ); +# endif } bool operator!=( PhysicalDeviceDeviceGeneratedCommandsFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -47343,9 +50134,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -47372,18 +50164,32 @@ namespace VULKAN_HPP_NAMESPACE minSequencesIndexBufferOffsetAlignment, minIndirectCommandsBufferOffsetAlignment ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceDeviceGeneratedCommandsPropertiesNV const & ) const = default; #else bool operator==( PhysicalDeviceDeviceGeneratedCommandsPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( maxGraphicsShaderGroupCount == rhs.maxGraphicsShaderGroupCount ) && + ( maxIndirectSequenceCount == rhs.maxIndirectSequenceCount ) && + ( maxIndirectCommandsTokenCount == rhs.maxIndirectCommandsTokenCount ) && + ( maxIndirectCommandsStreamCount == rhs.maxIndirectCommandsStreamCount ) && + ( maxIndirectCommandsTokenOffset == rhs.maxIndirectCommandsTokenOffset ) && + ( maxIndirectCommandsStreamStride == rhs.maxIndirectCommandsStreamStride ) && + ( minSequencesCountBufferOffsetAlignment == rhs.minSequencesCountBufferOffsetAlignment ) && + ( minSequencesIndexBufferOffsetAlignment == rhs.minSequencesIndexBufferOffsetAlignment ) && + ( minIndirectCommandsBufferOffsetAlignment == rhs.minIndirectCommandsBufferOffsetAlignment ); +# endif } bool operator!=( PhysicalDeviceDeviceGeneratedCommandsPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -47475,27 +50281,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, deviceMemoryReport ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceDeviceMemoryReportFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceDeviceMemoryReportFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceMemoryReport == rhs.deviceMemoryReport ); +# endif } bool operator!=( PhysicalDeviceDeviceMemoryReportFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -47579,27 +50391,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, diagnosticsConfig ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceDiagnosticsConfigFeaturesNV const & ) const = default; #else bool operator==( PhysicalDeviceDiagnosticsConfigFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( diagnosticsConfig == rhs.diagnosticsConfig ); +# endif } bool operator!=( PhysicalDeviceDiagnosticsConfigFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -47668,27 +50486,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, maxDiscardRectangles ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceDiscardRectanglePropertiesEXT const & ) const = default; #else bool operator==( PhysicalDeviceDiscardRectanglePropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxDiscardRectangles == rhs.maxDiscardRectangles ); +# endif } bool operator!=( PhysicalDeviceDiscardRectanglePropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -47759,32 +50583,40 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple const &, VULKAN_HPP_NAMESPACE::ArrayWrapper1D const &, VULKAN_HPP_NAMESPACE::ConformanceVersion const &> -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, driverID, driverName, driverInfo, conformanceVersion ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceDriverProperties const & ) const = default; #else bool operator==( PhysicalDeviceDriverProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( driverID == rhs.driverID ) && + ( driverName == rhs.driverName ) && ( driverInfo == rhs.driverInfo ) && + ( conformanceVersion == rhs.conformanceVersion ); +# endif } bool operator!=( PhysicalDeviceDriverProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -47861,9 +50693,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, hasPrimary, hasRender, primaryMajor, primaryMinor, renderMajor, renderMinor ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceDrmPropertiesEXT const & ) const = default; #else bool operator==( PhysicalDeviceDrmPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( hasPrimary == rhs.hasPrimary ) && + ( hasRender == rhs.hasRender ) && ( primaryMajor == rhs.primaryMajor ) && + ( primaryMinor == rhs.primaryMinor ) && ( renderMajor == rhs.renderMajor ) && + ( renderMinor == rhs.renderMinor ); +# endif } bool operator!=( PhysicalDeviceDrmPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -47975,27 +50816,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, dynamicRendering ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceDynamicRenderingFeaturesKHR const & ) const = default; #else bool operator==( PhysicalDeviceDynamicRenderingFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dynamicRendering == rhs.dynamicRendering ); +# endif } bool operator!=( PhysicalDeviceDynamicRenderingFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -48078,27 +50925,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, exclusiveScissor ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceExclusiveScissorFeaturesNV const & ) const = default; #else bool operator==( PhysicalDeviceExclusiveScissorFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( exclusiveScissor == rhs.exclusiveScissor ); +# endif } bool operator!=( PhysicalDeviceExclusiveScissorFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -48201,32 +51054,41 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, extendedDynamicState2, extendedDynamicState2LogicOp, extendedDynamicState2PatchControlPoints ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceExtendedDynamicState2FeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceExtendedDynamicState2FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( extendedDynamicState2 == rhs.extendedDynamicState2 ) && + ( extendedDynamicState2LogicOp == rhs.extendedDynamicState2LogicOp ) && + ( extendedDynamicState2PatchControlPoints == rhs.extendedDynamicState2PatchControlPoints ); +# endif } bool operator!=( PhysicalDeviceExtendedDynamicState2FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -48313,27 +51175,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, extendedDynamicState ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceExtendedDynamicStateFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceExtendedDynamicStateFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( extendedDynamicState == rhs.extendedDynamicState ); +# endif } bool operator!=( PhysicalDeviceExtendedDynamicStateFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -48432,31 +51300,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, flags, usage, handleType ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceExternalBufferInfo const & ) const = default; #else bool operator==( PhysicalDeviceExternalBufferInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( usage == rhs.usage ) && + ( handleType == rhs.handleType ); +# endif } bool operator!=( PhysicalDeviceExternalBufferInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -48540,29 +51415,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, handleType ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceExternalFenceInfo const & ) const = default; #else bool operator==( PhysicalDeviceExternalFenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleType == rhs.handleType ); +# endif } bool operator!=( PhysicalDeviceExternalFenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -48647,29 +51528,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, handleType ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceExternalImageFormatInfo const & ) const = default; #else bool operator==( PhysicalDeviceExternalImageFormatInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleType == rhs.handleType ); +# endif } bool operator!=( PhysicalDeviceExternalImageFormatInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -48739,27 +51626,34 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, minImportedHostPointerAlignment ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceExternalMemoryHostPropertiesEXT const & ) const = default; #else bool operator==( PhysicalDeviceExternalMemoryHostPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( minImportedHostPointerAlignment == rhs.minImportedHostPointerAlignment ); +# endif } bool operator!=( PhysicalDeviceExternalMemoryHostPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -48843,27 +51737,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, externalMemoryRDMA ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceExternalMemoryRDMAFeaturesNV const & ) const = default; #else bool operator==( PhysicalDeviceExternalMemoryRDMAFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( externalMemoryRDMA == rhs.externalMemoryRDMA ); +# endif } bool operator!=( PhysicalDeviceExternalMemoryRDMAFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -48946,29 +51846,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, handleType ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceExternalSemaphoreInfo const & ) const = default; #else bool operator==( PhysicalDeviceExternalSemaphoreInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleType == rhs.handleType ); +# endif } bool operator!=( PhysicalDeviceExternalSemaphoreInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -49047,29 +51953,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, features ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceFeatures2 const & ) const = default; #else bool operator==( PhysicalDeviceFeatures2 const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( features == rhs.features ); +# endif } bool operator!=( PhysicalDeviceFeatures2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -49170,9 +52082,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -49215,18 +52128,40 @@ namespace VULKAN_HPP_NAMESPACE shaderRoundingModeRTZFloat32, shaderRoundingModeRTZFloat64 ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceFloatControlsProperties const & ) const = default; #else bool operator==( PhysicalDeviceFloatControlsProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( denormBehaviorIndependence == rhs.denormBehaviorIndependence ) && + ( roundingModeIndependence == rhs.roundingModeIndependence ) && + ( shaderSignedZeroInfNanPreserveFloat16 == rhs.shaderSignedZeroInfNanPreserveFloat16 ) && + ( shaderSignedZeroInfNanPreserveFloat32 == rhs.shaderSignedZeroInfNanPreserveFloat32 ) && + ( shaderSignedZeroInfNanPreserveFloat64 == rhs.shaderSignedZeroInfNanPreserveFloat64 ) && + ( shaderDenormPreserveFloat16 == rhs.shaderDenormPreserveFloat16 ) && + ( shaderDenormPreserveFloat32 == rhs.shaderDenormPreserveFloat32 ) && + ( shaderDenormPreserveFloat64 == rhs.shaderDenormPreserveFloat64 ) && + ( shaderDenormFlushToZeroFloat16 == rhs.shaderDenormFlushToZeroFloat16 ) && + ( shaderDenormFlushToZeroFloat32 == rhs.shaderDenormFlushToZeroFloat32 ) && + ( shaderDenormFlushToZeroFloat64 == rhs.shaderDenormFlushToZeroFloat64 ) && + ( shaderRoundingModeRTEFloat16 == rhs.shaderRoundingModeRTEFloat16 ) && + ( shaderRoundingModeRTEFloat32 == rhs.shaderRoundingModeRTEFloat32 ) && + ( shaderRoundingModeRTEFloat64 == rhs.shaderRoundingModeRTEFloat64 ) && + ( shaderRoundingModeRTZFloat16 == rhs.shaderRoundingModeRTZFloat16 ) && + ( shaderRoundingModeRTZFloat32 == rhs.shaderRoundingModeRTZFloat32 ) && + ( shaderRoundingModeRTZFloat64 == rhs.shaderRoundingModeRTZFloat64 ); +# endif } bool operator!=( PhysicalDeviceFloatControlsProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -49328,27 +52263,34 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, fragmentDensityMapDeferred ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceFragmentDensityMap2FeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceFragmentDensityMap2FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( fragmentDensityMapDeferred == rhs.fragmentDensityMapDeferred ); +# endif } bool operator!=( PhysicalDeviceFragmentDensityMap2FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -49423,16 +52365,17 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -49442,18 +52385,26 @@ namespace VULKAN_HPP_NAMESPACE maxSubsampledArrayLayers, maxDescriptorSetSubsampledSamplers ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceFragmentDensityMap2PropertiesEXT const & ) const = default; #else bool operator==( PhysicalDeviceFragmentDensityMap2PropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( subsampledLoads == rhs.subsampledLoads ) && + ( subsampledCoarseReconstructionEarlyAccess == rhs.subsampledCoarseReconstructionEarlyAccess ) && + ( maxSubsampledArrayLayers == rhs.maxSubsampledArrayLayers ) && + ( maxDescriptorSetSubsampledSamplers == rhs.maxDescriptorSetSubsampledSamplers ); +# endif } bool operator!=( PhysicalDeviceFragmentDensityMap2PropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -49558,32 +52509,40 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, fragmentDensityMap, fragmentDensityMapDynamic, fragmentDensityMapNonSubsampledImages ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceFragmentDensityMapFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceFragmentDensityMapFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fragmentDensityMap == rhs.fragmentDensityMap ) && + ( fragmentDensityMapDynamic == rhs.fragmentDensityMapDynamic ) && + ( fragmentDensityMapNonSubsampledImages == rhs.fragmentDensityMapNonSubsampledImages ); +# endif } bool operator!=( PhysicalDeviceFragmentDensityMapFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -49671,27 +52630,34 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, fragmentDensityMapOffset ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM const & ) const = default; #else bool operator==( PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( fragmentDensityMapOffset == rhs.fragmentDensityMapOffset ); +# endif } bool operator!=( PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -49761,27 +52727,34 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, fragmentDensityOffsetGranularity ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM const & ) const = default; #else bool operator==( PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( fragmentDensityOffsetGranularity == rhs.fragmentDensityOffsetGranularity ); +# endif } bool operator!=( PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -49854,32 +52827,41 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, minFragmentDensityTexelSize, maxFragmentDensityTexelSize, fragmentDensityInvocations ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceFragmentDensityMapPropertiesEXT const & ) const = default; #else bool operator==( PhysicalDeviceFragmentDensityMapPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( minFragmentDensityTexelSize == rhs.minFragmentDensityTexelSize ) && + ( maxFragmentDensityTexelSize == rhs.maxFragmentDensityTexelSize ) && + ( fragmentDensityInvocations == rhs.fragmentDensityInvocations ); +# endif } bool operator!=( PhysicalDeviceFragmentDensityMapPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -49967,27 +52949,34 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, fragmentShaderBarycentric ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceFragmentShaderBarycentricFeaturesNV const & ) const = default; #else bool operator==( PhysicalDeviceFragmentShaderBarycentricFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( fragmentShaderBarycentric == rhs.fragmentShaderBarycentric ); +# endif } bool operator!=( PhysicalDeviceFragmentShaderBarycentricFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -50090,32 +53079,41 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, fragmentShaderSampleInterlock, fragmentShaderPixelInterlock, fragmentShaderShadingRateInterlock ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceFragmentShaderInterlockFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceFragmentShaderInterlockFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( fragmentShaderSampleInterlock == rhs.fragmentShaderSampleInterlock ) && + ( fragmentShaderPixelInterlock == rhs.fragmentShaderPixelInterlock ) && + ( fragmentShaderShadingRateInterlock == rhs.fragmentShaderShadingRateInterlock ); +# endif } bool operator!=( PhysicalDeviceFragmentShaderInterlockFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -50220,32 +53218,41 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, fragmentShadingRateEnums, supersampleFragmentShadingRates, noInvocationFragmentShadingRates ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceFragmentShadingRateEnumsFeaturesNV const & ) const = default; #else bool operator==( PhysicalDeviceFragmentShadingRateEnumsFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( fragmentShadingRateEnums == rhs.fragmentShadingRateEnums ) && + ( supersampleFragmentShadingRates == rhs.supersampleFragmentShadingRates ) && + ( noInvocationFragmentShadingRates == rhs.noInvocationFragmentShadingRates ); +# endif } bool operator!=( PhysicalDeviceFragmentShadingRateEnumsFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -50335,29 +53342,36 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, maxFragmentShadingRateInvocationCount ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceFragmentShadingRateEnumsPropertiesNV const & ) const = default; #else bool operator==( PhysicalDeviceFragmentShadingRateEnumsPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( maxFragmentShadingRateInvocationCount == rhs.maxFragmentShadingRateInvocationCount ); +# endif } bool operator!=( PhysicalDeviceFragmentShadingRateEnumsPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -50460,32 +53474,41 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, pipelineFragmentShadingRate, primitiveFragmentShadingRate, attachmentFragmentShadingRate ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceFragmentShadingRateFeaturesKHR const & ) const = default; #else bool operator==( PhysicalDeviceFragmentShadingRateFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( pipelineFragmentShadingRate == rhs.pipelineFragmentShadingRate ) && + ( primitiveFragmentShadingRate == rhs.primitiveFragmentShadingRate ) && + ( attachmentFragmentShadingRate == rhs.attachmentFragmentShadingRate ); +# endif } bool operator!=( PhysicalDeviceFragmentShadingRateFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -50556,30 +53579,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, sampleCounts, fragmentSize ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceFragmentShadingRateKHR const & ) const = default; #else bool operator==( PhysicalDeviceFragmentShadingRateKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( sampleCounts == rhs.sampleCounts ) && + ( fragmentSize == rhs.fragmentSize ); +# endif } bool operator!=( PhysicalDeviceFragmentShadingRateKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -50681,9 +53711,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -50726,18 +53757,44 @@ namespace VULKAN_HPP_NAMESPACE fragmentShadingRateWithCustomSampleLocations, fragmentShadingRateStrictMultiplyCombiner ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceFragmentShadingRatePropertiesKHR const & ) const = default; #else bool operator==( PhysicalDeviceFragmentShadingRatePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( minFragmentShadingRateAttachmentTexelSize == rhs.minFragmentShadingRateAttachmentTexelSize ) && + ( maxFragmentShadingRateAttachmentTexelSize == rhs.maxFragmentShadingRateAttachmentTexelSize ) && + ( maxFragmentShadingRateAttachmentTexelSizeAspectRatio == + rhs.maxFragmentShadingRateAttachmentTexelSizeAspectRatio ) && + ( primitiveFragmentShadingRateWithMultipleViewports == + rhs.primitiveFragmentShadingRateWithMultipleViewports ) && + ( layeredShadingRateAttachments == rhs.layeredShadingRateAttachments ) && + ( fragmentShadingRateNonTrivialCombinerOps == rhs.fragmentShadingRateNonTrivialCombinerOps ) && + ( maxFragmentSize == rhs.maxFragmentSize ) && + ( maxFragmentSizeAspectRatio == rhs.maxFragmentSizeAspectRatio ) && + ( maxFragmentShadingRateCoverageSamples == rhs.maxFragmentShadingRateCoverageSamples ) && + ( maxFragmentShadingRateRasterizationSamples == rhs.maxFragmentShadingRateRasterizationSamples ) && + ( fragmentShadingRateWithShaderDepthStencilWrites == + rhs.fragmentShadingRateWithShaderDepthStencilWrites ) && + ( fragmentShadingRateWithSampleMask == rhs.fragmentShadingRateWithSampleMask ) && + ( fragmentShadingRateWithShaderSampleMask == rhs.fragmentShadingRateWithShaderSampleMask ) && + ( fragmentShadingRateWithConservativeRasterization == + rhs.fragmentShadingRateWithConservativeRasterization ) && + ( fragmentShadingRateWithFragmentShaderInterlock == rhs.fragmentShadingRateWithFragmentShaderInterlock ) && + ( fragmentShadingRateWithCustomSampleLocations == rhs.fragmentShadingRateWithCustomSampleLocations ) && + ( fragmentShadingRateStrictMultiplyCombiner == rhs.fragmentShadingRateStrictMultiplyCombiner ); +# endif } bool operator!=( PhysicalDeviceFragmentShadingRatePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -50838,27 +53895,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, globalPriorityQuery ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceGlobalPriorityQueryFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceGlobalPriorityQueryFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( globalPriorityQuery == rhs.globalPriorityQuery ); +# endif } bool operator!=( PhysicalDeviceGlobalPriorityQueryFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -50927,32 +53990,39 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple< VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, uint32_t const &, VULKAN_HPP_NAMESPACE::ArrayWrapper1D const &, VULKAN_HPP_NAMESPACE::Bool32 const &> -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, physicalDeviceCount, physicalDevices, subsetAllocation ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceGroupProperties const & ) const = default; #else bool operator==( PhysicalDeviceGroupProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( physicalDeviceCount == rhs.physicalDeviceCount ) && + ( physicalDevices == rhs.physicalDevices ) && ( subsetAllocation == rhs.subsetAllocation ); +# endif } bool operator!=( PhysicalDeviceGroupProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -51037,27 +54107,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, hostQueryReset ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceHostQueryResetFeatures const & ) const = default; #else bool operator==( PhysicalDeviceHostQueryResetFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( hostQueryReset == rhs.hostQueryReset ); +# endif } bool operator!=( PhysicalDeviceHostQueryResetFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -51129,9 +54205,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple const &, @@ -51139,23 +54216,30 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::ArrayWrapper1D const &, uint32_t const &, VULKAN_HPP_NAMESPACE::Bool32 const &> -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, deviceUUID, driverUUID, deviceLUID, deviceNodeMask, deviceLUIDValid ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceIDProperties const & ) const = default; #else bool operator==( PhysicalDeviceIDProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceUUID == rhs.deviceUUID ) && + ( driverUUID == rhs.driverUUID ) && ( deviceLUID == rhs.deviceLUID ) && + ( deviceNodeMask == rhs.deviceNodeMask ) && ( deviceLUIDValid == rhs.deviceLUIDValid ); +# endif } bool operator!=( PhysicalDeviceIDProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -51292,32 +54376,40 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, drmFormatModifier, sharingMode, queueFamilyIndexCount, pQueueFamilyIndices ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceImageDrmFormatModifierInfoEXT const & ) const = default; #else bool operator==( PhysicalDeviceImageDrmFormatModifierInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( drmFormatModifier == rhs.drmFormatModifier ) && + ( sharingMode == rhs.sharingMode ) && ( queueFamilyIndexCount == rhs.queueFamilyIndexCount ) && + ( pQueueFamilyIndices == rhs.pQueueFamilyIndices ); +# endif } bool operator!=( PhysicalDeviceImageDrmFormatModifierInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -51436,9 +54528,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, format, type, tiling, usage, flags ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceImageFormatInfo2 const & ) const = default; #else bool operator==( PhysicalDeviceImageFormatInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( format == rhs.format ) && ( type == rhs.type ) && + ( tiling == rhs.tiling ) && ( usage == rhs.usage ) && ( flags == rhs.flags ); +# endif } bool operator!=( PhysicalDeviceImageFormatInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -51550,27 +54649,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, robustImageAccess ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceImageRobustnessFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceImageRobustnessFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( robustImageAccess == rhs.robustImageAccess ); +# endif } bool operator!=( PhysicalDeviceImageRobustnessFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -51655,27 +54760,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, imageViewType ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceImageViewImageFormatInfoEXT const & ) const = default; #else bool operator==( PhysicalDeviceImageViewImageFormatInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageViewType == rhs.imageViewType ); +# endif } bool operator!=( PhysicalDeviceImageViewImageFormatInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -51759,27 +54870,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, minLod ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceImageViewMinLodFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceImageViewMinLodFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( minLod == rhs.minLod ); +# endif } bool operator!=( PhysicalDeviceImageViewMinLodFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -51863,27 +54980,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, imagelessFramebuffer ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceImagelessFramebufferFeatures const & ) const = default; #else bool operator==( PhysicalDeviceImagelessFramebufferFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imagelessFramebuffer == rhs.imagelessFramebuffer ); +# endif } bool operator!=( PhysicalDeviceImagelessFramebufferFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -51967,27 +55090,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, indexTypeUint8 ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceIndexTypeUint8FeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceIndexTypeUint8FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( indexTypeUint8 == rhs.indexTypeUint8 ); +# endif } bool operator!=( PhysicalDeviceIndexTypeUint8FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -52072,27 +55201,34 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, inheritedViewportScissor2D ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceInheritedViewportScissorFeaturesNV const & ) const = default; #else bool operator==( PhysicalDeviceInheritedViewportScissorFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( inheritedViewportScissor2D == rhs.inheritedViewportScissor2D ); +# endif } bool operator!=( PhysicalDeviceInheritedViewportScissorFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -52186,30 +55322,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, inlineUniformBlock, descriptorBindingInlineUniformBlockUpdateAfterBind ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceInlineUniformBlockFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceInlineUniformBlockFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( inlineUniformBlock == rhs.inlineUniformBlock ) && + ( descriptorBindingInlineUniformBlockUpdateAfterBind == + rhs.descriptorBindingInlineUniformBlockUpdateAfterBind ); +# endif } bool operator!=( PhysicalDeviceInlineUniformBlockFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -52288,9 +55432,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -52309,18 +55454,30 @@ namespace VULKAN_HPP_NAMESPACE maxDescriptorSetInlineUniformBlocks, maxDescriptorSetUpdateAfterBindInlineUniformBlocks ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceInlineUniformBlockPropertiesEXT const & ) const = default; #else bool operator==( PhysicalDeviceInlineUniformBlockPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( maxInlineUniformBlockSize == rhs.maxInlineUniformBlockSize ) && + ( maxPerStageDescriptorInlineUniformBlocks == rhs.maxPerStageDescriptorInlineUniformBlocks ) && + ( maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks == + rhs.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks ) && + ( maxDescriptorSetInlineUniformBlocks == rhs.maxDescriptorSetInlineUniformBlocks ) && + ( maxDescriptorSetUpdateAfterBindInlineUniformBlocks == + rhs.maxDescriptorSetUpdateAfterBindInlineUniformBlocks ); +# endif } bool operator!=( PhysicalDeviceInlineUniformBlockPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -52407,27 +55564,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, invocationMask ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceInvocationMaskFeaturesHUAWEI const & ) const = default; #else bool operator==( PhysicalDeviceInvocationMaskFeaturesHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( invocationMask == rhs.invocationMask ); +# endif } bool operator!=( PhysicalDeviceInvocationMaskFeaturesHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -52697,9 +55860,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( maxImageDimension1D, @@ -52916,18 +56080,121 @@ namespace VULKAN_HPP_NAMESPACE optimalBufferCopyRowPitchAlignment, nonCoherentAtomSize ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceLimits const & ) const = default; #else bool operator==( PhysicalDeviceLimits const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( maxImageDimension1D == rhs.maxImageDimension1D ) && ( maxImageDimension2D == rhs.maxImageDimension2D ) && + ( maxImageDimension3D == rhs.maxImageDimension3D ) && + ( maxImageDimensionCube == rhs.maxImageDimensionCube ) && + ( maxImageArrayLayers == rhs.maxImageArrayLayers ) && + ( maxTexelBufferElements == rhs.maxTexelBufferElements ) && + ( maxUniformBufferRange == rhs.maxUniformBufferRange ) && + ( maxStorageBufferRange == rhs.maxStorageBufferRange ) && + ( maxPushConstantsSize == rhs.maxPushConstantsSize ) && + ( maxMemoryAllocationCount == rhs.maxMemoryAllocationCount ) && + ( maxSamplerAllocationCount == rhs.maxSamplerAllocationCount ) && + ( bufferImageGranularity == rhs.bufferImageGranularity ) && + ( sparseAddressSpaceSize == rhs.sparseAddressSpaceSize ) && + ( maxBoundDescriptorSets == rhs.maxBoundDescriptorSets ) && + ( maxPerStageDescriptorSamplers == rhs.maxPerStageDescriptorSamplers ) && + ( maxPerStageDescriptorUniformBuffers == rhs.maxPerStageDescriptorUniformBuffers ) && + ( maxPerStageDescriptorStorageBuffers == rhs.maxPerStageDescriptorStorageBuffers ) && + ( maxPerStageDescriptorSampledImages == rhs.maxPerStageDescriptorSampledImages ) && + ( maxPerStageDescriptorStorageImages == rhs.maxPerStageDescriptorStorageImages ) && + ( maxPerStageDescriptorInputAttachments == rhs.maxPerStageDescriptorInputAttachments ) && + ( maxPerStageResources == rhs.maxPerStageResources ) && + ( maxDescriptorSetSamplers == rhs.maxDescriptorSetSamplers ) && + ( maxDescriptorSetUniformBuffers == rhs.maxDescriptorSetUniformBuffers ) && + ( maxDescriptorSetUniformBuffersDynamic == rhs.maxDescriptorSetUniformBuffersDynamic ) && + ( maxDescriptorSetStorageBuffers == rhs.maxDescriptorSetStorageBuffers ) && + ( maxDescriptorSetStorageBuffersDynamic == rhs.maxDescriptorSetStorageBuffersDynamic ) && + ( maxDescriptorSetSampledImages == rhs.maxDescriptorSetSampledImages ) && + ( maxDescriptorSetStorageImages == rhs.maxDescriptorSetStorageImages ) && + ( maxDescriptorSetInputAttachments == rhs.maxDescriptorSetInputAttachments ) && + ( maxVertexInputAttributes == rhs.maxVertexInputAttributes ) && + ( maxVertexInputBindings == rhs.maxVertexInputBindings ) && + ( maxVertexInputAttributeOffset == rhs.maxVertexInputAttributeOffset ) && + ( maxVertexInputBindingStride == rhs.maxVertexInputBindingStride ) && + ( maxVertexOutputComponents == rhs.maxVertexOutputComponents ) && + ( maxTessellationGenerationLevel == rhs.maxTessellationGenerationLevel ) && + ( maxTessellationPatchSize == rhs.maxTessellationPatchSize ) && + ( maxTessellationControlPerVertexInputComponents == rhs.maxTessellationControlPerVertexInputComponents ) && + ( maxTessellationControlPerVertexOutputComponents == + rhs.maxTessellationControlPerVertexOutputComponents ) && + ( maxTessellationControlPerPatchOutputComponents == rhs.maxTessellationControlPerPatchOutputComponents ) && + ( maxTessellationControlTotalOutputComponents == rhs.maxTessellationControlTotalOutputComponents ) && + ( maxTessellationEvaluationInputComponents == rhs.maxTessellationEvaluationInputComponents ) && + ( maxTessellationEvaluationOutputComponents == rhs.maxTessellationEvaluationOutputComponents ) && + ( maxGeometryShaderInvocations == rhs.maxGeometryShaderInvocations ) && + ( maxGeometryInputComponents == rhs.maxGeometryInputComponents ) && + ( maxGeometryOutputComponents == rhs.maxGeometryOutputComponents ) && + ( maxGeometryOutputVertices == rhs.maxGeometryOutputVertices ) && + ( maxGeometryTotalOutputComponents == rhs.maxGeometryTotalOutputComponents ) && + ( maxFragmentInputComponents == rhs.maxFragmentInputComponents ) && + ( maxFragmentOutputAttachments == rhs.maxFragmentOutputAttachments ) && + ( maxFragmentDualSrcAttachments == rhs.maxFragmentDualSrcAttachments ) && + ( maxFragmentCombinedOutputResources == rhs.maxFragmentCombinedOutputResources ) && + ( maxComputeSharedMemorySize == rhs.maxComputeSharedMemorySize ) && + ( maxComputeWorkGroupCount == rhs.maxComputeWorkGroupCount ) && + ( maxComputeWorkGroupInvocations == rhs.maxComputeWorkGroupInvocations ) && + ( maxComputeWorkGroupSize == rhs.maxComputeWorkGroupSize ) && + ( subPixelPrecisionBits == rhs.subPixelPrecisionBits ) && + ( subTexelPrecisionBits == rhs.subTexelPrecisionBits ) && + ( mipmapPrecisionBits == rhs.mipmapPrecisionBits ) && + ( maxDrawIndexedIndexValue == rhs.maxDrawIndexedIndexValue ) && + ( maxDrawIndirectCount == rhs.maxDrawIndirectCount ) && ( maxSamplerLodBias == rhs.maxSamplerLodBias ) && + ( maxSamplerAnisotropy == rhs.maxSamplerAnisotropy ) && ( maxViewports == rhs.maxViewports ) && + ( maxViewportDimensions == rhs.maxViewportDimensions ) && + ( viewportBoundsRange == rhs.viewportBoundsRange ) && + ( viewportSubPixelBits == rhs.viewportSubPixelBits ) && + ( minMemoryMapAlignment == rhs.minMemoryMapAlignment ) && + ( minTexelBufferOffsetAlignment == rhs.minTexelBufferOffsetAlignment ) && + ( minUniformBufferOffsetAlignment == rhs.minUniformBufferOffsetAlignment ) && + ( minStorageBufferOffsetAlignment == rhs.minStorageBufferOffsetAlignment ) && + ( minTexelOffset == rhs.minTexelOffset ) && ( maxTexelOffset == rhs.maxTexelOffset ) && + ( minTexelGatherOffset == rhs.minTexelGatherOffset ) && + ( maxTexelGatherOffset == rhs.maxTexelGatherOffset ) && + ( minInterpolationOffset == rhs.minInterpolationOffset ) && + ( maxInterpolationOffset == rhs.maxInterpolationOffset ) && + ( subPixelInterpolationOffsetBits == rhs.subPixelInterpolationOffsetBits ) && + ( maxFramebufferWidth == rhs.maxFramebufferWidth ) && + ( maxFramebufferHeight == rhs.maxFramebufferHeight ) && + ( maxFramebufferLayers == rhs.maxFramebufferLayers ) && + ( framebufferColorSampleCounts == rhs.framebufferColorSampleCounts ) && + ( framebufferDepthSampleCounts == rhs.framebufferDepthSampleCounts ) && + ( framebufferStencilSampleCounts == rhs.framebufferStencilSampleCounts ) && + ( framebufferNoAttachmentsSampleCounts == rhs.framebufferNoAttachmentsSampleCounts ) && + ( maxColorAttachments == rhs.maxColorAttachments ) && + ( sampledImageColorSampleCounts == rhs.sampledImageColorSampleCounts ) && + ( sampledImageIntegerSampleCounts == rhs.sampledImageIntegerSampleCounts ) && + ( sampledImageDepthSampleCounts == rhs.sampledImageDepthSampleCounts ) && + ( sampledImageStencilSampleCounts == rhs.sampledImageStencilSampleCounts ) && + ( storageImageSampleCounts == rhs.storageImageSampleCounts ) && + ( maxSampleMaskWords == rhs.maxSampleMaskWords ) && + ( timestampComputeAndGraphics == rhs.timestampComputeAndGraphics ) && + ( timestampPeriod == rhs.timestampPeriod ) && ( maxClipDistances == rhs.maxClipDistances ) && + ( maxCullDistances == rhs.maxCullDistances ) && + ( maxCombinedClipAndCullDistances == rhs.maxCombinedClipAndCullDistances ) && + ( discreteQueuePriorities == rhs.discreteQueuePriorities ) && ( pointSizeRange == rhs.pointSizeRange ) && + ( lineWidthRange == rhs.lineWidthRange ) && ( pointSizeGranularity == rhs.pointSizeGranularity ) && + ( lineWidthGranularity == rhs.lineWidthGranularity ) && ( strictLines == rhs.strictLines ) && + ( standardSampleLocations == rhs.standardSampleLocations ) && + ( optimalBufferCopyOffsetAlignment == rhs.optimalBufferCopyOffsetAlignment ) && + ( optimalBufferCopyRowPitchAlignment == rhs.optimalBufferCopyRowPitchAlignment ) && + ( nonCoherentAtomSize == rhs.nonCoherentAtomSize ); +# endif } bool operator!=( PhysicalDeviceLimits const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -53150,9 +56417,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -53173,18 +56441,27 @@ namespace VULKAN_HPP_NAMESPACE stippledBresenhamLines, stippledSmoothLines ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceLineRasterizationFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceLineRasterizationFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( rectangularLines == rhs.rectangularLines ) && + ( bresenhamLines == rhs.bresenhamLines ) && ( smoothLines == rhs.smoothLines ) && + ( stippledRectangularLines == rhs.stippledRectangularLines ) && + ( stippledBresenhamLines == rhs.stippledBresenhamLines ) && + ( stippledSmoothLines == rhs.stippledSmoothLines ); +# endif } bool operator!=( PhysicalDeviceLineRasterizationFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -53258,27 +56535,34 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, lineSubPixelPrecisionBits ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceLineRasterizationPropertiesEXT const & ) const = default; #else bool operator==( PhysicalDeviceLineRasterizationPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( lineSubPixelPrecisionBits == rhs.lineSubPixelPrecisionBits ); +# endif } bool operator!=( PhysicalDeviceLineRasterizationPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -53363,27 +56647,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, linearColorAttachment ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceLinearColorAttachmentFeaturesNV const & ) const = default; #else bool operator==( PhysicalDeviceLinearColorAttachmentFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( linearColorAttachment == rhs.linearColorAttachment ); +# endif } bool operator!=( PhysicalDeviceLinearColorAttachmentFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -53452,30 +56742,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, maxPerSetDescriptors, maxMemoryAllocationSize ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceMaintenance3Properties const & ) const = default; #else bool operator==( PhysicalDeviceMaintenance3Properties const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxPerSetDescriptors == rhs.maxPerSetDescriptors ) && + ( maxMemoryAllocationSize == rhs.maxMemoryAllocationSize ); +# endif } bool operator!=( PhysicalDeviceMaintenance3Properties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -53559,27 +56856,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, maintenance4 ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceMaintenance4FeaturesKHR const & ) const = default; #else bool operator==( PhysicalDeviceMaintenance4FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maintenance4 == rhs.maintenance4 ); +# endif } bool operator!=( PhysicalDeviceMaintenance4FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -53645,27 +56948,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, maxBufferSize ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceMaintenance4PropertiesKHR const & ) const = default; #else bool operator==( PhysicalDeviceMaintenance4PropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxBufferSize == rhs.maxBufferSize ); +# endif } bool operator!=( PhysicalDeviceMaintenance4PropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -53735,30 +57044,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple const &, VULKAN_HPP_NAMESPACE::ArrayWrapper1D const &> -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, heapBudget, heapUsage ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceMemoryBudgetPropertiesEXT const & ) const = default; #else bool operator==( PhysicalDeviceMemoryBudgetPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( heapBudget == rhs.heapBudget ) && + ( heapUsage == rhs.heapUsage ); +# endif } bool operator!=( PhysicalDeviceMemoryBudgetPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -53842,27 +57158,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, memoryPriority ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceMemoryPriorityFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceMemoryPriorityFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryPriority == rhs.memoryPriority ); +# endif } bool operator!=( PhysicalDeviceMemoryPriorityFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -53930,30 +57252,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple const &, uint32_t const &, VULKAN_HPP_NAMESPACE::ArrayWrapper1D const &> -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( memoryTypeCount, memoryTypes, memoryHeapCount, memoryHeaps ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceMemoryProperties const & ) const = default; #else bool operator==( PhysicalDeviceMemoryProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( memoryTypeCount == rhs.memoryTypeCount ) && ( memoryTypes == rhs.memoryTypes ) && + ( memoryHeapCount == rhs.memoryHeapCount ) && ( memoryHeaps == rhs.memoryHeaps ); +# endif } bool operator!=( PhysicalDeviceMemoryProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -54012,29 +57341,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, memoryProperties ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceMemoryProperties2 const & ) const = default; #else bool operator==( PhysicalDeviceMemoryProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryProperties == rhs.memoryProperties ); +# endif } bool operator!=( PhysicalDeviceMemoryProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -54125,30 +57460,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, taskShader, meshShader ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceMeshShaderFeaturesNV const & ) const = default; #else bool operator==( PhysicalDeviceMeshShaderFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( taskShader == rhs.taskShader ) && + ( meshShader == rhs.meshShader ); +# endif } bool operator!=( PhysicalDeviceMeshShaderFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -54239,9 +57581,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -54276,18 +57619,36 @@ namespace VULKAN_HPP_NAMESPACE meshOutputPerVertexGranularity, meshOutputPerPrimitiveGranularity ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceMeshShaderPropertiesNV const & ) const = default; #else bool operator==( PhysicalDeviceMeshShaderPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( maxDrawMeshTasksCount == rhs.maxDrawMeshTasksCount ) && + ( maxTaskWorkGroupInvocations == rhs.maxTaskWorkGroupInvocations ) && + ( maxTaskWorkGroupSize == rhs.maxTaskWorkGroupSize ) && + ( maxTaskTotalMemorySize == rhs.maxTaskTotalMemorySize ) && + ( maxTaskOutputCount == rhs.maxTaskOutputCount ) && + ( maxMeshWorkGroupInvocations == rhs.maxMeshWorkGroupInvocations ) && + ( maxMeshWorkGroupSize == rhs.maxMeshWorkGroupSize ) && + ( maxMeshTotalMemorySize == rhs.maxMeshTotalMemorySize ) && + ( maxMeshOutputVertices == rhs.maxMeshOutputVertices ) && + ( maxMeshOutputPrimitives == rhs.maxMeshOutputPrimitives ) && + ( maxMeshMultiviewViewCount == rhs.maxMeshMultiviewViewCount ) && + ( meshOutputPerVertexGranularity == rhs.meshOutputPerVertexGranularity ) && + ( meshOutputPerPrimitiveGranularity == rhs.meshOutputPerPrimitiveGranularity ); +# endif } bool operator!=( PhysicalDeviceMeshShaderPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -54380,27 +57741,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, multiDraw ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceMultiDrawFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceMultiDrawFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( multiDraw == rhs.multiDraw ); +# endif } bool operator!=( PhysicalDeviceMultiDrawFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -54465,27 +57832,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, maxMultiDrawCount ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceMultiDrawPropertiesEXT const & ) const = default; #else bool operator==( PhysicalDeviceMultiDrawPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxMultiDrawCount == rhs.maxMultiDrawCount ); +# endif } bool operator!=( PhysicalDeviceMultiDrawPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -54582,31 +57955,39 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, multiview, multiviewGeometryShader, multiviewTessellationShader ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceMultiviewFeatures const & ) const = default; #else bool operator==( PhysicalDeviceMultiviewFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( multiview == rhs.multiview ) && + ( multiviewGeometryShader == rhs.multiviewGeometryShader ) && + ( multiviewTessellationShader == rhs.multiviewTessellationShader ); +# endif } bool operator!=( PhysicalDeviceMultiviewFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -54678,27 +58059,34 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, perViewPositionAllComponents ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const & ) const = default; #else bool operator==( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( perViewPositionAllComponents == rhs.perViewPositionAllComponents ); +# endif } bool operator!=( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -54767,27 +58155,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, maxMultiviewViewCount, maxMultiviewInstanceIndex ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceMultiviewProperties const & ) const = default; #else bool operator==( PhysicalDeviceMultiviewProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( maxMultiviewViewCount == rhs.maxMultiviewViewCount ) && + ( maxMultiviewInstanceIndex == rhs.maxMultiviewInstanceIndex ); +# endif } bool operator!=( PhysicalDeviceMultiviewProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -54873,27 +58269,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, mutableDescriptorType ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceMutableDescriptorTypeFeaturesVALVE const & ) const = default; #else bool operator==( PhysicalDeviceMutableDescriptorTypeFeaturesVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( mutableDescriptorType == rhs.mutableDescriptorType ); +# endif } bool operator!=( PhysicalDeviceMutableDescriptorTypeFeaturesVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -54966,32 +58368,39 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, pciDomain, pciBus, pciDevice, pciFunction ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDevicePCIBusInfoPropertiesEXT const & ) const = default; #else bool operator==( PhysicalDevicePCIBusInfoPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pciDomain == rhs.pciDomain ) && + ( pciBus == rhs.pciBus ) && ( pciDevice == rhs.pciDevice ) && ( pciFunction == rhs.pciFunction ); +# endif } bool operator!=( PhysicalDevicePCIBusInfoPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -55079,27 +58488,34 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, pageableDeviceLocalMemory ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( pageableDeviceLocalMemory == rhs.pageableDeviceLocalMemory ); +# endif } bool operator!=( PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -55192,30 +58608,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, performanceCounterQueryPools, performanceCounterMultipleQueryPools ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDevicePerformanceQueryFeaturesKHR const & ) const = default; #else bool operator==( PhysicalDevicePerformanceQueryFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( performanceCounterQueryPools == rhs.performanceCounterQueryPools ) && + ( performanceCounterMultipleQueryPools == rhs.performanceCounterMultipleQueryPools ); +# endif } bool operator!=( PhysicalDevicePerformanceQueryFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -55285,27 +58709,34 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, allowCommandBufferQueryCopies ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDevicePerformanceQueryPropertiesKHR const & ) const = default; #else bool operator==( PhysicalDevicePerformanceQueryPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( allowCommandBufferQueryCopies == rhs.allowCommandBufferQueryCopies ); +# endif } bool operator!=( PhysicalDevicePerformanceQueryPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -55391,27 +58822,34 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, pipelineCreationCacheControl ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDevicePipelineCreationCacheControlFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDevicePipelineCreationCacheControlFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( pipelineCreationCacheControl == rhs.pipelineCreationCacheControl ); +# endif } bool operator!=( PhysicalDevicePipelineCreationCacheControlFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -55498,27 +58936,34 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, pipelineExecutableInfo ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDevicePipelineExecutablePropertiesFeaturesKHR const & ) const = default; #else bool operator==( PhysicalDevicePipelineExecutablePropertiesFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( pipelineExecutableInfo == rhs.pipelineExecutableInfo ); +# endif } bool operator!=( PhysicalDevicePipelineExecutablePropertiesFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -55588,29 +59033,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, pointClippingBehavior ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDevicePointClippingProperties const & ) const = default; #else bool operator==( PhysicalDevicePointClippingProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pointClippingBehavior == rhs.pointClippingBehavior ); +# endif } bool operator!=( PhysicalDevicePointClippingProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -55822,9 +59273,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -55863,18 +59315,35 @@ namespace VULKAN_HPP_NAMESPACE triangleFans, vertexAttributeAccessBeyondStride ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDevicePortabilitySubsetFeaturesKHR const & ) const = default; # else bool operator==( PhysicalDevicePortabilitySubsetFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( constantAlphaColorBlendFactors == rhs.constantAlphaColorBlendFactors ) && ( events == rhs.events ) && + ( imageViewFormatReinterpretation == rhs.imageViewFormatReinterpretation ) && + ( imageViewFormatSwizzle == rhs.imageViewFormatSwizzle ) && + ( imageView2DOn3DImage == rhs.imageView2DOn3DImage ) && + ( multisampleArrayImage == rhs.multisampleArrayImage ) && + ( mutableComparisonSamplers == rhs.mutableComparisonSamplers ) && ( pointPolygons == rhs.pointPolygons ) && + ( samplerMipLodBias == rhs.samplerMipLodBias ) && + ( separateStencilMaskRef == rhs.separateStencilMaskRef ) && + ( shaderSampleRateInterpolationFunctions == rhs.shaderSampleRateInterpolationFunctions ) && + ( tessellationIsolines == rhs.tessellationIsolines ) && + ( tessellationPointMode == rhs.tessellationPointMode ) && ( triangleFans == rhs.triangleFans ) && + ( vertexAttributeAccessBeyondStride == rhs.vertexAttributeAccessBeyondStride ); +# endif } bool operator!=( PhysicalDevicePortabilitySubsetFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -55974,27 +59443,34 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, minVertexInputBindingStrideAlignment ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDevicePortabilitySubsetPropertiesKHR const & ) const = default; # else bool operator==( PhysicalDevicePortabilitySubsetPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( minVertexInputBindingStrideAlignment == rhs.minVertexInputBindingStrideAlignment ); +# endif } bool operator!=( PhysicalDevicePortabilitySubsetPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -56077,27 +59553,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, presentId ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDevicePresentIdFeaturesKHR const & ) const = default; #else bool operator==( PhysicalDevicePresentIdFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentId == rhs.presentId ); +# endif } bool operator!=( PhysicalDevicePresentIdFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -56178,27 +59660,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, presentWait ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDevicePresentWaitFeaturesKHR const & ) const = default; #else bool operator==( PhysicalDevicePresentWaitFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentWait == rhs.presentWait ); +# endif } bool operator!=( PhysicalDevicePresentWaitFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -56293,30 +59781,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, primitiveTopologyListRestart, primitiveTopologyPatchListRestart ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( primitiveTopologyListRestart == rhs.primitiveTopologyListRestart ) && + ( primitiveTopologyPatchListRestart == rhs.primitiveTopologyPatchListRestart ); +# endif } bool operator!=( PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -56400,27 +59896,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, privateData ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDevicePrivateDataFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDevicePrivateDataFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( privateData == rhs.privateData ); +# endif } bool operator!=( PhysicalDevicePrivateDataFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -56489,15 +59991,16 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( residencyStandard2DBlockShape, @@ -56506,18 +60009,27 @@ namespace VULKAN_HPP_NAMESPACE residencyAlignedMipSize, residencyNonResidentStrict ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceSparseProperties const & ) const = default; #else bool operator==( PhysicalDeviceSparseProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( residencyStandard2DBlockShape == rhs.residencyStandard2DBlockShape ) && + ( residencyStandard2DMultisampleBlockShape == rhs.residencyStandard2DMultisampleBlockShape ) && + ( residencyStandard3DBlockShape == rhs.residencyStandard3DBlockShape ) && + ( residencyAlignedMipSize == rhs.residencyAlignedMipSize ) && + ( residencyNonResidentStrict == rhs.residencyNonResidentStrict ); +# endif } bool operator!=( PhysicalDeviceSparseProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -56589,9 +60101,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple const &, VULKAN_HPP_NAMESPACE::PhysicalDeviceLimits const &, VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseProperties const &> -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( apiVersion, @@ -56614,18 +60127,26 @@ namespace VULKAN_HPP_NAMESPACE limits, sparseProperties ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceProperties const & ) const = default; #else bool operator==( PhysicalDeviceProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( apiVersion == rhs.apiVersion ) && ( driverVersion == rhs.driverVersion ) && + ( vendorID == rhs.vendorID ) && ( deviceID == rhs.deviceID ) && ( deviceType == rhs.deviceType ) && + ( deviceName == rhs.deviceName ) && ( pipelineCacheUUID == rhs.pipelineCacheUUID ) && + ( limits == rhs.limits ) && ( sparseProperties == rhs.sparseProperties ); +# endif } bool operator!=( PhysicalDeviceProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -56687,29 +60208,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, properties ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceProperties2 const & ) const = default; #else bool operator==( PhysicalDeviceProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( properties == rhs.properties ); +# endif } bool operator!=( PhysicalDeviceProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -56791,27 +60318,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, protectedMemory ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceProtectedMemoryFeatures const & ) const = default; #else bool operator==( PhysicalDeviceProtectedMemoryFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( protectedMemory == rhs.protectedMemory ); +# endif } bool operator!=( PhysicalDeviceProtectedMemoryFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -56878,27 +60411,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, protectedNoFault ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceProtectedMemoryProperties const & ) const = default; #else bool operator==( PhysicalDeviceProtectedMemoryProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( protectedNoFault == rhs.protectedNoFault ); +# endif } bool operator!=( PhysicalDeviceProtectedMemoryProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -56991,30 +60530,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, provokingVertexLast, transformFeedbackPreservesProvokingVertex ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceProvokingVertexFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceProvokingVertexFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( provokingVertexLast == rhs.provokingVertexLast ) && + ( transformFeedbackPreservesProvokingVertex == rhs.transformFeedbackPreservesProvokingVertex ); +# endif } bool operator!=( PhysicalDeviceProvokingVertexFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -57086,31 +60632,40 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, provokingVertexModePerPipeline, transformFeedbackPreservesTriangleFanProvokingVertex ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceProvokingVertexPropertiesEXT const & ) const = default; #else bool operator==( PhysicalDeviceProvokingVertexPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( provokingVertexModePerPipeline == rhs.provokingVertexModePerPipeline ) && + ( transformFeedbackPreservesTriangleFanProvokingVertex == + rhs.transformFeedbackPreservesTriangleFanProvokingVertex ); +# endif } bool operator!=( PhysicalDeviceProvokingVertexPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -57180,27 +60735,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, maxPushDescriptors ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDevicePushDescriptorPropertiesKHR const & ) const = default; #else bool operator==( PhysicalDevicePushDescriptorPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxPushDescriptors == rhs.maxPushDescriptors ); +# endif } bool operator!=( PhysicalDevicePushDescriptorPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -57284,27 +60845,34 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, formatRgba10x6WithoutYCbCrSampler ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceRGBA10X6FormatsFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceRGBA10X6FormatsFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( formatRgba10x6WithoutYCbCrSampler == rhs.formatRgba10x6WithoutYCbCrSampler ); +# endif } bool operator!=( PhysicalDeviceRGBA10X6FormatsFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -57412,15 +60980,16 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -57429,18 +60998,26 @@ namespace VULKAN_HPP_NAMESPACE rasterizationOrderDepthAttachmentAccess, rasterizationOrderStencilAttachmentAccess ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM const & ) const = default; #else bool operator==( PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( rasterizationOrderColorAttachmentAccess == rhs.rasterizationOrderColorAttachmentAccess ) && + ( rasterizationOrderDepthAttachmentAccess == rhs.rasterizationOrderDepthAttachmentAccess ) && + ( rasterizationOrderStencilAttachmentAccess == rhs.rasterizationOrderStencilAttachmentAccess ); +# endif } bool operator!=( PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -57526,27 +61103,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, rayQuery ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceRayQueryFeaturesKHR const & ) const = default; #else bool operator==( PhysicalDeviceRayQueryFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( rayQuery == rhs.rayQuery ); +# endif } bool operator!=( PhysicalDeviceRayQueryFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -57639,30 +61222,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, rayTracingMotionBlur, rayTracingMotionBlurPipelineTraceRaysIndirect ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceRayTracingMotionBlurFeaturesNV const & ) const = default; #else bool operator==( PhysicalDeviceRayTracingMotionBlurFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( rayTracingMotionBlur == rhs.rayTracingMotionBlur ) && + ( rayTracingMotionBlurPipelineTraceRaysIndirect == rhs.rayTracingMotionBlurPipelineTraceRaysIndirect ); +# endif } bool operator!=( PhysicalDeviceRayTracingMotionBlurFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -57785,9 +61375,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -57806,18 +61397,29 @@ namespace VULKAN_HPP_NAMESPACE rayTracingPipelineTraceRaysIndirect, rayTraversalPrimitiveCulling ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceRayTracingPipelineFeaturesKHR const & ) const = default; #else bool operator==( PhysicalDeviceRayTracingPipelineFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( rayTracingPipeline == rhs.rayTracingPipeline ) && + ( rayTracingPipelineShaderGroupHandleCaptureReplay == + rhs.rayTracingPipelineShaderGroupHandleCaptureReplay ) && + ( rayTracingPipelineShaderGroupHandleCaptureReplayMixed == + rhs.rayTracingPipelineShaderGroupHandleCaptureReplayMixed ) && + ( rayTracingPipelineTraceRaysIndirect == rhs.rayTracingPipelineTraceRaysIndirect ) && + ( rayTraversalPrimitiveCulling == rhs.rayTraversalPrimitiveCulling ); +# endif } bool operator!=( PhysicalDeviceRayTracingPipelineFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -57904,9 +61506,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -57931,18 +61534,31 @@ namespace VULKAN_HPP_NAMESPACE shaderGroupHandleAlignment, maxRayHitAttributeSize ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceRayTracingPipelinePropertiesKHR const & ) const = default; #else bool operator==( PhysicalDeviceRayTracingPipelinePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( shaderGroupHandleSize == rhs.shaderGroupHandleSize ) && + ( maxRayRecursionDepth == rhs.maxRayRecursionDepth ) && + ( maxShaderGroupStride == rhs.maxShaderGroupStride ) && + ( shaderGroupBaseAlignment == rhs.shaderGroupBaseAlignment ) && + ( shaderGroupHandleCaptureReplaySize == rhs.shaderGroupHandleCaptureReplaySize ) && + ( maxRayDispatchInvocationCount == rhs.maxRayDispatchInvocationCount ) && + ( shaderGroupHandleAlignment == rhs.shaderGroupHandleAlignment ) && + ( maxRayHitAttributeSize == rhs.maxRayHitAttributeSize ); +# endif } bool operator!=( PhysicalDeviceRayTracingPipelinePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -58030,9 +61646,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -58057,18 +61674,29 @@ namespace VULKAN_HPP_NAMESPACE maxTriangleCount, maxDescriptorSetAccelerationStructures ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceRayTracingPropertiesNV const & ) const = default; #else bool operator==( PhysicalDeviceRayTracingPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( shaderGroupHandleSize == rhs.shaderGroupHandleSize ) && ( maxRecursionDepth == rhs.maxRecursionDepth ) && + ( maxShaderGroupStride == rhs.maxShaderGroupStride ) && + ( shaderGroupBaseAlignment == rhs.shaderGroupBaseAlignment ) && + ( maxGeometryCount == rhs.maxGeometryCount ) && ( maxInstanceCount == rhs.maxInstanceCount ) && + ( maxTriangleCount == rhs.maxTriangleCount ) && + ( maxDescriptorSetAccelerationStructures == rhs.maxDescriptorSetAccelerationStructures ); +# endif } bool operator!=( PhysicalDeviceRayTracingPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -58160,27 +61788,34 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, representativeFragmentTest ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceRepresentativeFragmentTestFeaturesNV const & ) const = default; #else bool operator==( PhysicalDeviceRepresentativeFragmentTestFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( representativeFragmentTest == rhs.representativeFragmentTest ); +# endif } bool operator!=( PhysicalDeviceRepresentativeFragmentTestFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -58280,31 +61915,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, robustBufferAccess2, robustImageAccess2, nullDescriptor ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceRobustness2FeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceRobustness2FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( robustBufferAccess2 == rhs.robustBufferAccess2 ) && + ( robustImageAccess2 == rhs.robustImageAccess2 ) && ( nullDescriptor == rhs.nullDescriptor ); +# endif } bool operator!=( PhysicalDeviceRobustness2FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -58375,30 +62017,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, robustStorageBufferAccessSizeAlignment, robustUniformBufferAccessSizeAlignment ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceRobustness2PropertiesEXT const & ) const = default; #else bool operator==( PhysicalDeviceRobustness2PropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( robustStorageBufferAccessSizeAlignment == rhs.robustStorageBufferAccessSizeAlignment ) && + ( robustUniformBufferAccessSizeAlignment == rhs.robustUniformBufferAccessSizeAlignment ); +# endif } bool operator!=( PhysicalDeviceRobustness2PropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -58476,9 +62126,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple const &, uint32_t const &, VULKAN_HPP_NAMESPACE::Bool32 const &> -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -58497,18 +62148,28 @@ namespace VULKAN_HPP_NAMESPACE sampleLocationSubPixelBits, variableSampleLocations ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceSampleLocationsPropertiesEXT const & ) const = default; #else bool operator==( PhysicalDeviceSampleLocationsPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( sampleLocationSampleCounts == rhs.sampleLocationSampleCounts ) && + ( maxSampleLocationGridSize == rhs.maxSampleLocationGridSize ) && + ( sampleLocationCoordinateRange == rhs.sampleLocationCoordinateRange ) && + ( sampleLocationSubPixelBits == rhs.sampleLocationSubPixelBits ) && + ( variableSampleLocations == rhs.variableSampleLocations ); +# endif } bool operator!=( PhysicalDeviceSampleLocationsPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -58583,30 +62244,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, filterMinmaxSingleComponentFormats, filterMinmaxImageComponentMapping ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceSamplerFilterMinmaxProperties const & ) const = default; #else bool operator==( PhysicalDeviceSamplerFilterMinmaxProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( filterMinmaxSingleComponentFormats == rhs.filterMinmaxSingleComponentFormats ) && + ( filterMinmaxImageComponentMapping == rhs.filterMinmaxImageComponentMapping ); +# endif } bool operator!=( PhysicalDeviceSamplerFilterMinmaxProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -58692,27 +62361,34 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, samplerYcbcrConversion ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceSamplerYcbcrConversionFeatures const & ) const = default; #else bool operator==( PhysicalDeviceSamplerYcbcrConversionFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( samplerYcbcrConversion == rhs.samplerYcbcrConversion ); +# endif } bool operator!=( PhysicalDeviceSamplerYcbcrConversionFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -58795,27 +62471,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, scalarBlockLayout ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceScalarBlockLayoutFeatures const & ) const = default; #else bool operator==( PhysicalDeviceScalarBlockLayoutFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( scalarBlockLayout == rhs.scalarBlockLayout ); +# endif } bool operator!=( PhysicalDeviceScalarBlockLayoutFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -58902,27 +62584,34 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, separateDepthStencilLayouts ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceSeparateDepthStencilLayoutsFeatures const & ) const = default; #else bool operator==( PhysicalDeviceSeparateDepthStencilLayoutsFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( separateDepthStencilLayouts == rhs.separateDepthStencilLayouts ); +# endif } bool operator!=( PhysicalDeviceSeparateDepthStencilLayoutsFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -59106,9 +62795,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -59141,18 +62831,35 @@ namespace VULKAN_HPP_NAMESPACE shaderImageFloat32AtomicMinMax, sparseImageFloat32AtomicMinMax ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceShaderAtomicFloat2FeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceShaderAtomicFloat2FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( shaderBufferFloat16Atomics == rhs.shaderBufferFloat16Atomics ) && + ( shaderBufferFloat16AtomicAdd == rhs.shaderBufferFloat16AtomicAdd ) && + ( shaderBufferFloat16AtomicMinMax == rhs.shaderBufferFloat16AtomicMinMax ) && + ( shaderBufferFloat32AtomicMinMax == rhs.shaderBufferFloat32AtomicMinMax ) && + ( shaderBufferFloat64AtomicMinMax == rhs.shaderBufferFloat64AtomicMinMax ) && + ( shaderSharedFloat16Atomics == rhs.shaderSharedFloat16Atomics ) && + ( shaderSharedFloat16AtomicAdd == rhs.shaderSharedFloat16AtomicAdd ) && + ( shaderSharedFloat16AtomicMinMax == rhs.shaderSharedFloat16AtomicMinMax ) && + ( shaderSharedFloat32AtomicMinMax == rhs.shaderSharedFloat32AtomicMinMax ) && + ( shaderSharedFloat64AtomicMinMax == rhs.shaderSharedFloat64AtomicMinMax ) && + ( shaderImageFloat32AtomicMinMax == rhs.shaderImageFloat32AtomicMinMax ) && + ( sparseImageFloat32AtomicMinMax == rhs.sparseImageFloat32AtomicMinMax ); +# endif } bool operator!=( PhysicalDeviceShaderAtomicFloat2FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -59346,9 +63053,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -59381,18 +63089,35 @@ namespace VULKAN_HPP_NAMESPACE sparseImageFloat32Atomics, sparseImageFloat32AtomicAdd ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceShaderAtomicFloatFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceShaderAtomicFloatFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( shaderBufferFloat32Atomics == rhs.shaderBufferFloat32Atomics ) && + ( shaderBufferFloat32AtomicAdd == rhs.shaderBufferFloat32AtomicAdd ) && + ( shaderBufferFloat64Atomics == rhs.shaderBufferFloat64Atomics ) && + ( shaderBufferFloat64AtomicAdd == rhs.shaderBufferFloat64AtomicAdd ) && + ( shaderSharedFloat32Atomics == rhs.shaderSharedFloat32Atomics ) && + ( shaderSharedFloat32AtomicAdd == rhs.shaderSharedFloat32AtomicAdd ) && + ( shaderSharedFloat64Atomics == rhs.shaderSharedFloat64Atomics ) && + ( shaderSharedFloat64AtomicAdd == rhs.shaderSharedFloat64AtomicAdd ) && + ( shaderImageFloat32Atomics == rhs.shaderImageFloat32Atomics ) && + ( shaderImageFloat32AtomicAdd == rhs.shaderImageFloat32AtomicAdd ) && + ( sparseImageFloat32Atomics == rhs.sparseImageFloat32Atomics ) && + ( sparseImageFloat32AtomicAdd == rhs.sparseImageFloat32AtomicAdd ); +# endif } bool operator!=( PhysicalDeviceShaderAtomicFloatFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -59495,30 +63220,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, shaderBufferInt64Atomics, shaderSharedInt64Atomics ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceShaderAtomicInt64Features const & ) const = default; #else bool operator==( PhysicalDeviceShaderAtomicInt64Features const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( shaderBufferInt64Atomics == rhs.shaderBufferInt64Atomics ) && + ( shaderSharedInt64Atomics == rhs.shaderSharedInt64Atomics ); +# endif } bool operator!=( PhysicalDeviceShaderAtomicInt64Features const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -59611,30 +63344,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, shaderSubgroupClock, shaderDeviceClock ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceShaderClockFeaturesKHR const & ) const = default; #else bool operator==( PhysicalDeviceShaderClockFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderSubgroupClock == rhs.shaderSubgroupClock ) && + ( shaderDeviceClock == rhs.shaderDeviceClock ); +# endif } bool operator!=( PhysicalDeviceShaderClockFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -59704,30 +63444,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, shaderCoreFeatures, activeComputeUnitCount ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceShaderCoreProperties2AMD const & ) const = default; #else bool operator==( PhysicalDeviceShaderCoreProperties2AMD const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderCoreFeatures == rhs.shaderCoreFeatures ) && + ( activeComputeUnitCount == rhs.activeComputeUnitCount ); +# endif } bool operator!=( PhysicalDeviceShaderCoreProperties2AMD const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -59822,9 +63569,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -59861,18 +63609,31 @@ namespace VULKAN_HPP_NAMESPACE maxVgprAllocation, vgprAllocationGranularity ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceShaderCorePropertiesAMD const & ) const = default; #else bool operator==( PhysicalDeviceShaderCorePropertiesAMD const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderEngineCount == rhs.shaderEngineCount ) && + ( shaderArraysPerEngineCount == rhs.shaderArraysPerEngineCount ) && + ( computeUnitsPerShaderArray == rhs.computeUnitsPerShaderArray ) && + ( simdPerComputeUnit == rhs.simdPerComputeUnit ) && ( wavefrontsPerSimd == rhs.wavefrontsPerSimd ) && + ( wavefrontSize == rhs.wavefrontSize ) && ( sgprsPerSimd == rhs.sgprsPerSimd ) && + ( minSgprAllocation == rhs.minSgprAllocation ) && ( maxSgprAllocation == rhs.maxSgprAllocation ) && + ( sgprAllocationGranularity == rhs.sgprAllocationGranularity ) && ( vgprsPerSimd == rhs.vgprsPerSimd ) && + ( minVgprAllocation == rhs.minVgprAllocation ) && ( maxVgprAllocation == rhs.maxVgprAllocation ) && + ( vgprAllocationGranularity == rhs.vgprAllocationGranularity ); +# endif } bool operator!=( PhysicalDeviceShaderCorePropertiesAMD const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -59970,27 +63731,34 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, shaderDemoteToHelperInvocation ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( shaderDemoteToHelperInvocation == rhs.shaderDemoteToHelperInvocation ); +# endif } bool operator!=( PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -60075,27 +63843,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, shaderDrawParameters ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceShaderDrawParametersFeatures const & ) const = default; #else bool operator==( PhysicalDeviceShaderDrawParametersFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderDrawParameters == rhs.shaderDrawParameters ); +# endif } bool operator!=( PhysicalDeviceShaderDrawParametersFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -60188,30 +63962,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, shaderFloat16, shaderInt8 ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceShaderFloat16Int8Features const & ) const = default; #else bool operator==( PhysicalDeviceShaderFloat16Int8Features const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderFloat16 == rhs.shaderFloat16 ) && + ( shaderInt8 == rhs.shaderInt8 ); +# endif } bool operator!=( PhysicalDeviceShaderFloat16Int8Features const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -60308,30 +64089,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, shaderImageInt64Atomics, sparseImageInt64Atomics ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceShaderImageAtomicInt64FeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceShaderImageAtomicInt64FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( shaderImageInt64Atomics == rhs.shaderImageInt64Atomics ) && + ( sparseImageInt64Atomics == rhs.sparseImageInt64Atomics ); +# endif } bool operator!=( PhysicalDeviceShaderImageAtomicInt64FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -60415,27 +64204,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, imageFootprint ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceShaderImageFootprintFeaturesNV const & ) const = default; #else bool operator==( PhysicalDeviceShaderImageFootprintFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageFootprint == rhs.imageFootprint ); +# endif } bool operator!=( PhysicalDeviceShaderImageFootprintFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -60520,27 +64315,34 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, shaderIntegerDotProduct ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceShaderIntegerDotProductFeaturesKHR const & ) const = default; #else bool operator==( PhysicalDeviceShaderIntegerDotProductFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( shaderIntegerDotProduct == rhs.shaderIntegerDotProduct ); +# endif } bool operator!=( PhysicalDeviceShaderIntegerDotProductFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -60964,9 +64766,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -61035,18 +64838,74 @@ namespace VULKAN_HPP_NAMESPACE integerDotProductAccumulatingSaturating64BitSignedAccelerated, integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceShaderIntegerDotProductPropertiesKHR const & ) const = default; #else bool operator==( PhysicalDeviceShaderIntegerDotProductPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( integerDotProduct8BitUnsignedAccelerated == rhs.integerDotProduct8BitUnsignedAccelerated ) && + ( integerDotProduct8BitSignedAccelerated == rhs.integerDotProduct8BitSignedAccelerated ) && + ( integerDotProduct8BitMixedSignednessAccelerated == + rhs.integerDotProduct8BitMixedSignednessAccelerated ) && + ( integerDotProduct4x8BitPackedUnsignedAccelerated == + rhs.integerDotProduct4x8BitPackedUnsignedAccelerated ) && + ( integerDotProduct4x8BitPackedSignedAccelerated == rhs.integerDotProduct4x8BitPackedSignedAccelerated ) && + ( integerDotProduct4x8BitPackedMixedSignednessAccelerated == + rhs.integerDotProduct4x8BitPackedMixedSignednessAccelerated ) && + ( integerDotProduct16BitUnsignedAccelerated == rhs.integerDotProduct16BitUnsignedAccelerated ) && + ( integerDotProduct16BitSignedAccelerated == rhs.integerDotProduct16BitSignedAccelerated ) && + ( integerDotProduct16BitMixedSignednessAccelerated == + rhs.integerDotProduct16BitMixedSignednessAccelerated ) && + ( integerDotProduct32BitUnsignedAccelerated == rhs.integerDotProduct32BitUnsignedAccelerated ) && + ( integerDotProduct32BitSignedAccelerated == rhs.integerDotProduct32BitSignedAccelerated ) && + ( integerDotProduct32BitMixedSignednessAccelerated == + rhs.integerDotProduct32BitMixedSignednessAccelerated ) && + ( integerDotProduct64BitUnsignedAccelerated == rhs.integerDotProduct64BitUnsignedAccelerated ) && + ( integerDotProduct64BitSignedAccelerated == rhs.integerDotProduct64BitSignedAccelerated ) && + ( integerDotProduct64BitMixedSignednessAccelerated == + rhs.integerDotProduct64BitMixedSignednessAccelerated ) && + ( integerDotProductAccumulatingSaturating8BitUnsignedAccelerated == + rhs.integerDotProductAccumulatingSaturating8BitUnsignedAccelerated ) && + ( integerDotProductAccumulatingSaturating8BitSignedAccelerated == + rhs.integerDotProductAccumulatingSaturating8BitSignedAccelerated ) && + ( integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated == + rhs.integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated ) && + ( integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated == + rhs.integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated ) && + ( integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated == + rhs.integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated ) && + ( integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated == + rhs.integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated ) && + ( integerDotProductAccumulatingSaturating16BitUnsignedAccelerated == + rhs.integerDotProductAccumulatingSaturating16BitUnsignedAccelerated ) && + ( integerDotProductAccumulatingSaturating16BitSignedAccelerated == + rhs.integerDotProductAccumulatingSaturating16BitSignedAccelerated ) && + ( integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated == + rhs.integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated ) && + ( integerDotProductAccumulatingSaturating32BitUnsignedAccelerated == + rhs.integerDotProductAccumulatingSaturating32BitUnsignedAccelerated ) && + ( integerDotProductAccumulatingSaturating32BitSignedAccelerated == + rhs.integerDotProductAccumulatingSaturating32BitSignedAccelerated ) && + ( integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated == + rhs.integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated ) && + ( integerDotProductAccumulatingSaturating64BitUnsignedAccelerated == + rhs.integerDotProductAccumulatingSaturating64BitUnsignedAccelerated ) && + ( integerDotProductAccumulatingSaturating64BitSignedAccelerated == + rhs.integerDotProductAccumulatingSaturating64BitSignedAccelerated ) && + ( integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated == + rhs.integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated ); +# endif } bool operator!=( PhysicalDeviceShaderIntegerDotProductPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -61161,27 +65020,34 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, shaderIntegerFunctions2 ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const & ) const = default; #else bool operator==( PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( shaderIntegerFunctions2 == rhs.shaderIntegerFunctions2 ); +# endif } bool operator!=( PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -61264,27 +65130,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, shaderSMBuiltins ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceShaderSMBuiltinsFeaturesNV const & ) const = default; #else bool operator==( PhysicalDeviceShaderSMBuiltinsFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderSMBuiltins == rhs.shaderSMBuiltins ); +# endif } bool operator!=( PhysicalDeviceShaderSMBuiltinsFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -61355,27 +65227,34 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, shaderSMCount, shaderWarpsPerSM ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceShaderSMBuiltinsPropertiesNV const & ) const = default; #else bool operator==( PhysicalDeviceShaderSMBuiltinsPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderSMCount == rhs.shaderSMCount ) && + ( shaderWarpsPerSM == rhs.shaderWarpsPerSM ); +# endif } bool operator!=( PhysicalDeviceShaderSMBuiltinsPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -61462,27 +65341,34 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, shaderSubgroupExtendedTypes ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceShaderSubgroupExtendedTypesFeatures const & ) const = default; #else bool operator==( PhysicalDeviceShaderSubgroupExtendedTypesFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( shaderSubgroupExtendedTypes == rhs.shaderSubgroupExtendedTypes ); +# endif } bool operator!=( PhysicalDeviceShaderSubgroupExtendedTypesFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -61571,27 +65457,34 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, shaderSubgroupUniformControlFlow ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR const & ) const = default; #else bool operator==( PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( shaderSubgroupUniformControlFlow == rhs.shaderSubgroupUniformControlFlow ); +# endif } bool operator!=( PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -61679,27 +65572,34 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, shaderTerminateInvocation ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceShaderTerminateInvocationFeaturesKHR const & ) const = default; #else bool operator==( PhysicalDeviceShaderTerminateInvocationFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( shaderTerminateInvocation == rhs.shaderTerminateInvocation ); +# endif } bool operator!=( PhysicalDeviceShaderTerminateInvocationFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -61792,30 +65692,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, shadingRateImage, shadingRateCoarseSampleOrder ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceShadingRateImageFeaturesNV const & ) const = default; #else bool operator==( PhysicalDeviceShadingRateImageFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shadingRateImage == rhs.shadingRateImage ) && + ( shadingRateCoarseSampleOrder == rhs.shadingRateCoarseSampleOrder ); +# endif } bool operator!=( PhysicalDeviceShadingRateImageFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -61889,31 +65796,39 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, shadingRateTexelSize, shadingRatePaletteSize, shadingRateMaxCoarseSamples ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceShadingRateImagePropertiesNV const & ) const = default; #else bool operator==( PhysicalDeviceShadingRateImagePropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shadingRateTexelSize == rhs.shadingRateTexelSize ) && + ( shadingRatePaletteSize == rhs.shadingRatePaletteSize ) && + ( shadingRateMaxCoarseSamples == rhs.shadingRateMaxCoarseSamples ); +# endif } bool operator!=( PhysicalDeviceShadingRateImagePropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -62033,9 +65948,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, format, type, samples, usage, tiling ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceSparseImageFormatInfo2 const & ) const = default; #else bool operator==( PhysicalDeviceSparseImageFormatInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( format == rhs.format ) && ( type == rhs.type ) && + ( samples == rhs.samples ) && ( usage == rhs.usage ) && ( tiling == rhs.tiling ); +# endif } bool operator!=( PhysicalDeviceSparseImageFormatInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -62134,32 +66056,40 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, subgroupSize, supportedStages, supportedOperations, quadOperationsInAllStages ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceSubgroupProperties const & ) const = default; #else bool operator==( PhysicalDeviceSubgroupProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( subgroupSize == rhs.subgroupSize ) && + ( supportedStages == rhs.supportedStages ) && ( supportedOperations == rhs.supportedOperations ) && + ( quadOperationsInAllStages == rhs.quadOperationsInAllStages ); +# endif } bool operator!=( PhysicalDeviceSubgroupProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -62254,30 +66184,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, subgroupSizeControl, computeFullSubgroups ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceSubgroupSizeControlFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceSubgroupSizeControlFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( subgroupSizeControl == rhs.subgroupSizeControl ) && + ( computeFullSubgroups == rhs.computeFullSubgroups ); +# endif } bool operator!=( PhysicalDeviceSubgroupSizeControlFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -62353,33 +66290,42 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, minSubgroupSize, maxSubgroupSize, maxComputeWorkgroupSubgroups, requiredSubgroupSizeStages ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceSubgroupSizeControlPropertiesEXT const & ) const = default; #else bool operator==( PhysicalDeviceSubgroupSizeControlPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( minSubgroupSize == rhs.minSubgroupSize ) && + ( maxSubgroupSize == rhs.maxSubgroupSize ) && + ( maxComputeWorkgroupSubgroups == rhs.maxComputeWorkgroupSubgroups ) && + ( requiredSubgroupSizeStages == rhs.requiredSubgroupSizeStages ); +# endif } bool operator!=( PhysicalDeviceSubgroupSizeControlPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -62465,27 +66411,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, subpassShading ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceSubpassShadingFeaturesHUAWEI const & ) const = default; #else bool operator==( PhysicalDeviceSubpassShadingFeaturesHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( subpassShading == rhs.subpassShading ); +# endif } bool operator!=( PhysicalDeviceSubpassShadingFeaturesHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -62554,27 +66506,34 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, maxSubpassShadingWorkgroupSizeAspectRatio ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceSubpassShadingPropertiesHUAWEI const & ) const = default; #else bool operator==( PhysicalDeviceSubpassShadingPropertiesHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( maxSubpassShadingWorkgroupSizeAspectRatio == rhs.maxSubpassShadingWorkgroupSizeAspectRatio ); +# endif } bool operator!=( PhysicalDeviceSubpassShadingPropertiesHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -62654,28 +66613,34 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std:: tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, surface ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceSurfaceInfo2KHR const & ) const = default; #else bool operator==( PhysicalDeviceSurfaceInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( surface == rhs.surface ); +# endif } bool operator!=( PhysicalDeviceSurfaceInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -62757,27 +66722,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, synchronization2 ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceSynchronization2FeaturesKHR const & ) const = default; #else bool operator==( PhysicalDeviceSynchronization2FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( synchronization2 == rhs.synchronization2 ); +# endif } bool operator!=( PhysicalDeviceSynchronization2FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -62862,27 +66833,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, texelBufferAlignment ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceTexelBufferAlignmentFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceTexelBufferAlignmentFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( texelBufferAlignment == rhs.texelBufferAlignment ); +# endif } bool operator!=( PhysicalDeviceTexelBufferAlignmentFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -62957,16 +66934,17 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -62976,18 +66954,27 @@ namespace VULKAN_HPP_NAMESPACE uniformTexelBufferOffsetAlignmentBytes, uniformTexelBufferOffsetSingleTexelAlignment ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceTexelBufferAlignmentPropertiesEXT const & ) const = default; #else bool operator==( PhysicalDeviceTexelBufferAlignmentPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( storageTexelBufferOffsetAlignmentBytes == rhs.storageTexelBufferOffsetAlignmentBytes ) && + ( storageTexelBufferOffsetSingleTexelAlignment == rhs.storageTexelBufferOffsetSingleTexelAlignment ) && + ( uniformTexelBufferOffsetAlignmentBytes == rhs.uniformTexelBufferOffsetAlignmentBytes ) && + ( uniformTexelBufferOffsetSingleTexelAlignment == rhs.uniformTexelBufferOffsetSingleTexelAlignment ); +# endif } bool operator!=( PhysicalDeviceTexelBufferAlignmentPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -63076,27 +67063,34 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, textureCompressionASTC_HDR ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( textureCompressionASTC_HDR == rhs.textureCompressionASTC_HDR ); +# endif } bool operator!=( PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -63178,27 +67172,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, timelineSemaphore ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceTimelineSemaphoreFeatures const & ) const = default; #else bool operator==( PhysicalDeviceTimelineSemaphoreFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( timelineSemaphore == rhs.timelineSemaphore ); +# endif } bool operator!=( PhysicalDeviceTimelineSemaphoreFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -63267,27 +67267,34 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, maxTimelineSemaphoreValueDifference ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceTimelineSemaphoreProperties const & ) const = default; #else bool operator==( PhysicalDeviceTimelineSemaphoreProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( maxTimelineSemaphoreValueDifference == rhs.maxTimelineSemaphoreValueDifference ); +# endif } bool operator!=( PhysicalDeviceTimelineSemaphoreProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -63361,9 +67368,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple const &, @@ -63371,23 +67379,29 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::ToolPurposeFlagsEXT const &, VULKAN_HPP_NAMESPACE::ArrayWrapper1D const &, VULKAN_HPP_NAMESPACE::ArrayWrapper1D const &> -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, name, version, purposes, description, layer ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceToolPropertiesEXT const & ) const = default; #else bool operator==( PhysicalDeviceToolPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( name == rhs.name ) && ( version == rhs.version ) && + ( purposes == rhs.purposes ) && ( description == rhs.description ) && ( layer == rhs.layer ); +# endif } bool operator!=( PhysicalDeviceToolPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -63483,30 +67497,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, transformFeedback, geometryStreams ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceTransformFeedbackFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceTransformFeedbackFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( transformFeedback == rhs.transformFeedback ) && + ( geometryStreams == rhs.geometryStreams ); +# endif } bool operator!=( PhysicalDeviceTransformFeedbackFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -63594,9 +67615,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -63625,18 +67647,33 @@ namespace VULKAN_HPP_NAMESPACE transformFeedbackRasterizationStreamSelect, transformFeedbackDraw ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceTransformFeedbackPropertiesEXT const & ) const = default; #else bool operator==( PhysicalDeviceTransformFeedbackPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( maxTransformFeedbackStreams == rhs.maxTransformFeedbackStreams ) && + ( maxTransformFeedbackBuffers == rhs.maxTransformFeedbackBuffers ) && + ( maxTransformFeedbackBufferSize == rhs.maxTransformFeedbackBufferSize ) && + ( maxTransformFeedbackStreamDataSize == rhs.maxTransformFeedbackStreamDataSize ) && + ( maxTransformFeedbackBufferDataSize == rhs.maxTransformFeedbackBufferDataSize ) && + ( maxTransformFeedbackBufferDataStride == rhs.maxTransformFeedbackBufferDataStride ) && + ( transformFeedbackQueries == rhs.transformFeedbackQueries ) && + ( transformFeedbackStreamsLinesTriangles == rhs.transformFeedbackStreamsLinesTriangles ) && + ( transformFeedbackRasterizationStreamSelect == rhs.transformFeedbackRasterizationStreamSelect ) && + ( transformFeedbackDraw == rhs.transformFeedbackDraw ); +# endif } bool operator!=( PhysicalDeviceTransformFeedbackPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -63731,27 +67768,34 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, uniformBufferStandardLayout ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceUniformBufferStandardLayoutFeatures const & ) const = default; #else bool operator==( PhysicalDeviceUniformBufferStandardLayoutFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( uniformBufferStandardLayout == rhs.uniformBufferStandardLayout ); +# endif } bool operator!=( PhysicalDeviceUniformBufferStandardLayoutFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -63844,30 +67888,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, variablePointersStorageBuffer, variablePointers ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceVariablePointersFeatures const & ) const = default; #else bool operator==( PhysicalDeviceVariablePointersFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( variablePointersStorageBuffer == rhs.variablePointersStorageBuffer ) && + ( variablePointers == rhs.variablePointers ); +# endif } bool operator!=( PhysicalDeviceVariablePointersFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -63965,30 +68017,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, vertexAttributeInstanceRateDivisor, vertexAttributeInstanceRateZeroDivisor ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceVertexAttributeDivisorFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceVertexAttributeDivisorFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( vertexAttributeInstanceRateDivisor == rhs.vertexAttributeInstanceRateDivisor ) && + ( vertexAttributeInstanceRateZeroDivisor == rhs.vertexAttributeInstanceRateZeroDivisor ); +# endif } bool operator!=( PhysicalDeviceVertexAttributeDivisorFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -64059,27 +68119,34 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, maxVertexAttribDivisor ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceVertexAttributeDivisorPropertiesEXT const & ) const = default; #else bool operator==( PhysicalDeviceVertexAttributeDivisorPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( maxVertexAttribDivisor == rhs.maxVertexAttribDivisor ); +# endif } bool operator!=( PhysicalDeviceVertexAttributeDivisorPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -64164,27 +68231,34 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, vertexInputDynamicState ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceVertexInputDynamicStateFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceVertexInputDynamicStateFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( vertexInputDynamicState == rhs.vertexInputDynamicState ); +# endif } bool operator!=( PhysicalDeviceVertexInputDynamicStateFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -64291,32 +68365,40 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, videoCodecOperation, chromaSubsampling, lumaBitDepth, chromaBitDepth ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoProfileKHR const & ) const = default; # else bool operator==( VideoProfileKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( videoCodecOperation == rhs.videoCodecOperation ) && + ( chromaSubsampling == rhs.chromaSubsampling ) && ( lumaBitDepth == rhs.lumaBitDepth ) && + ( chromaBitDepth == rhs.chromaBitDepth ); +# endif } bool operator!=( VideoProfileKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -64405,30 +68487,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, profileCount, pProfiles ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoProfilesKHR const & ) const = default; # else bool operator==( VideoProfilesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( profileCount == rhs.profileCount ) && + ( pProfiles == rhs.pProfiles ); +# endif } bool operator!=( VideoProfilesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -64495,30 +68584,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, imageUsage, pVideoProfiles ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceVideoFormatInfoKHR const & ) const = default; # else bool operator==( PhysicalDeviceVideoFormatInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageUsage == rhs.imageUsage ) && + ( pVideoProfiles == rhs.pVideoProfiles ); +# endif } bool operator!=( PhysicalDeviceVideoFormatInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -64698,9 +68794,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -64733,18 +68830,33 @@ namespace VULKAN_HPP_NAMESPACE samplerYcbcrConversion, shaderDrawParameters ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceVulkan11Features const & ) const = default; #else bool operator==( PhysicalDeviceVulkan11Features const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( storageBuffer16BitAccess == rhs.storageBuffer16BitAccess ) && + ( uniformAndStorageBuffer16BitAccess == rhs.uniformAndStorageBuffer16BitAccess ) && + ( storagePushConstant16 == rhs.storagePushConstant16 ) && + ( storageInputOutput16 == rhs.storageInputOutput16 ) && ( multiview == rhs.multiview ) && + ( multiviewGeometryShader == rhs.multiviewGeometryShader ) && + ( multiviewTessellationShader == rhs.multiviewTessellationShader ) && + ( variablePointersStorageBuffer == rhs.variablePointersStorageBuffer ) && + ( variablePointers == rhs.variablePointers ) && ( protectedMemory == rhs.protectedMemory ) && + ( samplerYcbcrConversion == rhs.samplerYcbcrConversion ) && + ( shaderDrawParameters == rhs.shaderDrawParameters ); +# endif } bool operator!=( PhysicalDeviceVulkan11Features const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -64848,9 +68960,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple const &, @@ -64868,7 +68981,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::Bool32 const &, uint32_t const &, VULKAN_HPP_NAMESPACE::DeviceSize const &> -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -64889,18 +69002,33 @@ namespace VULKAN_HPP_NAMESPACE maxPerSetDescriptors, maxMemoryAllocationSize ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceVulkan11Properties const & ) const = default; #else bool operator==( PhysicalDeviceVulkan11Properties const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceUUID == rhs.deviceUUID ) && + ( driverUUID == rhs.driverUUID ) && ( deviceLUID == rhs.deviceLUID ) && + ( deviceNodeMask == rhs.deviceNodeMask ) && ( deviceLUIDValid == rhs.deviceLUIDValid ) && + ( subgroupSize == rhs.subgroupSize ) && ( subgroupSupportedStages == rhs.subgroupSupportedStages ) && + ( subgroupSupportedOperations == rhs.subgroupSupportedOperations ) && + ( subgroupQuadOperationsInAllStages == rhs.subgroupQuadOperationsInAllStages ) && + ( pointClippingBehavior == rhs.pointClippingBehavior ) && + ( maxMultiviewViewCount == rhs.maxMultiviewViewCount ) && + ( maxMultiviewInstanceIndex == rhs.maxMultiviewInstanceIndex ) && + ( protectedNoFault == rhs.protectedNoFault ) && ( maxPerSetDescriptors == rhs.maxPerSetDescriptors ) && + ( maxMemoryAllocationSize == rhs.maxMemoryAllocationSize ); +# endif } bool operator!=( PhysicalDeviceVulkan11Properties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -65408,9 +69536,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -65513,18 +69642,70 @@ namespace VULKAN_HPP_NAMESPACE shaderOutputLayer, subgroupBroadcastDynamicId ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceVulkan12Features const & ) const = default; #else bool operator==( PhysicalDeviceVulkan12Features const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( samplerMirrorClampToEdge == rhs.samplerMirrorClampToEdge ) && + ( drawIndirectCount == rhs.drawIndirectCount ) && + ( storageBuffer8BitAccess == rhs.storageBuffer8BitAccess ) && + ( uniformAndStorageBuffer8BitAccess == rhs.uniformAndStorageBuffer8BitAccess ) && + ( storagePushConstant8 == rhs.storagePushConstant8 ) && + ( shaderBufferInt64Atomics == rhs.shaderBufferInt64Atomics ) && + ( shaderSharedInt64Atomics == rhs.shaderSharedInt64Atomics ) && ( shaderFloat16 == rhs.shaderFloat16 ) && + ( shaderInt8 == rhs.shaderInt8 ) && ( descriptorIndexing == rhs.descriptorIndexing ) && + ( shaderInputAttachmentArrayDynamicIndexing == rhs.shaderInputAttachmentArrayDynamicIndexing ) && + ( shaderUniformTexelBufferArrayDynamicIndexing == rhs.shaderUniformTexelBufferArrayDynamicIndexing ) && + ( shaderStorageTexelBufferArrayDynamicIndexing == rhs.shaderStorageTexelBufferArrayDynamicIndexing ) && + ( shaderUniformBufferArrayNonUniformIndexing == rhs.shaderUniformBufferArrayNonUniformIndexing ) && + ( shaderSampledImageArrayNonUniformIndexing == rhs.shaderSampledImageArrayNonUniformIndexing ) && + ( shaderStorageBufferArrayNonUniformIndexing == rhs.shaderStorageBufferArrayNonUniformIndexing ) && + ( shaderStorageImageArrayNonUniformIndexing == rhs.shaderStorageImageArrayNonUniformIndexing ) && + ( shaderInputAttachmentArrayNonUniformIndexing == rhs.shaderInputAttachmentArrayNonUniformIndexing ) && + ( shaderUniformTexelBufferArrayNonUniformIndexing == + rhs.shaderUniformTexelBufferArrayNonUniformIndexing ) && + ( shaderStorageTexelBufferArrayNonUniformIndexing == + rhs.shaderStorageTexelBufferArrayNonUniformIndexing ) && + ( descriptorBindingUniformBufferUpdateAfterBind == rhs.descriptorBindingUniformBufferUpdateAfterBind ) && + ( descriptorBindingSampledImageUpdateAfterBind == rhs.descriptorBindingSampledImageUpdateAfterBind ) && + ( descriptorBindingStorageImageUpdateAfterBind == rhs.descriptorBindingStorageImageUpdateAfterBind ) && + ( descriptorBindingStorageBufferUpdateAfterBind == rhs.descriptorBindingStorageBufferUpdateAfterBind ) && + ( descriptorBindingUniformTexelBufferUpdateAfterBind == + rhs.descriptorBindingUniformTexelBufferUpdateAfterBind ) && + ( descriptorBindingStorageTexelBufferUpdateAfterBind == + rhs.descriptorBindingStorageTexelBufferUpdateAfterBind ) && + ( descriptorBindingUpdateUnusedWhilePending == rhs.descriptorBindingUpdateUnusedWhilePending ) && + ( descriptorBindingPartiallyBound == rhs.descriptorBindingPartiallyBound ) && + ( descriptorBindingVariableDescriptorCount == rhs.descriptorBindingVariableDescriptorCount ) && + ( runtimeDescriptorArray == rhs.runtimeDescriptorArray ) && + ( samplerFilterMinmax == rhs.samplerFilterMinmax ) && ( scalarBlockLayout == rhs.scalarBlockLayout ) && + ( imagelessFramebuffer == rhs.imagelessFramebuffer ) && + ( uniformBufferStandardLayout == rhs.uniformBufferStandardLayout ) && + ( shaderSubgroupExtendedTypes == rhs.shaderSubgroupExtendedTypes ) && + ( separateDepthStencilLayouts == rhs.separateDepthStencilLayouts ) && + ( hostQueryReset == rhs.hostQueryReset ) && ( timelineSemaphore == rhs.timelineSemaphore ) && + ( bufferDeviceAddress == rhs.bufferDeviceAddress ) && + ( bufferDeviceAddressCaptureReplay == rhs.bufferDeviceAddressCaptureReplay ) && + ( bufferDeviceAddressMultiDevice == rhs.bufferDeviceAddressMultiDevice ) && + ( vulkanMemoryModel == rhs.vulkanMemoryModel ) && + ( vulkanMemoryModelDeviceScope == rhs.vulkanMemoryModelDeviceScope ) && + ( vulkanMemoryModelAvailabilityVisibilityChains == rhs.vulkanMemoryModelAvailabilityVisibilityChains ) && + ( shaderOutputViewportIndex == rhs.shaderOutputViewportIndex ) && + ( shaderOutputLayer == rhs.shaderOutputLayer ) && + ( subgroupBroadcastDynamicId == rhs.subgroupBroadcastDynamicId ); +# endif } bool operator!=( PhysicalDeviceVulkan12Features const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -65738,9 +69919,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -65853,18 +70035,86 @@ namespace VULKAN_HPP_NAMESPACE maxTimelineSemaphoreValueDifference, framebufferIntegerColorSampleCounts ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceVulkan12Properties const & ) const = default; #else bool operator==( PhysicalDeviceVulkan12Properties const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( driverID == rhs.driverID ) && + ( driverName == rhs.driverName ) && ( driverInfo == rhs.driverInfo ) && + ( conformanceVersion == rhs.conformanceVersion ) && + ( denormBehaviorIndependence == rhs.denormBehaviorIndependence ) && + ( roundingModeIndependence == rhs.roundingModeIndependence ) && + ( shaderSignedZeroInfNanPreserveFloat16 == rhs.shaderSignedZeroInfNanPreserveFloat16 ) && + ( shaderSignedZeroInfNanPreserveFloat32 == rhs.shaderSignedZeroInfNanPreserveFloat32 ) && + ( shaderSignedZeroInfNanPreserveFloat64 == rhs.shaderSignedZeroInfNanPreserveFloat64 ) && + ( shaderDenormPreserveFloat16 == rhs.shaderDenormPreserveFloat16 ) && + ( shaderDenormPreserveFloat32 == rhs.shaderDenormPreserveFloat32 ) && + ( shaderDenormPreserveFloat64 == rhs.shaderDenormPreserveFloat64 ) && + ( shaderDenormFlushToZeroFloat16 == rhs.shaderDenormFlushToZeroFloat16 ) && + ( shaderDenormFlushToZeroFloat32 == rhs.shaderDenormFlushToZeroFloat32 ) && + ( shaderDenormFlushToZeroFloat64 == rhs.shaderDenormFlushToZeroFloat64 ) && + ( shaderRoundingModeRTEFloat16 == rhs.shaderRoundingModeRTEFloat16 ) && + ( shaderRoundingModeRTEFloat32 == rhs.shaderRoundingModeRTEFloat32 ) && + ( shaderRoundingModeRTEFloat64 == rhs.shaderRoundingModeRTEFloat64 ) && + ( shaderRoundingModeRTZFloat16 == rhs.shaderRoundingModeRTZFloat16 ) && + ( shaderRoundingModeRTZFloat32 == rhs.shaderRoundingModeRTZFloat32 ) && + ( shaderRoundingModeRTZFloat64 == rhs.shaderRoundingModeRTZFloat64 ) && + ( maxUpdateAfterBindDescriptorsInAllPools == rhs.maxUpdateAfterBindDescriptorsInAllPools ) && + ( shaderUniformBufferArrayNonUniformIndexingNative == + rhs.shaderUniformBufferArrayNonUniformIndexingNative ) && + ( shaderSampledImageArrayNonUniformIndexingNative == + rhs.shaderSampledImageArrayNonUniformIndexingNative ) && + ( shaderStorageBufferArrayNonUniformIndexingNative == + rhs.shaderStorageBufferArrayNonUniformIndexingNative ) && + ( shaderStorageImageArrayNonUniformIndexingNative == + rhs.shaderStorageImageArrayNonUniformIndexingNative ) && + ( shaderInputAttachmentArrayNonUniformIndexingNative == + rhs.shaderInputAttachmentArrayNonUniformIndexingNative ) && + ( robustBufferAccessUpdateAfterBind == rhs.robustBufferAccessUpdateAfterBind ) && + ( quadDivergentImplicitLod == rhs.quadDivergentImplicitLod ) && + ( maxPerStageDescriptorUpdateAfterBindSamplers == rhs.maxPerStageDescriptorUpdateAfterBindSamplers ) && + ( maxPerStageDescriptorUpdateAfterBindUniformBuffers == + rhs.maxPerStageDescriptorUpdateAfterBindUniformBuffers ) && + ( maxPerStageDescriptorUpdateAfterBindStorageBuffers == + rhs.maxPerStageDescriptorUpdateAfterBindStorageBuffers ) && + ( maxPerStageDescriptorUpdateAfterBindSampledImages == + rhs.maxPerStageDescriptorUpdateAfterBindSampledImages ) && + ( maxPerStageDescriptorUpdateAfterBindStorageImages == + rhs.maxPerStageDescriptorUpdateAfterBindStorageImages ) && + ( maxPerStageDescriptorUpdateAfterBindInputAttachments == + rhs.maxPerStageDescriptorUpdateAfterBindInputAttachments ) && + ( maxPerStageUpdateAfterBindResources == rhs.maxPerStageUpdateAfterBindResources ) && + ( maxDescriptorSetUpdateAfterBindSamplers == rhs.maxDescriptorSetUpdateAfterBindSamplers ) && + ( maxDescriptorSetUpdateAfterBindUniformBuffers == rhs.maxDescriptorSetUpdateAfterBindUniformBuffers ) && + ( maxDescriptorSetUpdateAfterBindUniformBuffersDynamic == + rhs.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic ) && + ( maxDescriptorSetUpdateAfterBindStorageBuffers == rhs.maxDescriptorSetUpdateAfterBindStorageBuffers ) && + ( maxDescriptorSetUpdateAfterBindStorageBuffersDynamic == + rhs.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic ) && + ( maxDescriptorSetUpdateAfterBindSampledImages == rhs.maxDescriptorSetUpdateAfterBindSampledImages ) && + ( maxDescriptorSetUpdateAfterBindStorageImages == rhs.maxDescriptorSetUpdateAfterBindStorageImages ) && + ( maxDescriptorSetUpdateAfterBindInputAttachments == + rhs.maxDescriptorSetUpdateAfterBindInputAttachments ) && + ( supportedDepthResolveModes == rhs.supportedDepthResolveModes ) && + ( supportedStencilResolveModes == rhs.supportedStencilResolveModes ) && + ( independentResolveNone == rhs.independentResolveNone ) && + ( independentResolve == rhs.independentResolve ) && + ( filterMinmaxSingleComponentFormats == rhs.filterMinmaxSingleComponentFormats ) && + ( filterMinmaxImageComponentMapping == rhs.filterMinmaxImageComponentMapping ) && + ( maxTimelineSemaphoreValueDifference == rhs.maxTimelineSemaphoreValueDifference ) && + ( framebufferIntegerColorSampleCounts == rhs.framebufferIntegerColorSampleCounts ); +# endif } bool operator!=( PhysicalDeviceVulkan12Properties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -66017,32 +70267,40 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, vulkanMemoryModel, vulkanMemoryModelDeviceScope, vulkanMemoryModelAvailabilityVisibilityChains ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceVulkanMemoryModelFeatures const & ) const = default; #else bool operator==( PhysicalDeviceVulkanMemoryModelFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( vulkanMemoryModel == rhs.vulkanMemoryModel ) && + ( vulkanMemoryModelDeviceScope == rhs.vulkanMemoryModelDeviceScope ) && + ( vulkanMemoryModelAvailabilityVisibilityChains == rhs.vulkanMemoryModelAvailabilityVisibilityChains ); +# endif } bool operator!=( PhysicalDeviceVulkanMemoryModelFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -66161,16 +70419,17 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -66180,18 +70439,27 @@ namespace VULKAN_HPP_NAMESPACE workgroupMemoryExplicitLayout8BitAccess, workgroupMemoryExplicitLayout16BitAccess ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR const & ) const = default; #else bool operator==( PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( workgroupMemoryExplicitLayout == rhs.workgroupMemoryExplicitLayout ) && + ( workgroupMemoryExplicitLayoutScalarBlockLayout == rhs.workgroupMemoryExplicitLayoutScalarBlockLayout ) && + ( workgroupMemoryExplicitLayout8BitAccess == rhs.workgroupMemoryExplicitLayout8BitAccess ) && + ( workgroupMemoryExplicitLayout16BitAccess == rhs.workgroupMemoryExplicitLayout16BitAccess ); +# endif } bool operator!=( PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -66280,27 +70548,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, ycbcr2plane444Formats ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( ycbcr2plane444Formats == rhs.ycbcr2plane444Formats ); +# endif } bool operator!=( PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -66383,27 +70657,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, ycbcrImageArrays ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceYcbcrImageArraysFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceYcbcrImageArraysFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( ycbcrImageArrays == rhs.ycbcrImageArrays ); +# endif } bool operator!=( PhysicalDeviceYcbcrImageArraysFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -66490,27 +70770,34 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, shaderZeroInitializeWorkgroupMemory ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR const & ) const = default; #else bool operator==( PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( shaderZeroInitializeWorkgroupMemory == rhs.shaderZeroInitializeWorkgroupMemory ); +# endif } bool operator!=( PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -66623,31 +70910,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, flags, initialDataSize, pInitialData ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineCacheCreateInfo const & ) const = default; #else bool operator==( PipelineCacheCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && + ( initialDataSize == rhs.initialDataSize ) && ( pInitialData == rhs.pInitialData ); +# endif } bool operator!=( PipelineCacheCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -66752,31 +71046,39 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple const &> -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( headerSize, headerVersion, vendorID, deviceID, pipelineCacheUUID ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineCacheHeaderVersionOne const & ) const = default; #else bool operator==( PipelineCacheHeaderVersionOne const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( headerSize == rhs.headerSize ) && ( headerVersion == rhs.headerVersion ) && + ( vendorID == rhs.vendorID ) && ( deviceID == rhs.deviceID ) && + ( pipelineCacheUUID == rhs.pipelineCacheUUID ); +# endif } bool operator!=( PipelineCacheHeaderVersionOne const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -66876,31 +71178,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, srcPremultiplied, dstPremultiplied, blendOverlap ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineColorBlendAdvancedStateCreateInfoEXT const & ) const = default; #else bool operator==( PipelineColorBlendAdvancedStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcPremultiplied == rhs.srcPremultiplied ) && + ( dstPremultiplied == rhs.dstPremultiplied ) && ( blendOverlap == rhs.blendOverlap ); +# endif } bool operator!=( PipelineColorBlendAdvancedStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -67010,30 +71319,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, attachmentCount, pColorWriteEnables ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineColorWriteCreateInfoEXT const & ) const = default; #else bool operator==( PipelineColorWriteCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( attachmentCount == rhs.attachmentCount ) && + ( pColorWriteEnables == rhs.pColorWriteEnables ); +# endif } bool operator!=( PipelineColorWriteCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -67115,29 +71431,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, compilerControlFlags ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineCompilerControlCreateInfoAMD const & ) const = default; #else bool operator==( PipelineCompilerControlCreateInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( compilerControlFlags == rhs.compilerControlFlags ); +# endif } bool operator!=( PipelineCompilerControlCreateInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -67282,9 +71604,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -67303,18 +71626,27 @@ namespace VULKAN_HPP_NAMESPACE coverageModulationTableCount, pCoverageModulationTable ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineCoverageModulationStateCreateInfoNV const & ) const = default; #else bool operator==( PipelineCoverageModulationStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && + ( coverageModulationMode == rhs.coverageModulationMode ) && + ( coverageModulationTableEnable == rhs.coverageModulationTableEnable ) && + ( coverageModulationTableCount == rhs.coverageModulationTableCount ) && + ( pCoverageModulationTable == rhs.pCoverageModulationTable ); +# endif } bool operator!=( PipelineCoverageModulationStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -67414,30 +71746,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, flags, coverageReductionMode ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineCoverageReductionStateCreateInfoNV const & ) const = default; #else bool operator==( PipelineCoverageReductionStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && + ( coverageReductionMode == rhs.coverageReductionMode ); +# endif } bool operator!=( PipelineCoverageReductionStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -67542,31 +71881,39 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, flags, coverageToColorEnable, coverageToColorLocation ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineCoverageToColorStateCreateInfoNV const & ) const = default; #else bool operator==( PipelineCoverageToColorStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && + ( coverageToColorEnable == rhs.coverageToColorEnable ) && + ( coverageToColorLocation == rhs.coverageToColorLocation ); +# endif } bool operator!=( PipelineCoverageToColorStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -67631,27 +71978,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( flags, duration ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineCreationFeedbackEXT const & ) const = default; #else bool operator==( PipelineCreationFeedbackEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( flags == rhs.flags ) && ( duration == rhs.duration ); +# endif } bool operator!=( PipelineCreationFeedbackEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -67766,32 +72119,41 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, pPipelineCreationFeedback, pipelineStageCreationFeedbackCount, pPipelineStageCreationFeedbacks ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineCreationFeedbackCreateInfoEXT const & ) const = default; #else bool operator==( PipelineCreationFeedbackCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( pPipelineCreationFeedback == rhs.pPipelineCreationFeedback ) && + ( pipelineStageCreationFeedbackCount == rhs.pipelineStageCreationFeedbackCount ) && + ( pPipelineStageCreationFeedbacks == rhs.pPipelineStageCreationFeedbacks ); +# endif } bool operator!=( PipelineCreationFeedbackCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -67928,32 +72290,40 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, flags, discardRectangleMode, discardRectangleCount, pDiscardRectangles ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineDiscardRectangleStateCreateInfoEXT const & ) const = default; #else bool operator==( PipelineDiscardRectangleStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && + ( discardRectangleMode == rhs.discardRectangleMode ) && + ( discardRectangleCount == rhs.discardRectangleCount ) && ( pDiscardRectangles == rhs.pDiscardRectangles ); +# endif } bool operator!=( PipelineDiscardRectangleStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -68044,30 +72414,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, pipeline, executableIndex ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineExecutableInfoKHR const & ) const = default; #else bool operator==( PipelineExecutableInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pipeline == rhs.pipeline ) && + ( executableIndex == rhs.executableIndex ); +# endif } bool operator!=( PipelineExecutableInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -68157,9 +72534,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple const &, @@ -68167,23 +72545,30 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::Bool32 const &, size_t const &, void * const &> -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, name, description, isText, dataSize, pData ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineExecutableInternalRepresentationKHR const & ) const = default; #else bool operator==( PipelineExecutableInternalRepresentationKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( name == rhs.name ) && + ( description == rhs.description ) && ( isText == rhs.isText ) && ( dataSize == rhs.dataSize ) && + ( pData == rhs.pData ); +# endif } bool operator!=( PipelineExecutableInternalRepresentationKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -68258,32 +72643,39 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple const &, VULKAN_HPP_NAMESPACE::ArrayWrapper1D const &, uint32_t const &> -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, stages, name, description, subgroupSize ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineExecutablePropertiesKHR const & ) const = default; #else bool operator==( PipelineExecutablePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stages == rhs.stages ) && ( name == rhs.name ) && + ( description == rhs.description ) && ( subgroupSize == rhs.subgroupSize ); +# endif } bool operator!=( PipelineExecutablePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -68422,20 +72814,22 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple const &, VULKAN_HPP_NAMESPACE::ArrayWrapper1D const &, VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticFormatKHR const &, VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticValueKHR const &> -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, name, description, format, value ); } +#endif public: VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineExecutableStatisticKHR; @@ -68543,31 +72937,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple const &> -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, shadingRateType, shadingRate, combinerOps ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineFragmentShadingRateEnumStateCreateInfoNV const & ) const = default; #else - bool operator==( PipelineFragmentShadingRateEnumStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + bool operator==( PipelineFragmentShadingRateEnumStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shadingRateType == rhs.shadingRateType ) && + ( shadingRate == rhs.shadingRate ) && ( combinerOps == rhs.combinerOps ); +# endif } bool operator!=( PipelineFragmentShadingRateEnumStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -68667,30 +73068,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple const &> -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, fragmentSize, combinerOps ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineFragmentShadingRateStateCreateInfoKHR const & ) const = default; #else bool operator==( PipelineFragmentShadingRateStateCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fragmentSize == rhs.fragmentSize ) && + ( combinerOps == rhs.combinerOps ); +# endif } bool operator!=( PipelineFragmentShadingRateStateCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -68768,28 +73176,34 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std:: tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, pipeline ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineInfoKHR const & ) const = default; #else bool operator==( PipelineInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pipeline == rhs.pipeline ); +# endif } bool operator!=( PipelineInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -68870,27 +73284,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( stageFlags, offset, size ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PushConstantRange const & ) const = default; #else bool operator==( PushConstantRange const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( stageFlags == rhs.stageFlags ) && ( offset == rhs.offset ) && ( size == rhs.size ); +# endif } bool operator!=( PushConstantRange const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -69031,9 +73451,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, flags, setLayoutCount, pSetLayouts, pushConstantRangeCount, pPushConstantRanges ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineLayoutCreateInfo const & ) const = default; #else bool operator==( PipelineLayoutCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && + ( setLayoutCount == rhs.setLayoutCount ) && ( pSetLayouts == rhs.pSetLayouts ) && + ( pushConstantRangeCount == rhs.pushConstantRangeCount ) && + ( pPushConstantRanges == rhs.pPushConstantRanges ); +# endif } bool operator!=( PipelineLayoutCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -69164,30 +73593,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, libraryCount, pLibraries ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineLibraryCreateInfoKHR const & ) const = default; #else bool operator==( PipelineLibraryCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( libraryCount == rhs.libraryCount ) && + ( pLibraries == rhs.pLibraries ); +# endif } bool operator!=( PipelineLibraryCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -69292,31 +73728,39 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, flags, conservativeRasterizationMode, extraPrimitiveOverestimationSize ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineRasterizationConservativeStateCreateInfoEXT const & ) const = default; #else bool operator==( PipelineRasterizationConservativeStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && + ( conservativeRasterizationMode == rhs.conservativeRasterizationMode ) && + ( extraPrimitiveOverestimationSize == rhs.extraPrimitiveOverestimationSize ); +# endif } bool operator!=( PipelineRasterizationConservativeStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -69413,30 +73857,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, flags, depthClipEnable ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineRasterizationDepthClipStateCreateInfoEXT const & ) const = default; #else bool operator==( PipelineRasterizationDepthClipStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && + ( depthClipEnable == rhs.depthClipEnable ); +# endif } bool operator!=( PipelineRasterizationDepthClipStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -69550,32 +74001,41 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, lineRasterizationMode, stippledLineEnable, lineStippleFactor, lineStipplePattern ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineRasterizationLineStateCreateInfoEXT const & ) const = default; #else bool operator==( PipelineRasterizationLineStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( lineRasterizationMode == rhs.lineRasterizationMode ) && + ( stippledLineEnable == rhs.stippledLineEnable ) && ( lineStippleFactor == rhs.lineStippleFactor ) && + ( lineStipplePattern == rhs.lineStipplePattern ); +# endif } bool operator!=( PipelineRasterizationLineStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -69666,29 +74126,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, provokingVertexMode ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineRasterizationProvokingVertexStateCreateInfoEXT const & ) const = default; #else bool operator==( PipelineRasterizationProvokingVertexStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( provokingVertexMode == rhs.provokingVertexMode ); +# endif } bool operator!=( PipelineRasterizationProvokingVertexStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -69776,29 +74242,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, rasterizationOrder ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineRasterizationStateRasterizationOrderAMD const & ) const = default; #else bool operator==( PipelineRasterizationStateRasterizationOrderAMD const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( rasterizationOrder == rhs.rasterizationOrder ); +# endif } bool operator!=( PipelineRasterizationStateRasterizationOrderAMD const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -69893,30 +74365,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, flags, rasterizationStream ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineRasterizationStateStreamCreateInfoEXT const & ) const = default; #else bool operator==( PipelineRasterizationStateStreamCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && + ( rasterizationStream == rhs.rasterizationStream ); +# endif } bool operator!=( PipelineRasterizationStateStreamCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -70058,9 +74537,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -70079,18 +74559,27 @@ namespace VULKAN_HPP_NAMESPACE depthAttachmentFormat, stencilAttachmentFormat ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineRenderingCreateInfoKHR const & ) const = default; #else bool operator==( PipelineRenderingCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( viewMask == rhs.viewMask ) && + ( colorAttachmentCount == rhs.colorAttachmentCount ) && + ( pColorAttachmentFormats == rhs.pColorAttachmentFormats ) && + ( depthAttachmentFormat == rhs.depthAttachmentFormat ) && + ( stencilAttachmentFormat == rhs.stencilAttachmentFormat ); +# endif } bool operator!=( PipelineRenderingCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -70179,27 +74668,34 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, representativeFragmentTestEnable ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineRepresentativeFragmentTestStateCreateInfoNV const & ) const = default; #else bool operator==( PipelineRepresentativeFragmentTestStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( representativeFragmentTestEnable == rhs.representativeFragmentTestEnable ); +# endif } bool operator!=( PipelineRepresentativeFragmentTestStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -70293,30 +74789,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, sampleLocationsEnable, sampleLocationsInfo ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineSampleLocationsStateCreateInfoEXT const & ) const = default; #else bool operator==( PipelineSampleLocationsStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( sampleLocationsEnable == rhs.sampleLocationsEnable ) && + ( sampleLocationsInfo == rhs.sampleLocationsInfo ); +# endif } bool operator!=( PipelineSampleLocationsStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -70387,27 +74891,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, requiredSubgroupSize ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT const & ) const = default; #else bool operator==( PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( requiredSubgroupSize == rhs.requiredSubgroupSize ); +# endif } bool operator!=( PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -70492,29 +75002,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, domainOrigin ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineTessellationDomainOriginStateCreateInfo const & ) const = default; #else bool operator==( PipelineTessellationDomainOriginStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( domainOrigin == rhs.domainOrigin ); +# endif } bool operator!=( PipelineTessellationDomainOriginStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -70597,27 +75113,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( binding, divisor ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VertexInputBindingDivisorDescriptionEXT const & ) const = default; #else bool operator==( VertexInputBindingDivisorDescriptionEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( binding == rhs.binding ) && ( divisor == rhs.divisor ); +# endif } bool operator!=( VertexInputBindingDivisorDescriptionEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -70727,30 +75249,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, vertexBindingDivisorCount, pVertexBindingDivisors ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineVertexInputDivisorStateCreateInfoEXT const & ) const = default; #else bool operator==( PipelineVertexInputDivisorStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( vertexBindingDivisorCount == rhs.vertexBindingDivisorCount ) && + ( pVertexBindingDivisors == rhs.pVertexBindingDivisors ); +# endif } bool operator!=( PipelineVertexInputDivisorStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -70878,31 +75408,39 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, sampleOrderType, customSampleOrderCount, pCustomSampleOrders ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineViewportCoarseSampleOrderStateCreateInfoNV const & ) const = default; #else bool operator==( PipelineViewportCoarseSampleOrderStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( sampleOrderType == rhs.sampleOrderType ) && + ( customSampleOrderCount == rhs.customSampleOrderCount ) && + ( pCustomSampleOrders == rhs.pCustomSampleOrders ); +# endif } bool operator!=( PipelineViewportCoarseSampleOrderStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -70989,27 +75527,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, negativeOneToOne ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineViewportDepthClipControlCreateInfoEXT const & ) const = default; #else bool operator==( PipelineViewportDepthClipControlCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( negativeOneToOne == rhs.negativeOneToOne ); +# endif } bool operator!=( PipelineViewportDepthClipControlCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -71123,30 +75667,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, exclusiveScissorCount, pExclusiveScissors ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineViewportExclusiveScissorStateCreateInfoNV const & ) const = default; #else bool operator==( PipelineViewportExclusiveScissorStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( exclusiveScissorCount == rhs.exclusiveScissorCount ) && ( pExclusiveScissors == rhs.pExclusiveScissors ); +# endif } bool operator!=( PipelineViewportExclusiveScissorStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -71245,27 +75796,34 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( shadingRatePaletteEntryCount, pShadingRatePaletteEntries ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ShadingRatePaletteNV const & ) const = default; #else bool operator==( ShadingRatePaletteNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( shadingRatePaletteEntryCount == rhs.shadingRatePaletteEntryCount ) && + ( pShadingRatePaletteEntries == rhs.pShadingRatePaletteEntries ); +# endif } bool operator!=( ShadingRatePaletteNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -71381,31 +75939,39 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, shadingRateImageEnable, viewportCount, pShadingRatePalettes ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineViewportShadingRateImageStateCreateInfoNV const & ) const = default; #else bool operator==( PipelineViewportShadingRateImageStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( shadingRateImageEnable == rhs.shadingRateImageEnable ) && ( viewportCount == rhs.viewportCount ) && + ( pShadingRatePalettes == rhs.pShadingRatePalettes ); +# endif } bool operator!=( PipelineViewportShadingRateImageStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -71507,30 +76073,36 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( x, y, z, w ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ViewportSwizzleNV const & ) const = default; #else bool operator==( ViewportSwizzleNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( x == rhs.x ) && ( y == rhs.y ) && ( z == rhs.z ) && ( w == rhs.w ); +# endif } bool operator!=( ViewportSwizzleNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -71647,31 +76219,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, flags, viewportCount, pViewportSwizzles ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineViewportSwizzleStateCreateInfoNV const & ) const = default; #else bool operator==( PipelineViewportSwizzleStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && + ( viewportCount == rhs.viewportCount ) && ( pViewportSwizzles == rhs.pViewportSwizzles ); +# endif } bool operator!=( PipelineViewportSwizzleStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -71747,27 +76326,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( xcoeff, ycoeff ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ViewportWScalingNV const & ) const = default; #else bool operator==( ViewportWScalingNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( xcoeff == rhs.xcoeff ) && ( ycoeff == rhs.ycoeff ); +# endif } bool operator!=( ViewportWScalingNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -71882,31 +76467,39 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, viewportWScalingEnable, viewportCount, pViewportWScalings ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineViewportWScalingStateCreateInfoNV const & ) const = default; #else bool operator==( PipelineViewportWScalingStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( viewportWScalingEnable == rhs.viewportWScalingEnable ) && ( viewportCount == rhs.viewportCount ) && + ( pViewportWScalings == rhs.pViewportWScalings ); +# endif } bool operator!=( PipelineViewportWScalingStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -71985,27 +76578,34 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, frameToken ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PresentFrameTokenGGP const & ) const = default; # else bool operator==( PresentFrameTokenGGP const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( memcmp( &frameToken, &rhs.frameToken, sizeof( GgpFrameToken ) ) == 0 ); +# endif } bool operator!=( PresentFrameTokenGGP const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -72103,30 +76703,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, swapchainCount, pPresentIds ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PresentIdKHR const & ) const = default; #else bool operator==( PresentIdKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchainCount == rhs.swapchainCount ) && + ( pPresentIds == rhs.pPresentIds ); +# endif } bool operator!=( PresentIdKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -72323,9 +76930,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, waitSemaphoreCount, pWaitSemaphores, swapchainCount, pSwapchains, pImageIndices, pResults ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PresentInfoKHR const & ) const = default; #else bool operator==( PresentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( waitSemaphoreCount == rhs.waitSemaphoreCount ) && + ( pWaitSemaphores == rhs.pWaitSemaphores ) && ( swapchainCount == rhs.swapchainCount ) && + ( pSwapchains == rhs.pSwapchains ) && ( pImageIndices == rhs.pImageIndices ) && + ( pResults == rhs.pResults ); +# endif } bool operator!=( PresentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -72442,27 +77058,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( offset, extent, layer ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( RectLayerKHR const & ) const = default; #else bool operator==( RectLayerKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( offset == rhs.offset ) && ( extent == rhs.extent ) && ( layer == rhs.layer ); +# endif } bool operator!=( RectLayerKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -72548,27 +77170,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( rectangleCount, pRectangles ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PresentRegionKHR const & ) const = default; #else bool operator==( PresentRegionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( rectangleCount == rhs.rectangleCount ) && ( pRectangles == rhs.pRectangles ); +# endif } bool operator!=( PresentRegionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -72662,30 +77290,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, swapchainCount, pRegions ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PresentRegionsKHR const & ) const = default; #else bool operator==( PresentRegionsKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchainCount == rhs.swapchainCount ) && + ( pRegions == rhs.pRegions ); +# endif } bool operator!=( PresentRegionsKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -72759,27 +77394,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( presentID, desiredPresentTime ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PresentTimeGOOGLE const & ) const = default; #else bool operator==( PresentTimeGOOGLE const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( presentID == rhs.presentID ) && ( desiredPresentTime == rhs.desiredPresentTime ); +# endif } bool operator!=( PresentTimeGOOGLE const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -72873,30 +77514,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, swapchainCount, pTimes ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PresentTimesInfoGOOGLE const & ) const = default; #else bool operator==( PresentTimesInfoGOOGLE const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchainCount == rhs.swapchainCount ) && + ( pTimes == rhs.pTimes ); +# endif } bool operator!=( PresentTimesInfoGOOGLE const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -72973,29 +77621,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, flags ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PrivateDataSlotCreateInfoEXT const & ) const = default; #else bool operator==( PrivateDataSlotCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ); +# endif } bool operator!=( PrivateDataSlotCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -73071,27 +77725,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, protectedSubmit ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ProtectedSubmitInfo const & ) const = default; #else bool operator==( ProtectedSubmitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( protectedSubmit == rhs.protectedSubmit ); +# endif } bool operator!=( ProtectedSubmitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -73192,32 +77852,40 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, flags, queryType, queryCount, pipelineStatistics ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( QueryPoolCreateInfo const & ) const = default; #else bool operator==( QueryPoolCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && + ( queryType == rhs.queryType ) && ( queryCount == rhs.queryCount ) && + ( pipelineStatistics == rhs.pipelineStatistics ); +# endif } bool operator!=( QueryPoolCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -73335,31 +78003,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, queueFamilyIndex, counterIndexCount, pCounterIndices ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( QueryPoolPerformanceCreateInfoKHR const & ) const = default; #else bool operator==( QueryPoolPerformanceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( queueFamilyIndex == rhs.queueFamilyIndex ) && + ( counterIndexCount == rhs.counterIndexCount ) && ( pCounterIndices == rhs.pCounterIndices ); +# endif } bool operator!=( QueryPoolPerformanceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -73446,29 +78121,36 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, performanceCountersSampling ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( QueryPoolPerformanceQueryCreateInfoINTEL const & ) const = default; #else bool operator==( QueryPoolPerformanceQueryCreateInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( performanceCountersSampling == rhs.performanceCountersSampling ); +# endif } bool operator!=( QueryPoolPerformanceQueryCreateInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -73537,29 +78219,36 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, checkpointExecutionStageMask ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( QueueFamilyCheckpointProperties2NV const & ) const = default; #else bool operator==( QueueFamilyCheckpointProperties2NV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( checkpointExecutionStageMask == rhs.checkpointExecutionStageMask ); +# endif } bool operator!=( QueueFamilyCheckpointProperties2NV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -73624,29 +78313,36 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, checkpointExecutionStageMask ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( QueueFamilyCheckpointPropertiesNV const & ) const = default; #else bool operator==( QueueFamilyCheckpointPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( checkpointExecutionStageMask == rhs.checkpointExecutionStageMask ); +# endif } bool operator!=( QueueFamilyCheckpointPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -73754,31 +78450,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple const &> -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, priorityCount, priorities ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( QueueFamilyGlobalPriorityPropertiesEXT const & ) const = default; #else bool operator==( QueueFamilyGlobalPriorityPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( priorityCount == rhs.priorityCount ) && + ( priorities == rhs.priorities ); +# endif } bool operator!=( QueueFamilyGlobalPriorityPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -73846,30 +78549,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( queueFlags, queueCount, timestampValidBits, minImageTransferGranularity ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( QueueFamilyProperties const & ) const = default; #else bool operator==( QueueFamilyProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( queueFlags == rhs.queueFlags ) && ( queueCount == rhs.queueCount ) && + ( timestampValidBits == rhs.timestampValidBits ) && + ( minImageTransferGranularity == rhs.minImageTransferGranularity ); +# endif } bool operator!=( QueueFamilyProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -73924,29 +78635,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, queueFamilyProperties ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( QueueFamilyProperties2 const & ) const = default; #else bool operator==( QueueFamilyProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( queueFamilyProperties == rhs.queueFamilyProperties ); +# endif } bool operator!=( QueueFamilyProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -74030,27 +78747,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, supported ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( QueueFamilyQueryResultStatusProperties2KHR const & ) const = default; # else bool operator==( QueueFamilyQueryResultStatusProperties2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( supported == rhs.supported ); +# endif } bool operator!=( QueueFamilyQueryResultStatusProperties2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -74179,9 +78902,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -74202,18 +78926,26 @@ namespace VULKAN_HPP_NAMESPACE intersectionShader, pShaderGroupCaptureReplayHandle ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( RayTracingShaderGroupCreateInfoKHR const & ) const = default; #else bool operator==( RayTracingShaderGroupCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( type == rhs.type ) && + ( generalShader == rhs.generalShader ) && ( closestHitShader == rhs.closestHitShader ) && + ( anyHitShader == rhs.anyHitShader ) && ( intersectionShader == rhs.intersectionShader ) && + ( pShaderGroupCaptureReplayHandle == rhs.pShaderGroupCaptureReplayHandle ); +# endif } bool operator!=( RayTracingShaderGroupCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -74312,27 +79044,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, maxPipelineRayPayloadSize, maxPipelineRayHitAttributeSize ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( RayTracingPipelineInterfaceCreateInfoKHR const & ) const = default; #else bool operator==( RayTracingPipelineInterfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( maxPipelineRayPayloadSize == rhs.maxPipelineRayPayloadSize ) && + ( maxPipelineRayHitAttributeSize == rhs.maxPipelineRayHitAttributeSize ); +# endif } bool operator!=( RayTracingPipelineInterfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -74561,9 +79301,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -74596,18 +79337,28 @@ namespace VULKAN_HPP_NAMESPACE basePipelineHandle, basePipelineIndex ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( RayTracingPipelineCreateInfoKHR const & ) const = default; #else bool operator==( RayTracingPipelineCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && + ( stageCount == rhs.stageCount ) && ( pStages == rhs.pStages ) && ( groupCount == rhs.groupCount ) && + ( pGroups == rhs.pGroups ) && ( maxPipelineRayRecursionDepth == rhs.maxPipelineRayRecursionDepth ) && + ( pLibraryInfo == rhs.pLibraryInfo ) && ( pLibraryInterface == rhs.pLibraryInterface ) && + ( pDynamicState == rhs.pDynamicState ) && ( layout == rhs.layout ) && + ( basePipelineHandle == rhs.basePipelineHandle ) && ( basePipelineIndex == rhs.basePipelineIndex ); +# endif } bool operator!=( RayTracingPipelineCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -74735,9 +79486,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, type, generalShader, closestHitShader, anyHitShader, intersectionShader ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( RayTracingShaderGroupCreateInfoNV const & ) const = default; #else bool operator==( RayTracingShaderGroupCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( type == rhs.type ) && + ( generalShader == rhs.generalShader ) && ( closestHitShader == rhs.closestHitShader ) && + ( anyHitShader == rhs.anyHitShader ) && ( intersectionShader == rhs.intersectionShader ); +# endif } bool operator!=( RayTracingShaderGroupCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -74960,9 +79719,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -74989,18 +79749,26 @@ namespace VULKAN_HPP_NAMESPACE basePipelineHandle, basePipelineIndex ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( RayTracingPipelineCreateInfoNV const & ) const = default; #else bool operator==( RayTracingPipelineCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && + ( stageCount == rhs.stageCount ) && ( pStages == rhs.pStages ) && ( groupCount == rhs.groupCount ) && + ( pGroups == rhs.pGroups ) && ( maxRecursionDepth == rhs.maxRecursionDepth ) && ( layout == rhs.layout ) && + ( basePipelineHandle == rhs.basePipelineHandle ) && ( basePipelineIndex == rhs.basePipelineIndex ); +# endif } bool operator!=( RayTracingPipelineCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -75067,27 +79835,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( refreshDuration ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( RefreshCycleDurationGOOGLE const & ) const = default; #else bool operator==( RefreshCycleDurationGOOGLE const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( refreshDuration == rhs.refreshDuration ); +# endif } bool operator!=( RefreshCycleDurationGOOGLE const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -75184,30 +79958,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, attachmentCount, pAttachments ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( RenderPassAttachmentBeginInfo const & ) const = default; #else bool operator==( RenderPassAttachmentBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( attachmentCount == rhs.attachmentCount ) && + ( pAttachments == rhs.pAttachments ); +# endif } bool operator!=( RenderPassAttachmentBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -75346,9 +80127,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, renderPass, framebuffer, renderArea, clearValueCount, pClearValues ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( RenderPassBeginInfo const & ) const = default; #else bool operator==( RenderPassBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( renderPass == rhs.renderPass ) && + ( framebuffer == rhs.framebuffer ) && ( renderArea == rhs.renderArea ) && + ( clearValueCount == rhs.clearValueCount ) && ( pClearValues == rhs.pClearValues ); +# endif } bool operator!=( RenderPassBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -75602,9 +80391,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( flags, @@ -75629,18 +80419,29 @@ namespace VULKAN_HPP_NAMESPACE preserveAttachmentCount, pPreserveAttachments ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SubpassDescription const & ) const = default; #else bool operator==( SubpassDescription const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( flags == rhs.flags ) && ( pipelineBindPoint == rhs.pipelineBindPoint ) && + ( inputAttachmentCount == rhs.inputAttachmentCount ) && ( pInputAttachments == rhs.pInputAttachments ) && + ( colorAttachmentCount == rhs.colorAttachmentCount ) && ( pColorAttachments == rhs.pColorAttachments ) && + ( pResolveAttachments == rhs.pResolveAttachments ) && + ( pDepthStencilAttachment == rhs.pDepthStencilAttachment ) && + ( preserveAttachmentCount == rhs.preserveAttachmentCount ) && + ( pPreserveAttachments == rhs.pPreserveAttachments ); +# endif } bool operator!=( SubpassDescription const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -75759,9 +80560,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( srcSubpass, dstSubpass, srcStageMask, dstStageMask, srcAccessMask, dstAccessMask, dependencyFlags ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SubpassDependency const & ) const = default; #else bool operator==( SubpassDependency const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( srcSubpass == rhs.srcSubpass ) && ( dstSubpass == rhs.dstSubpass ) && + ( srcStageMask == rhs.srcStageMask ) && ( dstStageMask == rhs.dstStageMask ) && + ( srcAccessMask == rhs.srcAccessMask ) && ( dstAccessMask == rhs.dstAccessMask ) && + ( dependencyFlags == rhs.dependencyFlags ); +# endif } bool operator!=( SubpassDependency const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -75962,9 +80772,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, flags, attachmentCount, pAttachments, subpassCount, pSubpasses, dependencyCount, pDependencies ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( RenderPassCreateInfo const & ) const = default; #else bool operator==( RenderPassCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && + ( attachmentCount == rhs.attachmentCount ) && ( pAttachments == rhs.pAttachments ) && + ( subpassCount == rhs.subpassCount ) && ( pSubpasses == rhs.pSubpasses ) && + ( dependencyCount == rhs.dependencyCount ) && ( pDependencies == rhs.pDependencies ); +# endif } bool operator!=( RenderPassCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -76242,9 +81061,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -76275,18 +81095,30 @@ namespace VULKAN_HPP_NAMESPACE preserveAttachmentCount, pPreserveAttachments ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SubpassDescription2 const & ) const = default; #else bool operator==( SubpassDescription2 const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && + ( pipelineBindPoint == rhs.pipelineBindPoint ) && ( viewMask == rhs.viewMask ) && + ( inputAttachmentCount == rhs.inputAttachmentCount ) && ( pInputAttachments == rhs.pInputAttachments ) && + ( colorAttachmentCount == rhs.colorAttachmentCount ) && ( pColorAttachments == rhs.pColorAttachments ) && + ( pResolveAttachments == rhs.pResolveAttachments ) && + ( pDepthStencilAttachment == rhs.pDepthStencilAttachment ) && + ( preserveAttachmentCount == rhs.preserveAttachmentCount ) && + ( pPreserveAttachments == rhs.pPreserveAttachments ); +# endif } bool operator!=( SubpassDescription2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -76431,9 +81263,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -76458,18 +81291,27 @@ namespace VULKAN_HPP_NAMESPACE dependencyFlags, viewOffset ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SubpassDependency2 const & ) const = default; #else bool operator==( SubpassDependency2 const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcSubpass == rhs.srcSubpass ) && + ( dstSubpass == rhs.dstSubpass ) && ( srcStageMask == rhs.srcStageMask ) && + ( dstStageMask == rhs.dstStageMask ) && ( srcAccessMask == rhs.srcAccessMask ) && + ( dstAccessMask == rhs.dstAccessMask ) && ( dependencyFlags == rhs.dependencyFlags ) && + ( viewOffset == rhs.viewOffset ); +# endif } bool operator!=( SubpassDependency2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -76685,9 +81527,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -76714,18 +81557,28 @@ namespace VULKAN_HPP_NAMESPACE correlatedViewMaskCount, pCorrelatedViewMasks ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( RenderPassCreateInfo2 const & ) const = default; #else bool operator==( RenderPassCreateInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && + ( attachmentCount == rhs.attachmentCount ) && ( pAttachments == rhs.pAttachments ) && + ( subpassCount == rhs.subpassCount ) && ( pSubpasses == rhs.pSubpasses ) && + ( dependencyCount == rhs.dependencyCount ) && ( pDependencies == rhs.pDependencies ) && + ( correlatedViewMaskCount == rhs.correlatedViewMaskCount ) && + ( pCorrelatedViewMasks == rhs.pCorrelatedViewMasks ); +# endif } bool operator!=( RenderPassCreateInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -76816,29 +81669,36 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, fragmentDensityMapAttachment ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( RenderPassFragmentDensityMapCreateInfoEXT const & ) const = default; #else bool operator==( RenderPassFragmentDensityMapCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( fragmentDensityMapAttachment == rhs.fragmentDensityMapAttachment ); +# endif } bool operator!=( RenderPassFragmentDensityMapCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -76952,30 +81812,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, aspectReferenceCount, pAspectReferences ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( RenderPassInputAttachmentAspectCreateInfo const & ) const = default; #else bool operator==( RenderPassInputAttachmentAspectCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( aspectReferenceCount == rhs.aspectReferenceCount ) && + ( pAspectReferences == rhs.pAspectReferences ); +# endif } bool operator!=( RenderPassInputAttachmentAspectCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -77145,9 +82012,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -77168,18 +82036,26 @@ namespace VULKAN_HPP_NAMESPACE correlationMaskCount, pCorrelationMasks ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( RenderPassMultiviewCreateInfo const & ) const = default; #else bool operator==( RenderPassMultiviewCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( subpassCount == rhs.subpassCount ) && + ( pViewMasks == rhs.pViewMasks ) && ( dependencyCount == rhs.dependencyCount ) && + ( pViewOffsets == rhs.pViewOffsets ) && ( correlationMaskCount == rhs.correlationMaskCount ) && + ( pCorrelationMasks == rhs.pCorrelationMasks ); +# endif } bool operator!=( RenderPassMultiviewCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -77262,27 +82138,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( subpassIndex, sampleLocationsInfo ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SubpassSampleLocationsEXT const & ) const = default; #else bool operator==( SubpassSampleLocationsEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( subpassIndex == rhs.subpassIndex ) && ( sampleLocationsInfo == rhs.sampleLocationsInfo ); +# endif } bool operator!=( SubpassSampleLocationsEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -77419,16 +82301,17 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -77438,18 +82321,27 @@ namespace VULKAN_HPP_NAMESPACE postSubpassSampleLocationsCount, pPostSubpassSampleLocations ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( RenderPassSampleLocationsBeginInfoEXT const & ) const = default; #else bool operator==( RenderPassSampleLocationsBeginInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( attachmentInitialSampleLocationsCount == rhs.attachmentInitialSampleLocationsCount ) && + ( pAttachmentInitialSampleLocations == rhs.pAttachmentInitialSampleLocations ) && + ( postSubpassSampleLocationsCount == rhs.postSubpassSampleLocationsCount ) && + ( pPostSubpassSampleLocations == rhs.pPostSubpassSampleLocations ); +# endif } bool operator!=( RenderPassSampleLocationsBeginInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -77531,29 +82423,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, transform ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( RenderPassTransformBeginInfoQCOM const & ) const = default; #else bool operator==( RenderPassTransformBeginInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( transform == rhs.transform ); +# endif } bool operator!=( RenderPassTransformBeginInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -77695,9 +82593,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -77722,6 +82621,7 @@ namespace VULKAN_HPP_NAMESPACE storeOp, clearValue ); } +#endif public: VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eRenderingAttachmentInfoKHR; @@ -77819,30 +82719,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, imageView, imageLayout ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( RenderingFragmentDensityMapAttachmentInfoEXT const & ) const = default; #else bool operator==( RenderingFragmentDensityMapAttachmentInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageView == rhs.imageView ) && + ( imageLayout == rhs.imageLayout ); +# endif } bool operator!=( RenderingFragmentDensityMapAttachmentInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -77946,31 +82853,39 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, imageView, imageLayout, shadingRateAttachmentTexelSize ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( RenderingFragmentShadingRateAttachmentInfoKHR const & ) const = default; #else bool operator==( RenderingFragmentShadingRateAttachmentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageView == rhs.imageView ) && + ( imageLayout == rhs.imageLayout ) && + ( shadingRateAttachmentTexelSize == rhs.shadingRateAttachmentTexelSize ); +# endif } bool operator!=( RenderingFragmentShadingRateAttachmentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -78143,9 +83058,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -78170,18 +83086,26 @@ namespace VULKAN_HPP_NAMESPACE pDepthAttachment, pStencilAttachment ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( RenderingInfoKHR const & ) const = default; #else bool operator==( RenderingInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && + ( renderArea == rhs.renderArea ) && ( layerCount == rhs.layerCount ) && ( viewMask == rhs.viewMask ) && + ( colorAttachmentCount == rhs.colorAttachmentCount ) && ( pColorAttachments == rhs.pColorAttachments ) && + ( pDepthAttachment == rhs.pDepthAttachment ) && ( pStencilAttachment == rhs.pStencilAttachment ); +# endif } bool operator!=( RenderingInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -78334,9 +83258,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ResolveImageInfo2KHR const & ) const = default; #else bool operator==( ResolveImageInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcImage == rhs.srcImage ) && + ( srcImageLayout == rhs.srcImageLayout ) && ( dstImage == rhs.dstImage ) && + ( dstImageLayout == rhs.dstImageLayout ) && ( regionCount == rhs.regionCount ) && + ( pRegions == rhs.pRegions ); +# endif } bool operator!=( ResolveImageInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -78457,30 +83390,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, components, srgb ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SamplerBorderColorComponentMappingCreateInfoEXT const & ) const = default; #else bool operator==( SamplerBorderColorComponentMappingCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( components == rhs.components ) && + ( srgb == rhs.srgb ); +# endif } bool operator!=( SamplerBorderColorComponentMappingCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -78690,9 +83630,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -78733,18 +83674,30 @@ namespace VULKAN_HPP_NAMESPACE borderColor, unnormalizedCoordinates ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SamplerCreateInfo const & ) const = default; #else bool operator==( SamplerCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && + ( magFilter == rhs.magFilter ) && ( minFilter == rhs.minFilter ) && ( mipmapMode == rhs.mipmapMode ) && + ( addressModeU == rhs.addressModeU ) && ( addressModeV == rhs.addressModeV ) && + ( addressModeW == rhs.addressModeW ) && ( mipLodBias == rhs.mipLodBias ) && + ( anisotropyEnable == rhs.anisotropyEnable ) && ( maxAnisotropy == rhs.maxAnisotropy ) && + ( compareEnable == rhs.compareEnable ) && ( compareOp == rhs.compareOp ) && ( minLod == rhs.minLod ) && + ( maxLod == rhs.maxLod ) && ( borderColor == rhs.borderColor ) && + ( unnormalizedCoordinates == rhs.unnormalizedCoordinates ); +# endif } bool operator!=( SamplerCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -78848,18 +83801,20 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, customBorderColor, format ); } +#endif public: VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eSamplerCustomBorderColorCreateInfoEXT; @@ -78938,29 +83893,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, reductionMode ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SamplerReductionModeCreateInfo const & ) const = default; #else bool operator==( SamplerReductionModeCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( reductionMode == rhs.reductionMode ); +# endif } bool operator!=( SamplerReductionModeCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -79105,9 +84066,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -79132,18 +84094,26 @@ namespace VULKAN_HPP_NAMESPACE chromaFilter, forceExplicitReconstruction ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SamplerYcbcrConversionCreateInfo const & ) const = default; #else bool operator==( SamplerYcbcrConversionCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( format == rhs.format ) && + ( ycbcrModel == rhs.ycbcrModel ) && ( ycbcrRange == rhs.ycbcrRange ) && ( components == rhs.components ) && + ( xChromaOffset == rhs.xChromaOffset ) && ( yChromaOffset == rhs.yChromaOffset ) && + ( chromaFilter == rhs.chromaFilter ) && ( forceExplicitReconstruction == rhs.forceExplicitReconstruction ); +# endif } bool operator!=( SamplerYcbcrConversionCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -79220,27 +84190,34 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, combinedImageSamplerDescriptorCount ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SamplerYcbcrConversionImageFormatProperties const & ) const = default; #else bool operator==( SamplerYcbcrConversionImageFormatProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( combinedImageSamplerDescriptorCount == rhs.combinedImageSamplerDescriptorCount ); +# endif } bool operator!=( SamplerYcbcrConversionImageFormatProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -79320,29 +84297,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, conversion ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SamplerYcbcrConversionInfo const & ) const = default; #else bool operator==( SamplerYcbcrConversionInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( conversion == rhs.conversion ); +# endif } bool operator!=( SamplerYcbcrConversionInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -79438,31 +84421,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, flags, context, window ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ScreenSurfaceCreateInfoQNX const & ) const = default; # else bool operator==( ScreenSurfaceCreateInfoQNX const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( context == rhs.context ) && + ( window == rhs.window ); +# endif } bool operator!=( ScreenSurfaceCreateInfoQNX const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -79541,29 +84531,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, flags ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SemaphoreCreateInfo const & ) const = default; #else bool operator==( SemaphoreCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ); +# endif } bool operator!=( SemaphoreCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -79648,30 +84644,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, semaphore, handleType ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SemaphoreGetFdInfoKHR const & ) const = default; #else bool operator==( SemaphoreGetFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphore == rhs.semaphore ) && + ( handleType == rhs.handleType ); +# endif } bool operator!=( SemaphoreGetFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -79761,30 +84764,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, semaphore, handleType ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SemaphoreGetWin32HandleInfoKHR const & ) const = default; # else bool operator==( SemaphoreGetWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphore == rhs.semaphore ) && + ( handleType == rhs.handleType ); +# endif } bool operator!=( SemaphoreGetWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -79879,30 +84889,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, semaphore, handleType ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SemaphoreGetZirconHandleInfoFUCHSIA const & ) const = default; # else bool operator==( SemaphoreGetZirconHandleInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphore == rhs.semaphore ) && + ( handleType == rhs.handleType ); +# endif } bool operator!=( SemaphoreGetZirconHandleInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -79989,30 +85006,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, semaphore, value ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SemaphoreSignalInfo const & ) const = default; #else bool operator==( SemaphoreSignalInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphore == rhs.semaphore ) && + ( value == rhs.value ); +# endif } bool operator!=( SemaphoreSignalInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -80113,32 +85137,39 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, semaphore, value, stageMask, deviceIndex ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SemaphoreSubmitInfoKHR const & ) const = default; #else bool operator==( SemaphoreSubmitInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphore == rhs.semaphore ) && + ( value == rhs.value ) && ( stageMask == rhs.stageMask ) && ( deviceIndex == rhs.deviceIndex ); +# endif } bool operator!=( SemaphoreSubmitInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -80225,30 +85256,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, semaphoreType, initialValue ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SemaphoreTypeCreateInfo const & ) const = default; #else bool operator==( SemaphoreTypeCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphoreType == rhs.semaphoreType ) && + ( initialValue == rhs.initialValue ); +# endif } bool operator!=( SemaphoreTypeCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -80393,32 +85431,40 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, flags, semaphoreCount, pSemaphores, pValues ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SemaphoreWaitInfo const & ) const = default; #else bool operator==( SemaphoreWaitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && + ( semaphoreCount == rhs.semaphoreCount ) && ( pSemaphores == rhs.pSemaphores ) && + ( pValues == rhs.pValues ); +# endif } bool operator!=( SemaphoreWaitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -80486,27 +85532,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( data ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SetStateFlagsIndirectCommandNV const & ) const = default; #else bool operator==( SetStateFlagsIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( data == rhs.data ); +# endif } bool operator!=( SetStateFlagsIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -80607,31 +85659,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, flags, codeSize, pCode ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ShaderModuleCreateInfo const & ) const = default; #else bool operator==( ShaderModuleCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && + ( codeSize == rhs.codeSize ) && ( pCode == rhs.pCode ); +# endif } bool operator!=( ShaderModuleCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -80716,29 +85775,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, validationCache ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ShaderModuleValidationCacheCreateInfoEXT const & ) const = default; #else bool operator==( ShaderModuleValidationCacheCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( validationCache == rhs.validationCache ); +# endif } bool operator!=( ShaderModuleValidationCacheCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -80805,28 +85870,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( numUsedVgprs, numUsedSgprs, ldsSizePerLocalWorkGroup, ldsUsageSizeInBytes, scratchMemUsageInBytes ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ShaderResourceUsageAMD const & ) const = default; #else bool operator==( ShaderResourceUsageAMD const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( numUsedVgprs == rhs.numUsedVgprs ) && ( numUsedSgprs == rhs.numUsedSgprs ) && + ( ldsSizePerLocalWorkGroup == rhs.ldsSizePerLocalWorkGroup ) && + ( ldsUsageSizeInBytes == rhs.ldsUsageSizeInBytes ) && + ( scratchMemUsageInBytes == rhs.scratchMemUsageInBytes ); +# endif } bool operator!=( ShaderResourceUsageAMD const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -80893,9 +85967,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple const &> -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( shaderStageMask, @@ -80914,18 +85989,26 @@ namespace VULKAN_HPP_NAMESPACE numAvailableSgprs, computeWorkGroupSize ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ShaderStatisticsInfoAMD const & ) const = default; #else bool operator==( ShaderStatisticsInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( shaderStageMask == rhs.shaderStageMask ) && ( resourceUsage == rhs.resourceUsage ) && + ( numPhysicalVgprs == rhs.numPhysicalVgprs ) && ( numPhysicalSgprs == rhs.numPhysicalSgprs ) && + ( numAvailableVgprs == rhs.numAvailableVgprs ) && ( numAvailableSgprs == rhs.numAvailableSgprs ) && + ( computeWorkGroupSize == rhs.computeWorkGroupSize ); +# endif } bool operator!=( ShaderStatisticsInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -80988,28 +86071,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std:: tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, sharedPresentSupportedUsageFlags ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SharedPresentSurfaceCapabilitiesKHR const & ) const = default; #else bool operator==( SharedPresentSurfaceCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( sharedPresentSupportedUsageFlags == rhs.sharedPresentSupportedUsageFlags ); +# endif } bool operator!=( SharedPresentSurfaceCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -81073,29 +86163,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( aspectMask, imageGranularity, flags ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SparseImageFormatProperties const & ) const = default; #else bool operator==( SparseImageFormatProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( aspectMask == rhs.aspectMask ) && ( imageGranularity == rhs.imageGranularity ) && ( flags == rhs.flags ); +# endif } bool operator!=( SparseImageFormatProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -81152,29 +86248,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, properties ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SparseImageFormatProperties2 const & ) const = default; #else bool operator==( SparseImageFormatProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( properties == rhs.properties ); +# endif } bool operator!=( SparseImageFormatProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -81244,32 +86346,40 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( formatProperties, imageMipTailFirstLod, imageMipTailSize, imageMipTailOffset, imageMipTailStride ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SparseImageMemoryRequirements const & ) const = default; #else bool operator==( SparseImageMemoryRequirements const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( formatProperties == rhs.formatProperties ) && ( imageMipTailFirstLod == rhs.imageMipTailFirstLod ) && + ( imageMipTailSize == rhs.imageMipTailSize ) && ( imageMipTailOffset == rhs.imageMipTailOffset ) && + ( imageMipTailStride == rhs.imageMipTailStride ); +# endif } bool operator!=( SparseImageMemoryRequirements const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -81329,29 +86439,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, memoryRequirements ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SparseImageMemoryRequirements2 const & ) const = default; #else bool operator==( SparseImageMemoryRequirements2 const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryRequirements == rhs.memoryRequirements ); +# endif } bool operator!=( SparseImageMemoryRequirements2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -81443,30 +86559,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, flags, streamDescriptor ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( StreamDescriptorSurfaceCreateInfoGGP const & ) const = default; # else bool operator==( StreamDescriptorSurfaceCreateInfoGGP const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && + ( memcmp( &streamDescriptor, &rhs.streamDescriptor, sizeof( GgpStreamDescriptor ) ) == 0 ); +# endif } bool operator!=( StreamDescriptorSurfaceCreateInfoGGP const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -81556,29 +86679,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( deviceAddress, stride, size ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( StridedDeviceAddressRegionKHR const & ) const = default; #else bool operator==( StridedDeviceAddressRegionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( deviceAddress == rhs.deviceAddress ) && ( stride == rhs.stride ) && ( size == rhs.size ); +# endif } bool operator!=( StridedDeviceAddressRegionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -81773,9 +86902,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -81798,18 +86928,26 @@ namespace VULKAN_HPP_NAMESPACE signalSemaphoreCount, pSignalSemaphores ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SubmitInfo const & ) const = default; #else bool operator==( SubmitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( waitSemaphoreCount == rhs.waitSemaphoreCount ) && + ( pWaitSemaphores == rhs.pWaitSemaphores ) && ( pWaitDstStageMask == rhs.pWaitDstStageMask ) && + ( commandBufferCount == rhs.commandBufferCount ) && ( pCommandBuffers == rhs.pCommandBuffers ) && + ( signalSemaphoreCount == rhs.signalSemaphoreCount ) && ( pSignalSemaphores == rhs.pSignalSemaphores ); +# endif } bool operator!=( SubmitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -81995,9 +87133,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -82020,18 +87159,29 @@ namespace VULKAN_HPP_NAMESPACE signalSemaphoreInfoCount, pSignalSemaphoreInfos ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SubmitInfo2KHR const & ) const = default; #else bool operator==( SubmitInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && + ( waitSemaphoreInfoCount == rhs.waitSemaphoreInfoCount ) && + ( pWaitSemaphoreInfos == rhs.pWaitSemaphoreInfos ) && + ( commandBufferInfoCount == rhs.commandBufferInfoCount ) && + ( pCommandBufferInfos == rhs.pCommandBufferInfos ) && + ( signalSemaphoreInfoCount == rhs.signalSemaphoreInfoCount ) && + ( pSignalSemaphoreInfos == rhs.pSignalSemaphoreInfos ); +# endif } bool operator!=( SubmitInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -82112,29 +87262,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, contents ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SubpassBeginInfo const & ) const = default; #else bool operator==( SubpassBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( contents == rhs.contents ); +# endif } bool operator!=( SubpassBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -82233,31 +87389,39 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, depthResolveMode, stencilResolveMode, pDepthStencilResolveAttachment ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SubpassDescriptionDepthStencilResolve const & ) const = default; #else bool operator==( SubpassDescriptionDepthStencilResolve const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( depthResolveMode == rhs.depthResolveMode ) && + ( stencilResolveMode == rhs.stencilResolveMode ) && + ( pDepthStencilResolveAttachment == rhs.pDepthStencilResolveAttachment ); +# endif } bool operator!=( SubpassDescriptionDepthStencilResolve const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -82327,27 +87491,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SubpassEndInfo const & ) const = default; #else bool operator==( SubpassEndInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ); +# endif } bool operator!=( SubpassEndInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -82458,30 +87628,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, fragmentDensityOffsetCount, pFragmentDensityOffsets ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SubpassFragmentDensityMapOffsetEndInfoQCOM const & ) const = default; #else bool operator==( SubpassFragmentDensityMapOffsetEndInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( fragmentDensityOffsetCount == rhs.fragmentDensityOffsetCount ) && + ( pFragmentDensityOffsets == rhs.pFragmentDensityOffsets ); +# endif } bool operator!=( SubpassFragmentDensityMapOffsetEndInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -82551,30 +87729,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, renderPass, subpass ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SubpassShadingPipelineCreateInfoHUAWEI const & ) const = default; #else bool operator==( SubpassShadingPipelineCreateInfoHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( renderPass == rhs.renderPass ) && + ( subpass == rhs.subpass ); +# endif } bool operator!=( SubpassShadingPipelineCreateInfoHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -82659,9 +87844,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -82692,18 +87878,30 @@ namespace VULKAN_HPP_NAMESPACE supportedUsageFlags, supportedSurfaceCounters ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SurfaceCapabilities2EXT const & ) const = default; #else bool operator==( SurfaceCapabilities2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( minImageCount == rhs.minImageCount ) && + ( maxImageCount == rhs.maxImageCount ) && ( currentExtent == rhs.currentExtent ) && + ( minImageExtent == rhs.minImageExtent ) && ( maxImageExtent == rhs.maxImageExtent ) && + ( maxImageArrayLayers == rhs.maxImageArrayLayers ) && ( supportedTransforms == rhs.supportedTransforms ) && + ( currentTransform == rhs.currentTransform ) && + ( supportedCompositeAlpha == rhs.supportedCompositeAlpha ) && + ( supportedUsageFlags == rhs.supportedUsageFlags ) && + ( supportedSurfaceCounters == rhs.supportedSurfaceCounters ); +# endif } bool operator!=( SurfaceCapabilities2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -82791,9 +87989,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( minImageCount, @@ -82818,18 +88017,28 @@ namespace VULKAN_HPP_NAMESPACE supportedCompositeAlpha, supportedUsageFlags ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SurfaceCapabilitiesKHR const & ) const = default; #else bool operator==( SurfaceCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( minImageCount == rhs.minImageCount ) && ( maxImageCount == rhs.maxImageCount ) && + ( currentExtent == rhs.currentExtent ) && ( minImageExtent == rhs.minImageExtent ) && + ( maxImageExtent == rhs.maxImageExtent ) && ( maxImageArrayLayers == rhs.maxImageArrayLayers ) && + ( supportedTransforms == rhs.supportedTransforms ) && ( currentTransform == rhs.currentTransform ) && + ( supportedCompositeAlpha == rhs.supportedCompositeAlpha ) && + ( supportedUsageFlags == rhs.supportedUsageFlags ); +# endif } bool operator!=( SurfaceCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -82892,29 +88101,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, surfaceCapabilities ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SurfaceCapabilities2KHR const & ) const = default; #else bool operator==( SurfaceCapabilities2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( surfaceCapabilities == rhs.surfaceCapabilities ); +# endif } bool operator!=( SurfaceCapabilities2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -82997,27 +88212,34 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, fullScreenExclusiveSupported ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SurfaceCapabilitiesFullScreenExclusiveEXT const & ) const = default; # else bool operator==( SurfaceCapabilitiesFullScreenExclusiveEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( fullScreenExclusiveSupported == rhs.fullScreenExclusiveSupported ); +# endif } bool operator!=( SurfaceCapabilitiesFullScreenExclusiveEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -83081,27 +88303,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( format, colorSpace ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SurfaceFormatKHR const & ) const = default; #else bool operator==( SurfaceFormatKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( format == rhs.format ) && ( colorSpace == rhs.colorSpace ); +# endif } bool operator!=( SurfaceFormatKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -83154,28 +88382,34 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std:: tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, surfaceFormat ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SurfaceFormat2KHR const & ) const = default; #else bool operator==( SurfaceFormat2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( surfaceFormat == rhs.surfaceFormat ); +# endif } bool operator!=( SurfaceFormat2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -83255,29 +88489,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, fullScreenExclusive ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SurfaceFullScreenExclusiveInfoEXT const & ) const = default; # else bool operator==( SurfaceFullScreenExclusiveInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fullScreenExclusive == rhs.fullScreenExclusive ); +# endif } bool operator!=( SurfaceFullScreenExclusiveInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -83361,27 +88601,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, hmonitor ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SurfaceFullScreenExclusiveWin32InfoEXT const & ) const = default; # else bool operator==( SurfaceFullScreenExclusiveWin32InfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( hmonitor == rhs.hmonitor ); +# endif } bool operator!=( SurfaceFullScreenExclusiveWin32InfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -83462,27 +88708,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, supportsProtected ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SurfaceProtectedCapabilitiesKHR const & ) const = default; #else bool operator==( SurfaceProtectedCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( supportsProtected == rhs.supportsProtected ); +# endif } bool operator!=( SurfaceProtectedCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -83561,29 +88813,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, surfaceCounters ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SwapchainCounterCreateInfoEXT const & ) const = default; #else bool operator==( SwapchainCounterCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( surfaceCounters == rhs.surfaceCounters ); +# endif } bool operator!=( SwapchainCounterCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -83844,9 +89102,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -83887,18 +89146,30 @@ namespace VULKAN_HPP_NAMESPACE clipped, oldSwapchain ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SwapchainCreateInfoKHR const & ) const = default; #else bool operator==( SwapchainCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( surface == rhs.surface ) && + ( minImageCount == rhs.minImageCount ) && ( imageFormat == rhs.imageFormat ) && + ( imageColorSpace == rhs.imageColorSpace ) && ( imageExtent == rhs.imageExtent ) && + ( imageArrayLayers == rhs.imageArrayLayers ) && ( imageUsage == rhs.imageUsage ) && + ( imageSharingMode == rhs.imageSharingMode ) && ( queueFamilyIndexCount == rhs.queueFamilyIndexCount ) && + ( pQueueFamilyIndices == rhs.pQueueFamilyIndices ) && ( preTransform == rhs.preTransform ) && + ( compositeAlpha == rhs.compositeAlpha ) && ( presentMode == rhs.presentMode ) && + ( clipped == rhs.clipped ) && ( oldSwapchain == rhs.oldSwapchain ); +# endif } bool operator!=( SwapchainCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -83995,27 +89266,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, localDimmingEnable ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SwapchainDisplayNativeHdrCreateInfoAMD const & ) const = default; #else bool operator==( SwapchainDisplayNativeHdrCreateInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( localDimmingEnable == rhs.localDimmingEnable ); +# endif } bool operator!=( SwapchainDisplayNativeHdrCreateInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -84082,27 +89359,34 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, supportsTextureGatherLODBiasAMD ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( TextureLODGatherFormatPropertiesAMD const & ) const = default; #else bool operator==( TextureLODGatherFormatPropertiesAMD const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( supportsTextureGatherLODBiasAMD == rhs.supportsTextureGatherLODBiasAMD ); +# endif } bool operator!=( TextureLODGatherFormatPropertiesAMD const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -84238,16 +89522,17 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -84257,18 +89542,27 @@ namespace VULKAN_HPP_NAMESPACE signalSemaphoreValueCount, pSignalSemaphoreValues ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( TimelineSemaphoreSubmitInfo const & ) const = default; #else bool operator==( TimelineSemaphoreSubmitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( waitSemaphoreValueCount == rhs.waitSemaphoreValueCount ) && + ( pWaitSemaphoreValues == rhs.pWaitSemaphoreValues ) && + ( signalSemaphoreValueCount == rhs.signalSemaphoreValueCount ) && + ( pSignalSemaphoreValues == rhs.pSignalSemaphoreValues ); +# endif } bool operator!=( TimelineSemaphoreSubmitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -84359,27 +89653,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( width, height, depth ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( TraceRaysIndirectCommandKHR const & ) const = default; #else bool operator==( TraceRaysIndirectCommandKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( width == rhs.width ) && ( height == rhs.height ) && ( depth == rhs.depth ); +# endif } bool operator!=( TraceRaysIndirectCommandKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -84487,31 +89787,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, flags, initialDataSize, pInitialData ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ValidationCacheCreateInfoEXT const & ) const = default; #else bool operator==( ValidationCacheCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && + ( initialDataSize == rhs.initialDataSize ) && ( pInitialData == rhs.pInitialData ); +# endif } bool operator!=( ValidationCacheCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -84652,16 +89959,17 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -84671,18 +89979,27 @@ namespace VULKAN_HPP_NAMESPACE disabledValidationFeatureCount, pDisabledValidationFeatures ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ValidationFeaturesEXT const & ) const = default; #else bool operator==( ValidationFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( enabledValidationFeatureCount == rhs.enabledValidationFeatureCount ) && + ( pEnabledValidationFeatures == rhs.pEnabledValidationFeatures ) && + ( disabledValidationFeatureCount == rhs.disabledValidationFeatureCount ) && + ( pDisabledValidationFeatures == rhs.pDisabledValidationFeatures ); +# endif } bool operator!=( ValidationFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -84789,30 +90106,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, disabledValidationCheckCount, pDisabledValidationChecks ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ValidationFlagsEXT const & ) const = default; #else bool operator==( ValidationFlagsEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( disabledValidationCheckCount == rhs.disabledValidationCheckCount ) && + ( pDisabledValidationChecks == rhs.pDisabledValidationChecks ); +# endif } bool operator!=( ValidationFlagsEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -84916,32 +90241,39 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, location, binding, format, offset ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VertexInputAttributeDescription2EXT const & ) const = default; #else bool operator==( VertexInputAttributeDescription2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( location == rhs.location ) && + ( binding == rhs.binding ) && ( format == rhs.format ) && ( offset == rhs.offset ); +# endif } bool operator!=( VertexInputAttributeDescription2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -85048,32 +90380,39 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, binding, stride, inputRate, divisor ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VertexInputBindingDescription2EXT const & ) const = default; #else bool operator==( VertexInputBindingDescription2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( binding == rhs.binding ) && + ( stride == rhs.stride ) && ( inputRate == rhs.inputRate ) && ( divisor == rhs.divisor ); +# endif } bool operator!=( VertexInputBindingDescription2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -85161,30 +90500,36 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, flags, window ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ViSurfaceCreateInfoNN const & ) const = default; # else bool operator==( ViSurfaceCreateInfoNN const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( window == rhs.window ); +# endif } bool operator!=( ViSurfaceCreateInfoNN const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -85288,32 +90633,40 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, codedOffset, codedExtent, baseArrayLayer, imageViewBinding ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoPictureResourceKHR const & ) const = default; # else bool operator==( VideoPictureResourceKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( codedOffset == rhs.codedOffset ) && + ( codedExtent == rhs.codedExtent ) && ( baseArrayLayer == rhs.baseArrayLayer ) && + ( imageViewBinding == rhs.imageViewBinding ); +# endif } bool operator!=( VideoPictureResourceKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -85402,30 +90755,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, slotIndex, pPictureResource ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoReferenceSlotKHR const & ) const = default; # else bool operator==( VideoReferenceSlotKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( slotIndex == rhs.slotIndex ) && + ( pPictureResource == rhs.pPictureResource ); +# endif } bool operator!=( VideoReferenceSlotKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -85576,9 +90936,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -85599,18 +90960,26 @@ namespace VULKAN_HPP_NAMESPACE referenceSlotCount, pReferenceSlots ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoBeginCodingInfoKHR const & ) const = default; # else bool operator==( VideoBeginCodingInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && + ( codecQualityPreset == rhs.codecQualityPreset ) && ( videoSession == rhs.videoSession ) && + ( videoSessionParameters == rhs.videoSessionParameters ) && + ( referenceSlotCount == rhs.referenceSlotCount ) && ( pReferenceSlots == rhs.pReferenceSlots ); +# endif } bool operator!=( VideoBeginCodingInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -85718,32 +91087,39 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, memoryBindIndex, memory, memoryOffset, memorySize ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoBindMemoryKHR const & ) const = default; # else bool operator==( VideoBindMemoryKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryBindIndex == rhs.memoryBindIndex ) && + ( memory == rhs.memory ) && ( memoryOffset == rhs.memoryOffset ) && ( memorySize == rhs.memorySize ); +# endif } bool operator!=( VideoBindMemoryKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -85821,9 +91197,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -85848,18 +91225,29 @@ namespace VULKAN_HPP_NAMESPACE maxReferencePicturesSlotsCount, maxReferencePicturesActiveCount ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoCapabilitiesKHR const & ) const = default; # else bool operator==( VideoCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( capabilityFlags == rhs.capabilityFlags ) && + ( minBitstreamBufferOffsetAlignment == rhs.minBitstreamBufferOffsetAlignment ) && + ( minBitstreamBufferSizeAlignment == rhs.minBitstreamBufferSizeAlignment ) && + ( videoPictureExtentGranularity == rhs.videoPictureExtentGranularity ) && ( minExtent == rhs.minExtent ) && + ( maxExtent == rhs.maxExtent ) && + ( maxReferencePicturesSlotsCount == rhs.maxReferencePicturesSlotsCount ) && + ( maxReferencePicturesActiveCount == rhs.maxReferencePicturesActiveCount ); +# endif } bool operator!=( VideoCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -85944,29 +91332,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, flags ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoCodingControlInfoKHR const & ) const = default; # else bool operator==( VideoCodingControlInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ); +# endif } bool operator!=( VideoCodingControlInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -86035,31 +91429,39 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, maxLevel, fieldOffsetGranularity, stdExtensionVersion ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoDecodeH264CapabilitiesEXT const & ) const = default; # else bool operator==( VideoDecodeH264CapabilitiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxLevel == rhs.maxLevel ) && + ( fieldOffsetGranularity == rhs.fieldOffsetGranularity ) && + ( stdExtensionVersion == rhs.stdExtensionVersion ); +# endif } bool operator!=( VideoDecodeH264CapabilitiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -86142,29 +91544,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, pStdReferenceInfo ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoDecodeH264DpbSlotInfoEXT const & ) const = default; # else bool operator==( VideoDecodeH264DpbSlotInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pStdReferenceInfo == rhs.pStdReferenceInfo ); +# endif } bool operator!=( VideoDecodeH264DpbSlotInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -86242,27 +91650,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, pStdMvc ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoDecodeH264MvcEXT const & ) const = default; # else bool operator==( VideoDecodeH264MvcEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pStdMvc == rhs.pStdMvc ); +# endif } bool operator!=( VideoDecodeH264MvcEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -86377,31 +91791,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, pStdPictureInfo, slicesCount, pSlicesDataOffsets ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoDecodeH264PictureInfoEXT const & ) const = default; # else bool operator==( VideoDecodeH264PictureInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pStdPictureInfo == rhs.pStdPictureInfo ) && + ( slicesCount == rhs.slicesCount ) && ( pSlicesDataOffsets == rhs.pSlicesDataOffsets ); +# endif } bool operator!=( VideoDecodeH264PictureInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -86492,30 +91913,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, stdProfileIdc, pictureLayout ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoDecodeH264ProfileEXT const & ) const = default; # else bool operator==( VideoDecodeH264ProfileEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( memcmp( &stdProfileIdc, &rhs.stdProfileIdc, sizeof( StdVideoH264ProfileIdc ) ) == 0 ) && + ( pictureLayout == rhs.pictureLayout ); +# endif } bool operator!=( VideoDecodeH264ProfileEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -86607,30 +92036,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, flags, pStdExtensionVersion ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoDecodeH264SessionCreateInfoEXT const & ) const = default; # else bool operator==( VideoDecodeH264SessionCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && + ( pStdExtensionVersion == rhs.pStdExtensionVersion ); +# endif } bool operator!=( VideoDecodeH264SessionCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -86777,32 +92213,39 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, spsStdCount, pSpsStd, ppsStdCount, pPpsStd ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoDecodeH264SessionParametersAddInfoEXT const & ) const = default; # else bool operator==( VideoDecodeH264SessionParametersAddInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( spsStdCount == rhs.spsStdCount ) && + ( pSpsStd == rhs.pSpsStd ) && ( ppsStdCount == rhs.ppsStdCount ) && ( pPpsStd == rhs.pPpsStd ); +# endif } bool operator!=( VideoDecodeH264SessionParametersAddInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -86911,31 +92354,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, maxSpsStdCount, maxPpsStdCount, pParametersAddInfo ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoDecodeH264SessionParametersCreateInfoEXT const & ) const = default; # else bool operator==( VideoDecodeH264SessionParametersCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxSpsStdCount == rhs.maxSpsStdCount ) && + ( maxPpsStdCount == rhs.maxPpsStdCount ) && ( pParametersAddInfo == rhs.pParametersAddInfo ); +# endif } bool operator!=( VideoDecodeH264SessionParametersCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -87005,30 +92455,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, maxLevel, stdExtensionVersion ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoDecodeH265CapabilitiesEXT const & ) const = default; # else bool operator==( VideoDecodeH265CapabilitiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxLevel == rhs.maxLevel ) && + ( stdExtensionVersion == rhs.stdExtensionVersion ); +# endif } bool operator!=( VideoDecodeH265CapabilitiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -87110,29 +92567,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, pStdReferenceInfo ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoDecodeH265DpbSlotInfoEXT const & ) const = default; # else bool operator==( VideoDecodeH265DpbSlotInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pStdReferenceInfo == rhs.pStdReferenceInfo ); +# endif } bool operator!=( VideoDecodeH265DpbSlotInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -87249,31 +92712,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, pStdPictureInfo, slicesCount, pSlicesDataOffsets ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoDecodeH265PictureInfoEXT const & ) const = default; # else bool operator==( VideoDecodeH265PictureInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pStdPictureInfo == rhs.pStdPictureInfo ) && + ( slicesCount == rhs.slicesCount ) && ( pSlicesDataOffsets == rhs.pSlicesDataOffsets ); +# endif } bool operator!=( VideoDecodeH265PictureInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -87354,27 +92824,34 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, stdProfileIdc ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoDecodeH265ProfileEXT const & ) const = default; # else bool operator==( VideoDecodeH265ProfileEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( memcmp( &stdProfileIdc, &rhs.stdProfileIdc, sizeof( StdVideoH265ProfileIdc ) ) == 0 ); +# endif } bool operator!=( VideoDecodeH265ProfileEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -87465,30 +92942,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, flags, pStdExtensionVersion ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoDecodeH265SessionCreateInfoEXT const & ) const = default; # else bool operator==( VideoDecodeH265SessionCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && + ( pStdExtensionVersion == rhs.pStdExtensionVersion ); +# endif } bool operator!=( VideoDecodeH265SessionCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -87635,32 +93119,39 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, spsStdCount, pSpsStd, ppsStdCount, pPpsStd ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoDecodeH265SessionParametersAddInfoEXT const & ) const = default; # else bool operator==( VideoDecodeH265SessionParametersAddInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( spsStdCount == rhs.spsStdCount ) && + ( pSpsStd == rhs.pSpsStd ) && ( ppsStdCount == rhs.ppsStdCount ) && ( pPpsStd == rhs.pPpsStd ); +# endif } bool operator!=( VideoDecodeH265SessionParametersAddInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -87769,31 +93260,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, maxSpsStdCount, maxPpsStdCount, pParametersAddInfo ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoDecodeH265SessionParametersCreateInfoEXT const & ) const = default; # else bool operator==( VideoDecodeH265SessionParametersCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxSpsStdCount == rhs.maxSpsStdCount ) && + ( maxPpsStdCount == rhs.maxPpsStdCount ) && ( pParametersAddInfo == rhs.pParametersAddInfo ); +# endif } bool operator!=( VideoDecodeH265SessionParametersCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -87992,9 +93490,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -88023,18 +93522,28 @@ namespace VULKAN_HPP_NAMESPACE referenceSlotCount, pReferenceSlots ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoDecodeInfoKHR const & ) const = default; # else bool operator==( VideoDecodeInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && + ( codedOffset == rhs.codedOffset ) && ( codedExtent == rhs.codedExtent ) && + ( srcBuffer == rhs.srcBuffer ) && ( srcBufferOffset == rhs.srcBufferOffset ) && + ( srcBufferRange == rhs.srcBufferRange ) && ( dstPictureResource == rhs.dstPictureResource ) && + ( pSetupReferenceSlot == rhs.pSetupReferenceSlot ) && ( referenceSlotCount == rhs.referenceSlotCount ) && + ( pReferenceSlots == rhs.pReferenceSlots ); +# endif } bool operator!=( VideoDecodeInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -88212,9 +93721,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -88245,18 +93755,29 @@ namespace VULKAN_HPP_NAMESPACE qualityLevelCount, stdExtensionVersion ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeH264CapabilitiesEXT const & ) const = default; # else bool operator==( VideoEncodeH264CapabilitiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && + ( inputModeFlags == rhs.inputModeFlags ) && ( outputModeFlags == rhs.outputModeFlags ) && + ( minPictureSizeInMbs == rhs.minPictureSizeInMbs ) && ( maxPictureSizeInMbs == rhs.maxPictureSizeInMbs ) && + ( inputImageDataAlignment == rhs.inputImageDataAlignment ) && + ( maxNumL0ReferenceForP == rhs.maxNumL0ReferenceForP ) && + ( maxNumL0ReferenceForB == rhs.maxNumL0ReferenceForB ) && ( maxNumL1Reference == rhs.maxNumL1Reference ) && + ( qualityLevelCount == rhs.qualityLevelCount ) && ( stdExtensionVersion == rhs.stdExtensionVersion ); +# endif } bool operator!=( VideoEncodeH264CapabilitiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -88355,30 +93876,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, slotIndex, pStdPictureInfo ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeH264DpbSlotInfoEXT const & ) const = default; # else bool operator==( VideoEncodeH264DpbSlotInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( slotIndex == rhs.slotIndex ) && + ( pStdPictureInfo == rhs.pStdPictureInfo ); +# endif } bool operator!=( VideoEncodeH264DpbSlotInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -88512,32 +94040,40 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, spsId, emitSpsEnable, ppsIdEntryCount, ppsIdEntries ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeH264EmitPictureParametersEXT const & ) const = default; # else bool operator==( VideoEncodeH264EmitPictureParametersEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( spsId == rhs.spsId ) && + ( emitSpsEnable == rhs.emitSpsEnable ) && ( ppsIdEntryCount == rhs.ppsIdEntryCount ) && + ( ppsIdEntries == rhs.ppsIdEntries ); +# endif } bool operator!=( VideoEncodeH264EmitPictureParametersEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -88626,27 +94162,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( frameISize, framePSize, frameBSize ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeH264FrameSizeEXT const & ) const = default; # else bool operator==( VideoEncodeH264FrameSizeEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( frameISize == rhs.frameISize ) && ( framePSize == rhs.framePSize ) && ( frameBSize == rhs.frameBSize ); +# endif } bool operator!=( VideoEncodeH264FrameSizeEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -88803,9 +94345,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -88826,18 +94369,27 @@ namespace VULKAN_HPP_NAMESPACE refFinalList1EntryCount, pRefFinalList1Entries ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeH264NaluSliceEXT const & ) const = default; # else bool operator==( VideoEncodeH264NaluSliceEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pSliceHeaderStd == rhs.pSliceHeaderStd ) && + ( mbCount == rhs.mbCount ) && ( refFinalList0EntryCount == rhs.refFinalList0EntryCount ) && + ( pRefFinalList0Entries == rhs.pRefFinalList0Entries ) && + ( refFinalList1EntryCount == rhs.refFinalList1EntryCount ) && + ( pRefFinalList1Entries == rhs.pRefFinalList1Entries ); +# endif } bool operator!=( VideoEncodeH264NaluSliceEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -88921,27 +94473,34 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, stdProfileIdc ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeH264ProfileEXT const & ) const = default; # else bool operator==( VideoEncodeH264ProfileEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( memcmp( &stdProfileIdc, &rhs.stdProfileIdc, sizeof( StdVideoH264ProfileIdc ) ) == 0 ); +# endif } bool operator!=( VideoEncodeH264ProfileEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -89023,27 +94582,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( qpI, qpP, qpB ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeH264QpEXT const & ) const = default; # else bool operator==( VideoEncodeH264QpEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( qpI == rhs.qpI ) && ( qpP == rhs.qpP ) && ( qpB == rhs.qpB ); +# endif } bool operator!=( VideoEncodeH264QpEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -89153,9 +94718,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, gopFrameCount, idrPeriod, consecutiveBFrameCount, rateControlStructure, temporalLayerCount ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeH264RateControlInfoEXT const & ) const = default; # else bool operator==( VideoEncodeH264RateControlInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( gopFrameCount == rhs.gopFrameCount ) && + ( idrPeriod == rhs.idrPeriod ) && ( consecutiveBFrameCount == rhs.consecutiveBFrameCount ) && + ( rateControlStructure == rhs.rateControlStructure ) && ( temporalLayerCount == rhs.temporalLayerCount ); +# endif } bool operator!=( VideoEncodeH264RateControlInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -89341,9 +94914,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -89370,18 +94944,27 @@ namespace VULKAN_HPP_NAMESPACE useMaxFrameSize, maxFrameSize ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeH264RateControlLayerInfoEXT const & ) const = default; # else bool operator==( VideoEncodeH264RateControlLayerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( temporalLayerId == rhs.temporalLayerId ) && + ( useInitialRcQp == rhs.useInitialRcQp ) && ( initialRcQp == rhs.initialRcQp ) && + ( useMinQp == rhs.useMinQp ) && ( minQp == rhs.minQp ) && ( useMaxQp == rhs.useMaxQp ) && + ( maxQp == rhs.maxQp ) && ( useMaxFrameSize == rhs.useMaxFrameSize ) && + ( maxFrameSize == rhs.maxFrameSize ); +# endif } bool operator!=( VideoEncodeH264RateControlLayerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -89491,31 +95074,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, flags, maxPictureSizeInMbs, pStdExtensionVersion ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeH264SessionCreateInfoEXT const & ) const = default; # else bool operator==( VideoEncodeH264SessionCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && + ( maxPictureSizeInMbs == rhs.maxPictureSizeInMbs ) && ( pStdExtensionVersion == rhs.pStdExtensionVersion ); +# endif } bool operator!=( VideoEncodeH264SessionCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -89663,32 +95253,39 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, spsStdCount, pSpsStd, ppsStdCount, pPpsStd ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeH264SessionParametersAddInfoEXT const & ) const = default; # else bool operator==( VideoEncodeH264SessionParametersAddInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( spsStdCount == rhs.spsStdCount ) && + ( pSpsStd == rhs.pSpsStd ) && ( ppsStdCount == rhs.ppsStdCount ) && ( pPpsStd == rhs.pPpsStd ); +# endif } bool operator!=( VideoEncodeH264SessionParametersAddInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -89797,31 +95394,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, maxSpsStdCount, maxPpsStdCount, pParametersAddInfo ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeH264SessionParametersCreateInfoEXT const & ) const = default; # else bool operator==( VideoEncodeH264SessionParametersCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxSpsStdCount == rhs.maxSpsStdCount ) && + ( maxPpsStdCount == rhs.maxPpsStdCount ) && ( pParametersAddInfo == rhs.pParametersAddInfo ); +# endif } bool operator!=( VideoEncodeH264SessionParametersCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -90011,9 +95615,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -90036,18 +95641,29 @@ namespace VULKAN_HPP_NAMESPACE pNaluSliceEntries, pCurrentPictureInfo ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeH264VclFrameInfoEXT const & ) const = default; # else bool operator==( VideoEncodeH264VclFrameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( refDefaultFinalList0EntryCount == rhs.refDefaultFinalList0EntryCount ) && + ( pRefDefaultFinalList0Entries == rhs.pRefDefaultFinalList0Entries ) && + ( refDefaultFinalList1EntryCount == rhs.refDefaultFinalList1EntryCount ) && + ( pRefDefaultFinalList1Entries == rhs.pRefDefaultFinalList1Entries ) && + ( naluSliceEntryCount == rhs.naluSliceEntryCount ) && ( pNaluSliceEntries == rhs.pNaluSliceEntries ) && + ( pCurrentPictureInfo == rhs.pCurrentPictureInfo ); +# endif } bool operator!=( VideoEncodeH264VclFrameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -90224,9 +95840,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -90257,18 +95874,29 @@ namespace VULKAN_HPP_NAMESPACE qualityLevelCount, stdExtensionVersion ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeH265CapabilitiesEXT const & ) const = default; # else bool operator==( VideoEncodeH265CapabilitiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && + ( inputModeFlags == rhs.inputModeFlags ) && ( outputModeFlags == rhs.outputModeFlags ) && + ( ctbSizes == rhs.ctbSizes ) && ( inputImageDataAlignment == rhs.inputImageDataAlignment ) && + ( maxNumL0ReferenceForP == rhs.maxNumL0ReferenceForP ) && + ( maxNumL0ReferenceForB == rhs.maxNumL0ReferenceForB ) && ( maxNumL1Reference == rhs.maxNumL1Reference ) && + ( maxNumSubLayers == rhs.maxNumSubLayers ) && ( qualityLevelCount == rhs.qualityLevelCount ) && + ( stdExtensionVersion == rhs.stdExtensionVersion ); +# endif } bool operator!=( VideoEncodeH265CapabilitiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -90366,30 +95994,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, slotIndex, pStdReferenceInfo ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeH265DpbSlotInfoEXT const & ) const = default; # else bool operator==( VideoEncodeH265DpbSlotInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( slotIndex == rhs.slotIndex ) && + ( pStdReferenceInfo == rhs.pStdReferenceInfo ); +# endif } bool operator!=( VideoEncodeH265DpbSlotInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -90544,9 +96179,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, vpsId, spsId, emitVpsEnable, emitSpsEnable, ppsIdEntryCount, ppsIdEntries ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeH265EmitPictureParametersEXT const & ) const = default; # else bool operator==( VideoEncodeH265EmitPictureParametersEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( vpsId == rhs.vpsId ) && ( spsId == rhs.spsId ) && + ( emitVpsEnable == rhs.emitVpsEnable ) && ( emitSpsEnable == rhs.emitSpsEnable ) && + ( ppsIdEntryCount == rhs.ppsIdEntryCount ) && ( ppsIdEntries == rhs.ppsIdEntries ); +# endif } bool operator!=( VideoEncodeH265EmitPictureParametersEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -90662,27 +96305,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( frameISize, framePSize, frameBSize ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeH265FrameSizeEXT const & ) const = default; # else bool operator==( VideoEncodeH265FrameSizeEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( frameISize == rhs.frameISize ) && ( framePSize == rhs.framePSize ) && ( frameBSize == rhs.frameBSize ); +# endif } bool operator!=( VideoEncodeH265FrameSizeEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -90830,9 +96479,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -90851,18 +96501,28 @@ namespace VULKAN_HPP_NAMESPACE pReferenceList1Entries, pReferenceModifications ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeH265ReferenceListsEXT const & ) const = default; # else bool operator==( VideoEncodeH265ReferenceListsEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( referenceList0EntryCount == rhs.referenceList0EntryCount ) && + ( pReferenceList0Entries == rhs.pReferenceList0Entries ) && + ( referenceList1EntryCount == rhs.referenceList1EntryCount ) && + ( pReferenceList1Entries == rhs.pReferenceList1Entries ) && + ( pReferenceModifications == rhs.pReferenceModifications ); +# endif } bool operator!=( VideoEncodeH265ReferenceListsEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -90963,31 +96623,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, ctbCount, pReferenceFinalLists, pSliceHeaderStd ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeH265NaluSliceEXT const & ) const = default; # else bool operator==( VideoEncodeH265NaluSliceEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( ctbCount == rhs.ctbCount ) && + ( pReferenceFinalLists == rhs.pReferenceFinalLists ) && ( pSliceHeaderStd == rhs.pSliceHeaderStd ); +# endif } bool operator!=( VideoEncodeH265NaluSliceEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -91068,27 +96735,34 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, stdProfileIdc ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeH265ProfileEXT const & ) const = default; # else bool operator==( VideoEncodeH265ProfileEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( memcmp( &stdProfileIdc, &rhs.stdProfileIdc, sizeof( StdVideoH265ProfileIdc ) ) == 0 ); +# endif } bool operator!=( VideoEncodeH265ProfileEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -91170,27 +96844,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( qpI, qpP, qpB ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeH265QpEXT const & ) const = default; # else bool operator==( VideoEncodeH265QpEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( qpI == rhs.qpI ) && ( qpP == rhs.qpP ) && ( qpB == rhs.qpB ); +# endif } bool operator!=( VideoEncodeH265QpEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -91300,9 +96980,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, gopFrameCount, idrPeriod, consecutiveBFrameCount, rateControlStructure, subLayerCount ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeH265RateControlInfoEXT const & ) const = default; # else bool operator==( VideoEncodeH265RateControlInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( gopFrameCount == rhs.gopFrameCount ) && + ( idrPeriod == rhs.idrPeriod ) && ( consecutiveBFrameCount == rhs.consecutiveBFrameCount ) && + ( rateControlStructure == rhs.rateControlStructure ) && ( subLayerCount == rhs.subLayerCount ); +# endif } bool operator!=( VideoEncodeH265RateControlInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -91488,9 +97176,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -91517,18 +97206,27 @@ namespace VULKAN_HPP_NAMESPACE useMaxFrameSize, maxFrameSize ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeH265RateControlLayerInfoEXT const & ) const = default; # else bool operator==( VideoEncodeH265RateControlLayerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( temporalId == rhs.temporalId ) && + ( useInitialRcQp == rhs.useInitialRcQp ) && ( initialRcQp == rhs.initialRcQp ) && + ( useMinQp == rhs.useMinQp ) && ( minQp == rhs.minQp ) && ( useMaxQp == rhs.useMaxQp ) && + ( maxQp == rhs.maxQp ) && ( useMaxFrameSize == rhs.useMaxFrameSize ) && + ( maxFrameSize == rhs.maxFrameSize ); +# endif } bool operator!=( VideoEncodeH265RateControlLayerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -91629,30 +97327,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, flags, pStdExtensionVersion ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeH265SessionCreateInfoEXT const & ) const = default; # else bool operator==( VideoEncodeH265SessionCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && + ( pStdExtensionVersion == rhs.pStdExtensionVersion ); +# endif } bool operator!=( VideoEncodeH265SessionCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -91831,9 +97536,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, vpsStdCount, pVpsStd, spsStdCount, pSpsStd, ppsStdCount, pPpsStd ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeH265SessionParametersAddInfoEXT const & ) const = default; # else bool operator==( VideoEncodeH265SessionParametersAddInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( vpsStdCount == rhs.vpsStdCount ) && + ( pVpsStd == rhs.pVpsStd ) && ( spsStdCount == rhs.spsStdCount ) && ( pSpsStd == rhs.pSpsStd ) && + ( ppsStdCount == rhs.ppsStdCount ) && ( pPpsStd == rhs.pPpsStd ); +# endif } bool operator!=( VideoEncodeH265SessionParametersAddInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -91978,32 +97691,40 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, maxVpsStdCount, maxSpsStdCount, maxPpsStdCount, pParametersAddInfo ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeH265SessionParametersCreateInfoEXT const & ) const = default; # else bool operator==( VideoEncodeH265SessionParametersCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxVpsStdCount == rhs.maxVpsStdCount ) && + ( maxSpsStdCount == rhs.maxSpsStdCount ) && ( maxPpsStdCount == rhs.maxPpsStdCount ) && + ( pParametersAddInfo == rhs.pParametersAddInfo ); +# endif } bool operator!=( VideoEncodeH265SessionParametersCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -92139,33 +97860,41 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, pReferenceFinalLists, naluSliceEntryCount, pNaluSliceEntries, pCurrentPictureInfo ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeH265VclFrameInfoEXT const & ) const = default; # else bool operator==( VideoEncodeH265VclFrameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pReferenceFinalLists == rhs.pReferenceFinalLists ) && + ( naluSliceEntryCount == rhs.naluSliceEntryCount ) && ( pNaluSliceEntries == rhs.pNaluSliceEntries ) && + ( pCurrentPictureInfo == rhs.pCurrentPictureInfo ); +# endif } bool operator!=( VideoEncodeH265VclFrameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -92374,9 +98103,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -92407,18 +98137,30 @@ namespace VULKAN_HPP_NAMESPACE pReferenceSlots, precedingExternallyEncodedBytes ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeInfoKHR const & ) const = default; # else bool operator==( VideoEncodeInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && + ( qualityLevel == rhs.qualityLevel ) && ( codedExtent == rhs.codedExtent ) && + ( dstBitstreamBuffer == rhs.dstBitstreamBuffer ) && + ( dstBitstreamBufferOffset == rhs.dstBitstreamBufferOffset ) && + ( dstBitstreamBufferMaxRange == rhs.dstBitstreamBufferMaxRange ) && + ( srcPictureResource == rhs.srcPictureResource ) && ( pSetupReferenceSlot == rhs.pSetupReferenceSlot ) && + ( referenceSlotCount == rhs.referenceSlotCount ) && ( pReferenceSlots == rhs.pReferenceSlots ) && + ( precedingExternallyEncodedBytes == rhs.precedingExternallyEncodedBytes ); +# endif } bool operator!=( VideoEncodeInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -92554,9 +98296,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -92577,18 +98320,27 @@ namespace VULKAN_HPP_NAMESPACE virtualBufferSizeInMs, initialVirtualBufferSizeInMs ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeRateControlLayerInfoKHR const & ) const = default; # else bool operator==( VideoEncodeRateControlLayerInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( averageBitrate == rhs.averageBitrate ) && + ( maxBitrate == rhs.maxBitrate ) && ( frameRateNumerator == rhs.frameRateNumerator ) && + ( frameRateDenominator == rhs.frameRateDenominator ) && + ( virtualBufferSizeInMs == rhs.virtualBufferSizeInMs ) && + ( initialVirtualBufferSizeInMs == rhs.initialVirtualBufferSizeInMs ); +# endif } bool operator!=( VideoEncodeRateControlLayerInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -92725,32 +98477,40 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, flags, rateControlMode, layerCount, pLayerConfigs ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeRateControlInfoKHR const & ) const = default; # else bool operator==( VideoEncodeRateControlInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && + ( rateControlMode == rhs.rateControlMode ) && ( layerCount == rhs.layerCount ) && + ( pLayerConfigs == rhs.pLayerConfigs ); +# endif } bool operator!=( VideoEncodeRateControlInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -92833,29 +98593,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, flags ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEndCodingInfoKHR const & ) const = default; # else bool operator==( VideoEndCodingInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ); +# endif } bool operator!=( VideoEndCodingInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -92917,27 +98683,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, format ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoFormatPropertiesKHR const & ) const = default; # else bool operator==( VideoFormatPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( format == rhs.format ); +# endif } bool operator!=( VideoFormatPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -93025,30 +98797,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, memoryBindIndex, pMemoryRequirements ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoGetMemoryPropertiesKHR const & ) const = default; # else bool operator==( VideoGetMemoryPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryBindIndex == rhs.memoryBindIndex ) && + ( pMemoryRequirements == rhs.pMemoryRequirements ); +# endif } bool operator!=( VideoGetMemoryPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -93130,29 +98909,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, videoCodecOperations ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoQueueFamilyProperties2KHR const & ) const = default; # else bool operator==( VideoQueueFamilyProperties2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( videoCodecOperations == rhs.videoCodecOperations ); +# endif } bool operator!=( VideoQueueFamilyProperties2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -93295,9 +99080,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -93322,18 +99108,28 @@ namespace VULKAN_HPP_NAMESPACE maxReferencePicturesSlotsCount, maxReferencePicturesActiveCount ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoSessionCreateInfoKHR const & ) const = default; # else bool operator==( VideoSessionCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( queueFamilyIndex == rhs.queueFamilyIndex ) && + ( flags == rhs.flags ) && ( pVideoProfile == rhs.pVideoProfile ) && + ( pictureFormat == rhs.pictureFormat ) && ( maxCodedExtent == rhs.maxCodedExtent ) && + ( referencePicturesFormat == rhs.referencePicturesFormat ) && + ( maxReferencePicturesSlotsCount == rhs.maxReferencePicturesSlotsCount ) && + ( maxReferencePicturesActiveCount == rhs.maxReferencePicturesActiveCount ); +# endif } bool operator!=( VideoSessionCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -93431,30 +99227,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, videoSessionParametersTemplate, videoSession ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoSessionParametersCreateInfoKHR const & ) const = default; # else bool operator==( VideoSessionParametersCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( videoSessionParametersTemplate == rhs.videoSessionParametersTemplate ) && + ( videoSession == rhs.videoSession ); +# endif } bool operator!=( VideoSessionParametersCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -93537,27 +99341,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, updateSequenceCount ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoSessionParametersUpdateInfoKHR const & ) const = default; # else bool operator==( VideoSessionParametersUpdateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( updateSequenceCount == rhs.updateSequenceCount ); +# endif } bool operator!=( VideoSessionParametersUpdateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -93652,31 +99462,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, flags, display, surface ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( WaylandSurfaceCreateInfoKHR const & ) const = default; # else bool operator==( WaylandSurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( display == rhs.display ) && + ( surface == rhs.surface ); +# endif } bool operator!=( WaylandSurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -93921,9 +99738,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -93946,18 +99764,26 @@ namespace VULKAN_HPP_NAMESPACE pReleaseSyncs, pReleaseKeys ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( Win32KeyedMutexAcquireReleaseInfoKHR const & ) const = default; # else bool operator==( Win32KeyedMutexAcquireReleaseInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( acquireCount == rhs.acquireCount ) && + ( pAcquireSyncs == rhs.pAcquireSyncs ) && ( pAcquireKeys == rhs.pAcquireKeys ) && + ( pAcquireTimeouts == rhs.pAcquireTimeouts ) && ( releaseCount == rhs.releaseCount ) && + ( pReleaseSyncs == rhs.pReleaseSyncs ) && ( pReleaseKeys == rhs.pReleaseKeys ); +# endif } bool operator!=( Win32KeyedMutexAcquireReleaseInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -94207,9 +100033,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -94232,18 +100059,27 @@ namespace VULKAN_HPP_NAMESPACE pReleaseSyncs, pReleaseKeys ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( Win32KeyedMutexAcquireReleaseInfoNV const & ) const = default; # else bool operator==( Win32KeyedMutexAcquireReleaseInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( acquireCount == rhs.acquireCount ) && + ( pAcquireSyncs == rhs.pAcquireSyncs ) && ( pAcquireKeys == rhs.pAcquireKeys ) && + ( pAcquireTimeoutMilliseconds == rhs.pAcquireTimeoutMilliseconds ) && + ( releaseCount == rhs.releaseCount ) && ( pReleaseSyncs == rhs.pReleaseSyncs ) && + ( pReleaseKeys == rhs.pReleaseKeys ); +# endif } bool operator!=( Win32KeyedMutexAcquireReleaseInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -94344,31 +100180,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, flags, hinstance, hwnd ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( Win32SurfaceCreateInfoKHR const & ) const = default; # else bool operator==( Win32SurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && + ( hinstance == rhs.hinstance ) && ( hwnd == rhs.hwnd ); +# endif } bool operator!=( Win32SurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -94575,9 +100418,10 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, @@ -94602,18 +100446,27 @@ namespace VULKAN_HPP_NAMESPACE pBufferInfo, pTexelBufferView ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( WriteDescriptorSet const & ) const = default; #else bool operator==( WriteDescriptorSet const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dstSet == rhs.dstSet ) && + ( dstBinding == rhs.dstBinding ) && ( dstArrayElement == rhs.dstArrayElement ) && + ( descriptorCount == rhs.descriptorCount ) && ( descriptorType == rhs.descriptorType ) && + ( pImageInfo == rhs.pImageInfo ) && ( pBufferInfo == rhs.pBufferInfo ) && + ( pTexelBufferView == rhs.pTexelBufferView ); +# endif } bool operator!=( WriteDescriptorSet const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -94731,30 +100584,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, accelerationStructureCount, pAccelerationStructures ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( WriteDescriptorSetAccelerationStructureKHR const & ) const = default; #else bool operator==( WriteDescriptorSetAccelerationStructureKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( accelerationStructureCount == rhs.accelerationStructureCount ) && + ( pAccelerationStructures == rhs.pAccelerationStructures ); +# endif } bool operator!=( WriteDescriptorSetAccelerationStructureKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -94869,30 +100730,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std::tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, accelerationStructureCount, pAccelerationStructures ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( WriteDescriptorSetAccelerationStructureNV const & ) const = default; #else bool operator==( WriteDescriptorSetAccelerationStructureNV const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( accelerationStructureCount == rhs.accelerationStructureCount ) && + ( pAccelerationStructures == rhs.pAccelerationStructures ); +# endif } bool operator!=( WriteDescriptorSetAccelerationStructureNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -95003,28 +100872,34 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -#if 14 <= VULKAN_HPP_CPP_VERSION +#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -#else +# else std:: tuple -#endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, dataSize, pData ); } +#endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( WriteDescriptorSetInlineUniformBlockEXT const & ) const = default; #else bool operator==( WriteDescriptorSetInlineUniformBlockEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dataSize == rhs.dataSize ) && ( pData == rhs.pData ); +# endif } bool operator!=( WriteDescriptorSetInlineUniformBlockEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } #endif @@ -95120,31 +100995,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, flags, connection, window ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( XcbSurfaceCreateInfoKHR const & ) const = default; # else bool operator==( XcbSurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && + ( connection == rhs.connection ) && ( memcmp( &window, &rhs.window, sizeof( xcb_window_t ) ) == 0 ); +# endif } bool operator!=( XcbSurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif @@ -95239,31 +101121,38 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } -# if 14 <= VULKAN_HPP_CPP_VERSION +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) +# if 14 <= VULKAN_HPP_CPP_VERSION auto -# else +# else std::tuple -# endif +# endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, flags, dpy, window ); } +# endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( XlibSurfaceCreateInfoKHR const & ) const = default; # else bool operator==( XlibSurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { +# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION ) return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( dpy == rhs.dpy ) && + ( memcmp( &window, &rhs.window, sizeof( Window ) ) == 0 ); +# endif } bool operator!=( XlibSurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return this->reflect() != rhs.reflect(); + return !operator==( rhs ); } # endif -- 2.7.4